laag-nasm 2.13.03.2

data/vendor/repo.or.cz/nasm/tools/cleanpatch

@@ -0,0 +1,258 @@
+#!/usr/bin/perl -w
+#
+# Clean a patch file -- or directory of patch files -- of stealth whitespace.
+# WARNING: this can be a highly destructive operation.  Use with caution.
+#
+
+use bytes;
+use File::Basename;
+
+# Default options
+$max_width = 79;
+
+# Clean up space-tab sequences, either by removing spaces or
+# replacing them with tabs.
+sub clean_space_tabs($)
+{
+    no bytes;			# Tab alignment depends on characters
+
+    my($li) = @_;
+    my($lo) = '';
+    my $pos = 0;
+    my $nsp = 0;
+    my($i, $c);
+
+    for ($i = 0; $i < length($li); $i++) {
+	$c = substr($li, $i, 1);
+	if ($c eq "\t") {
+	    my $npos = ($pos+$nsp+8) & ~7;
+	    my $ntab = ($npos >> 3) - ($pos >> 3);
+	    $lo .= "\t" x $ntab;
+	    $pos = $npos;
+	    $nsp = 0;
+	} elsif ($c eq "\n" || $c eq "\r") {
+	    $lo .= " " x $nsp;
+	    $pos += $nsp;
+	    $nsp = 0;
+	    $lo .= $c;
+	    $pos = 0;
+	} elsif ($c eq " ") {
+	    $nsp++;
+	} else {
+	    $lo .= " " x $nsp;
+	    $pos += $nsp;
+	    $nsp = 0;
+	    $lo .= $c;
+	    $pos++;
+	}
+    }
+    $lo .= " " x $nsp;
+    return $lo;
+}
+
+# Compute the visual width of a string
+sub strwidth($) {
+    no bytes;			# Tab alignment depends on characters
+
+    my($li) = @_;
+    my($c, $i);
+    my $pos = 0;
+    my $mlen = 0;
+
+    for ($i = 0; $i < length($li); $i++) {
+	$c = substr($li,$i,1);
+	if ($c eq "\t") {
+	    $pos = ($pos+8) & ~7;
+	} elsif ($c eq "\n") {
+	    $mlen = $pos if ($pos > $mlen);
+	    $pos = 0;
+	} else {
+	    $pos++;
+	}
+    }
+
+    $mlen = $pos if ($pos > $mlen);
+    return $mlen;
+}
+
+$name = basename($0);
+
+@files = ();
+
+while (defined($a = shift(@ARGV))) {
+    if ($a =~ /^-/) {
+	if ($a eq '-width' || $a eq '-w') {
+	    $max_width = shift(@ARGV)+0;
+	} else {
+	    print STDERR "Usage: $name [-width #] files...\n";
+	    exit 1;
+	}
+    } else {
+	push(@files, $a);
+    }
+}
+
+foreach $f ( @files ) {
+    print STDERR "$name: $f\n";
+
+    if (! -f $f) {
+	print STDERR "$f: not a file\n";
+	next;
+    }
+
+    if (!open(FILE, '+<', $f)) {
+	print STDERR "$name: Cannot open file: $f: $!\n";
+	next;
+    }
+
+    binmode FILE;
+
+    # First, verify that it is not a binary file; consider any file
+    # with a zero byte to be a binary file.  Is there any better, or
+    # additional, heuristic that should be applied?
+    $is_binary = 0;
+
+    while (read(FILE, $data, 65536) > 0) {
+	if ($data =~ /\0/) {
+	    $is_binary = 1;
+	    last;
+	}
+    }
+
+    if ($is_binary) {
+	print STDERR "$name: $f: binary file\n";
+	next;
+    }
+
+    seek(FILE, 0, 0);
+
+    $in_bytes = 0;
+    $out_bytes = 0;
+    $lineno = 0;
+
+    @lines  = ();
+
+    $in_hunk = 0;
+    $err = 0;
+
+    while ( defined($line = <FILE>) ) {
+	$lineno++;
+	$in_bytes += length($line);
+
+	if (!$in_hunk) {
+	    if ($line =~
+		/^\@\@\s+\-([0-9]+),([0-9]+)\s+\+([0-9]+),([0-9]+)\s\@\@/) {
+		$minus_lines = $2;
+		$plus_lines = $4;
+		if ($minus_lines || $plus_lines) {
+		    $in_hunk = 1;
+		    @hunk_lines = ($line);
+		}
+	    } else {
+		push(@lines, $line);
+		$out_bytes += length($line);
+	    }
+	} else {
+	    # We're in a hunk
+
+	    if ($line =~ /^\+/) {
+		$plus_lines--;
+
+		$text = substr($line, 1);
+		$text =~ s/[ \t\r]*$//;		# Remove trailing spaces
+		$text = clean_space_tabs($text);
+
+		$l_width = strwidth($text);
+		if ($max_width && $l_width > $max_width) {
+		    print STDERR
+			"$f:$lineno: adds line exceeds $max_width ",
+			"characters ($l_width)\n";
+		}
+
+		push(@hunk_lines, '+'.$text);
+	    } elsif ($line =~ /^\-/) {
+		$minus_lines--;
+		push(@hunk_lines, $line);
+	    } elsif ($line =~ /^ /) {
+		$plus_lines--;
+		$minus_lines--;
+		push(@hunk_lines, $line);
+	    } else {
+		print STDERR "$name: $f: malformed patch\n";
+		$err = 1;
+		last;
+	    }
+
+	    if ($plus_lines < 0 || $minus_lines < 0) {
+		print STDERR "$name: $f: malformed patch\n";
+		$err = 1;
+		last;
+	    } elsif ($plus_lines == 0 && $minus_lines == 0) {
+		# End of a hunk.  Process this hunk.
+		my $i;
+		my $l;
+		my @h = ();
+		my $adj = 0;
+		my $done = 0;
+
+		for ($i = scalar(@hunk_lines)-1; $i > 0; $i--) {
+		    $l = $hunk_lines[$i];
+		    if (!$done && $l eq "+\n") {
+			$adj++; # Skip this line
+		    } elsif ($l =~ /^[ +]/) {
+			$done = 1;
+			unshift(@h, $l);
+		    } else {
+			unshift(@h, $l);
+		    }
+		}
+
+		$l = $hunk_lines[0];  # Hunk header
+		undef @hunk_lines;    # Free memory
+
+		if ($adj) {
+		    die unless
+			($l =~ /^\@\@\s+\-([0-9]+),([0-9]+)\s+\+([0-9]+),([0-9]+)\s\@\@(.*)$/);
+		    my $mstart = $1;
+		    my $mlin = $2;
+		    my $pstart = $3;
+		    my $plin = $4;
+		    my $tail = $5; # doesn't include the final newline
+
+		    $l = sprintf("@@ -%d,%d +%d,%d @@%s\n",
+				 $mstart, $mlin, $pstart, $plin-$adj,
+				 $tail);
+		}
+		unshift(@h, $l);
+
+		# Transfer to the output array
+		foreach $l (@h) {
+		    $out_bytes += length($l);
+		    push(@lines, $l);
+		}
+
+		$in_hunk = 0;
+	    }
+	}
+    }
+
+    if ($in_hunk) {
+	print STDERR "$name: $f: malformed patch\n";
+	$err = 1;
+    }
+
+    if (!$err) {
+	if ($in_bytes != $out_bytes) {
+	    # Only write to the file if changed
+	    seek(FILE, 0, 0);
+	    print FILE @lines;
+
+	    if ( !defined($where = tell(FILE)) ||
+		 !truncate(FILE, $where) ) {
+		die "$name: Failed to truncate modified file: $f: $!\n";
+	    }
+	}
+    }
+
+    close(FILE);
+}

