Upgrade logrus / testify to stable versions

1 files changed, 579 insertions, 0 deletions

diff --git a/vendor/golang.org/x/sys/unix/mksyscall_aix_ppc64.pl b/vendor/golang.org/x/sys/unix/mksyscall_aix_ppc64.pl
new file mode 100644
index 00000000..53df26bb
--- /dev/null
+++ b/vendor/golang.org/x/sys/unix/mksyscall_aix_ppc64.pl
@@ -0,0 +1,579 @@
+#!/usr/bin/env perl
+# Copyright 2018 The Go Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file.
+
+# This program reads a file containing function prototypes
+# (like syscall_aix.go) and generates system call bodies.
+# The prototypes are marked by lines beginning with "//sys"
+# and read like func declarations if //sys is replaced by func, but:
+#	* The parameter lists must give a name for each argument.
+#	  This includes return parameters.
+#	* The parameter lists must give a type for each argument:
+#	  the (x, y, z int) shorthand is not allowed.
+#	* If the return parameter is an error number, it must be named err.
+#	* If go func name needs to be different than its libc name,
+#	* or the function is not in libc, name could be specified
+#	* at the end, after "=" sign, like
+#	  //sys getsockopt(s int, level int, name int, val uintptr, vallen *_Socklen) (err error) = libsocket.getsockopt
+
+# This program will generate three files and handle both gc and gccgo implementation:
+#   - zsyscall_aix_ppc64.go: the common part of each implementation (error handler, pointer creation)
+#   - zsyscall_aix_ppc64_gc.go: gc part with //go_cgo_import_dynamic and a call to syscall6
+#   - zsyscall_aix_ppc64_gccgo.go: gccgo part with C function and conversion to C type.
+
+# The generated code looks like this
+#
+# zsyscall_aix_ppc64.go
+# func asyscall(...) (n int, err error) {
+#	  // Pointer Creation
+#	  r1, e1 := callasyscall(...)
+#	  // Type Conversion
+#	  // Error Handler
+#	  return
+# }
+#
+# zsyscall_aix_ppc64_gc.go
+# //go:cgo_import_dynamic libc_asyscall asyscall "libc.a/shr_64.o"
+# //go:linkname libc_asyscall libc_asyscall
+# var asyscall syscallFunc
+#
+# func callasyscall(...) (r1 uintptr, e1 Errno) {
+#	  r1, _, e1 = syscall6(uintptr(unsafe.Pointer(&libc_asyscall)), "nb_args", ... )
+#	  return
+# }
+#
+# zsyscall_aix_ppc64_ggcgo.go
+# /*
+#  int asyscall(...)
+#
+# */
+# import "C"
+#
+# func callasyscall(...) (r1 uintptr, e1 Errno) {
+#	  r1 = uintptr(C.asyscall(...))
+#	  e1 = syscall.GetErrno()
+#	  return
+# }
+
+
+
+use strict;
+
+my $cmdline = "mksyscall_aix_ppc64.pl " . join(' ', @ARGV);
+my $errors = 0;
+my $_32bit = "";
+my $tags = "";  # build tags
+my $aix = 0;
+my $solaris = 0;
+
+binmode STDOUT;
+
+if($ARGV[0] eq "-b32") {
+	$_32bit = "big-endian";
+	shift;
+} elsif($ARGV[0] eq "-l32") {
+	$_32bit = "little-endian";
+	shift;
+}
+if($ARGV[0] eq "-aix") {
+	$aix = 1;
+	shift;
+}
+if($ARGV[0] eq "-tags") {
+	shift;
+	$tags = $ARGV[0];
+	shift;
+}
+
+if($ARGV[0] =~ /^-/) {
+	print STDERR "usage: mksyscall_aix.pl [-b32 | -l32] [-tags x,y] [file ...]\n";
+	exit 1;
+}
+
+sub parseparamlist($) {
+	my ($list) = @_;
+	$list =~ s/^\s*//;
+	$list =~ s/\s*$//;
+	if($list eq "") {
+		return ();
+	}
+	return split(/\s*,\s*/, $list);
+}
+
+sub parseparam($) {
+	my ($p) = @_;
+	if($p !~ /^(\S*) (\S*)$/) {
+		print STDERR "$ARGV:$.: malformed parameter: $p\n";
+		$errors = 1;
+		return ("xx", "int");
+	}
+	return ($1, $2);
+}
+
+my $package = "";
+# GCCGO
+my $textgccgo = "";
+my $c_extern = "/*\n#include <stdint.h>\n";
+# GC
+my $textgc = "";
+my $dynimports = "";
+my $linknames = "";
+my @vars = ();
+# COMMUN
+my $textcommon = "";
+
+while(<>) {
+	chomp;
+	s/\s+/ /g;
+	s/^\s+//;
+	s/\s+$//;
+	$package = $1 if !$package && /^package (\S+)$/;
+	my $nonblock = /^\/\/sysnb /;
+	next if !/^\/\/sys / && !$nonblock;
+
+	# Line must be of the form
+	# func Open(path string, mode int, perm int) (fd int, err error)
+	# Split into name, in params, out params.
+	if(!/^\/\/sys(nb)? (\w+)\(([^()]*)\)\s*(?:\(([^()]+)\))?\s*(?:=\s*(?:(\w*)\.)?(\w*))?$/) {
+		print STDERR "$ARGV:$.: malformed //sys declaration\n";
+		$errors = 1;
+		next;
+	}
+	my ($nb, $func, $in, $out, $modname, $sysname) = ($1, $2, $3, $4, $5, $6);
+
+	# Split argument lists on comma.
+	my @in = parseparamlist($in);
+	my @out = parseparamlist($out);
+
+	$in = join(', ', @in);
+	$out = join(', ', @out);
+
+	if($sysname eq "") {
+		$sysname = "$func";
+	}
+
+	my $onlyCommon = 0;
+	if ($func eq "readlen" || $func eq "writelen" || $func eq "FcntlInt" || $func eq "FcntlFlock") {
+		# This function call another syscall which is already implemented.
+		# Therefore, the gc and gccgo part must not be generated.
+		$onlyCommon = 1
+	}
+
+	# Try in vain to keep people from editing this file.
+	# The theory is that they jump into the middle of the file
+	# without reading the header.
+
+	$textcommon .= "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n";
+	if (!$onlyCommon) {
+		$textgccgo .= "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n";
+		$textgc .= "// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT\n\n";
+	}
+
+
+	# Check if value return, err return available
+	my $errvar = "";
+	my $retvar = "";
+	my $rettype = "";
+	foreach my $p (@out) {
+		my ($name, $type) = parseparam($p);
+		if($type eq "error") {
+			$errvar = $name;
+		} else {
+			$retvar = $name;
+			$rettype = $type;
+		}
+	}
+
+
+	$sysname =~ s/([a-z])([A-Z])/${1}_$2/g;
+	$sysname =~ y/A-Z/a-z/; # All libc functions are lowercase.
+
+	# GCCGO Prototype return type
+	my $C_rettype = "";
+	if($rettype eq "unsafe.Pointer") {
+		$C_rettype = "uintptr_t";
+	} elsif($rettype eq "uintptr") {
+		$C_rettype = "uintptr_t";
+	} elsif($rettype =~ /^_/) {
+		$C_rettype = "uintptr_t";
+	} elsif($rettype eq "int") {
+		$C_rettype = "int";
+	} elsif($rettype eq "int32") {
+		$C_rettype = "int";
+	} elsif($rettype eq "int64") {
+		$C_rettype = "long long";
+	} elsif($rettype eq "uint32") {
+		$C_rettype = "unsigned int";
+	} elsif($rettype eq "uint64") {
+		$C_rettype = "unsigned long long";
+	} else {
+		$C_rettype = "int";
+	}
+	if($sysname eq "exit") {
+		$C_rettype = "void";
+	}
+
+	# GCCGO Prototype arguments type
+	my @c_in = ();
+	foreach my $i (0 .. $#in) {
+		my ($name, $type) = parseparam($in[$i]);
+		if($type =~ /^\*/) {
+			push @c_in, "uintptr_t";
+			} elsif($type eq "string") {
+			push @c_in, "uintptr_t";
+		} elsif($type =~ /^\[\](.*)/) {
+			push @c_in, "uintptr_t", "size_t";
+		} elsif($type eq "unsafe.Pointer") {
+			push @c_in, "uintptr_t";
+		} elsif($type eq "uintptr") {
+			push @c_in, "uintptr_t";
+		} elsif($type =~ /^_/) {
+			push @c_in, "uintptr_t";
+		} elsif($type eq "int") {
+			if (($i == 0 || $i == 2) && $func eq "fcntl"){
+				# These fcntl arguments needs to be uintptr to be able to call FcntlInt and FcntlFlock
+				push @c_in, "uintptr_t";
+			} else {
+				push @c_in, "int";
+			}
+		} elsif($type eq "int32") {
+			push @c_in, "int";
+		} elsif($type eq "int64") {
+			push @c_in, "long long";
+		} elsif($type eq "uint32") {
+			push @c_in, "unsigned int";
+		} elsif($type eq "uint64") {
+			push @c_in, "unsigned long long";
+		} else {
+			push @c_in, "int";
+		}
+	}
+
+	if (!$onlyCommon){
+		# GCCGO Prototype Generation
+		# Imports of system calls from libc
+		$c_extern .= "$C_rettype $sysname";
+		my $c_in = join(', ', @c_in);
+		$c_extern .= "($c_in);\n";
+	}
+
+	# GC Library name
+	if($modname eq "") {
+		$modname = "libc.a/shr_64.o";
+	} else {
+		print STDERR "$func: only syscall using libc are available\n";
+		$errors = 1;
+		next;
+	}
+	my $sysvarname = "libc_${sysname}";
+
+	if (!$onlyCommon){
+		# GC Runtime import of function to allow cross-platform builds.
+		$dynimports .= "//go:cgo_import_dynamic ${sysvarname} ${sysname} \"$modname\"\n";
+		# GC Link symbol to proc address variable.
+		$linknames .= "//go:linkname ${sysvarname} ${sysvarname}\n";
+		# GC Library proc address variable.
+		push @vars, $sysvarname;
+	}
+
+	my $strconvfunc ="BytePtrFromString";
+	my $strconvtype = "*byte";
+
+	# Go function header.
+	if($out ne "") {
+		$out = " ($out)";
+	}
+	if($textcommon ne "") {
+		$textcommon .= "\n"
+	}
+
+	$textcommon .= sprintf "func %s(%s)%s {\n", $func, join(', ', @in), $out ;
+
+	# Prepare arguments to call.
+	my @argscommun = (); # Arguments in the commun part
+	my @argscall = ();   # Arguments for call prototype
+	my @argsgc = ();     # Arguments for gc call (with syscall6)
+	my @argsgccgo = ();  # Arguments for gccgo call (with C.name_of_syscall)
+	my $n = 0;
+	my $arg_n = 0;
+	foreach my $p (@in) {
+		my ($name, $type) = parseparam($p);
+		if($type =~ /^\*/) {
+			push @argscommun, "uintptr(unsafe.Pointer($name))";
+			push @argscall, "$name uintptr";
+			push @argsgc, "$name";
+			push @argsgccgo, "C.uintptr_t($name)";
+		} elsif($type eq "string" && $errvar ne "") {
+			$textcommon .= "\tvar _p$n $strconvtype\n";
+			$textcommon .= "\t_p$n, $errvar = $strconvfunc($name)\n";
+			$textcommon .= "\tif $errvar != nil {\n\t\treturn\n\t}\n";
+
+			push @argscommun, "uintptr(unsafe.Pointer(_p$n))";
+			push @argscall, "_p$n uintptr ";
+			push @argsgc, "_p$n";
+			push @argsgccgo, "C.uintptr_t(_p$n)";
+			$n++;
+		} elsif($type eq "string") {
+			print STDERR "$ARGV:$.: $func uses string arguments, but has no error return\n";
+			$textcommon .= "\tvar _p$n $strconvtype\n";
+			$textcommon .= "\t_p$n, $errvar = $strconvfunc($name)\n";
+			$textcommon .= "\tif $errvar != nil {\n\t\treturn\n\t}\n";
+
+			push @argscommun, "uintptr(unsafe.Pointer(_p$n))";
+			push @argscall, "_p$n uintptr";
+			push @argsgc, "_p$n";
+			push @argsgccgo, "C.uintptr_t(_p$n)";
+			$n++;
+		} elsif($type =~ /^\[\](.*)/) {
+			# Convert slice into pointer, length.
+			# Have to be careful not to take address of &a[0] if len == 0:
+			# pass nil in that case.
+			$textcommon .= "\tvar _p$n *$1\n";
+			$textcommon .= "\tif len($name) > 0 {\n\t\t_p$n = \&$name\[0]\n\t}\n";
+			push @argscommun, "uintptr(unsafe.Pointer(_p$n))", "len($name)";
+			push @argscall, "_p$n uintptr", "_lenp$n int";
+			push @argsgc, "_p$n", "uintptr(_lenp$n)";
+			push @argsgccgo, "C.uintptr_t(_p$n)", "C.size_t(_lenp$n)";
+			$n++;
+		} elsif($type eq "int64" && $_32bit ne "") {
+			print STDERR "$ARGV:$.: $func uses int64 with 32 bits mode. Case not yet implemented\n";
+			# if($_32bit eq "big-endian") {
+			# 	push @args, "uintptr($name >> 32)", "uintptr($name)";
+			# } else {
+			# 	push @args, "uintptr($name)", "uintptr($name >> 32)";
+			# }
+			# $n++;
+		} elsif($type eq "bool") {
+			print STDERR "$ARGV:$.: $func uses bool. Case not yet implemented\n";
+			# $text .= "\tvar _p$n uint32\n";
+			# $text .= "\tif $name {\n\t\t_p$n = 1\n\t} else {\n\t\t_p$n = 0\n\t}\n";
+			# push @args, "_p$n";
+			# $n++;
+		} elsif($type =~ /^_/ ||$type eq "unsafe.Pointer") {
+			push @argscommun, "uintptr($name)";
+			push @argscall, "$name uintptr";
+			push @argsgc, "$name";
+			push @argsgccgo, "C.uintptr_t($name)";
+		} elsif($type eq "int") {
+			if (($arg_n == 0 || $arg_n == 2) && ($func eq "fcntl" || $func eq "FcntlInt" || $func eq "FcntlFlock")) {
+				# These fcntl arguments need to be uintptr to be able to call FcntlInt and FcntlFlock
+				push @argscommun, "uintptr($name)";
+				push @argscall, "$name uintptr";
+				push @argsgc, "$name";
+				push @argsgccgo, "C.uintptr_t($name)";
+			} else {
+				push @argscommun, "$name";
+				push @argscall, "$name int";
+				push @argsgc, "uintptr($name)";
+				push @argsgccgo, "C.int($name)";
+			}
+		} elsif($type eq "int32") {
+			push @argscommun, "$name";
+			push @argscall, "$name int32";
+			push @argsgc, "uintptr($name)";
+			push @argsgccgo, "C.int($name)";
+		} elsif($type eq "int64") {
+			push @argscommun, "$name";
+			push @argscall, "$name int64";
+			push @argsgc, "uintptr($name)";
+			push @argsgccgo, "C.longlong($name)";
+		} elsif($type eq "uint32") {
+			push @argscommun, "$name";
+			push @argscall, "$name uint32";
+			push @argsgc, "uintptr($name)";
+			push @argsgccgo, "C.uint($name)";
+		} elsif($type eq "uint64") {
+			push @argscommun, "$name";
+			push @argscall, "$name uint64";
+			push @argsgc, "uintptr($name)";
+			push @argsgccgo, "C.ulonglong($name)";
+		} elsif($type eq "uintptr") {
+			push @argscommun, "$name";
+			push @argscall, "$name uintptr";
+			push @argsgc, "$name";
+			push @argsgccgo, "C.uintptr_t($name)";
+		} else {
+			push @argscommun, "int($name)";
+			push @argscall, "$name int";
+			push @argsgc, "uintptr($name)";
+			push @argsgccgo, "C.int($name)";
+		}
+		$arg_n++;
+	}
+	my $nargs = @argsgc;
+
+	# COMMUN function generation
+	my $argscommun = join(', ', @argscommun);
+	my $callcommun = "call$sysname($argscommun)";
+	my @ret = ("_", "_");
+	my $body = "";
+	my $do_errno = 0;
+	for(my $i=0; $i<@out; $i++) {
+		my $p = $out[$i];
+		my ($name, $type) = parseparam($p);
+		my $reg = "";
+		if($name eq "err") {
+			$reg = "e1";
+			$ret[1] = $reg;
+			$do_errno = 1;
+		} else {
+			$reg = "r0";
+			$ret[0] = $reg;
+		}
+		if($type eq "bool") {
+			$reg = "$reg != 0";
+		}
+		if($reg ne "e1") {
+			$body .= "\t$name = $type($reg)\n";
+		}
+	}
+	if ($ret[0] eq "_"  && $ret[1] eq "_") {
+		$textcommon .= "\t$callcommun\n";
+	} else {
+		$textcommon .= "\t$ret[0], $ret[1] := $callcommun\n";
+	}
+	$textcommon .= $body;
+
+	if ($do_errno) {
+		$textcommon .= "\tif e1 != 0 {\n";
+		$textcommon .= "\t\terr = errnoErr(e1)\n";
+		$textcommon .= "\t}\n";
+	}
+	$textcommon .= "\treturn\n";
+	$textcommon .= "}\n";
+
+	if ($onlyCommon){
+		next
+	}
+	# CALL Prototype
+	my $callProto = sprintf "func call%s(%s) (r1 uintptr, e1 Errno) {\n", $sysname, join(', ', @argscall);
+
+	# GC function generation
+	my $asm = "syscall6";
+	if ($nonblock) {
+		$asm = "rawSyscall6";
+	}
+
+	if(@argsgc <= 6) {
+		while(@argsgc < 6) {
+			push @argsgc, "0";
+		}
+	} else {
+		print STDERR "$ARGV:$.: too many arguments to system call\n";
+	}
+	my $argsgc = join(', ', @argsgc);
+	my $callgc = "$asm(uintptr(unsafe.Pointer(&$sysvarname)), $nargs, $argsgc)";
+
+	$textgc .= $callProto;
+	$textgc .= "\tr1, _, e1 = $callgc\n";
+	$textgc .= "\treturn\n}\n";
+
+	# GCCGO function generation
+	my $argsgccgo = join(', ', @argsgccgo);
+	my $callgccgo = "C.$sysname($argsgccgo)";
+	$textgccgo .= $callProto;
+	$textgccgo .= "\tr1 = uintptr($callgccgo)\n";
+	$textgccgo .= "\te1 = syscall.GetErrno()\n";
+	$textgccgo .= "\treturn\n}\n";
+}
+
+if($errors) {
+	exit 1;
+}
+
+# Print zsyscall_aix_ppc64.go
+open(my $fcommun, '>', 'zsyscall_aix_ppc64.go');
+my $tofcommun = <<EOF;
+// $cmdline
+// Code generated by the command above; see README.md. DO NOT EDIT.
+
+// +build $tags
+
+package $package
+
+import (
+	"unsafe"
+)
+
+EOF
+
+$tofcommun .= "import \"golang.org/x/sys/unix\"\n" if $package ne "unix";
+
+$tofcommun .=<<EOF;
+
+$textcommon
+EOF
+print $fcommun $tofcommun;
+
+
+# Print zsyscall_aix_ppc64_gc.go
+open(my $fgc, '>', 'zsyscall_aix_ppc64_gc.go');
+my $tofgc = <<EOF;
+// $cmdline
+// Code generated by the command above; see README.md. DO NOT EDIT.
+
+// +build $tags
+// +build !gccgo
+
+package $package
+
+import (
+	"unsafe"
+)
+
+
+EOF
+
+$tofgc .= "import \"golang.org/x/sys/unix\"\n" if $package ne "unix";
+
+my $vardecls = "\t" . join(",\n\t", @vars);
+$vardecls .= " syscallFunc";
+
+$tofgc .=<<EOF;
+$dynimports
+$linknames
+type syscallFunc uintptr
+
+var (
+$vardecls
+)
+
+// Implemented in runtime/syscall_aix.go.
+func rawSyscall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
+func syscall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
+
+$textgc
+EOF
+print $fgc $tofgc;
+
+# Print zsyscall_aix_ppc64_gc.go
+open(my $fgccgo, '>', 'zsyscall_aix_ppc64_gccgo.go');
+my $tofgccgo = <<EOF;
+// $cmdline
+// Code generated by the command above; see README.md. DO NOT EDIT.
+
+// +build $tags
+// +build gccgo
+
+package $package
+
+
+$c_extern
+*/
+import "C"
+import (
+	"syscall"
+)
+
+
+EOF
+
+$tofgccgo .= "import \"golang.org/x/sys/unix\"\n" if $package ne "unix";
+
+$tofgccgo .=<<EOF;
+
+$textgccgo
+EOF
+print $fgccgo $tofgccgo;
+exit 0;