data/vendor/repo.or.cz/nasm/tools/mkdep.pl

@@ -0,0 +1,261 @@
+#!/usr/bin/perl
+## --------------------------------------------------------------------------
+##   
+##   Copyright 1996-2016 The NASM Authors - All Rights Reserved
+##   See the file AUTHORS included with the NASM distribution for
+##   the specific copyright holders.
+##
+##   Redistribution and use in source and binary forms, with or without
+##   modification, are permitted provided that the following
+##   conditions are met:
+##
+##   * Redistributions of source code must retain the above copyright
+##     notice, this list of conditions and the following disclaimer.
+##   * Redistributions in binary form must reproduce the above
+##     copyright notice, this list of conditions and the following
+##     disclaimer in the documentation and/or other materials provided
+##     with the distribution.
+##     
+##     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+##     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+##     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+##     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+##     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+##     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+##     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+##     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+##     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+##     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+##     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+##     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+##     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+##
+## --------------------------------------------------------------------------
+
+#
+# Script to create Makefile-style dependencies.
+#
+# Usage: perl mkdep.pl [-s path-separator] [-o obj-ext] dir... > deps
+#
+
+use File::Spec;
+use File::Basename;
+use Fcntl;
+
+$barrier = "#-- Everything below is generated by mkdep.pl - do not edit --#\n";
+
+# This converts from filenames to full pathnames for our dependencies
+%dep_path = {};
+
+#
+# Scan files for dependencies
+#
+sub scandeps($) {
+    my($file) = @_;
+    my $line;
+    my @xdeps = ();
+    my @mdeps = ();
+
+    open(my $fh, '<', $file)
+	or return;		# If not openable, assume generated
+
+    while ( defined($line = <$fh>) ) {
+	chomp $line;
+	$line =~ s:/\*.*\*/::g;
+	$line =~ s://.*$::;
+	if ( $line =~ /^\s*\#\s*include\s+\"(.*)\"\s*$/ ) {
+	    my $nf = $1;
+	    if (!defined($dep_path{$nf})) {
+		die "$0: cannot determine path for dependency: $file -> $nf\n";
+	    }
+	    $nf = $dep_path{$nf};
+	    push(@mdeps, $nf);
+	    push(@xdeps, $nf) unless ( defined($deps{$nf}) );
+	}
+    }
+    close($fh);
+    $deps{$file} = [@mdeps];
+
+    foreach my $xf ( @xdeps ) {
+	scandeps($xf);
+    }
+}
+
+# %deps contains direct dependencies.  This subroutine resolves
+# indirect dependencies that result.
+sub alldeps($$) {
+    my($file, $level) = @_;
+    my %adeps;
+
+    foreach my $dep ( @{$deps{$file}} ) {
+	$adeps{$dep} = 1;
+	foreach my $idep ( alldeps($dep, $level+1) ) {
+	    $adeps{$idep} = 1;
+	}
+    }
+    return sort(keys(%adeps));
+}
+
+# This converts a filename from host syntax to target syntax
+# This almost certainly works only on relative filenames...
+sub convert_file($$) {
+    my($file,$sep) = @_;
+    my @fspec = (basename($file));
+    while ( ($file = dirname($file)) ne File::Spec->curdir() &&
+	    $file ne File::Spec->rootdir() ) {
+	unshift(@fspec, basename($file));
+    }
+
+    if ( $sep eq '' ) {
+	# This means kill path completely.  Used with Makes who do
+	# path searches, but doesn't handle output files in subdirectories,
+	# like OpenWatcom WMAKE.
+	return $fspec[scalar(@fspec)-1];
+    } else {
+	return join($sep, @fspec);
+    }
+}
+
+#
+# Insert dependencies into a Makefile
+#
+sub insert_deps($) {
+    my($file) = @_;
+    $nexttemp++;		# Unique serial number for each temp file
+    my $tmp = File::Spec->catfile(dirname($file), 'tmp.'.$nexttemp);
+
+    open(my $in, '<', $file)
+	or die "$0: Cannot open input: $file\n";
+    open(my $out, '>', $tmp)
+	or die "$0: Cannot open output: $tmp\n";
+
+    my($line,$parm,$val);
+    my($obj) = '.o';		# Defaults
+    my($sep) = '/';
+    my($cont) = "\\";
+    my($maxline) = 78;		# Seems like a reasonable default
+    my @exclude = ();		# Don't exclude anything
+    my @genhdrs = ();
+
+    while ( defined($line = <$in>) ) {
+	if ( $line =~ /^([^\s\#\$\:]+\.h):/ ) {
+	    # Note: we trust the first Makefile given best
+	    my $fpath = $1;
+	    my $fbase = basename($fpath);
+	    if (!defined($dep_path{$fbase})) {
+		$dep_path{$fbase} = $fpath;
+		print STDERR "Makefile: $fbase -> $fpath\n";
+	    }
+	} elsif ( $line =~ /^\s*\#\s*@([a-z0-9-]+):\s*\"([^\"]*)\"/ ) {
+	    $parm = $1;  $val = $2;
+	    if ( $parm eq 'object-ending' ) {
+		$obj = $val;
+	    } elsif ( $parm eq 'path-separator' ) {
+		$sep = $val;
+	    } elsif ( $parm eq 'line-width' ) {
+		$maxline = $val+0;
+	    } elsif ( $parm eq 'continuation' ) {
+		$cont = $val;
+	    } elsif ( $parm eq 'exclude' ) {
+		@exclude = split(/\,/, $val);
+	    }
+	} elsif ( $line eq $barrier ) {
+	    last;		# Stop reading input at barrier line
+	}
+	print $out $line;
+    }
+    close($in);
+
+    my $e;
+    my %do_exclude = ();
+    foreach $e (@exclude) {
+	$do_exclude{$e} = 1;
+    }
+
+    my $dfile, $ofile, $str, $sl, $len;
+    my @deps, $dep;
+
+    print $out $barrier;
+
+    foreach $dfile ( sort(keys(%deps)) ) {
+	if ( $dfile =~ /^(.*)\.[Cc]$/ ) {
+	    $ofile = $1;
+	    $str = convert_file($ofile, $sep).$obj.':';
+	    $len = length($str);
+	    print $out $str;
+	    foreach $dep ($dfile, alldeps($dfile,1)) {
+		unless ($do_exclude{$dep}) {
+		    $str = convert_file($dep, $sep);
+		    $sl = length($str)+1;
+		    if ( $len+$sl > $maxline-2 ) {
+			print $out ' ', $cont, "\n ", $str;
+			$len = $sl;
+		    } else {
+			print $out ' ', $str;
+			$len += $sl;
+		    }
+		}
+	    }
+	    print $out "\n";
+	}
+    }
+    close($out);
+
+    (unlink($file) && rename($tmp, $file))
+	or die "$0: Failed to change $tmp -> $file\n";
+}
+
+#
+# Main program
+#
+
+my %deps = ();
+my @files = ();
+my @mkfiles = ();
+my $mkmode = 0;
+
+while ( defined(my $arg = shift(@ARGV)) ) {
+    if ( $arg eq '-m' ) {
+	$arg = shift(@ARGV);
+	push(@mkfiles, $arg);
+    } elsif ( $arg eq '-M' ) {
+	$mkmode = 1;		# Futher filenames are output Makefile names
+    } elsif ( $arg eq '--' && $mkmode ) {
+	$mkmode = 0;
+    } elsif ( $arg =~ /^-/ ) {
+	die "Unknown option: $arg\n";
+    } else {
+	if ( $mkmode ) {
+	    push(@mkfiles, $arg);
+	} else {
+	    push(@files, $arg);
+	}
+    }
+}
+
+my @cfiles = ();
+
+foreach my $dir ( @files ) {
+    opendir(DIR, $dir) or die "$0: Cannot open directory: $dir";
+
+    while ( my $file = readdir(DIR) ) {
+	$path = ($dir eq File::Spec->curdir())
+	    ? $file : File::Spec->catfile($dir,$file);
+	if ( $file =~ /\.[Cc]$/ ) {
+	    push(@cfiles, $path);
+	} elsif ( $file =~ /\.[Hh]$/ ) {
+	    print STDERR "Filesystem: $file -> $path\n";
+	    $dep_path{$file} = $path; # Allow the blank filename
+	    $dep_path{$path} = $path; # Also allow the full pathname
+	}
+    }
+    closedir(DIR);
+}
+
+foreach my $cfile ( @cfiles ) {
+    scandeps($cfile);
+}
+
+foreach my $mkfile ( @mkfiles ) {
+    insert_deps($mkfile);
+}