Bommels05/Mozilla
Bommels05/Mozilla
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

This commit was manufactured by cvs2svn to create tag 'sspitzer-news-tag'.

Browse Source 
git-svn-id: svn://10.0.0.236/tags/sspitzer-news-tag@35841 18797224-902f-48f8-a5cc-f745e15eee43
This commit is contained in:
(no author) 1999-06-18 02:37:26 +00:00
parent 629522fb4c
commit fb1a4d74b8
13681 changed files with 0 additions and 3497743 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CVSROOT/FilesToNotExport
View File

@ -1 +0,0 @@
CVSROOT/history

20
CVSROOT/checkoutlist
View File

@ -1,20 +0,0 @@
# The "checkoutlist" file is used to support additional version controlled
# administrative files in $CVSROOT/CVSROOT, such as template files.
#
# The first entry on a line is a filename which will be checked out from
# the corresponding RCS file in the $CVSROOT/CVSROOT directory.
# The remainder of the line is an error message to use if the file cannot
# be checked out.
#
# File format:
#
# [<whitespace>]<filename><whitespace><error message><end-of-line>
#
# comment lines begin with '#'
passwd
readers
commitcheck.pl
dolog.pl
FilesToNotExport
cvsmailfilter.pl
sendnotification.pl

400
CVSROOT/commitcheck.pl
View File

@ -1,400 +0,0 @@
#!/tools/ns/bin/perl5.004 --
# DO NOT EDIT THIS FILE! You must instead go to http://cvs-mirror.mozilla.org/webtools/despot, and
# tweak things from there.
$mode{'95'} = 'Open';
$branch{'95'} = 'HEAD';
$fullname{'95'} = '2-D Graphics';
$mode{'52'} = 'Open';
$branch{'52'} = 'HEAD';
$fullname{'52'} = 'Aurora/RDF BE';
$mode{'94'} = 'Closed';
$branch{'94'} = 'HEAD';
$fullname{'94'} = 'Base XPCOM Classes';
$blessed{'94'} = [];
$super{'94'} = ['dp%netscape.com','kipp%netscape.com','scullin%netscape.com',];
$mode{'53'} = 'Open';
$branch{'53'} = 'HEAD';
$fullname{'53'} = 'Berkeley DB';
$mode{'54'} = 'Open';
$branch{'54'} = 'HEAD';
$fullname{'54'} = 'Browser Hooks';
$mode{'55'} = 'Open';
$branch{'55'} = 'HEAD';
$fullname{'55'} = 'Build Config';
$mode{'108'} = 'Open';
$branch{'108'} = 'HEAD';
$fullname{'108'} = 'CCK';
$mode{'96'} = 'Open';
$branch{'96'} = 'HEAD';
$fullname{'96'} = 'Clipping and Compositing';
$mode{'15'} = 'Restricted';
$branch{'15'} = 'ColorSync_19980824_BRANCH';
$fullname{'15'} = 'ColorSync Branch';
$blessed{'15'} = [];
$super{'15'} = ['ebb3%apple.com','pinkerton%netscape.com','pnunn%netscape.com','saari%netscape.com',];
$mode{'56'} = 'Open';
$branch{'56'} = 'HEAD';
$fullname{'56'} = 'Composer';
$mode{'4'} = 'Open';
$branch{'4'} = 'HEAD';
$fullname{'4'} = 'default';
$defaultid = '4';
$mode{'3'} = 'Closed';
$branch{'3'} = 'HEAD';
$fullname{'3'} = 'despotaccess';
$blessed{'3'} = [];
$super{'3'} = ['despotdaemon%netscape.com',];
$mode{'58'} = 'Open';
$branch{'58'} = 'HEAD';
$fullname{'58'} = 'Dialup';
$mode{'59'} = 'Open';
$branch{'59'} = 'HEAD';
$fullname{'59'} = 'Directory SDK';
$mode{'103'} = 'Open';
$branch{'103'} = 'HEAD';
$fullname{'103'} = 'Document Object Model';
$mode{'46'} = 'Open';
$branch{'46'} = 'HEAD';
$fullname{'46'} = 'ef';
$mode{'101'} = 'Open';
$branch{'101'} = 'HEAD';
$fullname{'101'} = 'Embeddable Web Browser';
$mode{'49'} = 'Open';
$branch{'49'} = 'HEAD';
$fullname{'49'} = 'GTK';
$mode{'62'} = 'Open';
$branch{'62'} = 'HEAD';
$fullname{'62'} = 'HTML to Text/PostScript Translation';
$mode{'67'} = 'Open';
$branch{'67'} = 'HEAD';
$fullname{'67'} = 'I18N Library';
$mode{'66'} = 'Open';
$branch{'66'} = 'HEAD';
$fullname{'66'} = 'Image Conversion Library';
$mode{'63'} = 'Open';
$branch{'63'} = 'HEAD';
$fullname{'63'} = 'ImageLib';
$mode{'69'} = 'Open';
$branch{'69'} = 'HEAD';
$fullname{'69'} = 'Java and JS Capability-Based Security';
$mode{'68'} = 'Open';
$branch{'68'} = 'HEAD';
$fullname{'68'} = 'Java Stubs';
$mode{'70'} = 'Open';
$branch{'70'} = 'HEAD';
$fullname{'70'} = 'JavaScript';
$mode{'71'} = 'Open';
$branch{'71'} = 'HEAD';
$fullname{'71'} = 'JavaScript Debugger';
$mode{'12'} = 'Open';
$branch{'12'} = 'HEAD';
$fullname{'12'} = 'jpeg';
$mode{'64'} = 'Open';
$branch{'64'} = 'HEAD';
$fullname{'64'} = 'JPEG Image Handling';
$mode{'114'} = 'Open';
$branch{'114'} = 'HEAD';
$fullname{'114'} = 'js-tests';
$mode{'72'} = 'Open';
$branch{'72'} = 'HEAD';
$fullname{'72'} = 'LiveConnect';
$mode{'47'} = 'Open';
$branch{'47'} = 'HEAD';
$fullname{'47'} = 'Macintosh FE';
$mode{'76'} = 'Open';
$branch{'76'} = 'HEAD';
$fullname{'76'} = 'MIMELib';
$mode{'112'} = 'Restricted';
$branch{'112'} = 'HEAD';
$fullname{'112'} = 'Mozilla Tools';
$blessed{'112'} = ['slamm%netscape.com','phillip%netscape.com','petitta%netscape.com','kipp%netscape.com','jj%netscape.com','friedman%splode.com','endico%mozilla.org','donm%bluemartini.com','bsharma%netscape.com','briano%netscape.com','braddr%puremagic.com','amasri%netscape.com',];
$super{'112'} = ['leaf%mozilla.org','cyeh%netscape.com',];
$mode{'19'} = 'Open';
$branch{'19'} = 'HEAD';
$fullname{'19'} = 'mozilla-toplevel';
$mode{'77'} = 'Open';
$branch{'77'} = 'HEAD';
$fullname{'77'} = 'NetLib';
$mode{'99'} = 'Open';
$branch{'99'} = 'HEAD';
$fullname{'99'} = 'New HTML Layout Engine';
$mode{'102'} = 'Open';
$branch{'102'} = 'HEAD';
$fullname{'102'} = 'New HTML Parser';
$mode{'100'} = 'Open';
$branch{'100'} = 'HEAD';
$fullname{'100'} = 'New HTML Style System';
$mode{'98'} = 'Open';
$branch{'98'} = 'HEAD';
$fullname{'98'} = 'New Layout Engine';
$mode{'78'} = 'Restricted';
$branch{'78'} = 'HEAD';
$fullname{'78'} = 'NSPR';
$blessed{'78'} = ['sdagley%netscape.com','gordon%netscape.com',];
$super{'78'} = ['wtc%netscape.com','larryh%netscape.com','srinivas%netscape.com',];
$mode{'111'} = 'Open';
$branch{'111'} = 'HEAD';
$fullname{'111'} = 'PerlConnect';
$mode{'113'} = 'Open';
$branch{'113'} = 'HEAD';
$fullname{'113'} = 'Photon';
$mode{'80'} = 'Open';
$branch{'80'} = 'HEAD';
$fullname{'80'} = 'PICS';
$mode{'81'} = 'Open';
$branch{'81'} = 'HEAD';
$fullname{'81'} = 'Plugins';
$mode{'65'} = 'Open';
$branch{'65'} = 'HEAD';
$fullname{'65'} = 'PNG Image Handling';
$mode{'82'} = 'Open';
$branch{'82'} = 'HEAD';
$fullname{'82'} = 'Preferences';
$mode{'120'} = 'Open';
$branch{'120'} = 'HEAD';
$fullname{'120'} = 'Profile Manager';
$mode{'83'} = 'Open';
$branch{'83'} = 'HEAD';
$fullname{'83'} = 'Progress Window';
$mode{'84'} = 'Open';
$branch{'84'} = 'HEAD';
$fullname{'84'} = 'Registry';
$mode{'86'} = 'Open';
$branch{'86'} = 'HEAD';
$fullname{'86'} = 'Security Stubs';
$mode{'110'} = 'Open';
$branch{'110'} = 'HEAD';
$fullname{'110'} = 'Silent Download';
$mode{'115'} = 'Open';
$branch{'115'} = 'HEAD';
$fullname{'115'} = 'small-devices';
$mode{'87'} = 'Open';
$branch{'87'} = 'HEAD';
$fullname{'87'} = 'SmartUpdate';
$mode{'48'} = 'Open';
$branch{'48'} = 'HEAD';
$fullname{'48'} = 'Windows FE';
$mode{'88'} = 'Open';
$branch{'88'} = 'HEAD';
$fullname{'88'} = 'XML';
$mode{'90'} = 'Open';
$branch{'90'} = 'HEAD';
$fullname{'90'} = 'XP File Handling';
$mode{'91'} = 'Open';
$branch{'91'} = 'HEAD';
$fullname{'91'} = 'XP Miscellany';
$mode{'97'} = 'Open';
$branch{'97'} = 'HEAD';
$fullname{'97'} = 'XP Widgets';
$mode{'105'} = 'Open';
$branch{'105'} = 'HEAD';
$fullname{'105'} = 'XPApps';
$mode{'89'} = 'Open';
$branch{'89'} = 'HEAD';
$fullname{'89'} = 'XPCOM';
$mode{'118'} = 'Open';
$branch{'118'} = 'HEAD';
$fullname{'118'} = 'XPConnect';
$mode{'117'} = 'Open';
$branch{'117'} = 'HEAD';
$fullname{'117'} = 'XPIDL';
$mode{'106'} = 'Open';
$branch{'106'} = 'HEAD';
$fullname{'106'} = 'XPToolkit';
$mode{'93'} = 'Open';
$branch{'93'} = 'HEAD';
$fullname{'93'} = 'Zlib';
sub GetT {
($b,$_) = (@_);
if ($b eq 'ColorSync_19980824_BRANCH') {
}
if ($b eq 'HEAD') {
if (m:^CVSROOT/commitcheck\.pl$:) {return '3';}
if (m:^CVSROOT/passwd$:) {return '3';}
if (m:^jpeg/.*$:) {return '12';}
if (m:^mozilla/[^/]*$:) {return '19';}
if (m:^mozilla/cmd/macfe/.*$:) {return '47';}
if (m:^mozilla/ef/.*$:) {return '46';}
if (m:^mozilla/cmd/wincom/.*$:) {return '48';}
if (m:^mozilla/cmd/winfe/.*$:) {return '48';}
if (m:^mozilla/gfx/src/gtk/.*$:) {return '49';}
if (m:^mozilla/widget/src/gtk/.*$:) {return '49';}
if (m:^mozilla/rdf/.*$:) {return '52';}
if (m:^mozilla/dbm/.*$:) {return '53';}
if (m:^mozilla/modules/libhook/.*$:) {return '54';}
if (m:^mozilla/build/.*$:) {return '55';}
if (m:^mozilla/config/.*$:) {return '55';}
if (m:^mozilla/l10n/.*$:) {return '55';}
if (m:^mozilla/editor$:) {return '56';}
if (m:^mozilla/cmd/dialup/.*$:) {return '58';}
if (m:^mozilla/directory/.*$:) {return '59';}
if (m:^mozilla/modules/libimg/.*$:) {return '63';}
if (m:^mozilla/modules/libutil/.*$:) {return '63';}
if (m:^mozilla/lib/libcnv/.*$:) {return '65';}
if (m:^mozilla/include/libcnv\.h/.*$:) {return '66';}
if (m:^mozilla/include/csid\.h/.*$:) {return '67';}
if (m:^mozilla/include/intl_csi\.h/.*$:) {return '67';}
if (m:^mozilla/include/libi18n\.h/.*$:) {return '67';}
if (m:^mozilla/include/resdef\.h/.*$:) {return '67';}
if (m:^mozilla/include/xpgetstr\.h/.*$:) {return '67';}
if (m:^mozilla/include/xplocale\.h/.*$:) {return '67';}
if (m:^mozilla/include/xpresdef\.h/.*$:) {return '67';}
if (m:^mozilla/include/xupfonts\.h/.*$:) {return '67';}
if (m:^mozilla/lib/libi18n/.*$:) {return '67';}
if (m:^mozilla/modules/oji/.*$:) {return '68';}
if (m:^mozilla/nav-java/.*$:) {return '68';}
if (m:^mozilla/sun-java/.*$:) {return '68';}
if (m:^mozilla/caps/.*$:) {return '69';}
if (m:^mozilla/js/ref/.*$:) {return '70';}
if (m:^mozilla/js/src/.*$:) {return '70';}
if (m:^mozilla/js/jsd/.*$:) {return '71';}
if (m:^mozilla/js/jsj/.*$:) {return '72';}
if (m:^mozilla/cck/.*$:) {return '108';}
if (m:^mozilla/lib/libmime/.*$:) {return '76';}
if (m:^mozilla/network/.*$:) {return '77';}
if (m:^mozilla/nsprpub/.*$:) {return '78';}
if (m:^mozilla/lib/libpics/.*$:) {return '80';}
if (m:^mozilla/modules/plugin/.*$:) {return '81';}
if (m:^mozilla/modules/libpref/.*$:) {return '82';}
if (m:^mozilla/modules/progress/.*$:) {return '83';}
if (m:^mozilla/modules/libreg/.*$:) {return '84';}
if (m:^mozilla/modules/security/.*$:) {return '86';}
if (m:^mozilla/modules/softupdt/.*$:) {return '87';}
if (m:^mozilla/expat/.*$:) {return '88';}
if (m:^mozilla/xpcom/.*$:) {return '89';}
if (m:^mozilla/include/shist\.h/.*$:) {return '91';}
if (m:^mozilla/lib/libmisc/.*$:) {return '91';}
if (m:^mozilla/modules/zlib/.*$:) {return '93';}
if (m:^mozilla/base/.*$:) {return '94';}
if (m:^mozilla/view/.*$:) {return '96';}
if (m:^mozilla/layout/.*$:) {return '98';}
if (m:^mozilla/webshell/.*$:) {return '101';}
if (m:^mozilla/htmlparser/.*$:) {return '102';}
if (m:^mozilla/dom/.*$:) {return '103';}
if (m:^mozilla/js/tests$:) {return '114';}
if (m:^js/src/perlconnect$:) {return '111';}
if (m:^mozilla/silentdl/.*$:) {return '110';}
if (m:^base/src/photon/.*$:) {return '113';}
if (m:^gfx/src/photon/.*$:) {return '113';}
if (m:^widget/src/photon/.*$:) {return '113';}
if (m:^mozilla/xpfe$:) {return '105';}
if (m:^mozilla/profile$:) {return '120';}
if (m:^mozilla/tools/.*$:) {return '112';}
if (m:^xpcom/typelib$:) {return '117';}
if (m:^js/src/xpconnect$:) {return '118';}
if (m:^xpcom/reflect/xptcall$:) {return '118';}
if (m:^xpcom/reflect/xptinfo$:) {return '118';}
}
return '';
}
$debug = 0;
$origrepository = shift(@ARGV);
@files = @ARGV;
$envcvsroot = $ENV{'CVSROOT'};
open( REP, "<CVS/Repository");
$repository = <REP>;
chop($repository);
close(REP);
$repository =~ s:^$envcvsroot/::;
$doit = 0;
$| = 1;
if( $debug){
print STDERR "----------------------------------------------\n";
print STDERR "files: @files\n";
print STDERR "origrepository: $origrepository\n";
print STDERR " repository: $repository\n";
print STDERR "----------------------------------------------\n";
}
open(ENT, "<CVS/Entries" );
while( <ENT> ){
chop;
($d,$fn,$rev,$mod_time,$sticky,$tag) = split(/\//);
if ($tag =~ /^T(.*)$/) {
$fbranch{$fn} = $1;
}
}
close ENT;
foreach $f (@files) {
$b = "";
if (defined $fbranch{$f}) {$b = $fbranch{$f};}
if ($b eq "") {$b = "HEAD";}
$t = GetT($b, "$repository/$f");
if ($debug) {
print STDERR "GetT returned '$t' for '$repository/$f' branch '$b'\n";
}
if ($t eq "") {
$t = $defaultid;
}
if (!defined $mode{$t} || $mode{$t} eq "Open") {
next;
}
if ($debug) {
print STDERR "Checking twig $t\n";
}
# OK, we have a match. See if we're allowed to checkin here.
if ($username eq "") {
$username = $ENV{"CVS_USER"} || getlogin || (getpwuid($<))[0] || "nobody";
if ($debug) {
print STDERR "Username is $username\n";
print STDERR "getlogin returns " . getlogin . "\n";
print STDERR '(getpwuid($<))[0] returns ' . (getpwuid($<))[0] . "\n";
print STDERR "Environment:\n";
foreach $key (sort(keys %ENV)) {
print STDERR $key, '=', $ENV{$key}, "\n";
}
}
}
$ok = 0;
$s = $super{$t};
foreach $u (@$s) {
if ($debug) {
print STDERR "Checking against super $u\n";
}
if ($u eq $username) {
$ok = 1;
break;
}
}
if ($mode{$t} eq "Restricted") {
my $b = $blessed{$t};
foreach $u (@$b) {
if ($debug) {
print STDERR "Checking against blessed $u\n";
}
if ($u eq $username) {
$ok = 1;
break;
}
}
}
if (!$ok) {
print STDERR "You may not check into partition $fullname{$t}\n";
print STDERR "the file $repository/$f on branch $b\n";
print STDERR "If you think you should be allowed to, send mail to\n";
print STDERR "one of the below people:\n";
$s = $super{$t};
foreach $u (@$s) {
$u =~ s/%/@/;
print STDERR " $u\n";
}
exit 1;
}
}
exit 0;

16
CVSROOT/commitinfo
View File

@ -1,16 +0,0 @@
# The "commitinfo" file is used to control pre-commit checks.
# The filter on the right is invoked with the repository and a list
# of files to check. A non-zero exit of the filter program will
# cause the commit to be aborted.
#
# The first entry on a line is a regular expression which is tested
# against the directory that the change is being committed to, relative
# to the $CVSROOT. For the first match that is found, then the remainder
# of the line is the name of the filter to run.
#
# If the repository name does not match any of the regular expressions in this
# file, the "DEFAULT" line is used, if it is specified.
#
# If the name "ALL" appears as a regular expression it is always used
# in addition to the first matching regex or "DEFAULT".
ALL $CVSROOT/CVSROOT/commitcheck.pl

6
CVSROOT/config
View File

@ -1,6 +0,0 @@
# Set this to "no" if pserver shouldn't check system users/passwords
#SystemAuth=no
# Set `PreservePermissions' to `yes' to save file status information
# in the repository.
#PreservePermissions=no

32
CVSROOT/cvsignore
View File

@ -1,32 +0,0 @@
.gdbinit
.HSancillary
.Makedepend
.makedepend
.MCC_Cache_FAT
.MCC_Global_History
.md
.pure
made
make.log
make.dep
nuke
_jmc
*.class
.depends
.deps
.d
manifest.mnw
_gen
_stubs
*_DBG.OBJ
*_DBG_EDT.OBJ
*_OPT.OBJ
*_OPT_EDT.OBJ
*_DBG.OBJD
so_locations
*.flc
*.map
depend.mk
_xpidlgen
ti_files
*.rpo

24
CVSROOT/cvsmailfilter
View File

@ -1,24 +0,0 @@
#!/bin/sh
PATH=/bin:/usr/bin:/sbin:/usr/sbin;export PATH
(
URL="subdir=`dirname $1`&files=`basename $1`"
echo "Subject: $1"
echo 'Content-Type: text/html; charset=us-ascii'
echo 'Content-Transfer-Encoding: 7bit'
echo 'Content-Disposition: inline'
TMP=/tmp/cvsmf.$$
trap "rm -f $TMP" 0 1 2 15
cat > $TMP
BRANCH=`sed -n 's@^Revision/Branch: \(.*\)@\1@p' $TMP`
if test -n "$BRANCH"; then
URL="$URL&branch=$BRANCH"
fi
echo '<A HREF="http://warp.netscape.com/webtools/bonsai/cvsview2.cgi?'$URL'&command=DIRECTORY">View differences</A><BR>\n'
) | mail $2

145
CVSROOT/cvsmailfilter.pl
View File

@ -1,145 +0,0 @@
#! /tools/ns/bin/perl5.004
# -*- Mode: perl; indent-tabs-mode: nil -*-
# Arguments:
#
# -u <url> Base URL for the Bonsai directory; "/cvsview2.cgi" will get
# appended to this with appropriate args.
# -h <hostname> Host whose SMTP server we will contact to send mail.
# -s <string> String specifying dir and filenames. As generated by "%s"
# in a CVSROOT/loginfo file
# -f <file> A regexp. If present, then only checkins to files whose
# name (without the directory) matches the regexp will generate mail.
#
# The remaining args are email addresses of people who should get notified.
use Socket;
sub get_response_code {
my ($expecting) = @_;
# if ($flag_debug) {
# print STDERR "SMTP: Waiting for code $expecting\n";
# }
while (1) {
my $line = <S>;
# if ($flag_debug) {
# print STDERR "SMTP: $line";
# }
if ($line =~ /^[0-9]*-/) {
next;
}
if ($line =~ /(^[0-9]*) /) {
my $code = $1;
if ($code == $expecting) {
# if ($flag_debug) {
# print STDERR "SMTP: got it.\n";
# }
return;
}
die "Bad response from SMTP -- $line";
}
}
}
my $debug = 0;
my $mailhost = "127.0.0.1";
my $urlbase = "";
my $cvsargs = "";
my $cvsroot = "";
my @mailto;
my $fileregexp = "";
while (@ARGV) {
my $arg = shift @ARGV;
if ($arg eq '-d') {
$debug = 1;
print STDERR "Debug turned on...\n";
} elsif ($arg eq '-r') {
$cvsroot = shift @ARGV;
} elsif ($arg eq '-h') {
$mailhost = shift @ARGV;
} elsif ($arg eq '-u') {
$urlbase = shift @ARGV;
} elsif ($arg eq '-s') {
$cvsargs = shift @ARGV;
} elsif ($arg eq '-f') {
$fileregexp = shift @ARGV;
} else {
push(@mailto, $arg);
}
}
my $url = "";
if ($urlbase ne "" && $cvsargs ne "") {
my @list = split(/ /, $cvsargs);
my $dir = shift @list;
if ($fileregexp ne "") {
if (grep(m/$fileregexp/, @list) <= 0) {
exit;
}
}
$url = $urlbase . "/cvsview2.cgi?command=DIRECTORY&subdir=$dir&files=" .
join('+', @list);
}
my $message = "";
while (<>) {
my $line = $_;
if ($line =~ m@^Revision/Branch: (.*)$@) {
if ($url ne "") {
$url .= "&branch=$1";
}
}
$message .= $line;
}
if ($url ne "") {
if ($cvsroot ne "") {
$url .= "&root=$cvsroot";
}
$message = "Diffs: $url\n\n" . $message;
}
chop(my $hostname = `hostname`);
my ($remote,$port, $iaddr, $paddr, $proto, $line);
$remote = $mailhost;
$port = 25;
if ($port =~ /\D/) { $port = getservbyname($port, 'tcp') }
die "No port" unless $port;
$iaddr = inet_aton($remote) || die "no host: $remote";
$paddr = sockaddr_in($port, $iaddr);
$proto = getprotobyname('tcp');
socket(S, PF_INET, SOCK_STREAM, $proto) || die "socket: $!";
connect(S, $paddr) || die "connect: $!";
select(S); $| = 1; select(STDOUT);
get_response_code(220);
print S "EHLO $hostname\n";
get_response_code(250);
print S "MAIL FROM: cvsmailfilter@$hostname\n";
get_response_code(250);
foreach $i (@mailto) {
print S "RCPT TO: $i\n";
get_response_code(250);
}
print S "DATA\n";
get_response_code(354);
print S "Subject: $cvsargs\n";
print S "\n";
print S $message . "\n";
print S ".\n";
get_response_code(250);
print S "QUIT\n";
close(S);

23
CVSROOT/cvswrappers
View File

@ -1,23 +0,0 @@
# This file affects handling of files based on their names.
#
# The -t/-f options allow one to treat directories of files
# as a single file, or to transform a file in other ways on
# its way in and out of CVS.
#
# The -m option specifies whether CVS attempts to merge files.
#
# The -k option specifies keyword expansion (e.g. -kb for binary).
#
# Format of wrapper file ($CVSROOT/CVSROOT/cvswrappers or .cvswrappers)
#
# wildcard [option value][option value]...
#
# where option is one of
# -f from cvs filter value: path to filter
# -t to cvs filter value: path to filter
# -m update methodology value: MERGE or COPY
# -k expansion mode value: b, o, kkv, &c
#
# and value is a single-quote delimited value.
# For example:
#*.gif -k 'b'

270
CVSROOT/dolog.pl
View File

@ -1,270 +0,0 @@
#! /tools/ns/bin/perl5
use Socket;
$username = $ENV{"CVS_USER"} || getlogin || (getpwuid($<))[0] || "nobody";
$envcvsroot = $ENV{'CVSROOT'};
$cvsroot = $envcvsroot;
$flag_debug = 0;
$flag_tagcmd = 0;
$repository = '';
$repository_tag = '';
$mailhost = 'localhost';
@mailto=();
@changed_files = ();
@added_files = ();
@removed_files = ();
@log_lines = ();
@outlist = ();
$STATE_NONE = 0;
$STATE_CHANGED = 1;
$STATE_ADDED = 2;
$STATE_REMOVED = 3;
$STATE_LOG = 4;
&process_args;
if ($flag_debug ){
print STDERR "----------------------------------------------\n";
print STDERR "LOGINFO:\n";
print STDERR " pwd:" . `pwd` . "\n";
print STDERR " Args @ARGV\n";
print STDERR " CVSROOT: $cvsroot\n";
print STDERR " who: $username\n";
print STDERR " Repository: $repository\n";
print STDERR " mailto: @mailto\n";
print STDERR "----------------------------------------------\n";
}
if ($flag_tagcmd) {
&process_tag_command;
} else {
&get_loginfo;
&process_cvs_info;
}
if( $flag_debug){
print STDERR "----------------------------------------------\n";
print STDERR @outlist;
print STDERR "----------------------------------------------\n";
}
&mail_notification;
0;
sub process_args {
while (@ARGV) {
$arg = shift @ARGV;
if ($arg eq '-d') {
$flag_debug = 1;
print STDERR "Debug turned on...\n";
} elsif ($arg eq '-r') {
$cvsroot = shift @ARGV;
} elsif ($arg eq '-t') {
$flag_tagcmd = 1;
last; # Keep the rest in ARGV; they're handled later.
} elsif ($arg eq '-h') {
$mailhost = shift @ARGV;
} else {
push(@mailto, $arg);
}
}
if( $repository eq '' ){
open( REP, "<CVS/Repository");
$repository = <REP>;
chop($repository);
close(REP);
}
$repository =~ s:^$cvsroot/::;
$repository =~ s:^$envcvsroot/::;
if (!$flag_tagcmd) {
if( open( REP, "<CVS/Tag") ) {
$repository_tag = <REP>;
chop($repository_tag);
close(REP);
}
}
}
sub get_loginfo {
if( $flag_debug){
print STDERR "----------------------------------------------\n";
}
# Iterate over the body of the message collecting information.
#
while (<STDIN>) {
chop; # Drop the newline
if( $flag_debug){
print STDERR "$_\n";
}
if (/^In directory/) {
next;
}
if (/^Modified Files/) { $state = $STATE_CHANGED; next; }
if (/^Added Files/) { $state = $STATE_ADDED; next; }
if (/^Removed Files/) { $state = $STATE_REMOVED; next; }
if (/^Log Message/) { $state = $STATE_LOG; next; }
s/^[ \t\n]+//; # delete leading whitespace
s/[ \t\n]+$//; # delete trailing whitespace
if ($state == $STATE_CHANGED) { push(@changed_files, split); }
if ($state == $STATE_ADDED) { push(@added_files, split); }
if ($state == $STATE_REMOVED) { push(@removed_files, split); }
if ($state == $STATE_LOG) { push(@log_lines, $_); }
}
if( $flag_debug){
print STDERR "----------------------------------------------\n"
. "changed files: @changed_files\n"
. "added files: @added_files\n"
. "removed files: @removed_files\n";
print STDERR "----------------------------------------------\n";
}
}
sub process_cvs_info {
local($d,$fn,$rev,$mod_time,$sticky,$tag,$stat,@d,$l,$rcsfile);
if (!open(ENT, "<CVS/Entries.Log" )) {
open(ENT, "<CVS/Entries");
}
$time = time;
while( <ENT> ){
chop;
($d,$fn,$rev,$mod_time,$sticky,$tag) = split(/\//);
$stat = 'C';
for $i (@changed_files, "BEATME.NOW", @added_files ) {
if( $i eq "BEATME.NOW" ){ $stat = 'A'; }
if($i eq $fn ){
$rcsfile = "$envcvsroot/$repository/$fn,v";
if( ! -r $rcsfile ){
$rcsfile = "$envcvsroot/$repository/Attic/$fn,v";
}
open(LOG, "/tools/ns/bin/rlog -N -r$rev $rcsfile |")
|| print STDERR "dolog.pl: Couldn't run rlog\n";
while(<LOG>){
if (/^date:.* author: ([^;]*);.*/) {
$username = $1;
if (/lines: \+([0-9]*) -([0-9]*)/) {
$lines_added = $1;
$lines_removed = $2;
}
}
}
close( LOG );
push(@outlist, ("$stat|$time|$username|$cvsroot|$repository|$fn|$rev|$sticky|$tag|$lines_added|$lines_removed\n"));
}
}
}
close(ENT);
for $i (@removed_files) {
push( @outlist, ("R|$time|$username|$cvsroot|$repository|$i|||$repository_tag\n"));
}
push (@outlist, "LOGCOMMENT\n");
push (@outlist, join("\n",@log_lines));
push (@outlist, "\n:ENDLOGCOMMENT\n");
}
sub process_tag_command {
local($str,$part,$time);
$time = time;
$str = "Tag|$cvsroot|$time";
while (@ARGV) {
$part = shift @ARGV;
$str .= "|" . $part;
}
push (@outlist, ("$str\n"));
}
sub do_commitinfo {
}
sub get_response_code {
my ($expecting) = @_;
# if ($flag_debug) {
# print STDERR "SMTP: Waiting for code $expecting\n";
# }
while (1) {
my $line = <S>;
# if ($flag_debug) {
# print STDERR "SMTP: $line";
# }
if ($line =~ /^[0-9]*-/) {
next;
}
if ($line =~ /(^[0-9]*) /) {
my $code = $1;
if ($code == $expecting) {
# if ($flag_debug) {
# print STDERR "SMTP: got it.\n";
# }
return;
}
die "Bad response from SMTP -- $line";
}
}
}
sub mail_notification {
chop(my $hostname = `hostname`);
my ($remote,$port, $iaddr, $paddr, $proto, $line);
$remote = $mailhost;
$port = 25;
if ($port =~ /\D/) { $port = getservbyname($port, 'tcp') }
die "No port" unless $port;
$iaddr = inet_aton($remote) || die "no host: $remote";
$paddr = sockaddr_in($port, $iaddr);
$proto = getprotobyname('tcp');
socket(S, PF_INET, SOCK_STREAM, $proto) || die "socket: $!";
connect(S, $paddr) || die "connect: $!";
select(S); $| = 1; select(STDOUT);
get_response_code(220);
print S "EHLO $hostname\n";
get_response_code(250);
print S "MAIL FROM: bonsai-daemon@$hostname\n";
get_response_code(250);
foreach $i (@mailto) {
print S "RCPT TO: $i\n";
get_response_code(250);
}
print S "DATA\n";
get_response_code(354);
# Get one line starting with "354 ".
if ($flag_tagcmd) {
print S "Subject: cvs tag in $repository\n";
} else {
print S "Subject: cvs commit to $repository\n";
}
print S "\n";
print S @outlist, "\n";
print S ".\n";
get_response_code(250);
print S "QUIT\n";
close(S);
}

21
CVSROOT/editinfo
View File

@ -1,21 +0,0 @@
# The "editinfo" file is used to allow verification of logging
# information. It works best when a template (as specified in the
# rcsinfo file) is provided for the logging procedure. Given a
# template with locations for, a bug-id number, a list of people who
# reviewed the code before it can be checked in, and an external
# process to catalog the differences that were code reviewed, the
# following test can be applied to the code:
#
# Making sure that the entered bug-id number is correct.
# Validating that the code that was reviewed is indeed the code being
# checked in (using the bug-id number or a seperate review
# number to identify this particular code set.).
#
# If any of the above test failed, then the commit would be aborted.
#
# Actions such as mailing a copy of the report to each reviewer are
# better handled by an entry in the loginfo file.
#
# One thing that should be noted is the the ALL keyword is not
# supported. There can be only one entry that matches a given
# repository.

32
CVSROOT/loginfo
View File

@ -1,32 +0,0 @@
# The "loginfo" file controls where "cvs commit" log information
# is sent. The first entry on a line is a regular expression which must match
# the directory that the change is being made to, relative to the
# $CVSROOT. If a match is found, then the remainder of the line is a filter
# program that should expect log information on its standard input.
#
# If the repository name does not match any of the regular expressions in this
# file, the "DEFAULT" line is used, if it is specified.
#
# If the name ALL appears as a regular expression it is always used
# in addition to the first matching regex or DEFAULT.
#
# You may specify a format string as part of the
# filter. The string is composed of a `%' followed
# by a single format character, or followed by a set of format
# characters surrounded by `{' and `}' as separators. The format
# characters are:
#
# s = file name
# V = old version number (pre-checkin)
# v = new version number (post-checkin)
#
# For example:
#DEFAULT (echo ""; id; echo %s; date; cat) >> $CVSROOT/CVSROOT/commitlog
# or
#DEFAULT (echo ""; id; echo %{sVv}; date; cat) >> $CVSROOT/CVSROOT/commitlog
ALL $CVSROOT/CVSROOT/dolog.pl -h 127.0.0.1 -r /m/mozilla-mirror bonsai-new-checkin-daemon@warp.mcom.com
ALL $CVSROOT/CVSROOT/dolog.pl -h 127.0.0.1 -r /cvsroot bonsai-new-checkin-daemon@lounge.mozilla.org
# ALL $CVSROOT/CVSROOT/dolog.pl -h 127.0.0.1 -r /cvsroot bonsai@tinderbox.seawood.org
# mozilla/webtools $CVSROOT/CVSROOT/dolog.pl -h 127.0.0.1 -r /cvsroot webtools-changed@warp.mcom.com
mozilla/webtools $CVSROOT/CVSROOT/cvsmailfilter.pl -u http://cvs-mirror.mozilla.org/webtools/bonsai -r /cvsroot -s %s webtools-changed@warp.mcom.com
CVSROOT $CVSROOT/CVSROOT/cvsmailfilter.pl -u http://cvs-mirror.mozilla.org/webtools/bonsai -r /cvsroot -s %s -f modules cyeh@netscape.com sar@netscape.com leaf@netscape.com donm@netscape.com

650
CVSROOT/modules
View File

@ -1,650 +0,0 @@
# Three different line formats are valid:
# key -a aliases...
# key [options] directory
# key [options] directory files...
#
# Where "options" are composed of:
# -i prog Run "prog" on "cvs commit" from top-level of module.
# -o prog Run "prog" on "cvs checkout" of module.
# -e prog Run "prog" on "cvs export" of module.
# -t prog Run "prog" on "cvs rtag" of module.
# -u prog Run "prog" on "cvs update" of module.
# -d dir Place module in directory "dir" instead of module name.
# -l Top-level directory only -- do not recurse.
#
# NOTE: If you change any of the "Run" options above, you'll have to
# release and re-checkout any working directories of these modules.
#
# And "directory" is a path to a directory relative to $CVSROOT.
#
# The "-a" option specifies an alias. An alias is interpreted as if
# everything on the right of the "-a" had been typed on the command line.
#
# You can encode a module within a module by using the special '&'
# character to interpose another module into the current module. This
# can be useful for creating a module that consists of many directories
# spread out over the entire source repository.
######################################################################
#
# Module that contains the LEGAL and the LICENSE file. This should be
# a part of every logical source pull for a component. Care should
# be given so that this module is not specified twice for a given
# source pull.
#
MozillaLicense -a \
mozilla/LEGAL \
mozilla/LICENSE
Grendel -a \
MozillaLicense \
mozilla/grendel
######################################################################
#
# Modules for the MozillaClassic Browser, based on the original
# layout engine. If you wish to develop on the Mozilla Classic
# codebase, pull using these modules and using the branch tag
# MozillaSourceClassic_19981026_BRANCH.
# These modules should be considered obsolete.
#
MozillaSource -a \
MozillaSourceWin \
MozillaSourceMac \
MozillaSourceUnix
MozillaSourceWin -a \
MozillaSourceCommon \
MozillaSourceWinOnly
MozillaSourceMac -a \
MozillaSourceCommon \
MozillaSourceMacOnly
MozillaSourceUnix -a \
MozillaSourceCommon \
MozillaSourceUnixOnly \
mozilla/cmd/xfe \
mozilla/cmd/gnomefe \
mozilla/cmd/qtfe \
mozilla/cmd/ybfe
MozillaSourceMotif -a \
MozillaSourceCommon \
mozilla/cmd/xfe \
MozillaSourceUnixOnly
MozillaSourceQtfe -a \
MozillaSourceCommon \
mozilla/cmd/qtfe \
MozillaSourceUnixOnly
MozillaSourceGnomefe -a \
MozillaSourceCommon \
mozilla/cmd/gnomefe \
MozillaSourceUnixOnly
MozillaSourceYbfe -a \
MozillaSourceCommon \
mozilla/cmd/ybfe \
MozillaSourceUnixOnly
MozillaSourceCommon -a \
mozilla/LEGAL \
mozilla/LICENSE \
mozilla/base \
mozilla/build \
!mozilla/build/mac/client.mac \
mozilla/include \
mozilla/caps \
mozilla/jpeg \
mozilla/js \
mozilla/lib/htmldlgs \
mozilla/lib/layout \
mozilla/lib/libcnv \
mozilla/lib/libdom \
mozilla/lib/libi18n \
mozilla/lib/liblayer \
mozilla/lib/libmisc \
mozilla/lib/libmime \
mozilla/lib/libmocha \
mozilla/lib/libnet \
mozilla/lib/libparse \
mozilla/lib/libpics \
mozilla/lib/libpwcac \
mozilla/lib/libstyle \
mozilla/lib/mailto \
mozilla/lib/plugin \
mozilla/lib/xlate \
mozilla/lib/xp \
mozilla/modules/calendar \
mozilla/modules/edtplug/classes \
mozilla/modules/edtplug/src \
mozilla/modules/edtplug/include \
mozilla/modules/libfont/classes \
mozilla/modules/libfont/public \
mozilla/modules/libfont/src \
mozilla/modules/libhook \
mozilla/modules/libimg \
mozilla/modules/libnls \
mozilla/modules/libpref \
mozilla/modules/libreg \
mozilla/modules/libutil \
mozilla/modules/oji \
mozilla/modules/plugin \
mozilla/modules/progress/src \
mozilla/modules/rdf \
mozilla/modules/schedulr \
mozilla/modules/security/freenav \
mozilla/modules/softupdt/classes \
mozilla/modules/softupdt/include \
mozilla/modules/softupdt/src \
mozilla/modules/xml \
mozilla/modules/zlib/src \
mozilla/nav-java/stubs \
mozilla/network \
mozilla/nsprpub \
mozilla/privacy \
mozilla/xpcom \
mozilla/l10n \
mozilla/dbm \
mozilla/README
MozillaSourceWinOnly -a \
mozilla/client.mak \
mozilla/cmd/makefile.win \
mozilla/cmd/wincom \
mozilla/cmd/winfe \
mozilla/config \
mozilla/lib/makefile.win \
mozilla/modules/coreincl \
mozilla/modules/edtplug/makefile.win \
mozilla/makefile.win \
mozilla/modules/libfont/jmcgen \
mozilla/modules/libfont/makefile.win \
mozilla/modules/libfont/producers/makefile.win \
mozilla/modules/libfont/producers/win \
mozilla/modules/libfont/producers/win/classes \
mozilla/modules/libfont/producers/win/classes/netscape \
mozilla/modules/libfont/producers/win/classes/netscape/fonts \
mozilla/modules/libfont/producers/win/src \
mozilla/modules/makefile.win \
mozilla/modules/progress/makefile.win \
mozilla/modules/progress/public \
mozilla/modules/security/makefile.win \
mozilla/modules/softupdt/makefile.win \
mozilla/modules/zlib/makefile.win \
mozilla/nav-java/makefile.win \
JavaStubWin
MozillaSourceUnixOnly -a \
mozilla/.cvsignore \
mozilla/Makefile \
mozilla/Makefile.in \
mozilla/configure \
mozilla/configure.in \
mozilla/allmakefiles.sh \
mozilla/cmd/Makefile \
mozilla/cmd/Makefile.in \
mozilla/cmd/stubfe \
mozilla/cmd/unixfe \
mozilla/config/.cvsignore \
mozilla/config/AIX.mk \
mozilla/config/BSD_OS.mk \
mozilla/config/DGUX.mk \
mozilla/config/FreeBSD.mk \
mozilla/config/HP-UX.mk \
mozilla/config/IRIX.mk \
mozilla/config/Linux.mk \
mozilla/config/NCR.mk \
mozilla/config/NEC.mk \
mozilla/config/NEWS-OS.mk \
mozilla/config/NEXTSTEP.mk \
mozilla/config/NetBSD.mk \
mozilla/config/OSF1.mk \
mozilla/config/OpenBSD.mk \
mozilla/config/QNX.mk \
mozilla/config/Rhapsody.mk \
mozilla/config/SCOOS.mk \
mozilla/config/SINIX.mk \
mozilla/config/SunOS.mk \
mozilla/config/SunOS4.mk \
mozilla/config/SunOS5.mk \
mozilla/config/UNIXWARE.mk \
mozilla/config/common.mk \
mozilla/config/config.mk \
mozilla/config/coreconf.mk \
mozilla/config/rules.mk \
mozilla/config/Makefile \
mozilla/config/Makefile.in \
mozilla/config/autoconf.mk.in \
mozilla/config/bdate.c \
mozilla/config/bdate.pl \
mozilla/config/aboutime.pl \
mozilla/config/bsdecho.c \
mozilla/config/clobber_miss.pl \
mozilla/config/config.guess \
mozilla/config/cvsco.pl \
mozilla/config/fastcwd.pl \
mozilla/config/gtscc.c \
mozilla/config/makecopy.c \
mozilla/config/mangle.c \
mozilla/config/mantomak.c \
mozilla/config/mkdepend \
mozilla/config/mkdetect \
mozilla/config/nfspwd.pl \
mozilla/config/nodl.pl \
mozilla/config/nsinstall.c \
mozilla/config/outofdate.pl \
mozilla/config/pathsub.c \
mozilla/config/pathsub.h \
mozilla/config/pkg2dpth.pl \
mozilla/config/ports \
mozilla/config/revdepth.pl \
mozilla/config/set-timebomb.pl \
mozilla/config/sj.pl \
mozilla/lib/Makefile \
mozilla/lib/Makefile.in \
mozilla/modules/edtplug/Makefile \
mozilla/modules/edtplug/Makefile.in \
mozilla/modules/libfont/jmcgen \
mozilla/modules/libfont/Makefile \
mozilla/modules/libfont/Makefile.in \
mozilla/modules/libfont/producers/Makefile \
mozilla/modules/libfont/producers/Makefile.in \
mozilla/modules/Makefile \
mozilla/modules/Makefile.in \
mozilla/modules/progress/Makefile \
mozilla/modules/progress/Makefile.in \
mozilla/modules/progress/public \
mozilla/modules/security/Makefile \
mozilla/modules/security/Makefile.in \
mozilla/modules/softupdt/Makefile \
mozilla/modules/softupdt/Makefile.in \
mozilla/modules/zlib/Makefile \
mozilla/modules/zlib/Makefile.in \
mozilla/nav-java/Makefile \
mozilla/nav-java/Makefile.in \
mozilla/lib/mariner \
JavaStubUnix
MozillaSourceMacOnly -a \
mozilla/config/mac \
mozilla/config/bdate.pl \
mozilla/config/aboutime.pl \
mozilla/config/mac-set-timebomb.pl \
mozilla/cmd/macfe \
mozilla/lib/mac/AutoAdmin \
mozilla/lib/mac/Includes \
mozilla/lib/mac/MacMemoryAllocator \
mozilla/lib/mac/Misc \
mozilla/lib/mac/MoreFiles \
mozilla/lib/mac/NSRuntime \
mozilla/lib/mac/NSStdLib \
mozilla/lib/mac/patches \
mozilla/lib/mac/PowerPlant \
mozilla/lib/mac/UserInterface \
mozilla/modules/coreincl \
mozilla/modules/edtplug/macbuild \
mozilla/modules/libfont \
mozilla/modules/progress/macbuild \
mozilla/modules/progress/public \
mozilla/modules/softupdt/macbuild \
mozilla/modules/zlib/macbuild \
mozilla/lib/mariner \
JavaStubMac
JavaStubAll -a \
JavaStubWin \
JavaStubMac \
JavaStubUnix
JavaStubCore -a \
mozilla/sun-java/stubs/include \
mozilla/sun-java/stubs/src
JavaStubMac -a \
JavaStubCore \
mozilla/sun-java/stubs/macbuild \
mozilla/sun-java/stubs/macjri
JavaStubUnix -a \
JavaStubCore \
mozilla/sun-java/Makefile \
mozilla/sun-java/Makefile.in \
mozilla/sun-java/stubs/jri \
mozilla/sun-java/stubs/Makefile \
mozilla/sun-java/stubs/Makefile.in
JavaStubWin -a \
JavaStubCore \
mozilla/sun-java/makefile.win \
mozilla/sun-java/stubs/jri \
mozilla/sun-java/stubs/makefile.win
######################################################################
#
# Modules for the raptor layout effort. Note that raptor dist is temporary
# until raptor is integrated into the mainline build.
#
RaptorDoc -a \
mozilla/LICENSE \
mozilla/LEGAL \
mozilla/README/nglayout
RaptorDist -a \
mozilla/configure.in \
mozilla/allmakefiles.sh \
mozilla/Makefile.in \
mozilla/makefile.win \
mozilla/build \
!mozilla/build/mac/client.mac \
mozilla/caps \
mozilla/config \
mozilla/dbm \
mozilla/editor \
mozilla/include \
mozilla/intl \
mozilla/jpeg \
JSClient \
mozilla/lib/liblayer \
mozilla/lib/libpwcac \
mozilla/lib/xp \
mozilla/modules/libimg \
mozilla/modules/libjar \
mozilla/modules/libpref \
mozilla/modules/libreg \
mozilla/modules/libutil \
mozilla/modules/oji \
mozilla/modules/plugin \
mozilla/modules/security/freenav \
mozilla/modules/zlib \
mozilla/nav-java \
mozilla/network \
mozilla/nsprpub \
mozilla/rdf \
mozilla/silentdl \
mozilla/sun-java \
mozilla/xpcom
RaptorLayout -a \
mozilla/base \
mozilla/dom \
mozilla/gfx \
mozilla/expat \
mozilla/htmlparser \
mozilla/layout \
mozilla/view \
mozilla/webshell \
mozilla/widget
Raptor -a \
RaptorDoc \
RaptorDist \
RaptorLayout
RaptorWin -a \
Raptor
RaptorUnix -a \
Raptor \
mozilla/aclocal.m4 \
mozilla/nglayout.mk
RaptorMac -a \
Raptor \
mozilla/build/mac \
mozilla/cmd/macfe/applevnt \
mozilla/cmd/macfe/central \
mozilla/cmd/macfe/gui \
mozilla/cmd/macfe/include \
mozilla/cmd/macfe/pch \
mozilla/cmd/macfe/projects \
mozilla/cmd/macfe/utility \
mozilla/lib/mac/MacMemoryAllocator \
mozilla/lib/mac/Misc \
mozilla/lib/mac/MoreFiles \
mozilla/lib/mac/NSRuntime \
mozilla/lib/mac/NSStdLib \
mozilla/lib/mac/PowerPlant \
mozilla/silentdl
#####################
# An all inclusive modules for tinderbox to use
#####################
RaptorAll -a \
RaptorWin \
RaptorUnix \
RaptorMac
#######################################################################
# Modules for the Directory SDK. There are two users of the libldap
# Mozilla and the DirectorySDK. Maintained by Chuck Boatwright
# cboatwri@netscape.com
#
DirectorySDKSource -a \
DirectorySDKSourceCommon \
DirectorySDKSourceBuild
DirectorySDKSourceC -a \
mozilla/directory/ldapsdk.mak \
mozilla/directory/ldapsdk.mk \
mozilla/directory/buildsdk.txt \
mozilla/directory/Makefile \
mozilla/directory/c-sdk
DirectorySDKSourceJava -a \
mozilla/directory/buildjsdk.txt \
mozilla/directory/java-sdk
DirectorySDKSourceCommon -a \
DirectorySDKSourceC \
DirectorySDKSourceJava
DirectorySDKSourceBuild -a \
mozilla/config \
mozilla/nsprpub
PerLDAP -a \
mozilla/directory/perldap
#######################################################################
# Modules for the Messenging Server SDK. Code maintained by Prasad Yendluri
# (prasad@netscape.com)
#
MessagingSDK -a \
mozilla/msgsdk
#######################################################################
# Modules for Calendar client.
# (spider@netscape.com)
#
CalendarClient -a \
mozilla/calendar \
mozilla/modules/calendar \
mozilla/htmlparser \
mozilla/gconfig \
mozilla/gfx \
mozilla/widget \
mozilla/xpfc \
mozilla/view
#######################################################################
# Modules for the JavaScript
# (fur@netscape.com)
#
JSRef -a \
mozilla/js/src
#
# Can't pull all of js/src, because the server-style config filenames
# are illegal on some operating systems.
#
JSClient -a \
mozilla/js/Makefile.in \
mozilla/js/makefile.win \
mozilla/js/macbuild \
mozilla/js/src \
!mozilla/js/src/config \
!mozilla/js/src/editline \
!mozilla/js/src/liveconnect/config \
!mozilla/js/src/mininspr \
!mozilla/js/src/os \
!mozilla/js/src/perlconnect \
!mozilla/js/src/sh \
!mozilla/js/src/xpcom
#######################################################################
# Modules for SeaMonkey
# (5.0 Browser and 5.0 Mail/News based on nglayout)
#
# Initial wild ass guess: cyeh@netscape.com
# Second guess: mcafee@netscape.com
#
# We might want to do the platform-specific stuff like:
# SeaMonkeyCoreFoo = SeaMonkeyCore + <stuff for platform Foo>
# and so on, for each module.
#
NSPR -a \
mozilla/nsprpub
SeaMonkeyCore -a \
mozilla/.cvsignore \
mozilla/README \
mozilla/client.mk \
mozilla/client.mak \
mozilla/configure \
mozilla/configure.in \
mozilla/allmakefiles.sh \
mozilla/Makefile.in \
mozilla/makefile.win \
mozilla/aclocal.m4 \
mozilla/build \
!mozilla/build/mac/client.mac \
mozilla/caps \
mozilla/config \
mozilla/cmd/xfe/icons/icondata.h \
mozilla/dbm \
mozilla/include \
mozilla/intl \
mozilla/jpeg \
JSClient \
mozilla/lib/liblayer \
mozilla/lib/libpwcac \
mozilla/lib/mac/MacMemoryAllocator \
mozilla/lib/mac/Misc \
mozilla/lib/mac/MoreFiles \
mozilla/lib/mac/NSRuntime \
mozilla/lib/mac/NSStdLib \
mozilla/lib/mac/PowerPlant \
mozilla/lib/xp \
mozilla/modules/libimg \
mozilla/modules/libjar \
mozilla/modules/libpref \
mozilla/modules/libreg \
mozilla/modules/libutil \
mozilla/modules/oji \
mozilla/modules/plugin \
mozilla/modules/security/freenav \
mozilla/modules/zlib \
mozilla/nav-java \
mozilla/network \
mozilla/nglayout.mk \
mozilla/nsprpub \
mozilla/profile \
mozilla/rdf \
mozilla/sun-java \
mozilla/xpcom/.cvsignore \
mozilla/xpcom/Makefile.in \
mozilla/xpcom/makefile.win \
mozilla/xpcom/base \
mozilla/xpcom/build \
mozilla/xpcom/components \
mozilla/xpcom/doc \
mozilla/xpcom/ds \
mozilla/xpcom/io \
mozilla/xpcom/macbuild \
mozilla/xpcom/proxy \
mozilla/xpcom/reflect \
mozilla/xpcom/sample \
mozilla/xpcom/threads \
mozilla/xpcom/tests \
mozilla/xpcom/tools \
!mozilla/xpcom/tools/xpidl \
mozilla/xpcom/typelib \
mozilla/xpinstall \
MozillaLicense
SeaMonkeyLayout -a \
SeaMonkeyCore \
mozilla/dom \
mozilla/gfx \
mozilla/htmlparser \
mozilla/layout \
mozilla/view \
mozilla/webshell \
mozilla/widget \
mozilla/expat
SeaMonkeyXPToolKit -a \
SeaMonkeyLayout \
mozilla/cmd/macfe/applevnt \
mozilla/cmd/macfe/central \
mozilla/cmd/macfe/gui \
mozilla/cmd/macfe/include \
mozilla/cmd/macfe/pch \
mozilla/cmd/macfe/projects \
mozilla/cmd/macfe/utility \
mozilla/xpfe
SeaMonkeyBrowser -a \
mozilla/silentdl \
mozilla/editor/Makefile.in \
mozilla/editor/public \
mozilla/extensions \
SeaMonkeyXPToolKit
# This needs work!
SeaMonkeyMailNews -a \
SeaMonkeyLayout \
mozilla/mailnews
SeaMonkeyEditor -a \
SeaMonkeyBrowser \
mozilla/editor \
mozilla/mailnews
#############################################################
# This module is the whole banana, and this
# is the module that tinderbox and bonsai should
# track.
#
# Right now Editor pulls Browser which pulls XPToolKit
# which pulls Layout which pulls Core. But eventually,
# there will be more differentiation and uniqueness so
# All will need to contain more than Editor. Perhaps it
# will contain SeaMonkeyUnix, SeaMonkeyMac, SeaMonkeyWin
# et cetera, et cetera, et cetera. But that is in the
# future. --sarah
#
SeaMonkeyAll -a \
SeaMonkeyEditor
#############################################################
#
# Alexander Larsson's GTK+ widget for embedding mozilla into
# gtk applications.
#
#############################################################
GtkMozilla -a \
mozilla/webshell/embed/gtk

14
CVSROOT/notify
View File

@ -1,14 +0,0 @@
# The "notify" file controls where notifications from watches set by
# "cvs watch add" or "cvs edit" are sent. The first entry on a line is
# a regular expression which is tested against the directory that the
# change is being made to, relative to the $CVSROOT. If it matches,
# then the remainder of the line is a filter program that should contain
# one occurrence of %s for the user to notify, and information on its
# standard input.
#
# "ALL" or "DEFAULT" can be used in place of the regular expression.
#
# For example:
#ALL mail %s -s "CVS notification"
ALL $CVSROOT/CVSROOT/sendnotification.pl %s

252
CVSROOT/passwd
View File

@ -1,252 +0,0 @@
# DO NOT EDIT THIS FILE! You must instead go to http://warp/mozilla.org, and
# tweak things from there.
agulbra%troll.no:lETTiVluCyWos:cvsuser
akhil.arora%sun.com:TN1wLIB1TKJmQ:cvsuser
akkana%netscape.com:/6KEK8AoMvE26:cvsuser
alecf%netscape.com:xY/EzwiSEg43U:cvsuser
alla%lysator.liu.se:PfaCJJD7S/Vyc:cvsuser
amasri%netscape.com:lZwFesuj.knI6:cvsuser
amusil%netscape.com:WOEqI48Qb5sRw:cvsuser
andreas.otte%primus-online.de:kydQ2aAIGwhkA:cvsuser
andrew%redhat.com:Q5vhhvO.ksq/E:cvsuser
anthonyd%netscape.com:NXsj33UUPHog6:cvsuser
aoki%netscape.com:eU12jN9/L2XPw:cvsuser
arshad%netscape.com:FdntM58EL9wNI:cvsuser
atotic%netscape.com:gB8uLX/re/w76:cvsuser
av%netscape.com:fiIbkAqwtYUxg:cvsuser
beard%netscape.com:2Eed7KIBNPtL6:cvsuser
benito%netscape.com:FhdZqd0dMufZs:cvsuser
bienvenu%netscape.com:dzcEj09V1HQLg:cvsuser
bjorn%netscape.com:AXNpUjWR2SG7w:cvsuser
blipkin%netscape.com:aoT2t1E1F7rw.:cvsuser
blizzard%redhat.com:LQ5JllboZe2is:cvsuser
bobj%netscape.com:836g7PhtJ6fgE:cvsuser
braddr%puremagic.com:Tzs8cIqrzzC/I:cvsuser
brade%netscape.com:ouetdVzWLzsWs:cvsuser
brendan%netscape.com:q5aR3MqARGBMA:cvsuser
briano%netscape.com:zaJaSkn.pVbvc:cvsadm
bruce%cybersight.com:d0C.r5Tr5HCAY:cvsuser
bryce-mozilla%nextbus.com:c/0PqdhWr6GDM:cvsuser
bsharma%netscape.com:vjlb1xJC7MsAk:cvsuser
buster%netscape.com:1HDdQcbOylnkw:cvsuser
byrd%netscape.com:Nx4tVRTT0pPcE:cvsuser
cata%netscape.com:QXbqCOqTPrcs2:cvsuser
cathleen%netscape.com:Vlcba0DkNnXmA:cvsuser
cbegle%netscape.com:b27wx1.WLpEvs:cvsuser
chrisf%netscape.com:gdE0LJ9JBmaB2:cvsuser
chuang%netscape.com:fLaH9mJOJ5IE.:cvsuser
chuckb%netscape.com:i37zDOwgdHowo:cvsadm
claudius%netscape.com:sgCFTeeEj2J1U:cvsuser
cls%seawood.org:YLAr7ajnaXezg:cvsuser
cltbld%netscape.com:mla4CZgCloBSU:cvsuser
clu%netscape.com:DcMdXCk.GsnxI:cvsuser
cmanske%netscape.com:wZ2fFz6Y4JIkk:cvsuser
coop%netscape.com:7ZcX7KjDNdBGU:cvsuser
cpatrick%netscape.com:DF5FaodPgStbs:cvsuser
cyeh%netscape.com:iNnj4gHaxZYB2:cvsadm
Dale.Stansberry%Nexwarecorp.com:iFmg8YUyFSpA.:cvsuser
danda%netscape.com:9VJdsEJaBY9pU:cvsuser
danm%netscape.com:3h6FdkzmMqnyA:cvsuser
davidm%netscape.com:bc3H9S2xbteoY:cvsuser
davidmc%netscape.com:uMBAUPZHptZn.:cvsuser
dbragg%netscape.com:k34vc.FRrLRYI:cvsuser
dcone%netscape.com:dWcV1sBlGlAHU:cvsuser
ddrinan%netscape.com:U2jxjptrCGQio:cvsuser
despotdaemon%netscape.com:zJJgZOGMRo/FE:cvsadm
dfm%netscape.com:JoCJCNXM06GNs:cvsuser
dhiren%netscape.com:oGwYcygFQ2L1Y:cvsuser
dhiren%nuvomedia.com:dGhLhZY9klXXo:cvsuser
dionisio%netscape.com:3r8nWtL3w76U2:cvsuser
dmose%mozilla.org:sTIo1zYddteQc:cvsadm
don%netscape.com:BuU/Eh9Ulta5g:cvsuser
donley%tekka.wwa.com:ZdWwac/UPNyG.:cvsuser
donm%bluemartini.com:GE8t.bok/JKxI:cvsadm
dougt%netscape.com:6Dpld8jLb0Mcg:cvsuser
dp%netscape.com:jt.S0eDMnQVDo:cvsuser
drapeau%eng.sun.com:c3eJX2LEODkpI:cvsuser
driehuis%playbeing.org:BbR6IahGk6yGc:cvsuser
dshea%netscape.com:86X5a/1MA.IDo:cvsuser
ducarroz%netscape.com:B9ih04P7FDhrg:cvsuser
dveditz%netscape.com:S1X7iuOVZr0tI:cvsuser
ebb3%apple.com:cx3pnlvIifGmc:cvsuser
ebina%netscape.com:3sJ7F5oRt6v/A:cvsuser
edburns%acm.org:z7zqfOtPH9oic:cvsuser
edwin%woudt.nl:8dZB6Qv1GFw4E:cvsuser
endico%mozilla.org:yXO.M/SUdhzAc:cvsuser
erik%netscape.com:.yO3dSzx4Ixf.:cvsuser
evaughan%netscape.com:G0SdDP5pMwVew:cvsuser
eyork%netscape.com:VrUopS3iDoSJc:cvsuser
frankm%eng.sun.com:Ic2PpVScupvXg:cvsuser
freier%netscape.com:ff3KADRoprJ6I:cvsuser
friedman%netscape.com:spbzxH1g5zBi2:cvsadm
friedman%splode.com:mZ5UQ4/qb5h3E:cvsadm
ftang%netscape.com:cjA4Oe7qangyQ:cvsuser
fur%netscape.com:mYz4lGMkt02.6:cvsadm
gagan%netscape.com:aJDYc91m7tmpI:cvsuser
gayatrib%netscape.com:ELHSlB.ndtTwI:cvsuser
gbeasley%netscape.com:VpoPNXCuxW4/A:cvsuser
gem%netscape.com:penaHUSRE49SM:cvsuser
glynn%netscape.com:s/Vcskv6bKP1I:cvsuser
gordon%netscape.com:MCComT.xg8/GM:cvsuser
grail%cafebabe.org:KsBL5nzVbWFC6:cvsuser
guha%netscape.com:preQNO31mmT/Y:cvsuser
hangas%netscape.com:jKdYm.LiDEW2c:cvsuser
hardts%netscape.com:NXZ.kungSY0.g:cvsuser
harish%netscape.com:6NzUiwHrF2piQ:cvsuser
harishd%netscape.com:A0zdbDQ36sqs.:cvsuser
harrison%netscape.com:87pyepe7ggJRk:cvsuser
henrit%netscape.com:jcmMU719A.JOg:cvsuser
hoi%netscape.com:MbyE84dZhZ2jc:cvsuser
hshaw%netscape.com:/Ha1xKhxxuzIM:cvsuser
hyatt%netscape.com:/Sepj5wnpvupA:cvsuser
janc%netscape.com:qR35CNfwuC.nk:cvsuser
jar%netscape.com:EtliR6wGfxygA:cvsuser
jband%netscape.com:jc1KB4qvBDWxE:cvsuser
jdunn%netscape.com:nwle/bqcCtTMA:cvsuser
jefft%netscape.com:uEhLAvoBHSlBc:cvsuser
Jerry.Kirk%Nexwarecorp.com:iSvw9A.T6nH6w:cvsuser
jevering%netscape.com:qbV9dBT/6f6CA:cvsuser
jfrancis%netscape.com:n8gH7es/9NB6U:cvsuser
jg%netscape.com:gimPrIwXcAep2:cvsuser
jgellman%netscape.com:6JURNSBc2gPew:cvsuser
jj%netscape.com:Slemj8mwbIPao:cvsuser
John.Wilson%Nexwarecorp.com:hfzTdvMI7KleY:cvsuser
joki%netscape.com:MnZq0Nx3SCImc:cvsuser
jonas.utterstrom%vittran.norrnod.se:Yq1pP.nR9EEcY:cvsuser
jonm%netscape.com:wwKtYZbjSiNoM:cvsuser
jsun%netscape.com:coq.3Xx7ARTjs:cvsuser
jsw%netscape.com:SIElaupaBmL2E:cvsuser
jwz%mozilla.org:OdVBvbcKAZC5c:cvsuser
karnaze%netscape.com:C.H2iRqFy7CnY:cvsuser
kin%netscape.com:RexUJ7MbhHOeE:cvsuser
kipp%netscape.com:E3A/rPcOagw5.:cvsadm
kmcclusk%netscape.com:KiXYwpHlCP1nE:cvsuser
kostello%netscape.com:wyyv7J0a4TAVE:cvsuser
kristian%netscape.com:C2xmDAIePjc4k:cvsuser
larryh%netscape.com:HzwqCjpBbMmhM:cvsuser
law%netscape.com:QQU7Gc4FME9Ek:cvsuser
leaf%mozilla.org:u8bmgbEVjQQ6k:cvsadm
leaf%netscape.com:mpuxvp6/BLA02:cvsuser
leif%netscape.com:T8QO0FEdoLHd2:cvsuser
lindes%netscape.com:1U8XWEc.eozzE:cvsuser
locka%iol.ie:Odt22ztoqh7Pc:cvsuser
lpham%netscape.com:Hyg6DkfNbO4DQ:cvsuser
ltabb%netscape.com:4967GySWBBDZA:cvsuser
LuigiLira%aol.com:FN9ucTyIMYhzA:cvsuser
mahesht%netscape.com:Ir6f1vCY1i7vM:cvsuser
malmer%netscape.com:FoAPcM.Uz/pV2:cvsuser
mang%subcarrier.org:VuSc/CvF/y94A:cvsuser
martinl%netscape.com:AeYccd2rbGj7.:cvsuser
matt%netscape.com:HV1zrCvpyT7Mk:cvsuser
mcafee%netscape.com:Y/0zK7Dff2W8.:cvsadm
mccabe%netscape.com:3rKv1ZMBpeR36:cvsuser
mcmullen%netscape.com:acOnFLffmFPVE:cvsuser
Michael.Kedl%Nexwarecorp.com:/vumJNxEIWQnk:cvsuser
michaelp%meer.net:jB2yR8pV9vSN2:cvsuser
michaelp%netscape.com:66bcmtbVqkuyw:cvsuser
mike%neoplanet.com:BXgJNsh4IWFgQ:cvsuser
mike%wynholds.com:P8iDbiX0p6xzQ:cvsuser
miodrag%netscape.com:6t6mBrr0.woK6:cvsuser
mjudge%netscape.com:jBw1nVC8B7WBc:cvsuser
mlm%netscape.com:yJOMGm6lMkvAg:cvsuser
momoi%netscape.com:cTHpmapFPYprI:cvsuser
morse%netscape.com:1f8Ob4wB7JJ5I:cvsuser
msanz%netscape.com:llz7R0dXZuYhg:cvsuser
mscott%netscape.com:dHLGTClZyMWG6:cvsuser
msw%gimp.org:KB4CGqyGWzK5w:cvsuser
mtoy%netscape.com:7U9WCoU6Kauhg:cvsuser
mwelch%netscape.com:zIlUxCyR4XTng:cvsuser
namachi%netscape.com:qDMESx2IRg4m6:cvsuser
neeti%netscape.com:q2ekT3ZhwHrKg:cvsuser
nelsonb%netscape.com:5sKUWBAwkkj9k:cvsuser
newt%pobox.com:BEATMENOW:cvsuser
nhotta%netscape.com:7PCA6ZeTK24HQ:cvsuser
nisheeth%netscape.com:e69IbM7hbpN1c:cvsuser
norris%netscape.com:hbKSEw6zIzn8A:cvsuser
nsl%cybertech.apple.com:sGIRI7YDfQ2eA:cvsuser
ornduff%netscape.com:iLVI98cLr24G2:cvsuser
paquin%netscape.com:UwvbqhTlD92VQ:cvsuser
paulmac%netscape.com:Y.8e5R.tTrYj.:cvsuser
pavlov%pavlov.net:Wm/3gCaQhXNLo:cvsuser
peterl%netscape.com:8x3YXhSeI77Sc:cvsuser
petitta%netscape.com:hlSgMh.8gEOXc:cvsuser
phil%netscape.com:QUSFbaWljOXf6:cvsuser
phillip%netscape.com:sn9hFKnSuj94Q:cvsuser
pierre%netscape.com:/6xa.CBcV07tE:cvsuser
pinkerton%netscape.com:SXjRJmDJDtb1U:cvsuser
pnunn%netscape.com:VjAEnG0V6mLLY:cvsuser
pollmann%netscape.com:CB4NlijAkP2IM:cvsuser
ppandit%netscape.com:VYJl1LSaQC5dk:cvsuser
prasad%netscape.com:3ALA5FiQ3U2Ps:cvsuser
preed%verinet.com:b4eDfN0tWKiYY:cvsuser
priya%netscape.com:SiT1fy1pZ560Q:cvsuser
prusakov%netscape.com:L62HUC5opL/VM:cvsuser
pschwan%cmu.edu:ZB/jDU22iRkLE:cvsuser
putterman%netscape.com:CRfRGZi9Nrtg6:cvsuser
racham%netscape.com:G3oNVDE5uCV0o:cvsuser
radha%netscape.com:E8m/i8B0sIO5k:cvsuser
raman%netscape.com:VOcpWGKv4t/ic:cvsuser
ramiro%netscape.com:04T/4Hcs1Yr/c:cvsadm
rbs%maths.uq.edu.au:2urVlBcTziPaA:cvsuser
relliott%netscape.com:loQf9BFNFb/.M:cvsuser
repka%netscape.com:wAJzqYywvn8BU:cvsuser
rhp%netscape.com:f7mepbLzOmKn6:cvsuser
ricardob%netscape.com:lB44zzvcOCcVY:cvsuser
rickg%netscape.com:uMGnseYPj2sYI:cvsuser
rjc%netscape.com:RVRRe0F5Be03c:cvsuser
robinf%netscape.com:qsizhSBd/KLxw:cvsuser
rods%netscape.com:0IcCge9UaI6V6:cvsuser
roeber%netscape.com:OMLOrWoQVFZwQ:cvsadm
rogerl%netscape.com:EOrmrYUfmdcOk:cvsuser
rpotts%netscape.com:S0L.1Z15bd0qA:cvsuser
rth%cygnus.com:PgrJbhkbkSaXM:cvsuser
rudman%netscape.com:f4Sr79IYTY8Xc:cvsuser
saari%netscape.com:NxeVoGafqJ9S2:cvsuser
sar%netscape.com:MndAm1QiY.J4o:cvsadm
scc%netscape.com:rSANuSFML82vc:cvsuser
scullin%netscape.com:NJ/I8RQ1Nlkws:cvsuser
sdagley%netscape.com:PvYFZiRMRKuG.:cvsuser
selmer%netscape.com:0a0Zn2Mtb9RMM:cvsuser
sfraser%netscape.com:2mFWUaEqjN7lE:cvsuser
sgehani%netscape.com:6GHPo3hAIJqxg:cvsuser
shanjian%netscape.com:QB8g/ScTxKRkI:cvsuser
shaver%netscape.com:I4.grysVnENVM:cvsadm
sk%netscape.com:N.81P8Ox01.sE:cvsuser
slamm%netscape.com:KcUViF6GjKwtU:cvsuser
sman%netscape.com:gHR2VdSKyaV0Q:cvsuser
sol%netscape.com:NcyHBr55nteOw:cvsuser
spence%netscape.com:TXvWv7U1aKTfo:cvsuser
spider%netscape.com:sEOPi/ICZeJ6.:cvsuser
srilatha%netscape.com:vn.P0HO0ippg2:cvsuser
srinivas%netscape.com:S7u05VkFOtTeQ:cvsuser
sspitzer%netscape.com:JlQHq8F/C8kV6:cvsuser
ssu%netscape.com:7wD5bxYBHZeM6:cvsuser
stever%netscape.com:veCWvWkeusc5o:cvsuser
subbarao%computer.org:7JjQ.DwpYmX5U:cvsuser
sudu%netscape.com:vRlTJmCwpvYoU:cvsuser
syd%netscape.com:CUkm3PbBnrIsk:cvsuser
taek%netscape.com:7oZpC0ix52epo:cvsuser
tague%netscape.com:4kUZyqe/S5VaI:cvsuser
takacs%netscape.com:qgLCy3LuBsReg:cvsuser
talisman%anamorphic.com:KB7aseh1Ssuyg:cvsuser
tao%netscape.com:/6NoGVqWXpDC6:cvsuser
tarah%netscape.com:RY5NZCULYhagI:cvsuser
tcrowe%netscape.com:mq7wUMii.8yag:cvsuser
terry%mozilla.org:sYyehWIbexkrI:cvsadm
tgl%sss.pgh.pa.us:rr7pe1GPkjIw6:cvsuser
thom%netscape.com:if3C1jgoSESew:cvsuser
timm%netscape.com:5WvY0NY080alM:cvsuser
tomw%netscape.com:EOgwDqDZKOEVU:cvsuser
toshok%hungry.com:45BYKXpLObZ..:cvsuser
troy%netscape.com:Vr9m0vnQR52kY:cvsuser
trudelle%netscape.com:kguEx2XoA/qOQ:cvsuser
val4%cornell.edu:.MA49sSDjYK66:cvsuser
valeski%netscape.com:UQIy1R23X0tnc:cvsuser
varada%netscape.com:/PHzlvLt1d/Pk:cvsuser
vidur%netscape.com:QSvSExpE4HwEE:cvsuser
waldemar%netscape.com:hrfmZUyM.cQqw:cvsuser
waqar%netscape.com:FXqrsev4lzjX6:cvsuser
warren%netscape.com:b0lSiwRxkyoKE:cvsuser
waterson%netscape.com:UMOoIwsZgkNEM:cvsuser
wtc%netscape.com:qv4XOpmSQjJG2:cvsuser
zuperdee%penguinpowered.com:ltcWrFvUEUYTY:cvsuser

13
CVSROOT/rcsinfo
View File

@ -1,13 +0,0 @@
# The "rcsinfo" file is used to control templates with which the editor
# is invoked on commit and import.
#
# The first entry on a line is a regular expression which is tested
# against the directory that the change is being made to, relative to the
# $CVSROOT. For the first match that is found, then the remainder of the
# line is the name of the file that contains the template.
#
# If the repository name does not match any of the regular expressions in this
# file, the "DEFAULT" line is used, if it is specified.
#
# If the name "ALL" appears as a regular expression it is always used
# in addition to the first matching regex or "DEFAULT".

0
CVSROOT/readers
View File

78
CVSROOT/sendnotification.pl
View File

@ -1,78 +0,0 @@
#! /tools/ns/bin/perl5
use Socket;
sub get_response_code {
my ($expecting) = @_;
# if ($flag_debug) {
# print STDERR "SMTP: Waiting for code $expecting\n";
# }
while (1) {
my $line = <S>;
# if ($flag_debug) {
# print STDERR "SMTP: $line";
# }
if ($line =~ /^[0-9]*-/) {
next;
}
if ($line =~ /(^[0-9]*) /) {
my $code = $1;
if ($code == $expecting) {
# if ($flag_debug) {
# print STDERR "SMTP: got it.\n";
# }
return;
}
die "Bad response from SMTP -- $line";
}
}
}
my @mailto;
my $i;
foreach $i (@ARGV) {
# Deal with our "%" encoding of email addresses.
if ($i !~ /\@/) {
$i =~ s/%/\@/;
}
push(@mailto, $i);
}
chop(my $hostname = `hostname`);
my ($remote,$port, $iaddr, $paddr, $proto, $line);
$remote = $mailhost;
$port = 25;
if ($port =~ /\D/) { $port = getservbyname($port, 'tcp') }
die "No port" unless $port;
$iaddr = inet_aton($remote) || die "no host: $remote";
$paddr = sockaddr_in($port, $iaddr);
$proto = getprotobyname('tcp');
socket(S, PF_INET, SOCK_STREAM, $proto) || die "socket: $!";
connect(S, $paddr) || die "connect: $!";
select(S); $| = 1; select(STDOUT);
get_response_code(220);
print S "EHLO $hostname\n";
get_response_code(250);
print S "MAIL FROM: cvs-notify-daemon@$hostname\n";
get_response_code(250);
foreach $i (@mailto) {
print S "RCPT TO: $i\n";
get_response_code(250);
}
print S "DATA\n";
get_response_code(354);
# Get one line starting with "354 ".
print S "Subject: CVS notification\n";
print S "To: " . join(',', @mailto) . "\n";
print S "\n";
while (<STDIN>) {
print S $_;
}
print S ".\n";
get_response_code(250);
print S "QUIT\n";
close(S);

20
CVSROOT/taginfo
View File

@ -1,20 +0,0 @@
# The "taginfo" file is used to control pre-tag checks.
# The filter on the right is invoked with the following arguments:
#
# $1 -- tagname
# $2 -- operation "add" for tag, "mov" for tag -F, and "del" for tag -d
# $3 -- repository
# $4-> file revision [file revision ...]
#
# A non-zero exit of the filter program will cause the tag to be aborted.
#
# The first entry on a line is a regular expression which is tested
# against the directory that the change is being committed to, relative
# to the $CVSROOT. For the first match that is found, then the remainder
# of the line is the name of the filter to run.
#
# If the repository name does not match any of the regular expressions in this
# file, the "DEFAULT" line is used, if it is specified.
#
# If the name "ALL" appears as a regular expression it is always used
# in addition to the first matching regex or "DEFAULT".

21
CVSROOT/verifymsg
View File

@ -1,21 +0,0 @@
# The "verifymsg" file is used to allow verification of logging
# information. It works best when a template (as specified in the
# rcsinfo file) is provided for the logging procedure. Given a
# template with locations for, a bug-id number, a list of people who
# reviewed the code before it can be checked in, and an external
# process to catalog the differences that were code reviewed, the
# following test can be applied to the code:
#
# Making sure that the entered bug-id number is correct.
# Validating that the code that was reviewed is indeed the code being
# checked in (using the bug-id number or a seperate review
# number to identify this particular code set.).
#
# If any of the above test failed, then the commit would be aborted.
#
# Actions such as mailing a copy of the report to each reviewer are
# better handled by an entry in the loginfo file.
#
# One thing that should be noted is the the ALL keyword is not
# supported. There can be only one entry that matches a given
# repository.

74
buildtools/windows/batch/MOZENV.BAT
View File

@ -1,74 +0,0 @@
@echo off
rem * To set up your local build read and customize this batch file.
rem * You shouldn't have to touch anything but "set" statements
rem * Batch file contributed by Lucas Gonze (lucas@gonze.com) and
rem * Rick Ekle (rele@iconect.net)
rem * This stuff forces us to not reset the environment variables more
rem * than once. It would cause some vars to get longer than 127 chars
rem * (the longest possible batch line) to run this stuff more than once.
if "%1%" == "-force" goto skiptest
if "%MOZBUILD%" == "ALREADYDONE" goto alldone
:skiptest
echo setting up environment...
set MOZBUILD=ALREADYDONE
rem * if this isn't set properly your build will get
rem * "file './config/WIN' not found"
set MOZ_BITS=32
set MOZ_GOLD=1
set MOZ_MEDIUM=1
set NO_SECURITY=1
set NSPR20=1
rem * don't set this if you want to make an optimized release build
set MOZ_DEBUG=1
rem * set if running NT 3.51, don't set otherwise
rem * set MOZ_NT=351
rem * location of resulting executable and totally optional.
rem * If you don't set this, mozilla.exe will be generated into
rem * mozilla\cmd\winfe\mkfiles32\x86dbg (or x86rel for optimized builds)
rem * set MOZ_OUT=d:\bin
rem * top of your tree, drive letter and path, i.e. set d:\mozilla_src.
rem * The topmost directory under this should be mozilla
rem * so if you extracted zip file to z:\foo, this should be z:\foo
set MOZ_SRC=d:\moz\
rem * location of the bin directory containing your GNU tools. The build
rem * looks for MOZ_TOOLS\bin\gmake.exe, so after you download and unpack
rem * wintools.zip, make some directory called "bin", put your new
rem * uname.exe, shmsdos.exe, and gmake.exe in it, and set MOZ_TOOLS to
rem * the place where you put it.
set MOZ_TOOLS=d:
rem * where to find cp.exe and rm.exe, aka gnu tools for windows
set gnuTools=D:\CDK\H-I386~1\bin
rem * the important thing is that your new moz tools should be first
SET PATH=%MOZ_TOOLS%\bin;%gnuTools%;%PATH%
rem * if you are running VC++ 5.0 or higher, this will prevent the build
rem * from trying to pick up uuid2.lib, which only exists in previous
rem * versions of vc++.
set _MSC_VER=1100
rem * vcvars32.bat is created by visual c++ install to
rem * enable command line builds
echo setting up visual c++ environment...
call d:\bin\vcvars32.bat
:alldone
@echo environment set up, building mozilla...
rem * uncomment these to make the script build as well
rem cd %MOZ_SRC%
rem cd mozilla
rem nmake -f client.mak

26
buildtools/windows/bin/README
View File

@ -1,26 +0,0 @@
Building NSPR on Windows NT Using Netscape's gmake and Other Tools
This directory contains the following tools:
- gmake.exe: GNU make 3.74, modified to use shmsdos.exe as the shell
- shmsdos.exe: a lightweight shell developed by Netscape programmers.
It has most of the file manipulation operations (such as cp,
rm, mkdir as well as Netscape's own nsinstall) as built-in
commands, so even if you have these
file utilities installed on your NT machine, they won't be invoked
by gmake and shmsdos. Also, since shmsdos is not a full-blown
shell and its built-in file commands are not fully compatible
with the true Unix file utilities, our makefiles have had to
avoid some features of sh and work around the incompatibilities
on Windows NT.
- uname.exe: this uname.exe returns the OS as "WINNT", which is what
our makefiles assume. Do not use a uname.exe that returns other
strings, such as "Windows_NT".
Binaries for the x86 processors can be found in the 'x86' subdirectory.
Binaries for the alpha processors can be found in the 'alpha'
subdirectory.
INSTALLATION:
Install gmake.exe, shmsdos.exe, and uname.exe in any directory.
Add that directory to your Path environment variable.

BIN
buildtools/windows/bin/alpha/gmake.exe
View File

Binary file not shown.

BIN
buildtools/windows/bin/alpha/nsinstall.exe
View File

Binary file not shown.

BIN
buildtools/windows/bin/alpha/shmsdos.exe
View File

Binary file not shown.

BIN
buildtools/windows/bin/alpha/uname.exe
View File

Binary file not shown.

BIN
buildtools/windows/bin/x86/glib-1.2.dll
View File

Binary file not shown.

BIN
buildtools/windows/bin/x86/gmake.exe
View File

Binary file not shown.

BIN
buildtools/windows/bin/x86/gmodule-1.2.dll
View File

Binary file not shown.

BIN
buildtools/windows/bin/x86/gthread-1.2.dll
View File

Binary file not shown.

BIN
buildtools/windows/bin/x86/libIDL-0.6.dll
View File

Binary file not shown.

BIN
buildtools/windows/bin/x86/nsinstall.exe
View File

Binary file not shown.

BIN
buildtools/windows/bin/x86/shmsdos.exe
View File

Binary file not shown.

BIN
buildtools/windows/bin/x86/uname.exe
View File

Binary file not shown.

107
buildtools/windows/include/acconfig.h
View File

@ -1,107 +0,0 @@
/* GLIB - Library of useful routines for C programming
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
/* acconfig.h
This file is in the public domain.
Descriptive text for the C preprocessor macros that
the distributed Autoconf macros can define.
No software package will use all of them; autoheader copies the ones
your configure.in uses into your configuration header file templates.
The entries are in sort -df order: alphabetical, case insensitive,
ignoring punctuation (such as underscores). Although this order
can split up related entries, it makes it easier to check whether
a given entry is in the file.
Leave the following blank line there!! Autoheader needs it. */
/* Other stuff */
#undef ENABLE_MEM_CHECK
#undef ENABLE_MEM_PROFILE
#undef G_COMPILED_WITH_DEBUGGING
#undef G_THREADS_ENABLED
#undef GLIB_SIZEOF_GMUTEX
#undef GLIB_BYTE_CONTENTS_GMUTEX
#undef HAVE_BROKEN_WCTYPE
#undef HAVE_DOPRNT
#undef HAVE_FLOAT_H
#undef HAVE_GETPWUID_R
#undef HAVE_GETPWUID_R_POSIX
#undef HAVE_LIMITS_H
#undef HAVE_LONG_DOUBLE
#undef HAVE_POLL
#undef HAVE_PTHREAD_GETSPECIFIC_POSIX
#undef HAVE_PWD_H
#undef HAVE_SYS_PARAM_H
#undef HAVE_SYS_POLL_H
#undef HAVE_SYS_SELECT_H
#undef HAVE_SYS_TIME_H
#undef HAVE_SYS_TIMES_H
#undef HAVE_STRERROR
#undef HAVE_STRSIGNAL
#undef HAVE_UNISTD_H
#undef HAVE_VALUES_H
#undef HAVE_WCHAR_H
#undef HAVE_WCTYPE_H
#undef NO_FD_SET
#undef NO_SYS_ERRLIST
#undef NO_SYS_SIGLIST
#undef NO_SYS_SIGLIST_DECL
#undef WITH_SYMBOL_UNDERSCORE
#undef SIZEOF_CHAR
#undef SIZEOF_SHORT
#undef SIZEOF_LONG
#undef SIZEOF_INT
#undef SIZEOF_VOID_P
#undef G_VA_COPY
#undef G_VA_COPY_AS_ARRAY
#undef G_HAVE___INLINE
#undef G_HAVE___INLINE__
#undef G_HAVE_INLINE
#undef GLIB_MAJOR_VERSION
#undef GLIB_MINOR_VERSION
#undef GLIB_MICRO_VERSION
#undef GLIB_INTERFACE_AGE
#undef GLIB_BINARY_AGE
#undef WIN32
#undef NATIVE_WIN32
#undef G_THREAD_SOURCE
/* #undef PACKAGE */
/* #undef VERSION */
/* Leave that blank line there!! Autoheader needs it.
If you're adding to this file, keep in mind:
The entries are in sort -df order: alphabetical, case insensitive,
ignoring punctuation (such as underscores). */

138
buildtools/windows/include/config.h
View File

@ -1,138 +0,0 @@
/* config.h.win32. Handcrafted for Microsoft C */
/* Define to empty if the keyword does not work. */
/* #undef const */
/* Define if you don't have vprintf but do have _doprnt. */
/* #undef HAVE_DOPRNT */
/* Define if you have <unistd.h>. */
/* #undef HAVE_UNISTD_H */
/* Define if you have the vprintf function. */
#define HAVE_VPRINTF 1
/* Define if you have the ANSI C header files. */
#define STDC_HEADERS 1
/* Define if your processor stores words with the most significant
byte first (like Motorola and SPARC, unlike Intel and VAX). */
/* #undef WORDS_BIGENDIAN */
/* #undef ENABLE_MEM_CHECK */
/* #undef ENABLE_MEM_PROFILE */
#define G_COMPILED_WITH_DEBUGGING "minimum"
/* #undef HAVE_BROKEN_WCTYPE */
/* #undef HAVE_DOPRNT */
#define HAVE_FLOAT_H 1
#define HAVE_LIMITS_H 1
/* #undef HAVE_LOCALTIME_R */
/* #undef HAVE_LONG_DOUBLE */
/* #undef HAVE_POLL */
/* #undef HAVE_PWD_H */
/* #undef HAVE_SYS_PARAM_H */
/* #undef HAVE_SYS_POLL_H */
/* #undef HAVE_SYS_SELECT_H */
/* #undef HAVE_SYS_TIME_H */
/* #undef HAVE_SYS_TIMES_H */
#define HAVE_STRERROR 1
/* #undef HAVE_STRSIGNAL */
/* #undef HAVE_UNISTD_H */
/* #undef HAVE_VSNPRINTF */
/* #undef HAVE_VALUES_H */
#define HAVE_VPRINTF 1
#define HAVE_WCHAR_H 1
#define HAVE_WCTYPE_H 1
/* #undef NO_FD_SET */
/* #undef NO_SYS_ERRLIST */
#define NO_SYS_SIGLIST 1
/* #undef G_VA_COPY */
/* #undef G_VA_COPY_AS_ARRAY */
#define G_HAVE___INLINE 1
#define GLIB_MAJOR_VERSION 1
#define GLIB_MINOR_VERSION 2
#define GLIB_MICRO_VERSION 0
#define GLIB_INTERFACE_AGE 0
#define GLIB_BINARY_AGE 0
#define G_THREAD_SOURCE "gthread-posix.c"
#define G_THREADS_IMPL_POSIX
#define HAVE_PTHREAD_GETSPECIFIC_POSIX 1
/* The number of bytes in a char. */
#define SIZEOF_CHAR 1
/* The number of bytes in a int. */
#define SIZEOF_INT 4
/* The number of bytes in a long. */
#define SIZEOF_LONG 4
/* The number of bytes in a long long. */
#define SIZEOF_LONG_LONG 8
/* The number of bytes in a short. */
#define SIZEOF_SHORT 2
/* The number of bytes in a void *. */
#define SIZEOF_VOID_P 4
/* Define if you have the atexit function. */
#define HAVE_ATEXIT 1
/* Define if you have the lstat function. */
/* #undef HAVE_LSTAT */
/* Define if you have the memmove function. */
#define HAVE_MEMMOVE 1
/* Define if you have the on_exit function. */
/* #undef HAVE_ON_EXIT */
/* Define if you have the strcasecmp function. */
/* #undef HAVE_STRCASECMP ^*/
/* Define if you have the strerror function. */
#define HAVE_STRERROR 1
/* Define if you have the strsignal function. */
/* #undef HAVE_STRSIGNAL */
/* Define if you have the vsnprintf function. */
/* #undef HAVE_VSNPRINTF */
/* Define if you have the <float.h> header file. */
#define HAVE_FLOAT_H 1
/* Define if you have the <limits.h> header file. */
#define HAVE_LIMITS_H 1
/* Define if you have the <pwd.h> header file. */
/* #undef HAVE_PWD_H */
/* Define if you have the <sys/param.h> header file. */
/* #undef HAVE_SYS_PARAM_H */
/* Define if you have the <sys/select.h> header file. */
/* #undef HAVE_SYS_SELECT_H */
/* Define if you have the <sys/time.h> header file. */
/* #undef HAVE_SYS_TIME_H */
/* Define if you have the <sys/times.h> header file. */
/* #undef HAVE_SYS_TIMES_H */
/* Define if you have the <unistd.h> header file. */
/* #undef HAVE_UNISTD_H */
/* Define if you have the <values.h> header file. */
/* #undef HAVE_VALUES_H */
/* Define if you have the w library (-lw). */
/* #undef HAVE_LIBW */

2786
buildtools/windows/include/glib.h
View File

File diff suppressed because it is too large Load Diff

173
buildtools/windows/include/glibconfig.h
View File

@ -1,173 +0,0 @@
/* glibconfig.h.win32 */
/* Handcrafted for Microsoft C. */
#ifndef GLIBCONFIG_H
#define GLIBCONFIG_H
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#ifdef _MSC_VER
/* Make MSVC more pedantic, this is a recommended pragma list
* from _Win32_Programming_ by Rector and Newcomer.
*/
#pragma warning(error:4002)
#pragma warning(error:4003)
#pragma warning(1:4010)
#pragma warning(error:4013)
#pragma warning(1:4016)
#pragma warning(error:4020)
#pragma warning(error:4021)
#pragma warning(error:4027)
#pragma warning(error:4029)
#pragma warning(error:4033)
#pragma warning(error:4035)
#pragma warning(error:4045)
#pragma warning(error:4047)
#pragma warning(error:4049)
#pragma warning(error:4053)
#pragma warning(error:4071)
#pragma warning(disable:4101)
#pragma warning(error:4150)
#pragma warning(disable:4244) /* No possible loss of data warnings */
#pragma warning(disable:4305) /* No truncation from int to char warnings */
#endif /* _MSC_VER */
#include <limits.h>
#include <float.h>
#define G_MINFLOAT FLT_MIN
#define G_MAXFLOAT FLT_MAX
#define G_MINDOUBLE DBL_MIN
#define G_MAXDOUBLE DBL_MAX
#define G_MINSHORT SHRT_MIN
#define G_MAXSHORT SHRT_MAX
#define G_MININT INT_MIN
#define G_MAXINT INT_MAX
#define G_MINLONG LONG_MIN
#define G_MAXLONG LONG_MAX
typedef signed char gint8;
typedef unsigned char guint8;
typedef signed short gint16;
typedef unsigned short guint16;
typedef signed int gint32;
typedef unsigned int guint32;
#define G_HAVE_GINT64 1
typedef __int64 gint64;
typedef unsigned __int64 guint64;
#define G_GINT64_CONSTANT(val) (val##i64)
#define GPOINTER_TO_INT(p) ((gint)(p))
#define GPOINTER_TO_UINT(p) ((guint)(p))
#define GINT_TO_POINTER(i) ((gpointer)(i))
#define GUINT_TO_POINTER(u) ((gpointer)(u))
#define g_ATEXIT(proc) (atexit (proc))
#define g_memmove(d,s,n) G_STMT_START { memmove ((d), (s), (n)); } G_STMT_END
#define G_HAVE_ALLOCA 1
#define alloca _alloca
#define GLIB_MAJOR_VERSION 1
#define GLIB_MINOR_VERSION 2
#define GLIB_MICRO_VERSION 0
#ifdef __cplusplus
#define G_HAVE_INLINE 1
#else /* !__cplusplus */
#define G_HAVE___INLINE 1
#endif
#define G_THREADS_ENABLED
/*
* The following program can be used to determine the magic values below:
* #include <stdio.h>
* #include <pthread.h>
* main(int argc, char **argv)
* {
* int i;
* pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
* printf ("sizeof (pthread_mutex_t) = %d\n", sizeof (pthread_mutex_t));
* printf ("PTHREAD_MUTEX_INITIALIZER = ");
* for (i = 0; i < sizeof (pthread_mutex_t); i++)
* printf ("%u, ", (unsigned) ((char *) &m)[i]);
* printf ("\n");
* exit(0);
* }
*/
typedef struct _GStaticMutex GStaticMutex;
struct _GStaticMutex
{
struct _GMutex *runtime_mutex;
union {
/* The size of the pad array should be sizeof (pthread_mutext_t) */
/* This value corresponds to the 1999-01-24 version of pthreads-win32 */
char pad[36];
double dummy_double;
void *dummy_pointer;
long dummy_long;
} aligned_pad_u;
};
/* This should be NULL followed by the bytes in PTHREAD_MUTEX_INITIALIZER */
#define G_STATIC_MUTEX_INIT { NULL, { { 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } }
#define g_static_mutex_get_mutex(mutex) \
(g_thread_use_default_impl ? ((GMutex*) &((mutex)->aligned_pad_u)) : \
g_static_mutex_get_mutex_impl (&((mutex)->runtime_mutex)))
#define G_BYTE_ORDER G_LITTLE_ENDIAN
#define GINT16_TO_LE(val) ((gint16) (val))
#define GUINT16_TO_LE(val) ((guint16) (val))
#define GINT16_TO_BE(val) ((gint16) GUINT16_SWAP_LE_BE (val))
#define GUINT16_TO_BE(val) (GUINT16_SWAP_LE_BE (val))
#define GINT32_TO_LE(val) ((gint32) (val))
#define GUINT32_TO_LE(val) ((guint32) (val))
#define GINT32_TO_BE(val) ((gint32) GUINT32_SWAP_LE_BE (val))
#define GUINT32_TO_BE(val) (GUINT32_SWAP_LE_BE (val))
#define GINT64_TO_LE(val) ((gint64) (val))
#define GUINT64_TO_LE(val) ((guint64) (val))
#define GINT64_TO_BE(val) ((gint64) GUINT64_SWAP_LE_BE (val))
#define GUINT64_TO_BE(val) (GUINT64_SWAP_LE_BE (val))
#define GLONG_TO_LE(val) ((glong) GINT32_TO_LE (val))
#define GULONG_TO_LE(val) ((gulong) GUINT32_TO_LE (val))
#define GLONG_TO_BE(val) ((glong) GINT32_TO_BE (val))
#define GULONG_TO_BE(val) ((gulong) GUINT32_TO_BE (val))
#define GINT_TO_LE(val) ((gint) GINT32_TO_LE (val))
#define GUINT_TO_LE(val) ((guint) GUINT32_TO_LE (val))
#define GINT_TO_BE(val) ((gint) GINT32_TO_BE (val))
#define GUINT_TO_BE(val) ((guint) GUINT32_TO_BE (val))
#define GLIB_SYSDEF_POLLIN = 1
#define GLIB_SYSDEF_POLLOUT = 4
#define GLIB_SYSDEF_POLLPRI = 2
#define GLIB_SYSDEF_POLLERR = 8
#define GLIB_SYSDEF_POLLHUP = 16
#define GLIB_SYSDEF_POLLNVAL = 32
#define G_HAVE_WCHAR_H 1
#define G_HAVE_WCTYPE_H 1
/* Define if this is Win32, possibly using the Cygwin emulation layer. */
#define WIN32 1
/* Define if this is Win32 without Cygwin. */
#define NATIVE_WIN32 1
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* GLIBCONFIG_H */

827
buildtools/windows/include/libIDL/IDL.h
View File

@ -1,827 +0,0 @@
/**************************************************************************
IDL.h (IDL parse tree and namespace components)
Include wide character support before this, if necessary.
Copyright (C) 1998, 1999 Andrew T. Veliath
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
$Id: IDL.h,v 1.1 1999-04-08 20:04:26 mccabe%netscape.com Exp $
***************************************************************************/
#ifndef __IDL_H
#define __IDL_H
#include <glib.h>
#ifdef __cplusplus
extern "C" {
#endif
/* version */
#define LIBIDL_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))
#define LIBIDL_MAJOR_VERSION 0
#define LIBIDL_MINOR_VERSION 6
#define LIBIDL_MICRO_VERSION 3
#define LIBIDL_VERSION_CODE LIBIDL_VERSION(0,6,3)
/* miscellaneous constants */
#define IDL_SUCCESS 0
#define IDL_ERROR 1
#define IDL_WARNING1 2
#define IDL_WARNING2 3
#define IDL_WARNING3 4
#define IDL_WARNINGMAX IDL_WARNING3
/* general parse flags */
#define IDLF_VERBOSE (1UL << 0)
#define IDLF_NO_EVAL_CONST (1UL << 1)
#define IDLF_COMBINE_REOPENED_MODULES (1UL << 2)
#define IDLF_PREFIX_FILENAME (1UL << 3)
#define IDLF_IGNORE_FORWARDS (1UL << 4)
#define IDLF_PEDANTIC (1UL << 5)
/* syntax extension parse flags */
#define IDLF_TYPECODES (1UL << 16)
#define IDLF_XPIDL (1UL << 17)
/* declaration specification flags */
#define IDLF_DECLSPEC_EXIST (1UL << 0)
#define IDLF_DECLSPEC_INHIBIT (1UL << 1)
/* output flags */
#define IDLF_OUTPUT_NO_NEWLINES (1UL << 0)
#define IDLF_OUTPUT_NO_QUALIFY_IDENTS (1UL << 1)
#define IDLF_OUTPUT_PROPERTIES (1UL << 2)
#define IDLF_OUTPUT_CODEFRAGS (1UL << 3)
#ifdef _WIN32
# define IDL_EXPORT __declspec (dllexport)
# define IDL_IMPORT __declspec (dllimport)
#else
# define IDL_EXPORT /* empty */
# define IDL_IMPORT extern
#endif
/* type casting checks */
#define IDL_check_cast_enable(boolean) do { \
IDL_IMPORT int __IDL_check_type_casts; \
__IDL_check_type_casts = (boolean); \
} while (0)
#define IDL_CHECK_CAST(tree, thetype, name) \
(IDL_check_type_cast(tree, thetype, \
__FILE__, __LINE__, \
G_GNUC_PRETTY_FUNCTION)->u.name)
#ifdef G_HAVE_GINT64
# if G_MAXLONG > 0xffffffffUL
# define IDL_LL "l"
# else
# define IDL_LL "ll"
# endif
typedef gint64 IDL_longlong_t;
typedef guint64 IDL_ulonglong_t;
#else
# define IDL_LL "l"
typedef long IDL_longlong_t;
typedef unsigned long IDL_ulonglong_t;
# warning 64-bit integer type not available, using 32-bit instead
#endif /* G_HAVE_GINT64 */
typedef unsigned int IDL_declspec_t;
typedef struct _IDL_tree_node IDL_tree_node;
typedef struct _IDL_tree_node * IDL_tree;
struct _IDL_LIST {
IDL_tree data;
IDL_tree prev;
IDL_tree next;
IDL_tree _tail; /* Internal use, may not be valid */
};
#define IDL_LIST(a) IDL_CHECK_CAST(a, IDLN_LIST, idl_list)
extern IDL_tree IDL_list_new (IDL_tree data);
extern IDL_tree IDL_list_concat (IDL_tree orig,
IDL_tree append);
extern IDL_tree IDL_list_remove (IDL_tree list,
IDL_tree p);
extern int IDL_list_length (IDL_tree list);
extern IDL_tree IDL_list_nth (IDL_tree list,
int n);
struct _IDL_GENTREE {
IDL_tree data;
GHashTable *siblings;
GHashTable *children;
GHashFunc hash_func;
GCompareFunc key_compare_func;
IDL_tree _import; /* Internal use, do not recurse */
char *_cur_prefix; /* Internal use */
};
#define IDL_GENTREE(a) IDL_CHECK_CAST(a, IDLN_GENTREE, idl_gentree)
extern IDL_tree IDL_gentree_new (GHashFunc hash_func,
GCompareFunc key_compare_func,
IDL_tree data);
extern IDL_tree IDL_gentree_new_sibling (IDL_tree from,
IDL_tree data);
extern IDL_tree IDL_gentree_chain_sibling (IDL_tree from,
IDL_tree data);
extern IDL_tree IDL_gentree_chain_child (IDL_tree from,
IDL_tree data);
struct _IDL_INTEGER {
IDL_longlong_t value;
};
#define IDL_INTEGER(a) IDL_CHECK_CAST(a, IDLN_INTEGER, idl_integer)
extern IDL_tree IDL_integer_new (IDL_longlong_t value);
struct _IDL_STRING {
char *value;
};
#define IDL_STRING(a) IDL_CHECK_CAST(a, IDLN_STRING, idl_string)
extern IDL_tree IDL_string_new (char *value);
struct _IDL_WIDE_STRING {
wchar_t *value;
};
#define IDL_WIDE_STRING(a) IDL_CHECK_CAST(a, IDLN_WIDE_STRING, idl_wide_string)
extern IDL_tree IDL_wide_string_new (wchar_t *value);
struct _IDL_CHAR {
char *value;
};
#define IDL_CHAR(a) IDL_CHECK_CAST(a, IDLN_CHAR, idl_char)
extern IDL_tree IDL_char_new (char *value);
struct _IDL_WIDE_CHAR {
wchar_t *value;
};
#define IDL_WIDE_CHAR(a) IDL_CHECK_CAST(a, IDLN_WIDE_CHAR, idl_wide_char)
extern IDL_tree IDL_wide_char_new (wchar_t *value);
struct _IDL_FIXED {
char *value;
};
#define IDL_FIXED(a) IDL_CHECK_CAST(a, IDLN_FIXED, idl_fixed)
extern IDL_tree IDL_fixed_new (char *value);
struct _IDL_FLOAT {
double value;
};
#define IDL_FLOAT(a) IDL_CHECK_CAST(a, IDLN_FLOAT, idl_float)
extern IDL_tree IDL_float_new (double value);
struct _IDL_BOOLEAN {
unsigned value;
};
#define IDL_BOOLEAN(a) IDL_CHECK_CAST(a, IDLN_BOOLEAN, idl_boolean)
extern IDL_tree IDL_boolean_new (unsigned value);
struct _IDL_IDENT {
char *str;
char *repo_id;
GSList *comments;
IDL_tree _ns_ref; /* Internal use, do not recurse */
unsigned _flags; /* Internal use */
#define IDLF_IDENT_CASE_MISMATCH_HIT (1UL << 0)
};
#define IDL_IDENT(a) IDL_CHECK_CAST(a, IDLN_IDENT, idl_ident)
#define IDL_IDENT_TO_NS(a) IDL_CHECK_CAST(a, IDLN_IDENT, idl_ident._ns_ref)
#define IDL_IDENT_REPO_ID(a) IDL_CHECK_CAST(a, IDLN_IDENT, idl_ident.repo_id)
extern IDL_tree IDL_ident_new (char *str);
extern void IDL_queue_new_ident_comment (const char *str);
enum IDL_float_type {
IDL_FLOAT_TYPE_FLOAT,
IDL_FLOAT_TYPE_DOUBLE,
IDL_FLOAT_TYPE_LONGDOUBLE
};
struct _IDL_TYPE_FLOAT {
enum IDL_float_type f_type;
};
#define IDL_TYPE_FLOAT(a) IDL_CHECK_CAST(a, IDLN_TYPE_FLOAT, idl_type_float)
extern IDL_tree IDL_type_float_new (enum IDL_float_type f_type);
struct _IDL_TYPE_FIXED {
IDL_tree positive_int_const;
IDL_tree integer_lit;
};
#define IDL_TYPE_FIXED(a) IDL_CHECK_CAST(a, IDLN_TYPE_FIXED, idl_type_fixed)
extern IDL_tree IDL_type_fixed_new (IDL_tree positive_int_const,
IDL_tree integer_lit);
enum IDL_integer_type {
IDL_INTEGER_TYPE_SHORT,
IDL_INTEGER_TYPE_LONG,
IDL_INTEGER_TYPE_LONGLONG
};
struct _IDL_TYPE_INTEGER {
unsigned f_signed : 1;
enum IDL_integer_type f_type;
};
#define IDL_TYPE_INTEGER(a) IDL_CHECK_CAST(a, IDLN_TYPE_INTEGER, idl_type_integer)
extern IDL_tree IDL_type_integer_new (unsigned f_signed,
enum IDL_integer_type f_type);
extern IDL_tree IDL_type_char_new (void);
extern IDL_tree IDL_type_wide_char_new (void);
extern IDL_tree IDL_type_boolean_new (void);
extern IDL_tree IDL_type_octet_new (void);
extern IDL_tree IDL_type_any_new (void);
extern IDL_tree IDL_type_object_new (void);
extern IDL_tree IDL_type_typecode_new (void);
struct _IDL_TYPE_STRING {
IDL_tree positive_int_const;
};
#define IDL_TYPE_STRING(a) IDL_CHECK_CAST(a, IDLN_TYPE_STRING, idl_type_string)
extern IDL_tree IDL_type_string_new (IDL_tree positive_int_const);
struct _IDL_TYPE_WIDE_STRING {
IDL_tree positive_int_const;
};
#define IDL_TYPE_WIDE_STRING(a) IDL_CHECK_CAST(a, IDLN_TYPE_WIDE_STRING, idl_type_wide_string)
extern IDL_tree IDL_type_wide_string_new (IDL_tree positive_int_const);
struct _IDL_TYPE_ENUM {
IDL_tree ident;
IDL_tree enumerator_list;
};
#define IDL_TYPE_ENUM(a) IDL_CHECK_CAST(a, IDLN_TYPE_ENUM, idl_type_enum)
extern IDL_tree IDL_type_enum_new (IDL_tree ident,
IDL_tree enumerator_list);
struct _IDL_TYPE_ARRAY {
IDL_tree ident;
IDL_tree size_list;
};
#define IDL_TYPE_ARRAY(a) IDL_CHECK_CAST(a, IDLN_TYPE_ARRAY, idl_type_array)
extern IDL_tree IDL_type_array_new (IDL_tree ident,
IDL_tree size_list);
struct _IDL_TYPE_SEQUENCE {
IDL_tree simple_type_spec;
IDL_tree positive_int_const;
};
#define IDL_TYPE_SEQUENCE(a) IDL_CHECK_CAST(a, IDLN_TYPE_SEQUENCE, idl_type_sequence)
extern IDL_tree IDL_type_sequence_new (IDL_tree simple_type_spec,
IDL_tree positive_int_const);
struct _IDL_TYPE_STRUCT {
IDL_tree ident;
IDL_tree member_list;
};
#define IDL_TYPE_STRUCT(a) IDL_CHECK_CAST(a, IDLN_TYPE_STRUCT, idl_type_struct)
extern IDL_tree IDL_type_struct_new (IDL_tree ident,
IDL_tree member_list);
struct _IDL_TYPE_UNION {
IDL_tree ident;
IDL_tree switch_type_spec;
IDL_tree switch_body;
};
#define IDL_TYPE_UNION(a) IDL_CHECK_CAST(a, IDLN_TYPE_UNION, idl_type_union)
extern IDL_tree IDL_type_union_new (IDL_tree ident,
IDL_tree switch_type_spec,
IDL_tree switch_body);
struct _IDL_MEMBER {
IDL_tree type_spec;
IDL_tree dcls;
};
#define IDL_MEMBER(a) IDL_CHECK_CAST(a, IDLN_MEMBER, idl_member)
extern IDL_tree IDL_member_new (IDL_tree type_spec,
IDL_tree dcls);
struct _IDL_NATIVE {
IDL_tree ident;
char *user_type; /* XPIDL extension */
};
#define IDL_NATIVE(a) IDL_CHECK_CAST(a, IDLN_NATIVE, idl_native)
extern IDL_tree IDL_native_new (IDL_tree ident);
struct _IDL_TYPE_DCL {
IDL_tree type_spec;
IDL_tree dcls;
};
#define IDL_TYPE_DCL(a) IDL_CHECK_CAST(a, IDLN_TYPE_DCL, idl_type_dcl)
extern IDL_tree IDL_type_dcl_new (IDL_tree type_spec,
IDL_tree dcls);
struct _IDL_CONST_DCL {
IDL_tree const_type;
IDL_tree ident;
IDL_tree const_exp;
};
#define IDL_CONST_DCL(a) IDL_CHECK_CAST(a, IDLN_CONST_DCL, idl_const_dcl)
extern IDL_tree IDL_const_dcl_new (IDL_tree const_type,
IDL_tree ident,
IDL_tree const_exp);
struct _IDL_EXCEPT_DCL {
IDL_tree ident;
IDL_tree members;
};
#define IDL_EXCEPT_DCL(a) IDL_CHECK_CAST(a, IDLN_EXCEPT_DCL, idl_except_dcl)
extern IDL_tree IDL_except_dcl_new (IDL_tree ident,
IDL_tree members);
struct _IDL_ATTR_DCL {
unsigned f_readonly : 1;
IDL_tree param_type_spec;
IDL_tree simple_declarations;
};
#define IDL_ATTR_DCL(a) IDL_CHECK_CAST(a, IDLN_ATTR_DCL, idl_attr_dcl)
extern IDL_tree IDL_attr_dcl_new (unsigned f_readonly,
IDL_tree param_type_spec,
IDL_tree simple_declarations);
struct _IDL_OP_DCL {
unsigned f_noscript : 1;
unsigned f_oneway : 1;
/* XPIDL extension (varags) */
unsigned f_varargs : 1;
IDL_tree op_type_spec;
IDL_tree ident;
IDL_tree parameter_dcls;
IDL_tree raises_expr;
IDL_tree context_expr;
};
#define IDL_OP_DCL(a) IDL_CHECK_CAST(a, IDLN_OP_DCL, idl_op_dcl)
extern IDL_tree IDL_op_dcl_new (unsigned f_oneway,
IDL_tree op_type_spec,
IDL_tree ident,
IDL_tree parameter_dcls,
IDL_tree raises_expr,
IDL_tree context_expr);
enum IDL_param_attr {
IDL_PARAM_IN,
IDL_PARAM_OUT,
IDL_PARAM_INOUT
};
struct _IDL_PARAM_DCL {
enum IDL_param_attr attr;
IDL_tree param_type_spec;
IDL_tree simple_declarator;
};
#define IDL_PARAM_DCL(a) IDL_CHECK_CAST(a, IDLN_PARAM_DCL, idl_param_dcl)
extern IDL_tree IDL_param_dcl_new (enum IDL_param_attr attr,
IDL_tree param_type_spec,
IDL_tree simple_declarator);
struct _IDL_CASE_STMT {
IDL_tree labels;
IDL_tree element_spec;
};
#define IDL_CASE_STMT(a) IDL_CHECK_CAST(a, IDLN_CASE_STMT, idl_case_stmt)
extern IDL_tree IDL_case_stmt_new (IDL_tree labels,
IDL_tree element_spec);
struct _IDL_INTERFACE {
IDL_tree ident;
IDL_tree inheritance_spec;
IDL_tree body;
};
#define IDL_INTERFACE(a) IDL_CHECK_CAST(a, IDLN_INTERFACE, idl_interface)
extern IDL_tree IDL_interface_new (IDL_tree ident,
IDL_tree inheritance_spec,
IDL_tree body);
struct _IDL_FORWARD_DCL {
IDL_tree ident;
};
#define IDL_FORWARD_DCL(a) IDL_CHECK_CAST(a, IDLN_FORWARD_DCL, idl_forward_dcl)
extern IDL_tree IDL_forward_dcl_new (IDL_tree ident);
struct _IDL_MODULE {
IDL_tree ident;
IDL_tree definition_list;
};
#define IDL_MODULE(a) IDL_CHECK_CAST(a, IDLN_MODULE, idl_module)
extern IDL_tree IDL_module_new (IDL_tree ident,
IDL_tree definition_list);
enum IDL_binop {
IDL_BINOP_OR,
IDL_BINOP_XOR,
IDL_BINOP_AND,
IDL_BINOP_SHR,
IDL_BINOP_SHL,
IDL_BINOP_ADD,
IDL_BINOP_SUB,
IDL_BINOP_MULT,
IDL_BINOP_DIV,
IDL_BINOP_MOD
};
struct _IDL_BINOP {
enum IDL_binop op;
IDL_tree left, right;
};
#define IDL_BINOP(a) IDL_CHECK_CAST(a, IDLN_BINOP, idl_binop)
extern IDL_tree IDL_binop_new (enum IDL_binop op,
IDL_tree left,
IDL_tree right);
enum IDL_unaryop {
IDL_UNARYOP_PLUS,
IDL_UNARYOP_MINUS,
IDL_UNARYOP_COMPLEMENT
};
struct _IDL_UNARYOP {
enum IDL_unaryop op;
IDL_tree operand;
};
#define IDL_UNARYOP(a) IDL_CHECK_CAST(a, IDLN_UNARYOP, idl_unaryop)
extern IDL_tree IDL_unaryop_new (enum IDL_unaryop op,
IDL_tree operand);
/* XPIDL code fragments extension. */
struct _IDL_CODEFRAG {
char *desc;
GSList *lines;
};
#define IDL_CODEFRAG(a) IDL_CHECK_CAST(a, IDLN_CODEFRAG, idl_codefrag)
extern IDL_tree IDL_codefrag_new (char *desc,
GSList *lines);
/*
* IDL_tree_type - Enumerations of node types
*
* Note this enumerator list is subject to change in the future. A program should not need
* more than a recompilation to adjust for a change in this list, so instead of using a
* statically initialized jumptable, allocate an array of size IDLN_LAST and assign the
* elements manually.
*/
typedef enum {
IDLN_NONE,
IDLN_ANY,
IDLN_LIST,
IDLN_GENTREE,
IDLN_INTEGER,
IDLN_STRING,
IDLN_WIDE_STRING,
IDLN_CHAR,
IDLN_WIDE_CHAR,
IDLN_FIXED,
IDLN_FLOAT,
IDLN_BOOLEAN,
IDLN_IDENT,
IDLN_TYPE_DCL,
IDLN_CONST_DCL,
IDLN_EXCEPT_DCL,
IDLN_ATTR_DCL,
IDLN_OP_DCL,
IDLN_PARAM_DCL,
IDLN_FORWARD_DCL,
IDLN_TYPE_INTEGER,
IDLN_TYPE_FLOAT,
IDLN_TYPE_FIXED,
IDLN_TYPE_CHAR,
IDLN_TYPE_WIDE_CHAR,
IDLN_TYPE_STRING,
IDLN_TYPE_WIDE_STRING,
IDLN_TYPE_BOOLEAN,
IDLN_TYPE_OCTET,
IDLN_TYPE_ANY,
IDLN_TYPE_OBJECT,
IDLN_TYPE_TYPECODE,
IDLN_TYPE_ENUM,
IDLN_TYPE_SEQUENCE,
IDLN_TYPE_ARRAY,
IDLN_TYPE_STRUCT,
IDLN_TYPE_UNION,
IDLN_MEMBER,
IDLN_NATIVE,
IDLN_CASE_STMT,
IDLN_INTERFACE,
IDLN_MODULE,
IDLN_BINOP,
IDLN_UNARYOP,
IDLN_CODEFRAG,
IDLN_LAST
} IDL_tree_type;
IDL_IMPORT const char * IDL_tree_type_names[];
struct _IDL_tree_node {
IDL_tree_type _type;
IDL_tree up; /* Do not recurse */
IDL_declspec_t declspec;
/* properties is an XPIDL extension. It is a hash table of
* case-insensitive string keys to string values. */
GHashTable *properties;
int refs;
char *_file; /* Internal use */
int _line; /* Internal use */
union {
struct _IDL_LIST idl_list;
struct _IDL_GENTREE idl_gentree;
struct _IDL_INTEGER idl_integer;
struct _IDL_STRING idl_string;
struct _IDL_WIDE_STRING idl_wide_string;
struct _IDL_CHAR idl_char;
struct _IDL_WIDE_CHAR idl_wide_char;
struct _IDL_FIXED idl_fixed;
struct _IDL_FLOAT idl_float;
struct _IDL_BOOLEAN idl_boolean;
struct _IDL_IDENT idl_ident;
struct _IDL_TYPE_DCL idl_type_dcl;
struct _IDL_CONST_DCL idl_const_dcl;
struct _IDL_EXCEPT_DCL idl_except_dcl;
struct _IDL_ATTR_DCL idl_attr_dcl;
struct _IDL_OP_DCL idl_op_dcl;
struct _IDL_PARAM_DCL idl_param_dcl;
struct _IDL_FORWARD_DCL idl_forward_dcl;
struct _IDL_TYPE_FLOAT idl_type_float;
struct _IDL_TYPE_FIXED idl_type_fixed;
struct _IDL_TYPE_INTEGER idl_type_integer;
struct _IDL_TYPE_ENUM idl_type_enum;
struct _IDL_TYPE_STRING idl_type_string;
struct _IDL_TYPE_WIDE_STRING idl_type_wide_string;
struct _IDL_TYPE_SEQUENCE idl_type_sequence;
struct _IDL_TYPE_ARRAY idl_type_array;
struct _IDL_TYPE_STRUCT idl_type_struct;
struct _IDL_TYPE_UNION idl_type_union;
struct _IDL_MEMBER idl_member;
struct _IDL_NATIVE idl_native;
struct _IDL_CASE_STMT idl_case_stmt;
struct _IDL_INTERFACE idl_interface;
struct _IDL_MODULE idl_module;
struct _IDL_BINOP idl_binop;
struct _IDL_UNARYOP idl_unaryop;
struct _IDL_CODEFRAG idl_codefrag;
} u;
};
#define IDL_NODE_TYPE(a) ((a)->_type)
#define IDL_NODE_TYPE_NAME(a) ((a)?IDL_tree_type_names[IDL_NODE_TYPE(a)]:"NULL")
#define IDL_NODE_UP(a) ((a)->up)
#define IDL_NODE_PROPERTIES(a) ((a)->properties)
#define IDL_NODE_DECLSPEC(a) ((a)->declspec)
#define IDL_NODE_REFS(a) ((a)->refs)
#define IDL_NODE_IS_LITERAL(a) \
(IDL_NODE_TYPE(a) == IDLN_INTEGER || \
IDL_NODE_TYPE(a) == IDLN_STRING || \
IDL_NODE_TYPE(a) == IDLN_WIDE_STRING || \
IDL_NODE_TYPE(a) == IDLN_CHAR || \
IDL_NODE_TYPE(a) == IDLN_WIDE_CHAR || \
IDL_NODE_TYPE(a) == IDLN_FIXED || \
IDL_NODE_TYPE(a) == IDLN_FLOAT || \
IDL_NODE_TYPE(a) == IDLN_BOOLEAN)
#define IDL_NODE_IS_TYPE(a) \
(IDL_NODE_TYPE(a) == IDLN_TYPE_INTEGER || \
IDL_NODE_TYPE(a) == IDLN_TYPE_STRING || \
IDL_NODE_TYPE(a) == IDLN_TYPE_WIDE_STRING || \
IDL_NODE_TYPE(a) == IDLN_TYPE_CHAR || \
IDL_NODE_TYPE(a) == IDLN_TYPE_WIDE_CHAR || \
IDL_NODE_TYPE(a) == IDLN_TYPE_FIXED || \
IDL_NODE_TYPE(a) == IDLN_TYPE_FLOAT || \
IDL_NODE_TYPE(a) == IDLN_TYPE_BOOLEAN || \
IDL_NODE_TYPE(a) == IDLN_TYPE_OCTET || \
IDL_NODE_TYPE(a) == IDLN_TYPE_ANY || \
IDL_NODE_TYPE(a) == IDLN_TYPE_OBJECT || \
IDL_NODE_TYPE(a) == IDLN_TYPE_TYPECODE || \
IDL_NODE_TYPE(a) == IDLN_TYPE_ENUM || \
IDL_NODE_TYPE(a) == IDLN_TYPE_ARRAY || \
IDL_NODE_TYPE(a) == IDLN_TYPE_SEQUENCE || \
IDL_NODE_TYPE(a) == IDLN_TYPE_STRUCT || \
IDL_NODE_TYPE(a) == IDLN_TYPE_UNION)
#define IDL_NODE_IS_SCOPED(a) \
(IDL_NODE_TYPE(a) == IDLN_IDENT || \
IDL_NODE_TYPE(a) == IDLN_INTERFACE || \
IDL_NODE_TYPE(a) == IDLN_MODULE || \
IDL_NODE_TYPE(a) == IDLN_EXCEPT_DCL || \
IDL_NODE_TYPE(a) == IDLN_OP_DCL || \
IDL_NODE_TYPE(a) == IDLN_TYPE_ENUM || \
IDL_NODE_TYPE(a) == IDLN_TYPE_STRUCT || \
IDL_NODE_TYPE(a) == IDLN_TYPE_UNION)
typedef struct _IDL_ns * IDL_ns;
struct _IDL_ns {
IDL_tree global;
IDL_tree file;
IDL_tree current;
GHashTable *inhibits;
GHashTable *filename_hash;
};
#define IDL_NS(a) (*(a))
typedef enum {
IDL_INPUT_REASON_INIT,
IDL_INPUT_REASON_FILL,
IDL_INPUT_REASON_ABORT,
IDL_INPUT_REASON_FINISH
} IDL_input_reason;
union IDL_input_data {
struct {
const char *filename;
} init;
struct {
char *buffer;
size_t max_size;
} fill;
};
typedef int (*IDL_input_callback) (IDL_input_reason reason,
union IDL_input_data *data,
gpointer user_data);
typedef int (*IDL_msg_callback) (int level,
int num,
int line,
const char *filename,
const char *message);
typedef struct _IDL_tree_func_state IDL_tree_func_state;
typedef struct _IDL_tree_func_data IDL_tree_func_data;
/* Traversal state data. Recursive walks chain states. */
struct _IDL_tree_func_state {
IDL_tree_func_state *up;
IDL_tree start;
IDL_tree_func_data *bottom;
};
/* This holds a list of the up hierarchy traversed, beginning from traversal. This is
* useful since nodes referenced after initial definition will have a different traversal
* path than the actual up path. */
struct _IDL_tree_func_data {
IDL_tree_func_state *state;
IDL_tree_func_data *up;
IDL_tree tree;
};
typedef gboolean (*IDL_tree_func) (IDL_tree_func_data *tnfd,
gpointer user_data);
extern IDL_tree IDL_check_type_cast (const IDL_tree var,
IDL_tree_type type,
const char *file,
int line,
const char *function);
extern const char * IDL_get_libver_string (void);
extern const char * IDL_get_IDLver_string (void);
extern int IDL_parse_filename (const char *filename,
const char *cpp_args,
IDL_msg_callback msg_cb,
IDL_tree *tree, IDL_ns *ns,
unsigned long parse_flags,
int max_msg_level);
extern int IDL_parse_filename_with_input (const char *filename,
IDL_input_callback input_cb,
gpointer input_cb_user_data,
IDL_msg_callback msg_cb,
IDL_tree *tree, IDL_ns *ns,
unsigned long parse_flags,
int max_msg_level);
extern int IDL_ns_prefix (IDL_ns ns,
const char *s);
extern void IDL_ns_ID (IDL_ns ns,
const char *s);
extern void IDL_ns_version (IDL_ns ns,
const char *s);
extern int IDL_inhibit_get (void);
extern void IDL_inhibit_push (void);
extern void IDL_inhibit_pop (void);
extern void IDL_file_set (const char *filename,
int line);
extern void IDL_file_get (const char **filename,
int *line);
extern IDL_tree IDL_get_parent_node (IDL_tree p,
IDL_tree_type type,
int *scope_levels);
extern IDL_tree IDL_tree_get_scope (IDL_tree p);
extern int IDL_tree_get_node_info (IDL_tree tree,
char **who,
char **what);
extern void IDL_tree_error (IDL_tree p,
const char *fmt,
...);
extern void IDL_tree_warning (IDL_tree p,
int level,
const char *fmt,
...);
extern const char * IDL_tree_property_get (IDL_tree tree,
const char *key);
extern void IDL_tree_property_set (IDL_tree tree,
const char *key,
const char *value);
extern gboolean IDL_tree_property_remove (IDL_tree tree,
const char *key);
extern void IDL_tree_properties_copy (IDL_tree from_tree,
IDL_tree to_tree);
extern void IDL_tree_walk (IDL_tree p,
IDL_tree_func_data *current,
IDL_tree_func pre_tree_func,
IDL_tree_func post_tree_func,
gpointer user_data);
extern void IDL_tree_walk_in_order (IDL_tree p,
IDL_tree_func tree_func,
gpointer user_data);
extern void IDL_tree_free (IDL_tree root);
extern void IDL_tree_to_IDL (IDL_tree p,
IDL_ns ns,
FILE *output,
unsigned long output_flags);
extern char * IDL_do_escapes (const char *s);
extern IDL_tree IDL_resolve_const_exp (IDL_tree p,
IDL_tree_type type);
extern IDL_ns IDL_ns_new (void);
extern void IDL_ns_free (IDL_ns ns);
extern IDL_tree IDL_ns_resolve_this_scope_ident (IDL_ns ns,
IDL_tree scope,
IDL_tree ident);
extern IDL_tree IDL_ns_resolve_ident (IDL_ns ns,
IDL_tree ident);
extern IDL_tree IDL_ns_lookup_this_scope (IDL_ns ns,
IDL_tree scope,
IDL_tree ident,
gboolean *conflict);
extern IDL_tree IDL_ns_lookup_cur_scope (IDL_ns ns,
IDL_tree ident,
gboolean *conflict);
extern IDL_tree IDL_ns_place_new (IDL_ns ns,
IDL_tree ident);
extern void IDL_ns_push_scope (IDL_ns ns,
IDL_tree ident);
extern void IDL_ns_pop_scope (IDL_ns ns);
extern IDL_tree IDL_ns_qualified_ident_new (IDL_tree nsid);
extern char * IDL_ns_ident_to_qstring (IDL_tree ns_ident,
const char *join,
int scope_levels);
extern int IDL_ns_scope_levels_from_here (IDL_ns ns,
IDL_tree ident,
IDL_tree parent);
extern char * IDL_ns_ident_make_repo_id (IDL_ns ns,
IDL_tree p,
const char *p_prefix,
int *major,
int *minor);
#ifdef __cplusplus
}
#endif
#endif /* __IDL_H */

50
buildtools/windows/install.bat
View File

@ -1,50 +0,0 @@
@echo off
if "%MOZ_TOOLS%" == "" goto no_moz_tools
echo.
echo MOZ_TOOLS is set to %MOZ_TOOLS%
echo.
echo copying exes and dlls to %MOZ_TOOLS%\bin
if not exist %MOZ_TOOLS%\bin\NUL mkdir %MOZ_TOOLS%\bin >NUL
copy bin\x86\* %MOZ_TOOLS%\bin >NUL
echo copying include files to %MOZ_TOOLS%\include
if not exist %MOZ_TOOLS%\include\NUL mkdir %MOZ_TOOLS%\include >NUL
copy include\* %MOZ_TOOLS%\include >NUL
echo copying include files to %MOZ_TOOLS%\include\libIDL
if not exist %MOZ_TOOLS%\include\libIDL\NUL mkdir %MOZ_TOOLS%\include\libIDL >NUL
copy include\libIDL\* %MOZ_TOOLS%\include\libIDL >NUL
echo copying lib files to %MOZ_TOOLS%\lib
if not exist %MOZ_TOOLS%\lib\NUL mkdir %MOZ_TOOLS%\lib >NUL
copy lib\* %MOZ_TOOLS%\lib >NUL
echo.
echo done copying
echo.
echo make sure that MOZ_TOOLS\bin is on your path
echo.
goto done
:no_moz_tools
echo.
echo. ERROR!
echo.
echo You need to set MOZ_TOOLS in your environment.
echo MOZ_TOOLS should be the name of a directory that
echo you create to hold these tools.
echo.
echo. e.g.
echo. mkdir c:\moz_tools
echo. set MOZ_TOOLS=c:\moz_tools
echo.
echo MOZ_TOOLS should be set permanently so that it is
echo available to the build system whenever mozilla is building.
echo.
echo.
echo Please set MOZ_TOOLS and run install.bat again
echo.
:done

BIN
buildtools/windows/lib/glib-1.2.lib
View File

Binary file not shown.

BIN
buildtools/windows/lib/gmodule-1.2.lib
View File

Binary file not shown.

BIN
buildtools/windows/lib/gthread-1.2.lib
View File

Binary file not shown.

BIN
buildtools/windows/lib/libIDL-0.6.lib
View File

Binary file not shown.

12
buildtools/windows/source/glib/README
View File

@ -1,12 +0,0 @@
Sources for glib are available from gnome.org via cvs. See cvs
checkout instructions at http://www.gnome.org - or use
export CVSROOT=:pserver:anonymous@anoncvs.gnome.org:/cvs/gnome
cvs login (no password)
cvs -z3 checkout glib
or grap a package of the sources we're currently using from
ftp://ftp.mozilla.org/pub/mozilla/libraries/source/
These sources correspond to the GLIB_1_2_0 tag on the gnome cvs
server.

14
buildtools/windows/source/libIDL/README
View File

@ -1,14 +0,0 @@
Sources for libIDL are available from gnome.org via cvs. See cvs
checkout instructions at http://www.gnome.org - or use
export CVSROOT=:pserver:anonymous@anoncvs.gnome.org:/cvs/gnome
cvs login (no password)
cvs -z3 checkout ORBit
(libIDL files are in ORBit/libIDL)
or grap a package of the sources we're currently using from
ftp://ftp.mozilla.org/pub/mozilla/libraries/source/
These sources correspond to the LIBIDL_V0_6_3 tag on the gnome cvs
server.

339
buildtools/windows/source/make/COPYING
View File

@ -1,339 +0,0 @@
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
675 Mass Ave, Cambridge, MA 02139, USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
Appendix: How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) 19yy <name of author>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) 19yy name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
<signature of Ty Coon>, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Library General
Public License instead of this License.

3263
buildtools/windows/source/make/ChangeLog
View File

File diff suppressed because it is too large Load Diff

176
buildtools/windows/source/make/INSTALL
View File

@ -1,176 +0,0 @@
Basic Installation
==================
These are generic installation instructions.
The `configure' shell script attempts to guess correct values for
various system-dependent variables used during compilation. It uses
those values to create a `Makefile' in each directory of the package.
It may also create one or more `.h' files containing system-dependent
definitions. Finally, it creates a shell script `config.status' that
you can run in the future to recreate the current configuration, a file
`config.cache' that saves the results of its tests to speed up
reconfiguring, and a file `config.log' containing compiler output
(useful mainly for debugging `configure').
If you need to do unusual things to compile the package, please try
to figure out how `configure' could check whether to do them, and mail
diffs or instructions to the address given in the `README' so they can
be considered for the next release. If at some point `config.cache'
contains results you don't want to keep, you may remove or edit it.
The file `configure.in' is used to create `configure' by a program
called `autoconf'. You only need `configure.in' if you want to change
it or regenerate `configure' using a newer version of `autoconf'.
The simplest way to compile this package is:
1. `cd' to the directory containing the package's source code and type
`./configure' to configure the package for your system. If you're
using `csh' on an old version of System V, you might need to type
`sh ./configure' instead to prevent `csh' from trying to execute
`configure' itself.
Running `configure' takes awhile. While running, it prints some
messages telling which features it is checking for.
2. Type `make' to compile the package.
3. Optionally, type `make check' to run any self-tests that come with
the package.
4. Type `make install' to install the programs and any data files and
documentation.
5. You can remove the program binaries and object files from the
source code directory by typing `make clean'. To also remove the
files that `configure' created (so you can compile the package for
a different kind of computer), type `make distclean'. There is
also a `make maintainer-clean' target, but that is intended mainly
for the package's developers. If you use it, you may have to get
all sorts of other programs in order to regenerate files that came
with the distribution.
Compilers and Options
=====================
Some systems require unusual options for compilation or linking that
the `configure' script does not know about. You can give `configure'
initial values for variables by setting them in the environment. Using
a Bourne-compatible shell, you can do that on the command line like
this:
CC=c89 CFLAGS=-O2 LIBS=-lposix ./configure
Or on systems that have the `env' program, you can do it like this:
env CPPFLAGS=-I/usr/local/include LDFLAGS=-s ./configure
Compiling For Multiple Architectures
====================================
You can compile the package for more than one kind of computer at the
same time, by placing the object files for each architecture in their
own directory. To do this, you must use a version of `make' that
supports the `VPATH' variable, such as GNU `make'. `cd' to the
directory where you want the object files and executables to go and run
the `configure' script. `configure' automatically checks for the
source code in the directory that `configure' is in and in `..'.
If you have to use a `make' that does not supports the `VPATH'
variable, you have to compile the package for one architecture at a time
in the source code directory. After you have installed the package for
one architecture, use `make distclean' before reconfiguring for another
architecture.
Installation Names
==================
By default, `make install' will install the package's files in
`/usr/local/bin', `/usr/local/man', etc. You can specify an
installation prefix other than `/usr/local' by giving `configure' the
option `--prefix=PATH'.
You can specify separate installation prefixes for
architecture-specific files and architecture-independent files. If you
give `configure' the option `--exec-prefix=PATH', the package will use
PATH as the prefix for installing programs and libraries.
Documentation and other data files will still use the regular prefix.
If the package supports it, you can cause programs to be installed
with an extra prefix or suffix on their names by giving `configure' the
option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
Optional Features
=================
Some packages pay attention to `--enable-FEATURE' options to
`configure', where FEATURE indicates an optional part of the package.
They may also pay attention to `--with-PACKAGE' options, where PACKAGE
is something like `gnu-as' or `x' (for the X Window System). The
`README' should mention any `--enable-' and `--with-' options that the
package recognizes.
For packages that use the X Window System, `configure' can usually
find the X include and library files automatically, but if it doesn't,
you can use the `configure' options `--x-includes=DIR' and
`--x-libraries=DIR' to specify their locations.
Specifying the System Type
==========================
There may be some features `configure' can not figure out
automatically, but needs to determine by the type of host the package
will run on. Usually `configure' can figure that out, but if it prints
a message saying it can not guess the host type, give it the
`--host=TYPE' option. TYPE can either be a short name for the system
type, such as `sun4', or a canonical name with three fields:
CPU-COMPANY-SYSTEM
See the file `config.sub' for the possible values of each field. If
`config.sub' isn't included in this package, then this package doesn't
need to know the host type.
If you are building compiler tools for cross-compiling, you can also
use the `--target=TYPE' option to select the type of system they will
produce code for and the `--build=TYPE' option to select the type of
system on which you are compiling the package.
Sharing Defaults
================
If you want to set default values for `configure' scripts to share,
you can create a site shell script called `config.site' that gives
default values for variables like `CC', `cache_file', and `prefix'.
`configure' looks for `PREFIX/share/config.site' if it exists, then
`PREFIX/etc/config.site' if it exists. Or, you can set the
`CONFIG_SITE' environment variable to the location of the site script.
A warning: not all `configure' scripts look for a site script.
Operation Controls
==================
`configure' recognizes the following options to control how it
operates.
`--cache-file=FILE'
Use and save the results of the tests in FILE instead of
`./config.cache'. Set FILE to `/dev/null' to disable caching, for
debugging `configure'.
`--help'
Print a summary of the options to `configure', and exit.
`--quiet'
`--silent'
`-q'
Do not print messages saying which checks are being made.
`--srcdir=DIR'
Look for the package's source code in directory DIR. Usually
`configure' can determine that directory automatically.
`--version'
Print the version of Autoconf used to generate the `configure'
script, and exit.
`configure' also accepts some other, not widely useful, options.

62
buildtools/windows/source/make/Makefile
View File

@ -1,62 +0,0 @@
#
# GNU Makefile for building gmake.exe on WIN32
# This is the top-level makefile. It only does the optimized build.
#
CSRCS = ar.c \
arscan.c \
commands.c \
default.c \
dir.c \
expand.c \
file.c \
function.c \
getloadavg.c \
getopt.c \
getopt1.c \
implicit.c \
job.c \
main.c \
misc.c \
read.c \
remake.c \
remote-stub.c \
rule.c \
signame.c \
variable.c \
version.c \
vpath.c
OBJS = $(CSRCS:.c=.obj) glob/fnmatch.obj glob/glob.obj
CC = cl
CFLAGS = $(CC_SWITCHES) $(INCLUDES) $(DEFINES) $(CC_OUTPUTS)
CC_SWITCHES = -nologo -ML -W3 -O2
INCLUDES = -I. -Iglob
DEFINES = -DWIN32 -DNDEBUG -D_CONSOLE -DNETSCAPE -DHAVE_CONFIG_H
CC_OUTPUTS = -Fpgmake.pch -YX -c
LINK = link
LINK_FLAGS = -nologo -subsystem:console \
-incremental:no -machine:I386 -out:$@
all: gmake.exe
build_glob:
cd glob; $(MAKE)
gmake.exe: build_glob $(OBJS)
$(LINK) $(LINK_FLAGS) $(OBJS)
%.obj: %.c
$(CC) $(CFLAGS) $<
clean:
cd glob; $(MAKE) $@
rm -rf $(OBJS) gmake.pch gmake.exe

307
buildtools/windows/source/make/Makefile.in
View File

@ -1,307 +0,0 @@
# NOTE: If you have no `make' program at all to process this makefile, run
# `build.sh' instead.
#
# Copyright (C) 1988, 89, 91, 92, 93, 94, 1995 Free Software Foundation, Inc.
# This file is part of GNU Make.
#
# GNU Make is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
#
# GNU Make is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with GNU Make; see the file COPYING. If not, write to
# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
#
# Makefile for GNU Make
#
# Ultrix 2.2 make doesn't expand the value of VPATH.
VPATH = @srcdir@
# This must repeat the value, because configure will remove `VPATH = .'.
srcdir = @srcdir@
CC = @CC@
CFLAGS = @CFLAGS@
CPPFLAGS = @CPPFLAGS@
LDFLAGS = @LDFLAGS@
# Define these for your system as follows:
# -DNO_ARCHIVES To disable `ar' archive support.
# -DNO_FLOAT To avoid using floating-point numbers.
# -DENUM_BITFIELDS If the compiler isn't GCC but groks enum foo:2.
# Some compilers apparently accept this
# without complaint but produce losing code,
# so beware.
# NeXT 1.0a uses an old version of GCC, which required -D__inline=inline.
# See also `config.h'.
defines = @DEFS@ -DLIBDIR=\"$(libdir)\" -DINCLUDEDIR=\"$(includedir)\"
# Which flavor of remote job execution support to use.
# The code is found in `remote-$(REMOTE).c'.
REMOTE = @REMOTE@
# If you are using the GNU C library, or have the GNU getopt functions in
# your C library, you can comment these out.
GETOPT = getopt.o getopt1.o
GETOPT_SRC = $(srcdir)/getopt.c $(srcdir)/getopt1.c $(srcdir)/getopt.h
# If you are using the GNU C library, or have the GNU glob functions in
# your C library, you can comment this out. GNU make uses special hooks
# into the glob functions to be more efficient (by using make's directory
# cache for globbing), so you must use the GNU functions even if your
# system's C library has the 1003.2 glob functions already. Also, the glob
# functions in the AIX and HPUX C libraries are said to be buggy.
GLOB = glob/libglob.a
# If your system doesn't have alloca, or the one provided is bad, define this.
ALLOCA = @ALLOCA@
ALLOCA_SRC = $(srcdir)/alloca.c
# If your system needs extra libraries loaded in, define them here.
# System V probably need -lPW for alloca. HP-UX 7.0's alloca in
# libPW.a is broken on HP9000s300 and HP9000s400 machines. Use
# alloca.c instead on those machines.
LOADLIBES = @LIBS@
# Any extra object files your system needs.
extras = @LIBOBJS@
# Common prefix for machine-independent installed files.
prefix = @prefix@
# Common prefix for machine-dependent installed files.
exec_prefix = @exec_prefix@
# Directory to install `make' in.
bindir = $(exec_prefix)/bin
# Directory to find libraries in for `-lXXX'.
libdir = $(exec_prefix)/lib
# Directory to search by default for included makefiles.
includedir = $(prefix)/include
# Directory to install the Info files in.
infodir = $(prefix)/info
# Directory to install the man page in.
mandir = $(prefix)/man/man$(manext)
# Number to put on the man page filename.
manext = 1
# Prefix to put on installed `make' binary file name.
binprefix =
# Prefix to put on installed `make' man page file name.
manprefix = $(binprefix)
# Whether or not make needs to be installed setgid.
# The value should be either `true' or `false'.
# On many systems, the getloadavg function (used to implement the `-l'
# switch) will not work unless make is installed setgid kmem.
install_setgid = @NEED_SETGID@
# Install make setgid to this group so it can read /dev/kmem.
group = @KMEM_GROUP@
# Program to install `make'.
INSTALL_PROGRAM = @INSTALL_PROGRAM@
# Program to install the man page.
INSTALL_DATA = @INSTALL_DATA@
# Generic install program.
INSTALL = @INSTALL@
# Program to format Texinfo source into Info files.
MAKEINFO = makeinfo
# Program to format Texinfo source into DVI files.
TEXI2DVI = texi2dvi
# Programs to make tags files.
ETAGS = etags -w
CTAGS = ctags -w
objs = commands.o job.o dir.o file.o misc.o main.o read.o remake.o \
rule.o implicit.o default.o variable.o expand.o function.o \
vpath.o version.o ar.o arscan.o signame.o remote-$(REMOTE).o \
$(GLOB) $(GETOPT) $(ALLOCA) $(extras)
srcs = $(srcdir)/commands.c $(srcdir)/job.c $(srcdir)/dir.c \
$(srcdir)/file.c $(srcdir)/getloadavg.c $(srcdir)/misc.c \
$(srcdir)/main.c $(srcdir)/read.c $(srcdir)/remake.c \
$(srcdir)/rule.c $(srcdir)/implicit.c $(srcdir)/default.c \
$(srcdir)/variable.c $(srcdir)/expand.c $(srcdir)/function.c \
$(srcdir)/vpath.c $(srcdir)/version.c \
$(srcdir)/remote-$(REMOTE).c \
$(srcdir)/ar.c $(srcdir)/arscan.c \
$(srcdir)/signame.c $(srcdir)/signame.h $(GETOPT_SRC) \
$(srcdir)/commands.h $(srcdir)/dep.h $(srcdir)/file.h \
$(srcdir)/job.h $(srcdir)/make.h $(srcdir)/rule.h \
$(srcdir)/variable.h $(ALLOCA_SRC) $(srcdir)/config.h.in
.SUFFIXES:
.SUFFIXES: .o .c .h .ps .dvi .info .texinfo
all: make
info: make.info
dvi: make.dvi
# Some makes apparently use .PHONY as the default goal if it is before `all'.
.PHONY: all check info dvi
make.info: make.texinfo
$(MAKEINFO) -I$(srcdir) $(srcdir)/make.texinfo -o make.info
make.dvi: make.texinfo
$(TEXI2DVI) $(srcdir)/make.texinfo
make.ps: make.dvi
dvi2ps make.dvi > make.ps
make: $(objs)
$(CC) $(LDFLAGS) $(objs) $(LOADLIBES) -o make.new
mv -f make.new make
# -I. is needed to find config.h in the build directory.
.c.o:
$(CC) $(defines) -c -I. -I$(srcdir) -I$(srcdir)/glob \
$(CPPFLAGS) $(CFLAGS) $< $(OUTPUT_OPTION)
# For some losing Unix makes.
SHELL = /bin/sh
@SET_MAKE@
glob/libglob.a: FORCE config.h
cd glob; $(MAKE) libglob.a
FORCE:
tagsrcs = $(srcs) $(srcdir)/remote-*.c
TAGS: $(tagsrcs)
$(ETAGS) $(tagsrcs)
tags: $(tagsrcs)
$(CTAGS) $(tagsrcs)
.PHONY: install installdirs
install: installdirs \
$(bindir)/$(binprefix)make $(infodir)/make.info \
$(mandir)/$(manprefix)make.$(manext)
installdirs:
$(SHELL) ${srcdir}/mkinstalldirs $(bindir) $(infodir) $(mandir)
$(bindir)/$(binprefix)make: make
$(INSTALL_PROGRAM) make $@.new
@if $(install_setgid); then \
if chgrp $(group) $@.new && chmod g+s $@.new; then \
echo "chgrp $(group) $@.new && chmod g+s $@.new"; \
else \
echo "$@ needs to be owned by group $(group) and setgid;"; \
echo "otherwise the \`-l' option will probably not work."; \
echo "You may need special privileges to install $@."; \
fi; \
else true; fi
# Some systems can't deal with renaming onto a running binary.
-rm -f $@.old
-mv $@ $@.old
mv $@.new $@
$(infodir)/make.info: make.info
if [ -r ./make.info ]; then dir=.; else dir=$(srcdir); fi; \
for file in $${dir}/make.info*; do \
name="`basename $$file`"; \
$(INSTALL_DATA) $$file \
`echo $@ | sed "s,make.info\$$,$$name,"`; \
done
# Run install-info only if it exists.
# Use `if' instead of just prepending `-' to the
# line so we notice real errors from install-info.
# We use `$(SHELL) -c' because some shells do not
# fail gracefully when there is an unknown command.
if $(SHELL) -c 'install-info --version' >/dev/null 2>&1; then \
if [ -r ./make.info ]; then dir=.; else dir=$(srcdir); fi; \
install-info --infodir=$(infodir) $$dir/make.info; \
else true; fi
$(mandir)/$(manprefix)make.$(manext): make.man
$(INSTALL_DATA) $(srcdir)/make.man $@
loadavg: loadavg.c config.h
$(CC) $(defines) -DTEST -I. -I$(srcdir) $(CFLAGS) $(LDFLAGS) \
loadavg.c $(LOADLIBES) -o $@
# We copy getloadavg.c into a different file rather than compiling it
# directly because some compilers clobber getloadavg.o in the process.
loadavg.c: getloadavg.c
ln $(srcdir)/getloadavg.c loadavg.c || \
cp $(srcdir)/getloadavg.c loadavg.c
check-loadavg: loadavg
@echo The system uptime program believes the load average to be:
-uptime
@echo The GNU load average checking code believes:
./loadavg
check: check-loadavg
.PHONY: clean realclean distclean mostlyclean
clean: glob-clean
-rm -f make loadavg *.o core make.dvi
distclean: clean glob-realclean
-rm -f Makefile config.h config.status build.sh stamp-config
-rm -f config.log config.cache
-rm -f TAGS tags
-rm -f make.?? make.??s make.log make.toc make.*aux
-rm -f loadavg.c
realclean: distclean
-rm -f make.info*
mostlyclean: clean
.PHONY: glob-clean glob-realclean
glob-clean glob-realclean:
cd glob; $(MAKE) $@
Makefile: config.status $(srcdir)/Makefile.in
$(SHELL) config.status
glob/Makefile: config.status $(srcdir)/glob/Makefile.in
$(SHELL) config.status
config.h: stamp-config ;
stamp-config: config.status $(srcdir)/config.h.in
$(SHELL) config.status
touch stamp-config
#configure: configure.in aclocal.m4
# cd $(srcdir) && autoconf $(ACFLAGS)
#config.h.in: configure.in aclocal.m4
# cd $(srcdir) && autoheader $(ACFLAGS)
# This tells versions [3.59,3.63) of GNU make not to export all variables.
.NOEXPORT:
# The automatically generated dependencies below may omit config.h
# because it is included with ``#include <config.h>'' rather than
# ``#include "config.h"''. So we add the explicit dependency to make sure.
$(objs): config.h
# Automatically generated dependencies will be put at the end of the file.
# Automatically generated dependencies.
commands.o : commands.c make.h dep.h commands.h file.h variable.h job.h
job.o: job.c make.h commands.h job.h file.h variable.h
dir.o: dir.c make.h
file.o: file.c make.h commands.h dep.h file.h variable.h
misc.o: misc.c make.h dep.h
main.o: main.c make.h commands.h dep.h file.h variable.h job.h getopt.h
read.o: read.c make.h commands.h dep.h file.h variable.h glob/glob.h
remake.o: remake.c make.h commands.h job.h dep.h file.h
rule.o : rule.c make.h config.h commands.h dep.h file.h variable.h rule.h
implicit.o : implicit.c make.h rule.h dep.h file.h
default.o: default.c make.h rule.h dep.h file.h commands.h variable.h
variable.o : variable.c make.h commands.h variable.h dep.h file.h
expand.o: expand.c make.h commands.h file.h variable.h
function.o: function.c make.h variable.h dep.h commands.h job.h
vpath.o : vpath.c make.h file.h variable.h
version.o: version.c
ar.o : ar.c make.h file.h dep.h
arscan.o: arscan.c make.h
signame.o: signame.c signame.h
remote-stub.o : remote-stub.c make.h commands.h
getopt.o: getopt.c getopt.h
getopt1.o : getopt1.c getopt.h
getloadavg.o: getloadavg.c

557
buildtools/windows/source/make/NEWS
View File

@ -1,557 +0,0 @@
GNU make NEWS -- history of user-visible changes. 26 January 1995
Copyright (C) 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
See the end for copying conditions.
Please send GNU make bug reports to bug-gnu-utils@prep.ai.mit.edu.
Version 3.73
* Converted to use Autoconf version 2, so `configure' has some new options.
See INSTALL for details.
* You can now send a SIGUSR1 signal to Make to toggle printing of debugging
output enable by -d, at any time during the run.
Version 3.72
* DJ Delorie has ported Make to MS-DOS using the GO32 extender.
He is maintaining the DOS port, not the GNU Make maintainer;
please direct bugs and questions for DOS to <djgpp@sun.soe.clarkson.edu>.
MS-DOS binaries are available for FTP from oak.oakland.edu:pub/msdos/djgpp.
* The `MAKEFLAGS' variable (in the environment or in a makefile) can now
contain variable definitions itself; these are treated just like
command-line variable definitions. Make will automatically insert any
variable definitions from the environment value of `MAKEFLAGS' or from
the command line, into the `MAKEFLAGS' value exported to children. The
`MAKEOVERRIDES' variable previously included in the value of `$(MAKE)'
for sub-makes is now included in `MAKEFLAGS' instead. As before, you can
reset `MAKEOVERRIDES' in your makefile to avoid putting all the variables
in the environment when its size is limited.
* If `.DELETE_ON_ERROR' appears as a target, Make will delete the target of
a rule if it has changed when its commands exit with a nonzero status,
just as when the commands get a signal.
* The automatic variable `$+' is new. It lists all the dependencies like
`$^', but preserves duplicates listed in the makefile. This is useful
for linking rules, where library files sometimes need to be listed twice
in the link order.
* You can now specify the `.IGNORE' and `.SILENT' special targets with
dependencies to limit their effects to those files. If a file appears as
a dependency of `.IGNORE', then errors will be ignored while running the
commands to update that file. Likewise if a file appears as a dependency
of `.SILENT', then the commands to update that file will not be printed
before they are run. (This change was made to conform to POSIX.2.)
Version 3.71
* The automatic variables `$(@D)', `$(%D)', `$(*D)', `$(<D)', `$(?D)', and
`$(^D)' now omit the trailing slash from the directory name. (This change
was made to comply with POSIX.2.)
* The source distribution now includes the Info files for the Make manual.
There is no longer a separate distribution containing Info and DVI files.
* You can now set the variables `binprefix' and/or `manprefix' in
Makefile.in (or on the command line when installing) to install GNU make
under a name other than `make' (i.e., ``make binprefix=g install''
installs GNU make as `gmake').
* The built-in Texinfo rules use the new variables `TEXI2DVI_FLAGS' for
flags to the `texi2dvi' script, and `MAKEINFO_FLAGS' for flags to the
Makeinfo program.
* The exit status of Make when it runs into errors is now 2 instead of 1.
The exit status is 1 only when using -q and some target is not up to date.
(This change was made to comply with POSIX.2.)
Version 3.70
* It is no longer a fatal error to have a NUL character in a makefile.
You should never put a NUL in a makefile because it can have strange
results, but otherwise empty lines full of NULs (such as produced by
the `xmkmf' program) will always work fine.
* The error messages for nonexistent included makefiles now refer to the
makefile name and line number where the `include' appeared, so Emacs's
C-x ` command takes you there (in case it's a typo you need to fix).
Version 3.69
* Implicit rule search for archive member references is now done in the
opposite order from previous versions: the whole target name `LIB(MEM)'
first, and just the member name and parentheses `(MEM)' second.
* Make now gives an error for an unterminated variable or function reference.
For example, `$(foo' with no matching `)' or `${bar' with no matching `}'.
* The new default variable `MAKE_VERSION' gives the version number of
Make, and a string describing the remote job support compiled in (if any).
Thus the value (in this release) is something like `3.69' or `3.69-Customs'.
* Commands in an invocation of the `shell' function are no longer run with
a modified environment like target commands are. As in versions before
3.68, they now run with the environment that `make' started with. We
have reversed the change made in version 3.68 because it turned out to
cause a paradoxical situation in cases like:
export variable = $(shell echo value)
When Make attempted to put this variable in the environment for a target
command, it would try expand the value by running the shell command
`echo value'. In version 3.68, because it constructed an environment
for that shell command in the same way, Make would begin to go into an
infinite loop and then get a fatal error when it detected the loop.
* The commands given for `.DEFAULT' are now used for phony targets with no
commands.
Version 3.68
* You can list several archive member names inside parenthesis:
`lib(mem1 mem2 mem3)' is equivalent to `lib(mem1) lib(mem2) lib(mem3)'.
* You can use wildcards inside archive member references. For example,
`lib(*.o)' expands to all existing members of `lib' whose names end in
`.o' (e.g. `lib(a.o) lib(b.o)'); `*.a(*.o)' expands to all such members
of all existing files whose names end in `.a' (e.g. `foo.a(a.o)
foo.a(b.o) bar.a(c.o) bar.a(d.o)'.
* A suffix rule `.X.a' now produces two pattern rules:
(%.o): %.X # Previous versions produced only this.
%.a: %.X # Now produces this as well, just like other suffixes.
* The new flag `--warn-undefined-variables' says to issue a warning message
whenever Make expands a reference to an undefined variable.
* The new `-include' directive is just like `include' except that there is
no error (not even a warning) for a nonexistent makefile.
* Commands in an invocation of the `shell' function are now run with a
modified environment like target commands are, so you can use `export' et
al to set up variables for them. They used to run with the environment
that `make' started with.
Version 3.66
* `make --version' (or `make -v') now exits immediately after printing
the version number.
Version 3.65
* Make now supports long-named members in `ar' archive files.
Version 3.64
* Make now supports the `+=' syntax for a variable definition which appends
to the variable's previous value. See the section `Appending More Text
to Variables' in the manual for full details.
* The new option `--no-print-directory' inhibits the `-w' or
`--print-directory' feature. Make turns on `--print-directory'
automatically if you use `-C' or `--directory', and in sub-makes; some
users have found this behavior undesirable.
* The built-in implicit rules now support the alternative extension
`.txinfo' for Texinfo files, just like `.texinfo' and `.texi'.
Version 3.63
* Make now uses a standard GNU `configure' script. See the new file
INSTALL for the new (and much simpler) installation procedure.
* There is now a shell script to build Make the first time, if you have no
other `make' program. `build.sh' is created by `configure'; see README.
* GNU Make now completely conforms to the POSIX.2 specification for `make'.
* Elements of the `$^' and `$?' automatic variables that are archive
member references now list only the member name, as in Unix and POSIX.2.
* You should no longer ever need to specify the `-w' switch, which prints
the current directory before and after Make runs. The `-C' switch to
change directory, and recursive use of Make, now set `-w' automatically.
* Multiple double-colon rules for the same target will no longer have their
commands run simultaneously under -j, as this could result in the two
commands trying to change the file at the same time and interfering with
one another.
* The `SHELL' variable is now never taken from the environment.
Each makefile that wants a shell other than the default (/bin/sh) must
set SHELL itself. SHELL is always exported to child processes.
This change was made for compatibility with POSIX.2.
* Make now accepts long options. There is now an informative usage message
that tells you what all the options are and what they do. Try `make --help'.
* There are two new directives: `export' and `unexport'. All variables are
no longer automatically put into the environments of the commands that
Make runs. Instead, only variables specified on the command line or in
the environment are exported by default. To export others, use:
export VARIABLE
or you can define variables with:
export VARIABLE = VALUE
or:
export VARIABLE := VALUE
You can use just:
export
or:
.EXPORT_ALL_VARIABLES:
to get the old behavior. See the node `Variables/Recursion' in the manual
for a full description.
* The commands from the `.DEFAULT' special target are only applied to
targets which have no rules at all, not all targets with no commands.
This change was made for compatibility with Unix make.
* All fatal error messages now contain `***', so they are easy to find in
compilation logs.
* Dependency file names like `-lNAME' are now replaced with the actual file
name found, as with files found by normal directory search (VPATH).
The library file `libNAME.a' may now be found in the current directory,
which is checked before VPATH; the standard set of directories (/lib,
/usr/lib, /usr/local/lib) is now checked last.
See the node `Libraries/Search' in the manual for full details.
* A single `include' directive can now specify more than one makefile to
include, like this:
include file1 file2
You can also use shell file name patterns in an `include' directive:
include *.mk
* The default directories to search for included makefiles, and for
libraries specified with `-lNAME', are now set by configuration.
* You can now use blanks as well as colons to separate the directories in a
search path for the `vpath' directive or the `VPATH' variable.
* You can now use variables and functions in the left hand side of a
variable assignment, as in "$(foo)bar = value".
* The `MAKE' variable is always defined as `$(MAKE_COMMAND) $(MAKEOVERRIDES)'.
The `MAKE_COMMAND' variable is now defined to the name with which make
was invoked.
* The built-in rules for C++ compilation now use the variables `$(CXX)' and
`$(CXXFLAGS)' instead of `$(C++)' and `$(C++FLAGS)'. The old names had
problems with shells that cannot have `+' in environment variable names.
* The value of a recursively expanded variable is now expanded when putting
it into the environment for child processes. This change was made for
compatibility with Unix make.
* A rule with no targets before the `:' is now accepted and ignored.
This change was made for compatibility with SunOS 4 make.
We do not recommend that you write your makefiles to take advantage of this.
* The `-I' switch can now be used in MAKEFLAGS, and are put there
automatically just like other switches.
Version 3.61
* Built-in rules for C++ source files with the `.C' suffix.
We still recommend that you use `.cc' instead.
* If commands are given too many times for a single target,
the last set given is used, and a warning message is printed.
* Error messages about makefiles are in standard GNU error format,
so C-x ` in Emacs works on them.
* Dependencies of pattern rules which contain no % need not actually exist
if they can be created (just like dependencies which do have a %).
Version 3.60
* A message is always printed when Make decides there is nothing to be done.
It used to be that no message was printed for top-level phony targets
(because "`phony' is up to date" isn't quite right). Now a different
message "Nothing to be done for `phony'" is printed in that case.
* Archives on AIX now supposedly work.
* When the commands specified for .DEFAULT are used to update a target,
the $< automatic variable is given the same value as $@ for that target.
This is how Unix make behaves, and this behavior is mandated by POSIX.2.
Version 3.59
* The -n, -q, and -t options are not put in the `MAKEFLAGS' and `MFLAG'
variables while remaking makefiles, so recursive makes done while remaking
makefiles will behave properly.
* If the special target `.NOEXPORT' is specified in a makefile,
only variables that came from the environment and variables
defined on the command line are exported.
Version 3.58
* Suffix rules may have dependencies (which are ignored).
Version 3.57
* Dependencies of the form `-lLIB' are searched for as /usr/local/lib/libLIB.a
as well as libLIB.a in /usr/lib, /lib, the current directory, and VPATH.
Version 3.55
* There is now a Unix man page for GNU Make. It is certainly not a replacement
for the Texinfo manual, but it documents the basic functionality and the
switches. For full documentation, you should still read the Texinfo manual.
Thanks to Dennis Morse of Stanford University for contributing the initial
version of this.
* Variables which are defined by default (e.g., `CC') will no longer be put
into the environment for child processes. (If these variables are reset by the
environment, makefiles, or the command line, they will still go into the
environment.)
* Makefiles which have commands but no dependencies (and thus are always
considered out of date and in need of remaking), will not be remade (if they
were being remade only because they were makefiles). This means that GNU
Make will no longer go into an infinite loop when fed the makefiles that
`imake' (necessary to build X Windows) produces.
* There is no longer a warning for using the `vpath' directive with an explicit
pathname (instead of a `%' pattern).
Version 3.51
* When removing intermediate files, only one `rm' command line is printed,
listing all file names.
* There are now automatic variables `$(^D)', `$(^F)', `$(?D)', and `$(?F)'.
These are the directory-only and file-only versions of `$^' and `$?'.
* Library dependencies given as `-lNAME' will use "libNAME.a" in the current
directory if it exists.
* The automatic variable `$($/)' is no longer defined.
* Leading `+' characters on a command line make that line be executed even
under -n, -t, or -q (as if the line contained `$(MAKE)').
* For command lines containing `$(MAKE)', `${MAKE}', or leading `+' characters,
only those lines are executed, not their entire rules.
(This is how Unix make behaves for lines containing `$(MAKE)' or `${MAKE}'.)
Version 3.50
* Filenames in rules will now have ~ and ~USER expanded.
* The `-p' output has been changed so it can be used as a makefile.
(All information that isn't specified by makefiles is prefaced with comment
characters.)
Version 3.49
* The % character can be quoted with backslash in implicit pattern rules,
static pattern rules, `vpath' directives, and `patsubst', `filter', and
`filter-out' functions. A warning is issued if a `vpath' directive's
pattern contains no %.
* The `wildcard' variable expansion function now expands ~ and ~USER.
* Messages indicating failed commands now contain the target name:
make: *** [target] Error 1
* The `-p' output format has been changed somewhat to look more like
makefile rules and to give all information that Make has about files.
Version 3.48
Version 3.47
* The `-l' switch with no argument removes any previous load-average limit.
* When the `-w' switch is in effect, and Make has updated makefiles,
it will write a `Leaving directory' messagfe before re-executing itself.
This makes the `directory change tracking' changes to Emacs's compilation
commands work properly.
Version 3.46
* The automatic variable `$*' is now defined for explicit rules,
as it is in Unix make.
Version 3.45
* The `-j' switch is now put in the MAKEFLAGS and MFLAGS variables when
specified without an argument (indicating infinite jobs).
The `-l' switch is not always put in the MAKEFLAGS and MFLAGS variables.
* Make no longer checks hashed directories after running commands.
The behavior implemented in 3.41 caused too much slowdown.
Version 3.44
* A dependency is NOT considered newer than its dependent if
they have the same modification time. The behavior implemented
in 3.43 conflicts with RCS.
Version 3.43
* Dependency loops are no longer fatal errors.
* A dependency is considered newer than its dependent if
they have the same modification time.
Version 3.42
* The variables F77 and F77FLAGS are now set by default to $(FC) and
$(FFLAGS). Makefiles designed for System V make may use these variables in
explicit rules and expect them to be set. Unfortunately, there is no way to
make setting these affect the Fortran implicit rules unless FC and FFLAGS
are not used (and these are used by BSD make).
Version 3.41
* Make now checks to see if its hashed directories are changed by commands.
Other makes that hash directories (Sun, 4.3 BSD) don't do this.
Version 3.39
* The `shell' function no longer captures standard error output.
Version 3.32
* A file beginning with a dot can be the default target if it also contains
a slash (e.g., `../bin/foo'). (Unix make allows this as well.)
Version 3.31
* Archive member names are truncated to 15 characters.
* Yet more USG stuff.
* Minimal support for Microport System V (a 16-bit machine and a
brain-damaged compiler). This has even lower priority than other USG
support, so if it gets beyond trivial, I will take it out completely.
* Revamped default implicit rules (not much visible change).
* The -d and -p options can come from the environment.
Version 3.30
* Improved support for USG and HPUX (hopefully).
* A variable reference like `$(foo:a=b)', if `a' contains a `%', is
equivalent to `$(patsubst a,b,$(foo))'.
* Defining .DEFAULT with no deps or commands clears its commands.
* New default implicit rules for .S (cpp, then as), and .sh (copy and make
executable). All default implicit rules that use cpp (even indirectly), use
$(CPPFLAGS).
Version 3.29
* Giving the -j option with no arguments gives you infinite jobs.
Version 3.28
* New option: "-l LOAD" says not to start any new jobs while others are
running if the load average is not below LOAD (a floating-point number).
* There is support in place for implementations of remote command execution
in Make. See the file remote.c.
Version 3.26
* No more than 10 directories will be kept open at once.
(This number can be changed by redefining MAX_OPEN_DIRECTORIES in dir.c.)
Version 3.25
* Archive files will have their modification times recorded before doing
anything that might change their modification times by updating an archive
member.
Version 3.20
* The `MAKELEVEL' variable is defined for use by makefiles.
Version 3.19
* The recursion level indications in error messages are much shorter than
they were in version 3.14.
Version 3.18
* Leading spaces before directives are ignored (as documented).
* Included makefiles can determine the default goal target.
(System V Make does it this way, so we are being compatible).
Version 3.14.
* Variables that are defaults built into Make will not be put in the
environment for children. This just saves some environment space and,
except under -e, will be transparent to sub-makes.
* Error messages from sub-makes will indicate the level of recursion.
* Hopefully some speed-up for large directories due to a change in the
directory hashing scheme.
* One child will always get a standard input that is usable.
* Default makefiles that don't exist will be remade and read in.
Version 3.13.
* Count parentheses inside expansion function calls so you can
have nested calls: `$(sort $(foreach x,a b,$(x)))'.
Version 3.12.
* Several bug fixes, including USG and Sun386i support.
* `shell' function to expand shell commands a la `
* If the `-d' flag is given, version information will be printed.
* The `-c' option has been renamed to `-C' for compatibility with tar.
* The `-p' option no longer inhibits other normal operation.
* Makefiles will be updated and re-read if necessary.
* Can now run several commands at once (parallelism), -j option.
* Error messages will contain the level of Make recursion, if any.
* The `MAKEFLAGS' and `MFLAGS' variables will be scanned for options after
makefiles are read.
* A double-colon rule with no dependencies will always have its commands run.
(This is how both the BSD and System V versions of Make do it.)
Version 3.05
(Changes from versions 1 through 3.05 were never recorded. Sorry.)
----------------------------------------------------------------------
Copyright information:
Copyright (C) 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
Permission is granted to anyone to make or distribute verbatim copies
of this document as received, in any medium, provided that the
copyright notice and this permission notice are preserved,
thus giving the recipient permission to redistribute in turn.
Permission is granted to distribute modified versions
of this document, or of portions of it,
under the above conditions, provided also that they
carry prominent notices stating who last changed them.
Local variables:
version-control: never
end:

128
buildtools/windows/source/make/NMakefile
View File

@ -1,128 +0,0 @@
# NOTE: If you have no `make' program at all to process this makefile, run
# `build_w32.bat' instead.
#
# Copyright (C) 1988, 89, 91, 92, 93, 94, 95, 1996 Free Software Foundation, Inc.
# This file is part of GNU Make.
#
# GNU Make is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
#
# GNU Make is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with GNU Make; see the file COPYING. If not, write to
# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
#
# NMakefile for GNU Make
#
LINK = link
CC = cl
OUTDIR=.
MAKEFILE=NMakefile
# The cl switches we use:
# /Fd<filename> renames program database file
# /Fo<filename> creates an object file
# /Fp<filename> specifies a precompiled header file name
# /O2 creates fast code
# /Od disables optimization
# /W sets warning levels
# /YX Automates precompiled header
# /Zi Generates complete debugging information
CFLAGS_any = /nologo /W3 /YX /I . /I glob /D NETSCAPE /D WIN32 /D _CONSOLE /D HAVE_CONFIG_H
CFLAGS_debug = $(CFLAGS_any) /MLd /Zi /Od /D _DEBUG /FpWinDebug/make.pch /FoWinDebug/ /FdWinDebug/make.pdb
CFLAGS_release = $(CFLAGS_any) /ML /O2 /D NDEBUG /FpWinRel/make.pch /FoWinRel/
LDFLAGS_debug = /NOLOGO /SUBSYSTEM:console\
/INCREMENTAL:no /PDB:WinDebug/make.pdb \
/OUT:WinDebug/make.exe /DEBUG
LDFLAGS_release = /NOLOGO /SUBSYSTEM:console\
/INCREMENTAL:no /OUT:WinRel/make.exe
all: Release Debug
Release:
nmake /f $(MAKEFILE) LDFLAGS="$(LDFLAGS_release)" CFLAGS="$(CFLAGS_release)" OUTDIR=WinRel WinRel/make.exe
Debug:
nmake /f $(MAKEFILE) LDFLAGS="$(LDFLAGS_debug)" CFLAGS="$(CFLAGS_debug)" OUTDIR=WinDebug WinDebug/make.exe
clean:
rmdir /s /q WinDebug WinRel
$(OUTDIR):
if not exist .\$@\nul mkdir .\$@
#LIBS = kernel32.lib user32.lib advapi32.lib
#LIBS = kernel32.lib
OBJS = \
$(OUTDIR)/ar.obj \
$(OUTDIR)/arscan.obj \
$(OUTDIR)/commands.obj \
$(OUTDIR)/default.obj \
$(OUTDIR)/dir.obj \
$(OUTDIR)/expand.obj \
$(OUTDIR)/file.obj \
$(OUTDIR)/function.obj \
$(OUTDIR)/getloadavg.obj \
$(OUTDIR)/getopt.obj \
$(OUTDIR)/getopt1.obj \
$(OUTDIR)/implicit.obj \
$(OUTDIR)/job.obj \
$(OUTDIR)/main.obj \
$(OUTDIR)/misc.obj \
$(OUTDIR)/read.obj \
$(OUTDIR)/remake.obj \
$(OUTDIR)/remote-stub.obj \
$(OUTDIR)/rule.obj \
$(OUTDIR)/signame.obj \
$(OUTDIR)/variable.obj \
$(OUTDIR)/version.obj \
$(OUTDIR)/vpath.obj \
$(OUTDIR)/glob.obj \
$(OUTDIR)/fnmatch.obj
$(OUTDIR)/make.exe: $(OUTDIR) $(OBJS)
$(LINK) @<<
$(LDFLAGS) $(LIBS) $(OBJS)
<<
.c{$(OUTDIR)}.obj:
$(CC) $(CFLAGS) /c $<
$(OUTDIR)/ar.obj : ar.c make.h file.h dep.h
$(OUTDIR)/arscan.obj : arscan.c make.h
$(OUTDIR)/commands.obj : commands.c
$(OUTDIR)/default.obj : default.c make.h rule.h dep.h file.h job.h commands.h variable.h
$(OUTDIR)/dir.obj : dir.c make.h
$(OUTDIR)/expand.obj : expand.c make.h file.h job.h commands.h variable.h
$(OUTDIR)/file.obj : file.c make.h dep.h file.h job.h commands.h variable.h
$(OUTDIR)/function.obj : function.c make.h file.h variable.h dep.h job.h commands.h
$(OUTDIR)/getloadavg.obj : getloadavg.c
$(OUTDIR)/getopt.obj : getopt.c
$(OUTDIR)/getopt1.obj : getopt1.c getopt.h
$(OUTDIR)/implicit.obj : implicit.c make.h rule.h dep.h file.h
$(OUTDIR)/job.obj : job.c make.h job.h file.h commands.h variable.h
$(OUTDIR)/main.obj : main.c make.h dep.h file.h variable.h job.h commands.h getopt.h
$(OUTDIR)/misc.obj : misc.c make.h dep.h
$(OUTDIR)/read.obj : read.c make.h dep.h file.h job.h commands.h variable.h glob/glob.h
$(OUTDIR)/remake.obj : remake.c make.h file.h job.h commands.h dep.h
$(OUTDIR)/remote-stub.obj : remote-stub.c make.h file.h job.h commands.h
$(OUTDIR)/rule.obj : rule.c make.h dep.h file.h job.h commands.h variable.h rule.h
$(OUTDIR)/signame.obj : signame.c signame.h
$(OUTDIR)/variable.obj : variable.c make.h dep.h file.h job.h commands.h variable.h
$(OUTDIR)/version.obj : version.c
$(OUTDIR)/vpath.obj : vpath.c make.h file.h variable.h
$(OUTDIR)/glob.obj : glob/glob.c
$(CC) $(CFLAGS) /c glob/glob.c
$(OUTDIR)/fnmatch.obj : glob/fnmatch.c
$(CC) $(CFLAGS) /c glob/fnmatch.c

28
buildtools/windows/source/make/README
View File

@ -1,28 +0,0 @@
This directory contains the 3.74 test release of GNU Make.
All bugs reported for previous test releases have been fixed.
Some bugs surely remain.
For general building and installation instructions, see the file INSTALL.
If you need to build GNU Make and have no other `make' program to use,
you can use the shell script `build.sh' instead. To do this, first run
`configure' as described in INSTALL. Then, instead of typing `make' to
build the program, type `sh build.sh'. This should compile the program
in the current directory. Then you will have a Make program that you can
use for `make install', or whatever else.
It has been reported that the XLC 1.2 compiler on AIX 3.2 is buggy such
that if you compile make with `cc -O' on AIX 3.2, it will not work correctly.
It is said that using `cc' without `-O' does work.
One area that is often a problem in configuration and porting is the code
to check the system's current load average. To make it easier to test and
debug this code, you can do `make check-loadavg' to see if it works
properly on your system. (You must run `configure' beforehand, but you
need not build Make itself to run this test.)
See the file NEWS for what has changed since previous releases.
GNU Make is fully documented in make.texinfo. See the section entitled
`Problems and Bugs' for information on submitting bug reports.
GNU Make is free software. See the file COPYING for copying conditions.

16
buildtools/windows/source/make/README.MOZILLA
View File

@ -1,16 +0,0 @@
This directory contains the source files for the GNU make
that is used to build some components (e.g., NSPR) on Win32.
This GNU make is based on version 3.74 and was ported to
Win32 by Netscape engineers. Its default shell is shmsdos.exe,
a lightweight shell written by Netscape engineers.
To build it, you need Microsoft Visual C++ and nmake. If
you want to change the build number, which is displayed by
the '-v' command line option, you can edit the value of the
macro BUILD_NUMBER in main.c. Then, issue the command:
nmake /f NMakefile
The outputs are WinDebug\make.exe and WinRel\make.exe.
Assuming you want to use the optmized executable file,
copy WinRel\make.exe to a directory on your Path and
rename it gmake.exe.

17
buildtools/windows/source/make/acconfig.h
View File

@ -1,17 +0,0 @@
/* Define to the name of the SCCS `get' command. */
#undef SCCS_GET
/* Define this if the SCCS `get' command understands the `-G<file>' option. */
#undef SCCS_GET_MINUS_G
/* Define this if the C library defines the variable `sys_siglist'. */
#undef HAVE_SYS_SIGLIST
/* Define this if the C library defines the variable `_sys_siglist'. */
#undef HAVE__SYS_SIGLIST
/* Define this if you have the `union wait' type in <sys/wait.h>. */
#undef HAVE_UNION_WAIT
/* Define this if the POSIX.1 call `sysconf (_SC_OPEN_MAX)' works properly. */
#undef HAVE_SYSCONF_OPEN_MAX

492
buildtools/windows/source/make/alloca.c
View File

@ -1,492 +0,0 @@
/* alloca.c -- allocate automatically reclaimed memory
(Mostly) portable public-domain implementation -- D A Gwyn
This implementation of the PWB library alloca function,
which is used to allocate space off the run-time stack so
that it is automatically reclaimed upon procedure exit,
was inspired by discussions with J. Q. Johnson of Cornell.
J.Otto Tennant <jot@cray.com> contributed the Cray support.
There are some preprocessor constants that can
be defined when compiling for your specific system, for
improved efficiency; however, the defaults should be okay.
The general concept of this implementation is to keep
track of all alloca-allocated blocks, and reclaim any
that are found to be deeper in the stack than the current
invocation. This heuristic does not reclaim storage as
soon as it becomes invalid, but it will do so eventually.
As a special case, alloca(0) reclaims storage without
allocating any. It is a good idea to use alloca(0) in
your main control loop, etc. to force garbage collection. */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#ifdef emacs
#include "blockinput.h"
#endif
/* If compiling with GCC 2, this file's not needed. */
#if !defined (__GNUC__) || __GNUC__ < 2
/* If someone has defined alloca as a macro,
there must be some other way alloca is supposed to work. */
#ifndef alloca
#ifdef emacs
#ifdef static
/* actually, only want this if static is defined as ""
-- this is for usg, in which emacs must undefine static
in order to make unexec workable
*/
#ifndef STACK_DIRECTION
you
lose
-- must know STACK_DIRECTION at compile-time
#endif /* STACK_DIRECTION undefined */
#endif /* static */
#endif /* emacs */
/* If your stack is a linked list of frames, you have to
provide an "address metric" ADDRESS_FUNCTION macro. */
#if defined (CRAY) && defined (CRAY_STACKSEG_END)
long i00afunc ();
#define ADDRESS_FUNCTION(arg) (char *) i00afunc (&(arg))
#else
#define ADDRESS_FUNCTION(arg) &(arg)
#endif
#if __STDC__
typedef void *pointer;
#else
typedef char *pointer;
#endif
#define NULL 0
/* Different portions of Emacs need to call different versions of
malloc. The Emacs executable needs alloca to call xmalloc, because
ordinary malloc isn't protected from input signals. On the other
hand, the utilities in lib-src need alloca to call malloc; some of
them are very simple, and don't have an xmalloc routine.
Non-Emacs programs expect this to call use xmalloc.
Callers below should use malloc. */
#ifndef emacs
#define malloc xmalloc
#endif
extern pointer malloc ();
/* Define STACK_DIRECTION if you know the direction of stack
growth for your system; otherwise it will be automatically
deduced at run-time.
STACK_DIRECTION > 0 => grows toward higher addresses
STACK_DIRECTION < 0 => grows toward lower addresses
STACK_DIRECTION = 0 => direction of growth unknown */
#ifndef STACK_DIRECTION
#define STACK_DIRECTION 0 /* Direction unknown. */
#endif
#if STACK_DIRECTION != 0
#define STACK_DIR STACK_DIRECTION /* Known at compile-time. */
#else /* STACK_DIRECTION == 0; need run-time code. */
static int stack_dir; /* 1 or -1 once known. */
#define STACK_DIR stack_dir
static void
find_stack_direction ()
{
static char *addr = NULL; /* Address of first `dummy', once known. */
auto char dummy; /* To get stack address. */
if (addr == NULL)
{ /* Initial entry. */
addr = ADDRESS_FUNCTION (dummy);
find_stack_direction (); /* Recurse once. */
}
else
{
/* Second entry. */
if (ADDRESS_FUNCTION (dummy) > addr)
stack_dir = 1; /* Stack grew upward. */
else
stack_dir = -1; /* Stack grew downward. */
}
}
#endif /* STACK_DIRECTION == 0 */
/* An "alloca header" is used to:
(a) chain together all alloca'ed blocks;
(b) keep track of stack depth.
It is very important that sizeof(header) agree with malloc
alignment chunk size. The following default should work okay. */
#ifndef ALIGN_SIZE
#define ALIGN_SIZE sizeof(double)
#endif
typedef union hdr
{
char align[ALIGN_SIZE]; /* To force sizeof(header). */
struct
{
union hdr *next; /* For chaining headers. */
char *deep; /* For stack depth measure. */
} h;
} header;
static header *last_alloca_header = NULL; /* -> last alloca header. */
/* Return a pointer to at least SIZE bytes of storage,
which will be automatically reclaimed upon exit from
the procedure that called alloca. Originally, this space
was supposed to be taken from the current stack frame of the
caller, but that method cannot be made to work for some
implementations of C, for example under Gould's UTX/32. */
pointer
alloca (size)
unsigned size;
{
auto char probe; /* Probes stack depth: */
register char *depth = ADDRESS_FUNCTION (probe);
#if STACK_DIRECTION == 0
if (STACK_DIR == 0) /* Unknown growth direction. */
find_stack_direction ();
#endif
/* Reclaim garbage, defined as all alloca'd storage that
was allocated from deeper in the stack than currently. */
{
register header *hp; /* Traverses linked list. */
#ifdef emacs
BLOCK_INPUT;
#endif
for (hp = last_alloca_header; hp != NULL;)
if ((STACK_DIR > 0 && hp->h.deep > depth)
|| (STACK_DIR < 0 && hp->h.deep < depth))
{
register header *np = hp->h.next;
free ((pointer) hp); /* Collect garbage. */
hp = np; /* -> next header. */
}
else
break; /* Rest are not deeper. */
last_alloca_header = hp; /* -> last valid storage. */
#ifdef emacs
UNBLOCK_INPUT;
#endif
}
if (size == 0)
return NULL; /* No allocation required. */
/* Allocate combined header + user data storage. */
{
register pointer new = malloc (sizeof (header) + size);
/* Address of header. */
((header *) new)->h.next = last_alloca_header;
((header *) new)->h.deep = depth;
last_alloca_header = (header *) new;
/* User storage begins just after header. */
return (pointer) ((char *) new + sizeof (header));
}
}
#if defined (CRAY) && defined (CRAY_STACKSEG_END)
#ifdef DEBUG_I00AFUNC
#include <stdio.h>
#endif
#ifndef CRAY_STACK
#define CRAY_STACK
#ifndef CRAY2
/* Stack structures for CRAY-1, CRAY X-MP, and CRAY Y-MP */
struct stack_control_header
{
long shgrow:32; /* Number of times stack has grown. */
long shaseg:32; /* Size of increments to stack. */
long shhwm:32; /* High water mark of stack. */
long shsize:32; /* Current size of stack (all segments). */
};
/* The stack segment linkage control information occurs at
the high-address end of a stack segment. (The stack
grows from low addresses to high addresses.) The initial
part of the stack segment linkage control information is
0200 (octal) words. This provides for register storage
for the routine which overflows the stack. */
struct stack_segment_linkage
{
long ss[0200]; /* 0200 overflow words. */
long sssize:32; /* Number of words in this segment. */
long ssbase:32; /* Offset to stack base. */
long:32;
long sspseg:32; /* Offset to linkage control of previous
segment of stack. */
long:32;
long sstcpt:32; /* Pointer to task common address block. */
long sscsnm; /* Private control structure number for
microtasking. */
long ssusr1; /* Reserved for user. */
long ssusr2; /* Reserved for user. */
long sstpid; /* Process ID for pid based multi-tasking. */
long ssgvup; /* Pointer to multitasking thread giveup. */
long sscray[7]; /* Reserved for Cray Research. */
long ssa0;
long ssa1;
long ssa2;
long ssa3;
long ssa4;
long ssa5;
long ssa6;
long ssa7;
long sss0;
long sss1;
long sss2;
long sss3;
long sss4;
long sss5;
long sss6;
long sss7;
};
#else /* CRAY2 */
/* The following structure defines the vector of words
returned by the STKSTAT library routine. */
struct stk_stat
{
long now; /* Current total stack size. */
long maxc; /* Amount of contiguous space which would
be required to satisfy the maximum
stack demand to date. */
long high_water; /* Stack high-water mark. */
long overflows; /* Number of stack overflow ($STKOFEN) calls. */
long hits; /* Number of internal buffer hits. */
long extends; /* Number of block extensions. */
long stko_mallocs; /* Block allocations by $STKOFEN. */
long underflows; /* Number of stack underflow calls ($STKRETN). */
long stko_free; /* Number of deallocations by $STKRETN. */
long stkm_free; /* Number of deallocations by $STKMRET. */
long segments; /* Current number of stack segments. */
long maxs; /* Maximum number of stack segments so far. */
long pad_size; /* Stack pad size. */
long current_address; /* Current stack segment address. */
long current_size; /* Current stack segment size. This
number is actually corrupted by STKSTAT to
include the fifteen word trailer area. */
long initial_address; /* Address of initial segment. */
long initial_size; /* Size of initial segment. */
};
/* The following structure describes the data structure which trails
any stack segment. I think that the description in 'asdef' is
out of date. I only describe the parts that I am sure about. */
struct stk_trailer
{
long this_address; /* Address of this block. */
long this_size; /* Size of this block (does not include
this trailer). */
long unknown2;
long unknown3;
long link; /* Address of trailer block of previous
segment. */
long unknown5;
long unknown6;
long unknown7;
long unknown8;
long unknown9;
long unknown10;
long unknown11;
long unknown12;
long unknown13;
long unknown14;
};
#endif /* CRAY2 */
#endif /* not CRAY_STACK */
#ifdef CRAY2
/* Determine a "stack measure" for an arbitrary ADDRESS.
I doubt that "lint" will like this much. */
static long
i00afunc (long *address)
{
struct stk_stat status;
struct stk_trailer *trailer;
long *block, size;
long result = 0;
/* We want to iterate through all of the segments. The first
step is to get the stack status structure. We could do this
more quickly and more directly, perhaps, by referencing the
$LM00 common block, but I know that this works. */
STKSTAT (&status);
/* Set up the iteration. */
trailer = (struct stk_trailer *) (status.current_address
+ status.current_size
- 15);
/* There must be at least one stack segment. Therefore it is
a fatal error if "trailer" is null. */
if (trailer == 0)
abort ();
/* Discard segments that do not contain our argument address. */
while (trailer != 0)
{
block = (long *) trailer->this_address;
size = trailer->this_size;
if (block == 0 || size == 0)
abort ();
trailer = (struct stk_trailer *) trailer->link;
if ((block <= address) && (address < (block + size)))
break;
}
/* Set the result to the offset in this segment and add the sizes
of all predecessor segments. */
result = address - block;
if (trailer == 0)
{
return result;
}
do
{
if (trailer->this_size <= 0)
abort ();
result += trailer->this_size;
trailer = (struct stk_trailer *) trailer->link;
}
while (trailer != 0);
/* We are done. Note that if you present a bogus address (one
not in any segment), you will get a different number back, formed
from subtracting the address of the first block. This is probably
not what you want. */
return (result);
}
#else /* not CRAY2 */
/* Stack address function for a CRAY-1, CRAY X-MP, or CRAY Y-MP.
Determine the number of the cell within the stack,
given the address of the cell. The purpose of this
routine is to linearize, in some sense, stack addresses
for alloca. */
static long
i00afunc (long address)
{
long stkl = 0;
long size, pseg, this_segment, stack;
long result = 0;
struct stack_segment_linkage *ssptr;
/* Register B67 contains the address of the end of the
current stack segment. If you (as a subprogram) store
your registers on the stack and find that you are past
the contents of B67, you have overflowed the segment.
B67 also points to the stack segment linkage control
area, which is what we are really interested in. */
stkl = CRAY_STACKSEG_END ();
ssptr = (struct stack_segment_linkage *) stkl;
/* If one subtracts 'size' from the end of the segment,
one has the address of the first word of the segment.
If this is not the first segment, 'pseg' will be
nonzero. */
pseg = ssptr->sspseg;
size = ssptr->sssize;
this_segment = stkl - size;
/* It is possible that calling this routine itself caused
a stack overflow. Discard stack segments which do not
contain the target address. */
while (!(this_segment <= address && address <= stkl))
{
#ifdef DEBUG_I00AFUNC
fprintf (stderr, "%011o %011o %011o\n", this_segment, address, stkl);
#endif
if (pseg == 0)
break;
stkl = stkl - pseg;
ssptr = (struct stack_segment_linkage *) stkl;
size = ssptr->sssize;
pseg = ssptr->sspseg;
this_segment = stkl - size;
}
result = address - this_segment;
/* If you subtract pseg from the current end of the stack,
you get the address of the previous stack segment's end.
This seems a little convoluted to me, but I'll bet you save
a cycle somewhere. */
while (pseg != 0)
{
#ifdef DEBUG_I00AFUNC
fprintf (stderr, "%011o %011o\n", pseg, size);
#endif
stkl = stkl - pseg;
ssptr = (struct stack_segment_linkage *) stkl;
size = ssptr->sssize;
pseg = ssptr->sspseg;
result += size;
}
return (result);
}
#endif /* not CRAY2 */
#endif /* CRAY */
#endif /* no alloca */
#endif /* not GCC version 2 */

317
buildtools/windows/source/make/ar.c
View File

@ -1,317 +0,0 @@
/* Interface to `ar' archives for GNU Make.
Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
This file is part of GNU Make.
GNU Make is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Make is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Make; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "make.h"
#ifndef NO_ARCHIVES
#include "file.h"
#include "dep.h"
#include <fnmatch.h>
/* Defined in arscan.c. */
extern long int ar_scan ();
extern int ar_member_touch ();
extern int ar_name_equal ();
/* Return nonzero if NAME is an archive-member reference, zero if not.
An archive-member reference is a name like `lib(member)'.
If a name like `lib((entry))' is used, a fatal error is signaled at
the attempt to use this unsupported feature. */
int
ar_name (name)
char *name;
{
char *p = index (name, '('), *end = name + strlen (name) - 1;
if (p == 0 || p == name || *end != ')')
return 0;
if (p[1] == '(' && end[-1] == ')')
fatal ("attempt to use unsupported feature: `%s'", name);
return 1;
}
/* Parse the archive-member reference NAME into the archive and member names.
Put the malloc'd archive name in *ARNAME_P if ARNAME_P is non-nil;
put the malloc'd member name in *MEMNAME_P if MEMNAME_P is non-nil. */
void
ar_parse_name (name, arname_p, memname_p)
char *name, **arname_p, **memname_p;
{
char *p = index (name, '('), *end = name + strlen (name) - 1;
if (arname_p != 0)
*arname_p = savestring (name, p - name);
if (memname_p != 0)
*memname_p = savestring (p + 1, end - (p + 1));
}
static long int ar_member_date_1 ();
/* Return the modtime of NAME. */
time_t
ar_member_date (name)
char *name;
{
char *arname;
int arname_used = 0;
char *memname;
long int val;
ar_parse_name (name, &arname, &memname);
/* Make sure we know the modtime of the archive itself because we are
likely to be called just before commands to remake a member are run,
and they will change the archive itself.
But we must be careful not to enter_file the archive itself if it does
not exist, because pattern_search assumes that files found in the data
base exist or can be made. */
{
struct file *arfile;
arfile = lookup_file (arname);
if (arfile == 0 && file_exists_p (arname))
{
arfile = enter_file (arname);
arname_used = 1;
}
if (arfile != 0)
(void) f_mtime (arfile, 0);
}
val = ar_scan (arname, ar_member_date_1, (long int) memname);
if (!arname_used)
free (arname);
free (memname);
return (val <= 0 ? (time_t) -1 : (time_t) val);
}
/* This function is called by `ar_scan' to find which member to look at. */
/* ARGSUSED */
static long int
ar_member_date_1 (desc, mem, truncated,
hdrpos, datapos, size, date, uid, gid, mode, name)
int desc;
char *mem;
int truncated;
long int hdrpos, datapos, size, date;
int uid, gid, mode;
char *name;
{
return ar_name_equal (name, mem, truncated) ? date : 0;
}
/* Set the archive-member NAME's modtime to now. */
int
ar_touch (name)
char *name;
{
char *arname, *memname;
int arname_used = 0;
register int val;
ar_parse_name (name, &arname, &memname);
/* Make sure we know the modtime of the archive itself before we
touch the member, since this will change the archive itself. */
{
struct file *arfile;
arfile = lookup_file (arname);
if (arfile == 0)
{
arfile = enter_file (arname);
arname_used = 1;
}
(void) f_mtime (arfile, 0);
}
val = 1;
switch (ar_member_touch (arname, memname))
{
case -1:
error ("touch: Archive `%s' does not exist", arname);
break;
case -2:
error ("touch: `%s' is not a valid archive", arname);
break;
case -3:
perror_with_name ("touch: ", arname);
break;
case 1:
error ("touch: Member `%s' does not exist in `%s'", memname, arname);
break;
case 0:
val = 0;
break;
default:
error ("touch: Bad return code from ar_member_touch on `%s'", name);
}
if (!arname_used)
free (arname);
free (memname);
return val;
}
/* State of an `ar_glob' run, passed to `ar_glob_match'. */
struct ar_glob_state
{
char *arname;
char *pattern;
unsigned int size;
struct nameseq *chain;
unsigned int n;
};
/* This function is called by `ar_scan' to match one archive
element against the pattern in STATE. */
static long int
ar_glob_match (desc, mem, truncated,
hdrpos, datapos, size, date, uid, gid, mode,
state)
int desc;
char *mem;
int truncated;
long int hdrpos, datapos, size, date;
int uid, gid, mode;
struct ar_glob_state *state;
{
if (fnmatch (state->pattern, mem, FNM_PATHNAME|FNM_PERIOD) == 0)
{
/* We have a match. Add it to the chain. */
struct nameseq *new = (struct nameseq *) xmalloc (state->size);
new->name = concat (state->arname, mem, ")");
new->next = state->chain;
state->chain = new;
++state->n;
}
return 0L;
}
/* Alphabetic sorting function for `qsort'. */
static int
ar_glob_alphacompare (a, b)
char **a, **b;
{
return strcmp (*a, *b);
}
/* Return nonzero if PATTERN contains any metacharacters.
Metacharacters can be quoted with backslashes if QUOTE is nonzero. */
static int
glob_pattern_p (pattern, quote)
const char *pattern;
const int quote;
{
register const char *p;
int open = 0;
for (p = pattern; *p != '\0'; ++p)
switch (*p)
{
case '?':
case '*':
return 1;
case '\\':
if (quote)
++p;
break;
case '[':
open = 1;
break;
case ']':
if (open)
return 1;
break;
}
return 0;
}
/* Glob for MEMBER_PATTERN in archive ARNAME.
Return a malloc'd chain of matching elements (or nil if none). */
struct nameseq *
ar_glob (arname, member_pattern, size)
char *arname, *member_pattern;
unsigned int size;
{
struct ar_glob_state state;
char **names;
struct nameseq *n;
unsigned int i;
if (! glob_pattern_p (member_pattern, 1))
return 0;
/* Scan the archive for matches.
ar_glob_match will accumulate them in STATE.chain. */
i = strlen (arname);
state.arname = (char *) alloca (i + 2);
bcopy (arname, state.arname, i);
state.arname[i] = '(';
state.arname[i + 1] = '\0';
state.pattern = member_pattern;
state.size = size;
state.chain = 0;
state.n = 0;
(void) ar_scan (arname, ar_glob_match, (long int) &state);
if (state.chain == 0)
return 0;
/* Now put the names into a vector for sorting. */
names = (char **) alloca (state.n * sizeof (char *));
i = 0;
for (n = state.chain; n != 0; n = n->next)
names[i++] = n->name;
/* Sort them alphabetically. */
qsort ((char *) names, i, sizeof (*names), ar_glob_alphacompare);
/* Put them back into the chain in the sorted order. */
i = 0;
for (n = state.chain; n != 0; n = n->next)
n->name = names[i++];
return state.chain;
}
#endif /* Not NO_ARCHIVES. */

561
buildtools/windows/source/make/arscan.c
View File

@ -1,561 +0,0 @@
/* Library function for scanning an archive file.
Copyright (C) 1987, 89, 91, 92, 93, 94 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "make.h"
#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#else
#include <sys/file.h>
#endif
#ifndef NO_ARCHIVES
/* SCO Unix's compiler defines both of these. */
#ifdef M_UNIX
#undef M_XENIX
#endif
/* On the sun386i and in System V rel 3, ar.h defines two different archive
formats depending upon whether you have defined PORTAR (normal) or PORT5AR
(System V Release 1). There is no default, one or the other must be defined
to have a nonzero value. */
#if (!defined (PORTAR) || PORTAR == 0) && (!defined (PORT5AR) || PORT5AR == 0)
#undef PORTAR
#ifdef M_XENIX
/* According to Jim Sievert <jas1@rsvl.unisys.com>, for SCO XENIX defining
PORTAR to 1 gets the wrong archive format, and defining it to 0 gets the
right one. */
#define PORTAR 0
#else
#define PORTAR 1
#endif
#endif
#include <ar.h>
/* Cray's <ar.h> apparently defines this. */
#ifndef AR_HDR_SIZE
#define AR_HDR_SIZE (sizeof (struct ar_hdr))
#endif
/* Takes three arguments ARCHIVE, FUNCTION and ARG.
Open the archive named ARCHIVE, find its members one by one,
and for each one call FUNCTION with the following arguments:
archive file descriptor for reading the data,
member name,
member name might be truncated flag,
member header position in file,
member data position in file,
member data size,
member date,
member uid,
member gid,
member protection mode,
ARG.
The descriptor is poised to read the data of the member
when FUNCTION is called. It does not matter how much
data FUNCTION reads.
If FUNCTION returns nonzero, we immediately return
what FUNCTION returned.
Returns -1 if archive does not exist,
Returns -2 if archive has invalid format.
Returns 0 if have scanned successfully. */
long int
ar_scan (archive, function, arg)
char *archive;
long int (*function) ();
long int arg;
{
#ifdef AIAMAG
FL_HDR fl_header;
#else
int long_name = 0;
#endif
char *namemap = 0;
register int desc = open (archive, O_RDONLY, 0);
if (desc < 0)
return -1;
#ifdef SARMAG
{
char buf[SARMAG];
register int nread = read (desc, buf, SARMAG);
if (nread != SARMAG || bcmp (buf, ARMAG, SARMAG))
{
(void) close (desc);
return -2;
}
}
#else
#ifdef AIAMAG
{
register int nread = read (desc, (char *) &fl_header, FL_HSZ);
if (nread != FL_HSZ || bcmp (fl_header.fl_magic, AIAMAG, SAIAMAG))
{
(void) close (desc);
return -2;
}
}
#else
{
#ifndef M_XENIX
int buf;
#else
unsigned short int buf;
#endif
register int nread = read(desc, &buf, sizeof (buf));
if (nread != sizeof (buf) || buf != ARMAG)
{
(void) close (desc);
return -2;
}
}
#endif
#endif
/* Now find the members one by one. */
{
#ifdef SARMAG
register long int member_offset = SARMAG;
#else
#ifdef AIAMAG
long int member_offset;
long int last_member_offset;
sscanf (fl_header.fl_fstmoff, "%12ld", &member_offset);
sscanf (fl_header.fl_lstmoff, "%12ld", &last_member_offset);
#else
#ifndef M_XENIX
register long int member_offset = sizeof (int);
#else /* Xenix. */
register long int member_offset = sizeof (unsigned short int);
#endif /* Not Xenix. */
#endif
#endif
while (1)
{
register int nread;
struct ar_hdr member_header;
#ifdef AIAMAG
char name[256];
int name_len;
long int dateval;
int uidval, gidval;
long int data_offset;
#else
char namebuf[sizeof member_header.ar_name + 1];
char *name;
int is_namemap; /* Nonzero if this entry maps long names. */
#endif
long int eltsize;
int eltmode;
long int fnval;
if (lseek (desc, member_offset, 0) < 0)
{
(void) close (desc);
return -2;
}
#ifdef AIAMAG
#define AR_MEMHDR (AR_HDR_SIZE - sizeof (member_header._ar_name))
nread = read (desc, (char *) &member_header, AR_MEMHDR);
if (nread != AR_MEMHDR)
{
(void) close (desc);
return -2;
}
sscanf (member_header.ar_namlen, "%4d", &name_len);
nread = read (desc, name, name_len);
if (nread != name_len)
{
(void) close (desc);
return -2;
}
name[name_len] = 0;
sscanf (member_header.ar_date, "%12ld", &dateval);
sscanf (member_header.ar_uid, "%12d", &uidval);
sscanf (member_header.ar_gid, "%12d", &gidval);
sscanf (member_header.ar_mode, "%12o", &eltmode);
sscanf (member_header.ar_size, "%12ld", &eltsize);
if ((data_offset = member_offset + AR_MEMHDR + name_len + 2) % 2)
++data_offset;
fnval =
(*function) (desc, name, 0,
member_offset, data_offset, eltsize,
dateval, uidval, gidval,
eltmode, arg);
#else /* Not AIAMAG. */
nread = read (desc, (char *) &member_header, AR_HDR_SIZE);
if (nread == 0)
/* No data left means end of file; that is OK. */
break;
if (nread != AR_HDR_SIZE
#ifdef ARFMAG
|| bcmp (member_header.ar_fmag, ARFMAG, 2)
#endif
)
{
(void) close (desc);
return -2;
}
name = namebuf;
bcopy (member_header.ar_name, name, sizeof member_header.ar_name);
{
register char *p = name + sizeof member_header.ar_name;
do
*p = '\0';
while (p > name && *--p == ' ');
#ifndef AIAMAG
/* If the member name is "//" or "ARFILENAMES/" this may be
a list of file name mappings. The maximum file name
length supported by the standard archive format is 14
characters. This member will actually always be the
first or second entry in the archive, but we don't check
that. */
is_namemap = (!strcmp (name, "//")
|| !strcmp (name, "ARFILENAMES/"));
#endif /* Not AIAMAG. */
/* On some systems, there is a slash after each member name. */
if (*p == '/')
*p = '\0';
#ifndef AIAMAG
/* If the member name starts with a space or a slash, this
is an index into the file name mappings (used by GNU ar).
Otherwise if the member name looks like #1/NUMBER the
real member name appears in the element data (used by
4.4BSD). */
if (! is_namemap
&& (name[0] == ' ' || name[0] == '/')
&& namemap != 0)
{
name = namemap + atoi (name + 1);
long_name = 1;
}
else if (name[0] == '#'
&& name[1] == '1'
&& name[2] == '/')
{
int namesize = atoi (name + 3);
name = (char *) alloca (namesize + 1);
nread = read (desc, name, namesize);
if (nread != namesize)
{
close (desc);
return -2;
}
name[namesize] = '\0';
long_name = 1;
}
#endif /* Not AIAMAG. */
}
#ifndef M_XENIX
sscanf (member_header.ar_mode, "%o", &eltmode);
eltsize = atol (member_header.ar_size);
#else /* Xenix. */
eltmode = (unsigned short int) member_header.ar_mode;
eltsize = member_header.ar_size;
#endif /* Not Xenix. */
fnval =
(*function) (desc, name, ! long_name, member_offset,
member_offset + AR_HDR_SIZE, eltsize,
#ifndef M_XENIX
atol (member_header.ar_date),
atoi (member_header.ar_uid),
atoi (member_header.ar_gid),
#else /* Xenix. */
member_header.ar_date,
member_header.ar_uid,
member_header.ar_gid,
#endif /* Not Xenix. */
eltmode, arg);
#endif /* AIAMAG. */
if (fnval)
{
(void) close (desc);
return fnval;
}
#ifdef AIAMAG
if (member_offset == last_member_offset)
/* End of the chain. */
break;
sscanf (member_header.ar_nxtmem, "%12ld", &member_offset);
if (lseek (desc, member_offset, 0) != member_offset)
{
(void) close (desc);
return -2;
}
#else
/* If this member maps archive names, we must read it in. The
name map will always precede any members whose names must
be mapped. */
if (is_namemap)
{
char *clear;
char *limit;
namemap = (char *) alloca (eltsize);
nread = read (desc, namemap, eltsize);
if (nread != eltsize)
{
(void) close (desc);
return -2;
}
/* The names are separated by newlines. Some formats have
a trailing slash. Null terminate the strings for
convenience. */
limit = namemap + eltsize;
for (clear = namemap; clear < limit; clear++)
{
if (*clear == '\n')
{
*clear = '\0';
if (clear[-1] == '/')
clear[-1] = '\0';
}
}
is_namemap = 0;
}
member_offset += AR_HDR_SIZE + eltsize;
if (member_offset % 2 != 0)
member_offset++;
#endif
}
}
close (desc);
return 0;
}
/* Return nonzero iff NAME matches MEM.
If TRUNCATED is nonzero, MEM may be truncated to
sizeof (struct ar_hdr.ar_name) - 1. */
int
ar_name_equal (name, mem, truncated)
char *name, *mem;
int truncated;
{
char *p;
p = rindex (name, '/');
if (p != 0)
name = p + 1;
/* We no longer use this kludge, since we
now support long archive member names. */
#if 0 && !defined (AIAMAG) && !defined (APOLLO)
{
/* `reallylongname.o' matches `reallylongnam.o'.
If member names have a trailing slash, that's `reallylongna.o'. */
struct ar_hdr h;
unsigned int max = sizeof (h.ar_name);
unsigned int namelen, memlen;
if (strncmp (name, mem, max - 3))
return 0;
namelen = strlen (name);
memlen = strlen (mem);
if (namelen > memlen && memlen >= max - 1
&& name[namelen - 2] == '.' && name[namelen - 1] == 'o'
&& mem[memlen - 2] == '.' && mem[memlen - 1] == 'o')
return 1;
if (namelen != memlen)
return 0;
return (namelen < max - 3 || !strcmp (name + max - 3, mem + max - 3));
}
#else /* AIX or APOLLO. */
if (truncated)
{
#ifdef AIAMAG
/* TRUNCATED should never be set on this system. */
abort ();
#else
struct ar_hdr hdr;
return !strncmp (name, mem,
sizeof (hdr.ar_name) -
#if !defined (__hpux) && !defined (cray)
1
#else
2
#endif /* !__hpux && !cray */
);
#endif
}
return !strcmp (name, mem);
#endif
}
/* ARGSUSED */
static long int
ar_member_pos (desc, mem, truncated,
hdrpos, datapos, size, date, uid, gid, mode, name)
int desc;
char *mem;
int truncated;
long int hdrpos, datapos, size, date;
int uid, gid, mode;
char *name;
{
if (!ar_name_equal (name, mem, truncated))
return 0;
return hdrpos;
}
/* Set date of member MEMNAME in archive ARNAME to current time.
Returns 0 if successful,
-1 if file ARNAME does not exist,
-2 if not a valid archive,
-3 if other random system call error (including file read-only),
1 if valid but member MEMNAME does not exist. */
int
ar_member_touch (arname, memname)
char *arname, *memname;
{
register long int pos = ar_scan (arname, ar_member_pos, (long int) memname);
register int fd;
struct ar_hdr ar_hdr;
register int i;
struct stat statbuf;
if (pos < 0)
return (int) pos;
if (!pos)
return 1;
fd = open (arname, O_RDWR, 0666);
if (fd < 0)
return -3;
/* Read in this member's header */
if (lseek (fd, pos, 0) < 0)
goto lose;
if (AR_HDR_SIZE != read (fd, (char *) &ar_hdr, AR_HDR_SIZE))
goto lose;
/* Write back the header, thus touching the archive file. */
if (lseek (fd, pos, 0) < 0)
goto lose;
if (AR_HDR_SIZE != write (fd, (char *) &ar_hdr, AR_HDR_SIZE))
goto lose;
/* The file's mtime is the time we we want. */
#ifdef EINTR
while (fstat (fd, &statbuf) < 0 && errno == EINTR);
#else
fstat (fd, &statbuf);
#endif
#if defined(ARFMAG) || defined(AIAMAG)
/* Advance member's time to that time */
for (i = 0; i < sizeof ar_hdr.ar_date; i++)
ar_hdr.ar_date[i] = ' ';
sprintf (ar_hdr.ar_date, "%ld", (long int) statbuf.st_mtime);
#ifdef AIAMAG
ar_hdr.ar_date[strlen(ar_hdr.ar_date)] = ' ';
#endif
#else
ar_hdr.ar_date = statbuf.st_mtime;
#endif
/* Write back this member's header */
if (lseek (fd, pos, 0) < 0)
goto lose;
if (AR_HDR_SIZE != write (fd, (char *) &ar_hdr, AR_HDR_SIZE))
goto lose;
close (fd);
return 0;
lose:
i = errno;
close (fd);
errno = i;
return -3;
}
#ifdef TEST
long int
describe_member (desc, name, truncated,
hdrpos, datapos, size, date, uid, gid, mode)
int desc;
char *name;
int truncated;
long int hdrpos, datapos, size, date;
int uid, gid, mode;
{
extern char *ctime ();
printf ("Member `%s'%s: %ld bytes at %ld (%ld).\n",
name, truncated ? " (name might be truncated)" : "",
size, hdrpos, datapos);
printf (" Date %s", ctime (&date));
printf (" uid = %d, gid = %d, mode = 0%o.\n", uid, gid, mode);
return 0;
}
main (argc, argv)
int argc;
char **argv;
{
ar_scan (argv[1], describe_member);
return 0;
}
#endif /* TEST. */
#endif /* NO_ARCHIVES. */

69
buildtools/windows/source/make/build.sh.in
View File

@ -1,69 +0,0 @@
#!/bin/sh
# Shell script to build GNU Make in the absence of any `make' program.
# @configure_input@
# Copyright (C) 1993, 1994 Free Software Foundation, Inc.
# This file is part of GNU Make.
#
# GNU Make is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
#
# GNU Make is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with GNU Make; see the file COPYING. If not, write to
# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
# See Makefile.in for comments describing these variables.
srcdir='@srcdir@'
CC='@CC@'
CFLAGS='@CFLAGS@'
CPPFLAGS='@CPPFLAGS@'
LDFLAGS='@LDFLAGS@'
defines='@DEFS@ -DLIBDIR="${libdir}" -DINCLUDEDIR="${includedir}"'
ALLOCA='@ALLOCA@'
LOADLIBES='@LIBS@'
extras='@LIBOBJS@'
REMOTE='@REMOTE@'
# Common prefix for machine-independent installed files.
prefix='@prefix@'
# Common prefix for machine-dependent installed files.
exec_prefix='@exec_prefix@'
# Directory to find libraries in for `-lXXX'.
libdir=${exec_prefix}/lib
# Directory to search by default for included makefiles.
includedir=${prefix}/include
# Exit as soon as any command fails.
set -e
# These are all the objects we need to link together.
objs="commands.o job.o dir.o file.o misc.o main.o read.o remake.o rule.o implicit.o default.o variable.o expand.o function.o vpath.o version.o ar.o arscan.o signame.o getopt.o getopt1.o glob/glob.o glob/fnmatch.o remote-${REMOTE}.o ${extras} ${ALLOCA}"
# Compile the source files into those objects.
for file in `echo ${objs} | sed 's/\.o/.c/g'`; do
echo compiling ${file}...
$CC $defines $CPPFLAGS $CFLAGS \
-c -I. -I${srcdir} -I${srcdir}/glob ${srcdir}/$file
done
# The object files were actually all put in the current directory.
# Remove the source directory names from the list.
srcobjs="$objs"
objs=
for obj in $srcobjs; do
objs="$objs `basename $obj`"
done
# Link all the objects together.
echo linking make...
$CC $LDFLAGS $objs $LOADLIBES -o make.new
echo done
mv -f make.new make

521
buildtools/windows/source/make/commands.c
View File

@ -1,521 +0,0 @@
/* Command processing for GNU Make.
Copyright (C) 1988, 1989, 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
This file is part of GNU Make.
GNU Make is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Make is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Make; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "make.h"
#include "dep.h"
#include "commands.h"
#include "file.h"
#include "variable.h"
#include "job.h"
extern int remote_kill ();
#ifndef HAVE_UNISTD_H
extern int getpid ();
#endif
/* Set FILE's automatic variables up. */
static void
set_file_variables (file)
register struct file *file;
{
// register char *p;
char *at, *percent, *star, *less;
#ifndef NO_ARCHIVES
/* If the target is an archive member `lib(member)',
then $@ is `lib' and $% is `member'. */
if (ar_name (file->name))
{
unsigned int len;
p = index (file->name, '(');
at = (char *) alloca (p - file->name + 1);
bcopy (file->name, at, p - file->name);
at[p - file->name] = '\0';
len = strlen (p + 1);
percent = (char *) alloca (len);
bcopy (p + 1, percent, len - 1);
percent[len - 1] = '\0';
}
else
#endif /* NO_ARCHIVES. */
{
at = file->name;
percent = "";
}
/* $* is the stem from an implicit or static pattern rule. */
if (file->stem == 0)
{
/* In Unix make, $* is set to the target name with
any suffix in the .SUFFIXES list stripped off for
explicit rules. We store this in the `stem' member. */
register struct dep *d;
char *name;
unsigned int len;
#ifndef NO_ARCHIVES
if (ar_name (file->name))
{
name = index (file->name, '(') + 1;
len = strlen (name) - 1;
}
else
#endif
{
name = file->name;
len = strlen (name);
}
for (d = enter_file (".SUFFIXES")->deps; d != 0; d = d->next)
{
unsigned int slen = strlen (dep_name (d));
if (len > slen && !strncmp (dep_name (d), name + (len - slen), slen))
{
file->stem = savestring (name, len - slen);
break;
}
}
if (d == 0)
file->stem = "";
}
star = file->stem;
/* $< is the first dependency. */
less = file->deps != 0 ? dep_name (file->deps) : "";
if (file->cmds == default_file->cmds)
/* This file got its commands from .DEFAULT.
In this case $< is the same as $@. */
less = at;
#define DEFINE_VARIABLE(name, len, value) \
(void) define_variable_for_file (name, len, value, o_automatic, 0, file)
/* Define the variables. */
DEFINE_VARIABLE ("<", 1, less);
DEFINE_VARIABLE ("*", 1, star);
DEFINE_VARIABLE ("@", 1, at);
DEFINE_VARIABLE ("%", 1, percent);
/* Compute the values for $^, $+, and $?. */
{
register unsigned int qmark_len, plus_len;
char *caret_value, *plus_value;
register char *cp;
char *qmark_value;
register char *qp;
register struct dep *d;
unsigned int len;
/* Compute first the value for $+, which is supposed to contain
duplicate dependencies as they were listed in the makefile. */
plus_len = 0;
for (d = file->deps; d != 0; d = d->next)
plus_len += strlen (dep_name (d)) + 1;
len = plus_len == 0 ? 1 : plus_len;
cp = plus_value = (char *) alloca (len);
qmark_len = plus_len; /* Will be this or less. */
for (d = file->deps; d != 0; d = d->next)
{
char *c = dep_name (d);
#ifndef NO_ARCHIVES
if (ar_name (c))
{
c = index (c, '(') + 1;
len = strlen (c) - 1;
}
else
#endif
len = strlen (c);
bcopy (c, cp, len);
cp += len;
*cp++ = ' ';
if (! d->changed)
qmark_len -= len + 1; /* Don't space in $? for this one. */
}
/* Kill the last space and define the variable. */
cp[cp > plus_value ? -1 : 0] = '\0';
DEFINE_VARIABLE ("+", 1, plus_value);
/* Make sure that no dependencies are repeated. This does not
really matter for the purpose of updating targets, but it
might make some names be listed twice for $^ and $?. */
uniquize_deps (file->deps);
/* Compute the values for $^ and $?. */
cp = caret_value = plus_value; /* Reuse the buffer; it's big enough. */
len = qmark_len == 0 ? 1 : qmark_len;
qp = qmark_value = (char *) alloca (len);
for (d = file->deps; d != 0; d = d->next)
{
char *c = dep_name (d);
#ifndef NO_ARCHIVES
if (ar_name (c))
{
c = index (c, '(') + 1;
len = strlen (c) - 1;
}
else
#endif
len = strlen (c);
bcopy (c, cp, len);
cp += len;
*cp++ = ' ';
if (d->changed)
{
bcopy (c, qp, len);
qp += len;
*qp++ = ' ';
}
}
/* Kill the last spaces and define the variables. */
cp[cp > caret_value ? -1 : 0] = '\0';
DEFINE_VARIABLE ("^", 1, caret_value);
qp[qp > qmark_value ? -1 : 0] = '\0';
DEFINE_VARIABLE ("?", 1, qmark_value);
}
#undef DEFINE_VARIABLE
}
/* Chop CMDS up into individual command lines if necessary.
Also set the `lines_flag' and `any_recurse' members. */
void
chop_commands (cmds)
register struct commands *cmds;
{
if (cmds != 0 && cmds->command_lines == 0)
{
/* Chop CMDS->commands up into lines in CMDS->command_lines.
Also set the corresponding CMDS->lines_flags elements,
and the CMDS->any_recurse flag. */
register char *p;
unsigned int nlines, idx;
char **lines;
nlines = 5;
lines = (char **) xmalloc (5 * sizeof (char *));
idx = 0;
p = cmds->commands;
while (*p != '\0')
{
char *end = p;
find_end:;
end = index (end, '\n');
if (end == 0)
end = p + strlen (p);
else if (end > p && end[-1] == '\\')
{
int backslash = 1;
register char *b;
for (b = end - 2; b >= p && *b == '\\'; --b)
backslash = !backslash;
if (backslash)
{
++end;
goto find_end;
}
}
if (idx == nlines)
{
nlines += 2;
lines = (char **) xrealloc ((char *) lines,
nlines * sizeof (char *));
}
lines[idx++] = savestring (p, end - p);
p = end;
if (*p != '\0')
++p;
}
if (idx != nlines)
{
nlines = idx;
lines = (char **) xrealloc ((char *) lines,
nlines * sizeof (char *));
}
cmds->ncommand_lines = nlines;
cmds->command_lines = lines;
cmds->any_recurse = 0;
cmds->lines_flags = (char *) xmalloc (nlines);
for (idx = 0; idx < nlines; ++idx)
{
int flags = 0;
for (p = lines[idx];
isblank (*p) || *p == '-' || *p == '@' || *p == '+';
++p)
switch (*p)
{
case '+':
flags |= COMMANDS_RECURSE;
break;
case '@':
flags |= COMMANDS_SILENT;
break;
case '-':
flags |= COMMANDS_NOERROR;
break;
}
if (!(flags & COMMANDS_RECURSE))
{
unsigned int len = strlen (p);
if (sindex (p, len, "$(MAKE)", 7) != 0
|| sindex (p, len, "${MAKE}", 7) != 0)
flags |= COMMANDS_RECURSE;
}
cmds->lines_flags[idx] = flags;
cmds->any_recurse |= flags & COMMANDS_RECURSE;
}
}
}
/* Execute the commands to remake FILE. If they are currently executing,
return or have already finished executing, just return. Otherwise,
fork off a child process to run the first command line in the sequence. */
void
execute_file_commands (file)
struct file *file;
{
register char *p;
/* Don't go through all the preparations if
the commands are nothing but whitespace. */
for (p = file->cmds->commands; *p != '\0'; ++p)
if (!isspace (*p) && *p != '-' && *p != '@')
break;
if (*p == '\0')
{
/* We are all out of commands.
If we have gotten this far, all the previous commands
have run successfully, so we have winning update status. */
file->update_status = 0;
notice_finished_file (file);
return;
}
/* First set the automatic variables according to this file. */
initialize_file_variables (file);
set_file_variables (file);
/* Start the commands running. */
new_job (file);
}
/* This is set while we are inside fatal_error_signal,
so things can avoid nonreentrant operations. */
int handling_fatal_signal = 0;
/* Handle fatal signals. */
RETSIGTYPE
fatal_error_signal (sig)
int sig;
{
#if defined(__MSDOS__) || defined(NETSCAPE)
remove_intermediates (1);
exit (1);
#else /* Not MSDOS. */
handling_fatal_signal = 1;
/* Set the handling for this signal to the default.
It is blocked now while we run this handler. */
signal (sig, SIG_DFL);
/* A termination signal won't be sent to the entire
process group, but it means we want to kill the children. */
if (sig == SIGTERM)
{
register struct child *c;
for (c = children; c != 0; c = c->next)
if (!c->remote)
(void) kill (c->pid, SIGTERM);
}
/* If we got a signal that means the user
wanted to kill make, remove pending targets. */
if (sig == SIGTERM || sig == SIGINT || sig == SIGHUP || sig == SIGQUIT)
{
register struct child *c;
/* Remote children won't automatically get signals sent
to the process group, so we must send them. */
for (c = children; c != 0; c = c->next)
if (c->remote)
(void) remote_kill (c->pid, sig);
for (c = children; c != 0; c = c->next)
delete_child_targets (c);
/* Clean up the children. We don't just use the call below because
we don't want to print the "Waiting for children" message. */
while (job_slots_used > 0)
reap_children (1, 0);
}
else
/* Wait for our children to die. */
while (job_slots_used > 0)
reap_children (1, 1);
/* Delete any non-precious intermediate files that were made. */
remove_intermediates (1);
if (sig == SIGQUIT)
/* We don't want to send ourselves SIGQUIT, because it will
cause a core dump. Just exit instead. */
exit (1);
/* Signal the same code; this time it will really be fatal. The signal
will be unblocked when we return and arrive then to kill us. */
if (kill (getpid (), sig) < 0)
pfatal_with_name ("kill");
#endif /* MSDOS. */
}
/* Delete FILE unless it's precious or not actually a file (phony),
and it has changed on disk since we last stat'd it. */
static void
delete_target (file, on_behalf_of)
struct file *file;
char *on_behalf_of;
{
struct stat st;
if (file->precious || file->phony)
return;
#ifndef NO_ARCHIVES
if (ar_name (file->name))
{
if (ar_member_date (file->name) != file->last_mtime)
{
if (on_behalf_of)
error ("*** [%s] Archive member `%s' may be bogus; not deleted",
on_behalf_of, file->name);
else
error ("*** Archive member `%s' may be bogus; not deleted",
file->name);
}
return;
}
#endif
if (safe_stat (file->name, &st) == 0
&& S_ISREG (st.st_mode)
&& (time_t) st.st_mtime != file->last_mtime)
{
if (on_behalf_of)
error ("*** [%s] Deleting file `%s'", on_behalf_of, file->name);
else
error ("*** Deleting file `%s'", file->name);
if (unlink (file->name) < 0)
perror_with_name ("unlink: ", file->name);
}
}
/* Delete all non-precious targets of CHILD unless they were already deleted.
Set the flag in CHILD to say they've been deleted. */
void
delete_child_targets (child)
struct child *child;
{
struct dep *d;
if (child->deleted)
return;
/* Delete the target file if it changed. */
delete_target (child->file, (char *) 0);
/* Also remove any non-precious targets listed in the `also_make' member. */
for (d = child->file->also_make; d != 0; d = d->next)
delete_target (d->file, child->file->name);
child->deleted = 1;
}
/* Print out the commands in CMDS. */
void
print_commands (cmds)
register struct commands *cmds;
{
register char *s;
fputs ("# commands to execute", stdout);
if (cmds->filename == 0)
puts (" (built-in):");
else
printf (" (from `%s', line %u):\n", cmds->filename, cmds->lineno);
s = cmds->commands;
while (*s != '\0')
{
char *end;
while (isspace (*s))
++s;
end = index (s, '\n');
if (end == 0)
end = s + strlen (s);
printf ("\t%.*s\n", (int) (end - s), s);
s = end;
}
}

42
buildtools/windows/source/make/commands.h
View File

@ -1,42 +0,0 @@
/* Definition of data structures describing shell commands for GNU Make.
Copyright (C) 1988, 1989, 1991, 1993 Free Software Foundation, Inc.
This file is part of GNU Make.
GNU Make is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Make is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Make; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
/* Structure that gives the commands to make a file
and information about where these commands came from. */
struct commands
{
char *filename; /* File that contains commands. */
unsigned int lineno; /* Line number in file. */
char *commands; /* Commands text. */
unsigned int ncommand_lines;/* Number of command lines. */
char **command_lines; /* Commands chopped up into lines. */
char *lines_flags; /* One set of flag bits for each line. */
int any_recurse; /* Nonzero if any `lines_recurse' elt has */
/* the COMMANDS_RECURSE bit set. */
};
/* Bits in `lines_flags'. */
#define COMMANDS_RECURSE 1 /* Recurses: + or $(MAKE). */
#define COMMANDS_SILENT 2 /* Silent: @. */
#define COMMANDS_NOERROR 4 /* No errors: -. */
extern void execute_file_commands ();
extern void print_commands ();
extern void delete_child_targets ();
extern void chop_commands ();

275
buildtools/windows/source/make/config.h
View File

@ -1,275 +0,0 @@
/* config.h.in. Generated automatically from configure.in by autoheader. */
/* Define if on AIX 3.
System headers sometimes define this.
We just want to avoid a redefinition error message. */
#ifndef _ALL_SOURCE
#undef _ALL_SOURCE
#endif
/* Define if using alloca.c. */
#undef C_ALLOCA
/* Define to empty if the keyword does not work. */
#undef const
/* Define to one of _getb67, GETB67, getb67 for Cray-2 and Cray-YMP systems.
This function is required for alloca.c support on those systems. */
#undef CRAY_STACKSEG_END
/* Define for DGUX with <sys/dg_sys_info.h>. */
#undef DGUX
/* Define if the `getloadavg' function needs to be run setuid or setgid. */
#undef GETLOADAVG_PRIVILEGED
/* Define to `int' if <sys/types.h> doesn't define. */
#define gid_t
/* Define if you have alloca, as a function or macro. */
#undef HAVE_ALLOCA
/* Define if you have <alloca.h> and it should be used (not on Ultrix). */
#undef HAVE_ALLOCA_H
/* Define if you don't have vprintf but do have _doprnt. */
#undef HAVE_DOPRNT
/* Define if your system has its own `getloadavg' function. */
#undef HAVE_GETLOADAVG
/* Define if you have the getmntent function. */
#undef HAVE_GETMNTENT
/* Define if the `long double' type works. */
#undef HAVE_LONG_DOUBLE
/* Define if you support file names longer than 14 characters. */
#define HAVE_LONG_FILE_NAMES
/* Define if you have a working `mmap' system call. */
#undef HAVE_MMAP
/* Define if system calls automatically restart after interruption
by a signal. */
#undef HAVE_RESTARTABLE_SYSCALLS
/* Define if your struct stat has st_blksize. */
#undef HAVE_ST_BLKSIZE
/* Define if your struct stat has st_blocks. */
#undef HAVE_ST_BLOCKS
/* Define if you have the strcoll function and it is properly defined. */
#undef HAVE_STRCOLL
/* Define if your struct stat has st_rdev. */
#undef HAVE_ST_RDEV
/* Define if you have the strftime function. */
#define HAVE_STRFTIME
/* Define if you have <sys/wait.h> that is POSIX.1 compatible. */
#undef HAVE_SYS_WAIT_H
/* Define if your struct tm has tm_zone. */
#undef HAVE_TM_ZONE
/* Define if you don't have tm_zone but do have the external array
tzname. */
#define HAVE_TZNAME
/* Define if you have <unistd.h>. */
#undef HAVE_UNISTD_H
/* Define if utime(file, NULL) sets file's timestamp to the present. */
#define HAVE_UTIME_NULL
/* Define if you have <vfork.h>. */
#undef HAVE_VFORK_H
/* Define if you have the vprintf function. */
#undef HAVE_VPRINTF
/* Define if you have the wait3 system call. */
#undef HAVE_WAIT3
/* Define if on MINIX. */
#undef _MINIX
/* Define if your struct nlist has an n_un member. */
#undef NLIST_NAME_UNION
/* Define if you have <nlist.h>. */
#undef NLIST_STRUCT
/* Define if your C compiler doesn't accept -c and -o together. */
#define NO_MINUS_C_MINUS_O
/* Define to `int' if <sys/types.h> doesn't define. */
#define pid_t int
/* Define if the system does not provide POSIX.1 features except
with this defined. */
#undef _POSIX_1_SOURCE
/* Define if you need to in order for stat and other things to work. */
#undef _POSIX_SOURCE
/* Define as the return type of signal handlers (int or void). */
#undef RETSIGTYPE
/* Define if the setvbuf function takes the buffering type as its second
argument and the buffer pointer as the third, as on System V
before release 3. */
#undef SETVBUF_REVERSED
/* If using the C implementation of alloca, define if you know the
direction of stack growth for your system; otherwise it will be
automatically deduced at run-time.
STACK_DIRECTION > 0 => grows toward higher addresses
STACK_DIRECTION < 0 => grows toward lower addresses
STACK_DIRECTION = 0 => direction of growth unknown
*/
#undef STACK_DIRECTION
/* Define if the `S_IS*' macros in <sys/stat.h> do not work properly. */
#define STAT_MACROS_BROKEN
/* Define if you have the ANSI C header files. */
#define STDC_HEADERS
/* Define on System V Release 4. */
#undef SVR4
/* Define if `sys_siglist' is declared by <signal.h>. */
#undef SYS_SIGLIST_DECLARED
/* Define to `int' if <sys/types.h> doesn't define. */
#define uid_t int
/* Define for Encore UMAX. */
#undef UMAX
/* Define for Encore UMAX 4.3 that has <inq_status/cpustats.h>
instead of <sys/cpustats.h>. */
#undef UMAX4_3
/* Define vfork as fork if vfork does not work. */
#undef vfork
/* Define to the name of the SCCS `get' command. */
#define SCCS_GET "get"
/* Define this if the SCCS `get' command understands the `-G<file>' option. */
#undef SCCS_GET_MINUS_G
/* Define this if the C library defines the variable `sys_siglist'. */
#undef HAVE_SYS_SIGLIST
/* Define this if the C library defines the variable `_sys_siglist'. */
#undef HAVE__SYS_SIGLIST
/* Define this if you have the `union wait' type in <sys/wait.h>. */
#undef HAVE_UNION_WAIT
/* Define this if the POSIX.1 call `sysconf (_SC_OPEN_MAX)' works properly. */
#undef HAVE_SYSCONF_OPEN_MAX
/* Define if you have the dup2 function. */
#undef HAVE_DUP2
/* Define if you have the getcwd function. */
#define HAVE_GETCWD
/* Define if you have the getdtablesize function. */
#undef HAVE_GETDTABLESIZE
/* Define if you have the getgroups function. */
#undef HAVE_GETGROUPS
/* Define if you have the mktemp function. */
#undef HAVE_MKTEMP
/* Define if you have the psignal function. */
#undef HAVE_PSIGNAL
/* Define if you have the setegid function. */
#undef HAVE_SETEGID
/* Define if you have the seteuid function. */
#undef HAVE_SETEUID
/* Define if you have the setlinebuf function. */
#undef HAVE_SETLINEBUF
/* Define if you have the setregid function. */
#undef HAVE_SETREGID
/* Define if you have the setreuid function. */
#undef HAVE_SETREUID
/* Define if you have the sigsetmask function. */
#undef HAVE_SIGSETMASK
/* Define if you have the strerror function. */
#undef HAVE_STRERROR
/* Define if you have the strsignal function. */
#undef HAVE_STRSIGNAL
/* Define if you have the wait3 function. */
#undef HAVE_WAIT3
/* Define if you have the waitpid function. */
#undef HAVE_WAITPID
/* Define if you have the <dirent.h> header file. */
#undef HAVE_DIRENT_H
/* Define if you have the <fcntl.h> header file. */
#define HAVE_FCNTL_H
/* Define if you have the <limits.h> header file. */
#undef HAVE_LIMITS_H
/* Define if you have the <mach/mach.h> header file. */
#undef HAVE_MACH_MACH_H
/* Define if you have the <memory.h> header file. */
#define HAVE_MEMORY_H
/* Define if you have the <ndir.h> header file. */
#undef HAVE_NDIR_H
/* Define if you have the <string.h> header file. */
#define HAVE_STRING_H
/* Define if you have the <sys/dir.h> header file. */
#undef HAVE_SYS_DIR_H
/* Define if you have the <sys/ndir.h> header file. */
#undef HAVE_SYS_NDIR_H
/* Define if you have the <sys/param.h> header file. */
#undef HAVE_SYS_PARAM_H
/* Define if you have the <sys/timeb.h> header file. */
#undef HAVE_SYS_TIMEB_H
/* Define if you have the <sys/wait.h> header file. */
#undef HAVE_SYS_WAIT_H
/* Define if you have the <unistd.h> header file. */
#undef HAVE_UNISTD_H
/* Define if you have the dgc library (-ldgc). */
#undef HAVE_LIBDGC
/* Define if you have the sun library (-lsun). */
#undef HAVE_LIBSUN
/* NETSCAPE: Under win32, define default libdir */
#define LIBDIR "\\msvc20\\lib"
#define NO_ARCHIVES
#define HAVE_GLOB_H

270
buildtools/windows/source/make/config.h.in
View File

@ -1,270 +0,0 @@
/* config.h.in. Generated automatically from configure.in by autoheader. */
/* Define if on AIX 3.
System headers sometimes define this.
We just want to avoid a redefinition error message. */
#ifndef _ALL_SOURCE
#undef _ALL_SOURCE
#endif
/* Define if using alloca.c. */
#undef C_ALLOCA
/* Define to empty if the keyword does not work. */
#undef const
/* Define to one of _getb67, GETB67, getb67 for Cray-2 and Cray-YMP systems.
This function is required for alloca.c support on those systems. */
#undef CRAY_STACKSEG_END
/* Define for DGUX with <sys/dg_sys_info.h>. */
#undef DGUX
/* Define if the `getloadavg' function needs to be run setuid or setgid. */
#undef GETLOADAVG_PRIVILEGED
/* Define to `int' if <sys/types.h> doesn't define. */
#undef gid_t
/* Define if you have alloca, as a function or macro. */
#undef HAVE_ALLOCA
/* Define if you have <alloca.h> and it should be used (not on Ultrix). */
#undef HAVE_ALLOCA_H
/* Define if you don't have vprintf but do have _doprnt. */
#undef HAVE_DOPRNT
/* Define if your system has its own `getloadavg' function. */
#undef HAVE_GETLOADAVG
/* Define if you have the getmntent function. */
#undef HAVE_GETMNTENT
/* Define if the `long double' type works. */
#undef HAVE_LONG_DOUBLE
/* Define if you support file names longer than 14 characters. */
#undef HAVE_LONG_FILE_NAMES
/* Define if you have a working `mmap' system call. */
#undef HAVE_MMAP
/* Define if system calls automatically restart after interruption
by a signal. */
#undef HAVE_RESTARTABLE_SYSCALLS
/* Define if your struct stat has st_blksize. */
#undef HAVE_ST_BLKSIZE
/* Define if your struct stat has st_blocks. */
#undef HAVE_ST_BLOCKS
/* Define if you have the strcoll function and it is properly defined. */
#undef HAVE_STRCOLL
/* Define if your struct stat has st_rdev. */
#undef HAVE_ST_RDEV
/* Define if you have the strftime function. */
#undef HAVE_STRFTIME
/* Define if you have <sys/wait.h> that is POSIX.1 compatible. */
#undef HAVE_SYS_WAIT_H
/* Define if your struct tm has tm_zone. */
#undef HAVE_TM_ZONE
/* Define if you don't have tm_zone but do have the external array
tzname. */
#undef HAVE_TZNAME
/* Define if you have <unistd.h>. */
#undef HAVE_UNISTD_H
/* Define if utime(file, NULL) sets file's timestamp to the present. */
#undef HAVE_UTIME_NULL
/* Define if you have <vfork.h>. */
#undef HAVE_VFORK_H
/* Define if you have the vprintf function. */
#undef HAVE_VPRINTF
/* Define if you have the wait3 system call. */
#undef HAVE_WAIT3
/* Define if on MINIX. */
#undef _MINIX
/* Define if your struct nlist has an n_un member. */
#undef NLIST_NAME_UNION
/* Define if you have <nlist.h>. */
#undef NLIST_STRUCT
/* Define if your C compiler doesn't accept -c and -o together. */
#undef NO_MINUS_C_MINUS_O
/* Define to `int' if <sys/types.h> doesn't define. */
#undef pid_t
/* Define if the system does not provide POSIX.1 features except
with this defined. */
#undef _POSIX_1_SOURCE
/* Define if you need to in order for stat and other things to work. */
#undef _POSIX_SOURCE
/* Define as the return type of signal handlers (int or void). */
#undef RETSIGTYPE
/* Define if the setvbuf function takes the buffering type as its second
argument and the buffer pointer as the third, as on System V
before release 3. */
#undef SETVBUF_REVERSED
/* If using the C implementation of alloca, define if you know the
direction of stack growth for your system; otherwise it will be
automatically deduced at run-time.
STACK_DIRECTION > 0 => grows toward higher addresses
STACK_DIRECTION < 0 => grows toward lower addresses
STACK_DIRECTION = 0 => direction of growth unknown
*/
#undef STACK_DIRECTION
/* Define if the `S_IS*' macros in <sys/stat.h> do not work properly. */
#undef STAT_MACROS_BROKEN
/* Define if you have the ANSI C header files. */
#undef STDC_HEADERS
/* Define on System V Release 4. */
#undef SVR4
/* Define if `sys_siglist' is declared by <signal.h>. */
#undef SYS_SIGLIST_DECLARED
/* Define to `int' if <sys/types.h> doesn't define. */
#undef uid_t
/* Define for Encore UMAX. */
#undef UMAX
/* Define for Encore UMAX 4.3 that has <inq_status/cpustats.h>
instead of <sys/cpustats.h>. */
#undef UMAX4_3
/* Define vfork as fork if vfork does not work. */
#undef vfork
/* Define to the name of the SCCS `get' command. */
#undef SCCS_GET
/* Define this if the SCCS `get' command understands the `-G<file>' option. */
#undef SCCS_GET_MINUS_G
/* Define this if the C library defines the variable `sys_siglist'. */
#undef HAVE_SYS_SIGLIST
/* Define this if the C library defines the variable `_sys_siglist'. */
#undef HAVE__SYS_SIGLIST
/* Define this if you have the `union wait' type in <sys/wait.h>. */
#undef HAVE_UNION_WAIT
/* Define this if the POSIX.1 call `sysconf (_SC_OPEN_MAX)' works properly. */
#undef HAVE_SYSCONF_OPEN_MAX
/* Define if you have the dup2 function. */
#undef HAVE_DUP2
/* Define if you have the getcwd function. */
#undef HAVE_GETCWD
/* Define if you have the getdtablesize function. */
#undef HAVE_GETDTABLESIZE
/* Define if you have the getgroups function. */
#undef HAVE_GETGROUPS
/* Define if you have the mktemp function. */
#undef HAVE_MKTEMP
/* Define if you have the psignal function. */
#undef HAVE_PSIGNAL
/* Define if you have the setegid function. */
#undef HAVE_SETEGID
/* Define if you have the seteuid function. */
#undef HAVE_SETEUID
/* Define if you have the setlinebuf function. */
#undef HAVE_SETLINEBUF
/* Define if you have the setregid function. */
#undef HAVE_SETREGID
/* Define if you have the setreuid function. */
#undef HAVE_SETREUID
/* Define if you have the sigsetmask function. */
#undef HAVE_SIGSETMASK
/* Define if you have the strerror function. */
#undef HAVE_STRERROR
/* Define if you have the strsignal function. */
#undef HAVE_STRSIGNAL
/* Define if you have the wait3 function. */
#undef HAVE_WAIT3
/* Define if you have the waitpid function. */
#undef HAVE_WAITPID
/* Define if you have the <dirent.h> header file. */
#undef HAVE_DIRENT_H
/* Define if you have the <fcntl.h> header file. */
#undef HAVE_FCNTL_H
/* Define if you have the <limits.h> header file. */
#undef HAVE_LIMITS_H
/* Define if you have the <mach/mach.h> header file. */
#undef HAVE_MACH_MACH_H
/* Define if you have the <memory.h> header file. */
#undef HAVE_MEMORY_H
/* Define if you have the <ndir.h> header file. */
#undef HAVE_NDIR_H
/* Define if you have the <string.h> header file. */
#undef HAVE_STRING_H
/* Define if you have the <sys/dir.h> header file. */
#undef HAVE_SYS_DIR_H
/* Define if you have the <sys/ndir.h> header file. */
#undef HAVE_SYS_NDIR_H
/* Define if you have the <sys/param.h> header file. */
#undef HAVE_SYS_PARAM_H
/* Define if you have the <sys/timeb.h> header file. */
#undef HAVE_SYS_TIMEB_H
/* Define if you have the <sys/wait.h> header file. */
#undef HAVE_SYS_WAIT_H
/* Define if you have the <unistd.h> header file. */
#undef HAVE_UNISTD_H
/* Define if you have the dgc library (-ldgc). */
#undef HAVE_LIBDGC
/* Define if you have the sun library (-lsun). */
#undef HAVE_LIBSUN

136
buildtools/windows/source/make/configh.dos
View File

@ -1,136 +0,0 @@
/* Generated automatically from configure.in by autoheader. DO NOT EDIT! */
#define INCLUDEDIR "c:/djgpp/include"
#define LIBDIR "c:/djgpp/lib"
/* Define if you have dirent.h. */
#define DIRENT
/* Define if you have the strcoll function and it is properly defined. */
#define HAVE_STRCOLL
/* Define if you have unistd.h. */
#define HAVE_UNISTD_H
/* Define as the return type of signal handlers (int or void). */
#define RETSIGTYPE void
/* Define if you have the ANSI C header files. */
#ifndef STDC_HEADERS
#define STDC_HEADERS
#endif
/* Define if `sys_siglist' is declared by <signal.h>. */
#define SYS_SIGLIST_DECLARED
/* Define if you have getdtablesize. */
#define HAVE_GETDTABLESIZE
/* Define if you have dup2. */
#define HAVE_DUP2
/* Define if you have sys_siglist. */
#undef HAVE_SYS_SIGLIST
/* Define if you have _sys_siglist. */
#undef HAVE__SYS_SIGLIST
/* Define if you have psignal. */
#define HAVE_PSIGNAL
/* Define if you have getcwd. */
#define HAVE_GETCWD
/* Define if you have sigsetmask. */
#define HAVE_SIGSETMASK
/* Define if you have setlinebuf. */
#define HAVE_SETLINEBUF
/* Define if you have the <limits.h> header file. */
#define HAVE_LIMITS_H
/* Define if you have the <sys/param.h> header file. */
#undef HAVE_SYS_PARAM_H
/* Define if you have the <fcntl.h> header file. */
#define HAVE_FCNTL_H
/* Define if you have the <string.h> header file. */
#define HAVE_STRING_H
/* Define if you have the <memory.h> header file. */
#define HAVE_MEMORY_H
/* Define if you have the `strerror' function. */
#define HAVE_STRERROR
#define SCCS_GET "get"

2991
buildtools/windows/source/make/configure vendored
View File

File diff suppressed because it is too large Load Diff

88
buildtools/windows/source/make/configure.bat
View File

@ -1,88 +0,0 @@
@echo off
echo Configuring MAKE for go32
rem This batch file assumes a unix-type "sed" program
update configh.dos config.h
echo # Makefile generated by "configure.bat"> Makefile
if exist config.sed del config.sed
echo ": try_sl ">> config.sed
echo "/\\$/ { ">> config.sed
echo " N ">> config.sed
echo " s/[ ]*\\\n[ ]*/ / ">> config.sed
echo " b try_sl ">> config.sed
echo "} ">> config.sed
echo "s/@srcdir@/./ ">> config.sed
echo "s/@CC@/gcc/ ">> config.sed
echo "s/@CFLAGS@/-O2 -g/ ">> config.sed
echo "s/@CPPFLAGS@/-DHAVE_CONFIG_H/ ">> config.sed
echo "s/@LDFLAGS@// ">> config.sed
echo "s/@RANLIB@/ranlib/ ">> config.sed
echo "s/@DEFS@// ">> config.sed
echo "s/@REMOTE@/stub/ ">> config.sed
echo "s/@ALLOCA@// ">> config.sed
echo "s/@LIBS@// ">> config.sed
echo "s/@LIBOBJS@// ">> config.sed
echo "s/@SET_MAKE@// ">> config.sed
echo "s/^Makefile *:/_Makefile:/ ">> config.sed
echo "s/^config.h *:/_config.h:/ ">> config.sed
echo "s/^defines *=.*$/defines =/ ">> config.sed
echo "/mv -f make.new make/d ">> config.sed
echo "s/cd glob; $(MAKE)/$(MAKE) -C glob/ ">> config.sed
sed -e "s/^\"//" -e "s/\"$//" -e "s/[ ]*$//" config.sed > config2.sed
sed -f config2.sed Makefile.in >> Makefile
del config.sed
del config2.sed
cd glob
call configure
cd ..

131
buildtools/windows/source/make/configure.in
View File

@ -1,131 +0,0 @@
dnl Process this file with autoconf to produce a configure script.
AC_REVISION([$Id: configure.in,v 1.1 1998-04-13 22:35:14 cyeh Exp $])
AC_PREREQ(2.1)dnl dnl Minimum Autoconf version required.
AC_INIT(vpath.c)dnl dnl A distinctive file to look for in srcdir.
AC_CONFIG_HEADER(config.h)
AC_CONFIG_SUBDIRS(glob) dnl Run configure in glob subdirectory.
AC_PROG_MAKE_SET
AC_PROG_CC
AC_PROG_INSTALL
AC_PROG_CPP dnl Later checks need this.
AC_AIX
AC_ISC_POSIX
AC_MINIX
AC_HEADER_STDC
AC_HEADER_DIRENT
AC_TYPE_UID_T dnl Also does gid_t.
AC_TYPE_PID_T
AC_TYPE_SIGNAL
AC_CHECK_HEADERS(unistd.h limits.h sys/param.h fcntl.h string.h memory.h \
sys/timeb.h)
AC_PROG_CC_C_O
AC_C_CONST dnl getopt needs this.
AC_HEADER_STAT
AC_SUBST(LIBOBJS)
AC_DEFUN(AC_CHECK_SYMBOL, [dnl
AC_MSG_CHECKING(for $1)
AC_CACHE_VAL(ac_cv_check_symbol_$1, [dnl
AC_TRY_LINK(, [extern char *sys_siglist[]; puts(*sys_siglist);],
ac_cv_check_symbol_$1=yes, ac_cv_check_symbol_$1=no)])
if test "$ac_cv_check_symbol_$1" = yes; then
changequote(,)dnl
ac_tr_symbol=`echo $1 | tr '[a-z]' '[A-Z]'`
changequote([,])dnl
AC_DEFINE_UNQUOTED(HAVE_${ac_tr_symbol})
fi
AC_MSG_RESULT($ac_cv_check_symbol_$1)])dnl
AC_CHECK_FUNCS(getdtablesize psignal mktemp \
dup2 getcwd sigsetmask getgroups setlinebuf \
seteuid setegid setreuid setregid strerror strsignal)
AC_CHECK_SYMBOL(sys_siglist)
AC_CHECK_SYMBOL(_sys_siglist)
AC_FUNC_ALLOCA
AC_FUNC_VFORK
AC_FUNC_SETVBUF_REVERSED
AC_FUNC_GETLOADAVG
AC_FUNC_STRCOLL
if test $ac_cv_func_getdtablesize = no; then
AC_MSG_CHECKING(for sysconf (_SC_OPEN_MAX))
AC_CACHE_VAL(make_cv_sysconf_open_max, [dnl
AC_TRY_LINK([#include <unistd.h>], [int max = sysconf (_SC_OPEN_MAX);],
[make_cv_sysconf_open_max=yes], [make_cv_sysconf_open_max=no])])
if test $make_cv_sysconf_open_max = yes; then
AC_DEFINE(HAVE_SYSCONF_OPEN_MAX)
fi
AC_MSG_RESULT($make_cv_sysconf_open_max)
fi
# Check out the wait reality.
AC_CHECK_HEADERS(sys/wait.h) AC_CHECK_FUNCS(waitpid wait3)
AC_MSG_CHECKING(for union wait)
AC_CACHE_VAL(make_cv_union_wait, [dnl
AC_TRY_LINK([#include <sys/types.h>
#include <sys/wait.h>],
[union wait status; int pid; pid = wait (&status);
#ifdef WEXITSTATUS
/* Some POSIXoid systems have both the new-style macros and the old
union wait type, and they do not work together. If union wait
conflicts with WEXITSTATUS et al, we don't want to use it at all. */
if (WEXITSTATUS (status) != 0) pid = -1;
#ifdef WTERMSIG
/* If we have WEXITSTATUS and WTERMSIG, just use them on ints. */
-- blow chunks here --
#endif
#endif
#ifdef HAVE_WAITPID
/* Make sure union wait works with waitpid. */
pid = waitpid (-1, &status, 0);
#endif
],
[make_cv_union_wait=yes], [make_cv_union_wait=no])])
if test "$make_cv_union_wait" = yes; then
AC_DEFINE(HAVE_UNION_WAIT)
fi
AC_MSG_RESULT($make_cv_union_wait)
AC_DECL_SYS_SIGLIST
# The presence of the following is not meant to imply
# that make necessarily works on those systems.
AC_CHECK_LIB(sun, getpwnam)
AC_SUBST(REMOTE) REMOTE=stub
AC_ARG_WITH(customs, [export jobs with the Customs daemon (NOT SUPPORTED)],
[REMOTE=cstms LIBS="$LIBS libcustoms.a"])
echo checking for location of SCCS get command
if test -f /usr/sccs/get; then
SCCS_GET=/usr/sccs/get
AC_DEFINE(SCCS_GET, "/usr/sccs/get")
else
SCCS_GET=get
AC_DEFINE(SCCS_GET, "get")
fi
ac_clean_files="$ac_clean_files s.conftest conftoast" # Remove these later.
if ( /usr/sccs/admin -n s.conftest || admin -n s.conftest ) >/dev/null 2>&1 &&
test -f s.conftest; then
# We successfully created an SCCS file.
echo checking if SCCS get command understands -G
if $SCCS_GET -Gconftoast s.conftest >/dev/null 2>&1 &&
test -f conftoast; then
AC_DEFINE(SCCS_GET_MINUS_G)
fi
fi
rm -f s.conftest conftoast
AC_OUTPUT(Makefile build.sh, [
# Makefile uses this timestamp file to know when to remake Makefile,
# build.sh, and glob/Makefile.
touch stamp-config])
dnl Local Variables:
dnl comment-start: "dnl "
dnl comment-end: ""
dnl comment-start-skip: "\\bdnl\\b\\s *"
dnl compile-command: "make configure config.h.in"
dnl End:

403
buildtools/windows/source/make/default.c
View File

@ -1,403 +0,0 @@
/* Data base of default implicit rules for GNU Make.
Copyright (C) 1988, 89, 90, 91, 92, 93, 94, 1995 Free Software Foundation, Inc.
This file is part of GNU Make.
GNU Make is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Make is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Make; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "make.h"
#include "rule.h"
#include "dep.h"
#include "file.h"
#include "commands.h"
#include "variable.h"
/* Define GCC_IS_NATIVE if gcc is the native development environment on
your system (gcc/bison/flex vs cc/yacc/lex). */
#ifdef __MSDOS__
#define GCC_IS_NATIVE
#endif
/* This is the default list of suffixes for suffix rules.
`.s' must come last, so that a `.o' file will be made from
a `.c' or `.p' or ... file rather than from a .s file. */
static char default_suffixes[]
= ".out .a .ln .o .c .cc .C .p .f .F .r .y .l .s .S \
.mod .sym .def .h .info .dvi .tex .texinfo .texi .txinfo \
.w .ch .web .sh .elc .el";
static struct pspec default_pattern_rules[] =
{
{ "(%)", "%",
"$(AR) $(ARFLAGS) $@ $<" },
/* The X.out rules are only in BSD's default set because
BSD Make has no null-suffix rules, so `foo.out' and
`foo' are the same thing. */
{ "%.out", "%",
"@rm -f $@ \n cp $< $@" },
/* Syntax is "ctangle foo.w foo.ch foo.c". */
{ "%.c", "%.w %.ch",
"$(CTANGLE) $^ $@" },
{ "%.tex", "%.w %.ch",
"$(CWEAVE) $^ $@" },
{ 0, 0, 0 }
};
static struct pspec default_terminal_rules[] =
{
/* RCS. */
{ "%", "%,v",
"+$(CHECKOUT,v)" },
{ "%", "RCS/%,v",
"+$(CHECKOUT,v)" },
/* SCCS. */
{ "%", "s.%",
"$(GET) $(GFLAGS) $(SCCS_OUTPUT_OPTION) $<" },
{ "%", "SCCS/s.%",
"$(GET) $(GFLAGS) $(SCCS_OUTPUT_OPTION) $<" },
{ 0, 0, 0 }
};
static char *default_suffix_rules[] =
{
".o",
"$(LINK.o) $^ $(LOADLIBES) $(LDLIBS) -o $@",
".s",
"$(LINK.s) $^ $(LOADLIBES) $(LDLIBS) -o $@",
".S",
"$(LINK.S) $^ $(LOADLIBES) $(LDLIBS) -o $@",
".c",
"$(LINK.c) $^ $(LOADLIBES) $(LDLIBS) -o $@",
".cc",
"$(LINK.cc) $^ $(LOADLIBES) $(LDLIBS) -o $@",
".C",
"$(LINK.C) $^ $(LOADLIBES) $(LDLIBS) -o $@",
".f",
"$(LINK.f) $^ $(LOADLIBES) $(LDLIBS) -o $@",
".p",
"$(LINK.p) $^ $(LOADLIBES) $(LDLIBS) -o $@",
".F",
"$(LINK.F) $^ $(LOADLIBES) $(LDLIBS) -o $@",
".r",
"$(LINK.r) $^ $(LOADLIBES) $(LDLIBS) -o $@",
".mod",
"$(COMPILE.mod) -o $@ -e $@ $^",
".def.sym",
"$(COMPILE.def) -o $@ $<",
".sh",
"cat $< >$@ \n chmod a+x $@",
".s.o",
#if !defined(M_XENIX) || defined(__GNUC__)
"$(COMPILE.s) -o $@ $<",
#else /* Xenix. */
"$(COMPILE.s) -o$@ $<",
#endif /* Not Xenix. */
".S.o",
#if !defined(M_XENIX) || defined(__GNUC__)
"$(COMPILE.S) -o $@ $<",
#else /* Xenix. */
"$(COMPILE.S) -o$@ $<",
#endif /* Not Xenix. */
".c.o",
"$(COMPILE.c) $< $(OUTPUT_OPTION)",
".cc.o",
"$(COMPILE.cc) $< $(OUTPUT_OPTION)",
".C.o",
"$(COMPILE.C) $< $(OUTPUT_OPTION)",
".f.o",
"$(COMPILE.f) $< $(OUTPUT_OPTION)",
".p.o",
"$(COMPILE.p) $< $(OUTPUT_OPTION)",
".F.o",
"$(COMPILE.F) $< $(OUTPUT_OPTION)",
".r.o",
"$(COMPILE.r) $< $(OUTPUT_OPTION)",
".mod.o",
"$(COMPILE.mod) -o $@ $<",
".c.ln",
"$(LINT.c) -C$* $<",
".y.ln",
#ifndef __MSDOS__
"$(YACC.y) $< \n $(LINT.c) -C$* y.tab.c \n $(RM) y.tab.c",
#else
"$(YACC.y) $< \n $(LINT.c) -C$* y_tab.c \n $(RM) y_tab.c",
#endif
".l.ln",
"@$(RM) $*.c\n $(LEX.l) $< > $*.c\n$(LINT.c) -i $*.c -o $@\n $(RM) $*.c",
".y.c",
#ifndef __MSDOS__
"$(YACC.y) $< \n mv -f y.tab.c $@",
#else
"$(YACC.y) $< \n mv -f y_tab.c $@",
#endif
".l.c",
"@$(RM) $@ \n $(LEX.l) $< > $@",
".F.f",
"$(PREPROCESS.F) $< $(OUTPUT_OPTION)",
".r.f",
"$(PREPROCESS.r) $< $(OUTPUT_OPTION)",
/* This might actually make lex.yy.c if there's no %R%
directive in $*.l, but in that case why were you
trying to make $*.r anyway? */
".l.r",
"$(LEX.l) $< > $@ \n mv -f lex.yy.r $@",
".S.s",
"$(PREPROCESS.S) $< > $@",
".texinfo.info",
"$(MAKEINFO) $(MAKEINFO_FLAGS) $< -o $@",
".texi.info",
"$(MAKEINFO) $(MAKEINFO_FLAGS) $< -o $@",
".txinfo.info",
"$(MAKEINFO) $(MAKEINFO_FLAGS) $< -o $@",
".tex.dvi",
"$(TEX) $<",
".texinfo.dvi",
"$(TEXI2DVI) $(TEXI2DVI_FLAGS) $<",
".texi.dvi",
"$(TEXI2DVI) $(TEXI2DVI_FLAGS) $<",
".txinfo.dvi",
"$(TEXI2DVI) $(TEXI2DVI_FLAGS) $<",
".w.c",
"$(CTANGLE) $< - $@", /* The `-' says there is no `.ch' file. */
".web.p",
"$(TANGLE) $<",
".w.tex",
"$(CWEAVE) $< - $@", /* The `-' says there is no `.ch' file. */
".web.tex",
"$(WEAVE) $<",
0, 0,
};
static char *default_variables[] =
{
"AR", "ar",
"ARFLAGS", "rv",
"AS", "as",
#ifdef GCC_IS_NATIVE
"CC", "gcc",
"CXX", "gcc",
#else
"CC", "cc",
"CXX", "g++",
#endif
/* This expands to $(CO) $(COFLAGS) $< $@ if $@ does not exist,
and to the empty string if $@ does exist. */
"CHECKOUT,v",
"$(patsubst $@-noexist,$(CO) $(COFLAGS) $< $@,\
$(filter-out $@,$(firstword $(wildcard $@) $@-noexist)))",
"CO", "co",
"CPP", "$(CC) -E",
#ifdef CRAY
"CF77PPFLAGS", "-P",
"CF77PP", "/lib/cpp",
"CFT", "cft77",
"CF", "cf77",
"FC", "$(CF)",
#else /* Not CRAY. */
#ifdef _IBMR2
"FC", "xlf",
#else
#ifdef __convex__
"FC", "fc",
#else
"FC", "f77",
#endif /* __convex__ */
#endif /* _IBMR2 */
/* System V uses these, so explicit rules using them should work.
However, there is no way to make implicit rules use them and FC. */
"F77", "$(FC)",
"F77FLAGS", "$(FFLAGS)",
#endif /* Cray. */
"GET", SCCS_GET,
"LD", "ld",
#ifdef GCC_IS_NATIVE
"LEX", "flex",
#else
"LEX", "lex",
#endif
"LINT", "lint",
"M2C", "m2c",
#ifdef pyr
"PC", "pascal",
#else
#ifdef CRAY
"PC", "PASCAL",
"SEGLDR", "segldr",
#else
"PC", "pc",
#endif /* CRAY. */
#endif /* pyr. */
#ifdef GCC_IS_NATIVE
"YACC", "bison -y",
#else
"YACC", "yacc", /* Or "bison -y" */
#endif
"MAKEINFO", "makeinfo",
"TEX", "tex",
"TEXI2DVI", "texi2dvi",
"WEAVE", "weave",
"CWEAVE", "cweave",
"TANGLE", "tangle",
"CTANGLE", "ctangle",
"RM", "rm -f",
"LINK.o", "$(CC) $(LDFLAGS) $(TARGET_ARCH)",
"COMPILE.c", "$(CC) $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c",
"LINK.c", "$(CC) $(CFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_ARCH)",
"COMPILE.cc", "$(CXX) $(CXXFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c",
"COMPILE.C", "$(COMPILE.cc)",
"LINK.cc", "$(CXX) $(CXXFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_ARCH)",
"LINK.C", "$(LINK.cc)",
"YACC.y", "$(YACC) $(YFLAGS)",
"LEX.l", "$(LEX) $(LFLAGS) -t",
"COMPILE.f", "$(FC) $(FFLAGS) $(TARGET_ARCH) -c",
"LINK.f", "$(FC) $(FFLAGS) $(LDFLAGS) $(TARGET_ARCH)",
"COMPILE.F", "$(FC) $(FFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c",
"LINK.F", "$(FC) $(FFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_ARCH)",
"COMPILE.r", "$(FC) $(FFLAGS) $(RFLAGS) $(TARGET_ARCH) -c",
"LINK.r", "$(FC) $(FFLAGS) $(RFLAGS) $(LDFLAGS) $(TARGET_ARCH)",
"COMPILE.def", "$(M2C) $(M2FLAGS) $(DEFFLAGS) $(TARGET_ARCH)",
"COMPILE.mod", "$(M2C) $(M2FLAGS) $(MODFLAGS) $(TARGET_ARCH)",
"COMPILE.p", "$(PC) $(PFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c",
"LINK.p", "$(PC) $(PFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_ARCH)",
"LINK.s", "$(CC) $(ASFLAGS) $(LDFLAGS) $(TARGET_MACH)",
"COMPILE.s", "$(AS) $(ASFLAGS) $(TARGET_MACH)",
"LINK.S", "$(CC) $(ASFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_MACH)",
"COMPILE.S", "$(CC) $(ASFLAGS) $(CPPFLAGS) $(TARGET_MACH) -c",
#if !defined(M_XENIX) || defined(__GNUC__)
"PREPROCESS.S", "$(CC) -E $(CPPFLAGS)",
#else /* Xenix. */
"PREPROCESS.S", "$(CC) -EP $(CPPFLAGS)",
#endif /* Not Xenix. */
"PREPROCESS.F", "$(FC) $(FFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -F",
"PREPROCESS.r", "$(FC) $(FFLAGS) $(RFLAGS) $(TARGET_ARCH) -F",
"LINT.c", "$(LINT) $(LINTFLAGS) $(CPPFLAGS) $(TARGET_ARCH)",
#ifndef NO_MINUS_C_MINUS_O
#if !defined(M_XENIX) || defined(__GNUC__)
"OUTPUT_OPTION", "-o $@",
#else /* Xenix. */
"OUTPUT_OPTION", "-Fo$@",
#endif /* Not Xenix. */
#endif
#ifdef SCCS_GET_MINUS_G
"SCCS_OUTPUT_OPTION", "-G$@",
#endif
0, 0
};
/* Set up the default .SUFFIXES list. */
void
set_default_suffixes ()
{
suffix_file = enter_file (".SUFFIXES");
if (no_builtin_rules_flag)
(void) define_variable ("SUFFIXES", 8, "", o_default, 0);
else
{
char *p = default_suffixes;
suffix_file->deps = (struct dep *)
multi_glob (parse_file_seq (&p, '\0', sizeof (struct dep), 1),
sizeof (struct dep));
(void) define_variable ("SUFFIXES", 8, default_suffixes, o_default, 0);
}
}
/* Enter the default suffix rules as file rules. This used to be done in
install_default_implicit_rules, but that loses because we want the
suffix rules installed before reading makefiles, and thee pattern rules
installed after. */
void
install_default_suffix_rules ()
{
register char **s;
if (no_builtin_rules_flag)
return;
for (s = default_suffix_rules; *s != 0; s += 2)
{
register struct file *f = enter_file (s[0]);
/* Don't clobber cmds given in a makefile if there were any. */
if (f->cmds == 0)
{
f->cmds = (struct commands *) xmalloc (sizeof (struct commands));
f->cmds->filename = 0;
f->cmds->commands = s[1];
f->cmds->command_lines = 0;
}
}
}
/* Install the default pattern rules. */
void
install_default_implicit_rules ()
{
register struct pspec *p;
if (no_builtin_rules_flag)
return;
for (p = default_pattern_rules; p->target != 0; ++p)
install_pattern_rule (p, 0);
for (p = default_terminal_rules; p->target != 0; ++p)
install_pattern_rule (p, 1);
}
void
define_default_variables ()
{
register char **s;
for (s = default_variables; *s != 0; s += 2)
(void) define_variable (s[0], strlen (s[0]), s[1], o_default, 1);
}

66
buildtools/windows/source/make/dep.h
View File

@ -1,66 +0,0 @@
/* Definitions of dependency data structures for GNU Make.
Copyright (C) 1988, 1989, 1991, 1992, 1993 Free Software Foundation, Inc.
This file is part of GNU Make.
GNU Make is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Make is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Make; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
/* Structure representing one dependency of a file.
Each struct file's `deps' points to a chain of these,
chained through the `next'.
Note that the first two words of this match a struct nameseq. */
struct dep
{
struct dep *next;
char *name;
struct file *file;
int changed;
};
/* Structure used in chains of names, for parsing and globbing. */
struct nameseq
{
struct nameseq *next;
char *name;
};
extern struct nameseq *multi_glob (), *parse_file_seq ();
extern char *tilde_expand ();
#ifndef NO_ARCHIVES
extern struct nameseq *ar_glob ();
#endif
#ifndef iAPX286
#define dep_name(d) ((d)->name == 0 ? (d)->file->name : (d)->name)
#else
/* Buggy compiler can't hack this. */
extern char *dep_name ();
#endif
extern struct dep *read_all_makefiles ();
/* Flag bits for the second argument to `read_makefile'.
These flags are saved in the `changed' field of each
`struct dep' in the chain returned by `read_all_makefiles'. */
#define RM_NO_DEFAULT_GOAL (1 << 0) /* Do not set default goal. */
#define RM_INCLUDED (1 << 1) /* Search makefile search path. */
#define RM_DONTCARE (1 << 2) /* No error if it doesn't exist. */
#define RM_NO_TILDE (1 << 3) /* Don't expand ~ in file name. */
#define RM_NOFLAG 0

760
buildtools/windows/source/make/dir.c
View File

@ -1,760 +0,0 @@
/* Directory hashing for GNU Make.
Copyright (C) 1988, 1989, 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
This file is part of GNU Make.
GNU Make is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Make is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Make; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "make.h"
#ifdef NETSCAPE
#include "windir.h"
DIR *opendir(char *pathp)
{
DIR *ret = (DIR *) malloc(sizeof(DIR));
char path[_MAX_PATH];
int l;
sprintf(path, "%s", pathp);
l = strlen(path) - 1;
path[strlen(pathp)] = '\0';
if(path[strlen(path) - 1] != '\\')
strcpy (path + strlen(path), "\\*.*");
else
strcat(path, "*.*");
ret->de.d_name = NULL;
if( (ret->dp = FindFirstFile(path, &ret->fdata)) != INVALID_HANDLE_VALUE)
return ret;
free(ret);
return NULL;
}
struct dirent *readdir(DIR *ds)
{
if(FindNextFile(ds->dp, &ds->fdata) == FALSE)
return NULL;
if(ds->de.d_name)
free(ds->de.d_name);
ds->de.d_name = strdup(ds->fdata.cFileName);
return &ds->de;
}
void closedir(DIR *ds)
{
FindClose(ds->dp);
if(ds->de.d_name)
free(ds->de.d_name);
free(ds);
}
#endif
#if !defined(NETSCAPE) && defined (POSIX) || defined (HAVE_DIRENT_H) || defined (__GNU_LIBRARY__)
#include <dirent.h>
#ifndef __GNU_LIBRARY__
#define D_NAMLEN(d) strlen((d)->d_name)
#else /* GNU C library. */
#define D_NAMLEN(d) ((d)->d_namlen)
#endif /* Not GNU C library. */
#else /* Not POSIX or HAVE_DIRENT_H. */
#define direct dirent
#define D_NAMLEN(d) (strlen(d->d_name))
#ifdef HAVE_SYS_NDIR_H
#include <sys/ndir.h>
#endif /* HAVE_SYS_NDIR_H */
#ifdef HAVE_SYS_DIR_H
#include <sys/dir.h>
#endif /* HAVE_SYS_DIR_H */
#ifdef HAVE_NDIR_H
#include <ndir.h>
#endif /* HAVE_NDIR_H */
#endif /* POSIX or HAVE_DIRENT_H or __GNU_LIBRARY__. */
#if defined (POSIX) && !defined (__GNU_LIBRARY__) || defined(NETSCAPE)
/* Posix does not require that the d_ino field be present, and some
systems do not provide it. */
#define REAL_DIR_ENTRY(dp) 1
#else
#define REAL_DIR_ENTRY(dp) (dp->d_ino != 0)
#endif /* POSIX */
#ifdef __MSDOS__
#include <ctype.h>
static char *
dosify (filename)
char *filename;
{
static char dos_filename[14];
char *df;
int i;
if (filename == 0)
return 0;
if (strpbrk (filename, "\"*+,;<=>?[\\]|") != 0)
return filename;
df = dos_filename;
/* First, transform the name part. */
for (i = 0; *filename != '\0' && i < 8 && *filename != '.'; ++i)
*df++ = tolower (*filename++);
/* Now skip to the next dot. */
while (*filename != '\0' && *filename != '.')
++filename;
if (*filename != '\0')
{
*df++ = *filename++;
for (i = 0; *filename != '\0' && i < 3 && *filename != '.'; ++i)
*df++ = tolower (*filename++);
}
/* Look for more dots. */
while (*filename != '\0' && *filename != '.')
++filename;
if (*filename == '.')
return filename;
*df = 0;
return dos_filename;
}
#endif
/* Hash table of directories. */
#ifndef DIRECTORY_BUCKETS
#define DIRECTORY_BUCKETS 199
#endif
struct directory_contents
{
struct directory_contents *next;
#ifdef NETSCAPE
int dev; /* Device number of this dir. */
/*
* Inode means nothing on WIN32. Even file key information is
* unreliable because it is random per file open and undefined
* for remote filesystems. The most unique attribute I can
* come up with is the fully qualified name of the directory. Beware
* though, this is also unreliable. I'm open to suggestion on a better
* way to emulate inode.
*/
char *path_key;
int mtime; /* controls check for stale directory cache */
#else
int dev, ino; /* Device and inode numbers of this dir. */
#endif
struct dirfile **files; /* Files in this directory. */
DIR *dirstream; /* Stream reading this directory. */
};
/* Table of directory contents hashed by device and inode number. */
static struct directory_contents *directories_contents[DIRECTORY_BUCKETS];
struct directory
{
struct directory *next;
char *name; /* Name of the directory. */
/* The directory's contents. This data may be shared by several
entries in the hash table, which refer to the same directory
(identified uniquely by `dev' and `ino') under different names. */
struct directory_contents *contents;
};
/* Table of directories hashed by name. */
static struct directory *directories[DIRECTORY_BUCKETS];
/* Never have more than this many directories open at once. */
#define MAX_OPEN_DIRECTORIES 10
static unsigned int open_directories = 0;
/* Hash table of files in each directory. */
struct dirfile
{
struct dirfile *next;
char *name; /* Name of the file. */
char impossible; /* This file is impossible. */
};
#ifndef DIRFILE_BUCKETS
#define DIRFILE_BUCKETS 107
#endif
static int dir_contents_file_exists_p ();
/* Find the directory named NAME and return its `struct directory'. */
static struct directory *
find_directory (name)
register char *name;
{
register unsigned int hash = 0;
register char *p;
register struct directory *dir;
#ifdef NETSCAPE
char w32_path[_MAX_PATH];
#endif
for (p = name; *p != '\0'; ++p)
HASH (hash, *p);
hash %= DIRECTORY_BUCKETS;
for (dir = directories[hash]; dir != 0; dir = dir->next)
if (streq (dir->name, name))
break;
if (dir == 0)
{
struct stat st;
/* The directory was not found. Create a new entry for it. */
dir = (struct directory *) xmalloc (sizeof (struct directory));
dir->next = directories[hash];
directories[hash] = dir;
dir->name = savestring (name, p - name);
/* The directory is not in the name hash table.
Find its device and inode numbers, and look it up by them. */
if (safe_stat (name, &st) < 0)
/* Couldn't stat the directory. Mark this by
setting the `contents' member to a nil pointer. */
dir->contents = 0;
else
{
/* Search the contents hash table; device and inode are the key. */
struct directory_contents *dc;
#ifdef NETSCAPE
_fullpath (w32_path, name, sizeof (w32_path));
hash = ((unsigned int) st.st_dev << 16) | (unsigned int) st.st_ctime;
#else
hash = ((unsigned int) st.st_dev << 16) | (unsigned int) st.st_ino;
#endif
hash %= DIRECTORY_BUCKETS;
for (dc = directories_contents[hash]; dc != 0; dc = dc->next)
#ifdef NETSCAPE
if (!strcmp(dc->path_key, w32_path))
#else
if (dc->dev == (int)st.st_dev && dc->ino == (int)st.st_ino)
#endif
break;
if (dc == 0)
{
/* Nope; this really is a directory we haven't seen before. */
dc = (struct directory_contents *)
xmalloc (sizeof (struct directory_contents));
/* Enter it in the contents hash table. */
dc->dev = st.st_dev;
#ifdef NETSCAPE
dc->path_key = strdup(w32_path);
dc->mtime = st.st_mtime;
#else
dc->ino = st.st_ino;
#endif
dc->next = directories_contents[hash];
directories_contents[hash] = dc;
dc->dirstream = opendir (name);
if (dc->dirstream == 0)
/* Couldn't open the directory. Mark this by
setting the `files' member to a nil pointer. */
dc->files = 0;
else
{
/* Allocate an array of buckets for files and zero it. */
dc->files = (struct dirfile **)
xmalloc (sizeof (struct dirfile *) * DIRFILE_BUCKETS);
bzero ((char *) dc->files,
sizeof (struct dirfile *) * DIRFILE_BUCKETS);
/* Keep track of how many directories are open. */
++open_directories;
if (open_directories == MAX_OPEN_DIRECTORIES)
/* We have too many directories open already.
Read the entire directory and then close it. */
(void) dir_contents_file_exists_p (dc, (char *) 0);
}
}
/* Point the name-hashed entry for DIR at its contents data. */
dir->contents = dc;
}
}
return dir;
}
/* Return 1 if the name FILENAME is entered in DIR's hash table.
FILENAME must contain no slashes. */
static int
dir_contents_file_exists_p (dir, filename)
register struct directory_contents *dir;
register char *filename;
{
register unsigned int hash;
register char *p;
register struct dirfile *df;
register struct dirent *d;
#ifdef NETSCAPE
struct stat st;
int rehash = 0;
#endif
if (dir == 0 || dir->files == 0)
/* The directory could not be stat'd or opened. */
return 0;
#ifdef __MSDOS__
filename = dosify (filename);
#endif
hash = 0;
if (filename != 0)
{
if (*filename == '\0')
/* Checking if the directory exists. */
return 1;
for (p = filename; *p != '\0'; ++p)
HASH (hash, *p);
hash %= DIRFILE_BUCKETS;
/* Search the list of hashed files. */
for (df = dir->files[hash]; df != 0; df = df->next)
if (streq (df->name, filename))
return !df->impossible;
}
/* The file was not found in the hashed list.
Try to read the directory further. */
#ifdef NETSCAPE
if (dir->dirstream == 0)
{
/* Check to see if directory has changed since last read */
if (dir->path_key &&
stat(dir->path_key, &st) == 0 &&
st.st_mtime > dir->mtime) {
/* reset date stamp to show most recent re-process */
dir->mtime = st.st_mtime;
/* make sure directory can still be opened */
dir->dirstream = opendir(dir->path_key);
if (dir->dirstream)
rehash = 1;
else
return 0; /* couldn't re-read - fail */
} else
/* The directory has been all read in. */
return 0;
}
#else
if (dir->dirstream == 0)
/* The directory has been all read in. */
return 0;
#endif
while ((d = readdir (dir->dirstream)) != 0)
{
/* Enter the file in the hash table. */
register unsigned int newhash = 0;
unsigned int len;
register unsigned int i;
if (!REAL_DIR_ENTRY (d))
continue;
len = D_NAMLEN (d);
while (d->d_name[len - 1] == '\0')
--len;
for (i = 0; i < len; ++i)
HASH (newhash, d->d_name[i]);
newhash %= DIRFILE_BUCKETS;
#ifdef NETSCAPE
/*
* If re-reading a directory, check that this file isn't already
* in the cache.
*/
if (rehash) {
for (df = dir->files[newhash]; df != 0; df = df->next)
if (streq(df->name, d->d_name))
break;
} else
df = 0;
/*
* If re-reading a directory, don't cache files that have
* already been discovered.
*/
if (!df) {
#endif
df = (struct dirfile *) xmalloc (sizeof (struct dirfile));
df->next = dir->files[newhash];
dir->files[newhash] = df;
df->name = savestring (d->d_name, len);
df->impossible = 0;
#ifdef NETSCAPE
}
#endif
/* Check if the name matches the one we're searching for. */
if (filename != 0
&& newhash == hash && streq (d->d_name, filename))
return 1;
}
/* If the directory has been completely read in,
close the stream and reset the pointer to nil. */
if (d == 0)
{
--open_directories;
closedir (dir->dirstream);
dir->dirstream = 0;
}
return 0;
}
/* Return 1 if the name FILENAME in directory DIRNAME
is entered in the dir hash table.
FILENAME must contain no slashes. */
int
dir_file_exists_p (dirname, filename)
register char *dirname;
register char *filename;
{
return dir_contents_file_exists_p (find_directory (dirname)->contents,
filename);
}
/* Return 1 if the file named NAME exists. */
int
file_exists_p (name)
register char *name;
{
char *dirend;
char *dirname;
#ifndef NO_ARCHIVES
if (ar_name (name))
return ar_member_date (name) != (time_t) -1;
#endif
dirend = rindex (name, '/');
if (dirend == 0)
return dir_file_exists_p (".", name);
dirname = (char *) alloca (dirend - name + 1);
bcopy (name, dirname, dirend - name);
dirname[dirend - name] = '\0';
return dir_file_exists_p (dirname, dirend + 1);
}
/* Mark FILENAME as `impossible' for `file_impossible_p'.
This means an attempt has been made to search for FILENAME
as an intermediate file, and it has failed. */
void
file_impossible (filename)
register char *filename;
{
char *dirend;
register char *p = filename;
register unsigned int hash;
register struct directory *dir;
register struct dirfile *new;
dirend = rindex (p, '/');
if (dirend == 0)
dir = find_directory (".");
else
{
char *dirname = (char *) alloca (dirend - p + 1);
bcopy (p, dirname, dirend - p);
dirname[dirend - p] = '\0';
dir = find_directory (dirname);
filename = p = dirend + 1;
}
for (hash = 0; *p != '\0'; ++p)
HASH (hash, *p);
hash %= DIRFILE_BUCKETS;
if (dir->contents == 0)
{
/* The directory could not be stat'd. We allocate a contents
structure for it, but leave it out of the contents hash table. */
dir->contents = (struct directory_contents *)
xmalloc (sizeof (struct directory_contents));
#ifdef NETSCAPE
dir->contents->dev = 0;
dir->contents->path_key = NULL;
dir->contents->mtime = 0;
#else
dir->contents->dev = dir->contents->ino = 0;
#endif
dir->contents->files = 0;
dir->contents->dirstream = 0;
}
if (dir->contents->files == 0)
{
/* The directory was not opened; we must allocate the hash buckets. */
dir->contents->files = (struct dirfile **)
xmalloc (sizeof (struct dirfile) * DIRFILE_BUCKETS);
bzero ((char *) dir->contents->files,
sizeof (struct dirfile) * DIRFILE_BUCKETS);
}
/* Make a new entry and put it in the table. */
new = (struct dirfile *) xmalloc (sizeof (struct dirfile));
new->next = dir->contents->files[hash];
dir->contents->files[hash] = new;
new->name = savestring (filename, strlen (filename));
new->impossible = 1;
}
/* Return nonzero if FILENAME has been marked impossible. */
int
file_impossible_p (filename)
char *filename;
{
char *dirend;
register char *p = filename;
register unsigned int hash;
register struct directory_contents *dir;
register struct dirfile *next;
dirend = rindex (filename, '/');
if (dirend == 0)
dir = find_directory (".")->contents;
else
{
char *dirname = (char *) alloca (dirend - filename + 1);
bcopy (p, dirname, dirend - p);
dirname[dirend - p] = '\0';
dir = find_directory (dirname)->contents;
p = dirend + 1;
}
if (dir == 0 || dir->files == 0)
/* There are no files entered for this directory. */
return 0;
#ifdef __MSDOS__
p = filename = dosify (p);
#endif
for (hash = 0; *p != '\0'; ++p)
HASH (hash, *p);
hash %= DIRFILE_BUCKETS;
for (next = dir->files[hash]; next != 0; next = next->next)
if (streq (filename, next->name))
return next->impossible;
return 0;
}
/* Return the already allocated name in the
directory hash table that matches DIR. */
char *
dir_name (dir)
char *dir;
{
return find_directory (dir)->name;
}
/* Print the data base of directories. */
void
print_dir_data_base ()
{
register unsigned int i, dirs, files, impossible;
register struct directory *dir;
puts ("\n# Directories\n");
dirs = files = impossible = 0;
for (i = 0; i < DIRECTORY_BUCKETS; ++i)
for (dir = directories[i]; dir != 0; dir = dir->next)
{
++dirs;
if (dir->contents == 0)
printf ("# %s: could not be stat'd.\n", dir->name);
else if (dir->contents->files == 0)
#ifdef NETSCAPE
printf ("# %s (path_key %s, mtime %d): could not be opened.\n",
dir->name, dir->contents->path_key, dir->contents->mtime);
#else
printf ("# %s (device %d, inode %d): could not be opened.\n",
dir->name, dir->contents->dev, dir->contents->ino);
#endif
else
{
register unsigned int f = 0, im = 0;
register unsigned int j;
register struct dirfile *df;
for (j = 0; j < DIRFILE_BUCKETS; ++j)
for (df = dir->contents->files[j]; df != 0; df = df->next)
if (df->impossible)
++im;
else
++f;
#ifdef NETSCAPE
printf ("# %s (device %d, path_key %s, mtime %d): ",
dir->name, dir->contents->dev,
dir->contents->path_key, dir->contents->mtime);
#else
printf ("# %s (device %d, inode %d): ",
dir->name, dir->contents->dev, dir->contents->ino);
#endif
if (f == 0)
fputs ("No", stdout);
else
printf ("%u", f);
fputs (" files, ", stdout);
if (im == 0)
fputs ("no", stdout);
else
printf ("%u", im);
fputs (" impossibilities", stdout);
if (dir->contents->dirstream == 0)
puts (".");
else
puts (" so far.");
files += f;
impossible += im;
}
}
fputs ("\n# ", stdout);
if (files == 0)
fputs ("No", stdout);
else
printf ("%u", files);
fputs (" files, ", stdout);
if (impossible == 0)
fputs ("no", stdout);
else
printf ("%u", impossible);
printf (" impossibilities in %u directories.\n", dirs);
}
/* Hooks for globbing. */
#include <glob.h>
/* Structure describing state of iterating through a directory hash table. */
struct dirstream
{
struct directory_contents *contents; /* The directory being read. */
unsigned int bucket; /* Current hash bucket. */
struct dirfile *elt; /* Current elt in bucket. */
};
/* Forward declarations. */
static __ptr_t open_dirstream __P ((const char *));
static const char *read_dirstream __P ((__ptr_t));
static __ptr_t
open_dirstream (directory)
const char *directory;
{
struct dirstream *new;
struct directory *dir = find_directory (directory);
if (dir->contents == 0 || dir->contents->files == 0)
/* DIR->contents is nil if the directory could not be stat'd.
DIR->contents->files is nil if it could not be opened. */
return 0;
/* Read all the contents of the directory now. There is no benefit
in being lazy, since glob will want to see every file anyway. */
(void) dir_contents_file_exists_p (dir->contents, (char *) 0);
new = (struct dirstream *) xmalloc (sizeof (struct dirstream));
new->contents = dir->contents;
new->bucket = 0;
new->elt = new->contents->files[0];
return (__ptr_t) new;
}
static const char *
read_dirstream (stream)
__ptr_t stream;
{
struct dirstream *const ds = (struct dirstream *) stream;
register struct dirfile *df;
while (ds->bucket < DIRFILE_BUCKETS)
{
while ((df = ds->elt) != 0)
{
ds->elt = df->next;
if (!df->impossible)
return df->name;
}
if (++ds->bucket == DIRFILE_BUCKETS)
break;
ds->elt = ds->contents->files[ds->bucket];
}
return 0;
}
void
init_dir ()
{
__glob_opendir_hook = open_dirstream;
__glob_readdir_hook = read_dirstream;
__glob_closedir_hook = (void (*) __P ((__ptr_t stream))) free;
}

456
buildtools/windows/source/make/expand.c
View File

@ -1,456 +0,0 @@
/* Variable expansion functions for GNU Make.
Copyright (C) 1988, 89, 91, 92, 93, 95 Free Software Foundation, Inc.
This file is part of GNU Make.
GNU Make is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Make is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Make; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "make.h"
#include "commands.h"
#include "file.h"
#include "variable.h"
/* The next two describe the variable output buffer.
This buffer is used to hold the variable-expansion of a line of the
makefile. It is made bigger with realloc whenever it is too small.
variable_buffer_length is the size currently allocated.
variable_buffer is the address of the buffer. */
static unsigned int variable_buffer_length;
static char *variable_buffer;
/* Subroutine of variable_expand and friends:
The text to add is LENGTH chars starting at STRING to the variable_buffer.
The text is added to the buffer at PTR, and the updated pointer into
the buffer is returned as the value. Thus, the value returned by
each call to variable_buffer_output should be the first argument to
the following call. */
char *
variable_buffer_output (ptr, string, length)
char *ptr, *string;
unsigned int length;
{
register unsigned int newlen = length + (ptr - variable_buffer);
if (newlen > variable_buffer_length)
{
unsigned int offset = ptr - variable_buffer;
variable_buffer_length = (newlen + 100 > 2 * variable_buffer_length
? newlen + 100
: 2 * variable_buffer_length);
variable_buffer = (char *) xrealloc (variable_buffer,
variable_buffer_length);
ptr = variable_buffer + offset;
}
bcopy (string, ptr, length);
return ptr + length;
}
/* Return a pointer to the beginning of the variable buffer. */
static char *
initialize_variable_output ()
{
/* If we don't have a variable output buffer yet, get one. */
if (variable_buffer == 0)
{
variable_buffer_length = 200;
variable_buffer = (char *) xmalloc (variable_buffer_length);
variable_buffer[0] = '\0';
}
return variable_buffer;
}
/* Recursively expand V. The returned string is malloc'd. */
char *
recursively_expand (v)
register struct variable *v;
{
char *value;
if (v->expanding)
{
/* Expanding V causes infinite recursion. Lose. */
if (reading_filename == 0)
fatal ("Recursive variable `%s' references itself (eventually)",
v->name);
else
makefile_fatal
(reading_filename, *reading_lineno_ptr,
"Recursive variable `%s' references itself (eventually)",
v->name);
}
v->expanding = 1;
value = allocated_variable_expand (v->value);
v->expanding = 0;
return value;
}
/* Warn that NAME is an undefined variable. */
#ifdef __GNUC__
__inline
#endif
static void
warn_undefined (name, length)
char *name;
unsigned int length;
{
if (warn_undefined_variables_flag)
{
static const char warnmsg[] = "warning: undefined variable `%.*s'";
if (reading_filename != 0)
makefile_error (reading_filename, *reading_lineno_ptr,
warnmsg, length, name);
else
error (warnmsg, length, name);
}
}
/* Expand a simple reference to variable NAME, which is LENGTH chars long. */
#ifdef __GNUC__
__inline
#endif
static char *
reference_variable (o, name, length)
char *o;
char *name;
unsigned int length;
{
register struct variable *v = lookup_variable (name, length);
if (v == 0)
warn_undefined (name, length);
if (v != 0 && *v->value != '\0')
{
char *value = (v->recursive ? recursively_expand (v) : v->value);
o = variable_buffer_output (o, value, strlen (value));
if (v->recursive)
free (value);
}
return o;
}
/* Scan LINE for variable references and expansion-function calls.
Build in `variable_buffer' the result of expanding the references and calls.
Return the address of the resulting string, which is null-terminated
and is valid only until the next time this function is called. */
char *
variable_expand (line)
register char *line;
{
register struct variable *v;
register char *p, *o, *p1;
p = line;
o = initialize_variable_output ();
while (1)
{
/* Copy all following uninteresting chars all at once to the
variable output buffer, and skip them. Uninteresting chars end
at the next $ or the end of the input. */
p1 = index (p, '$');
o = variable_buffer_output (o, p, p1 != 0 ? p1 - p : strlen (p) + 1);
if (p1 == 0)
break;
p = p1 + 1;
/* Dispatch on the char that follows the $. */
switch (*p)
{
case '$':
/* $$ seen means output one $ to the variable output buffer. */
o = variable_buffer_output (o, p, 1);
break;
case '(':
case '{':
/* $(...) or ${...} is the general case of substitution. */
{
char openparen = *p;
char closeparen = (openparen == '(') ? ')' : '}';
register char *beg = p + 1;
int free_beg = 0;
char *op, *begp;
char *end, *colon;
op = o;
begp = p;
if (handle_function (&op, &begp))
{
o = op;
p = begp;
break;
}
/* Is there a variable reference inside the parens or braces?
If so, expand it before expanding the entire reference. */
end = index (beg, closeparen);
if (end == 0)
{
/* Unterminated variable reference. */
if (reading_filename != 0)
makefile_fatal (reading_filename, *reading_lineno_ptr,
"unterminated variable reference");
else
fatal ("unterminated variable reference");
}
p1 = lindex (beg, end, '$');
if (p1 != 0)
{
/* BEG now points past the opening paren or brace.
Count parens or braces until it is matched. */
int count = 0;
for (p = beg; *p != '\0'; ++p)
{
if (*p == openparen)
++count;
else if (*p == closeparen && --count < 0)
break;
}
/* If COUNT is >= 0, there were unmatched opening parens
or braces, so we go to the simple case of a variable name
such as `$($(a)'. */
if (count < 0)
{
beg = expand_argument (beg, p); /* Expand the name. */
free_beg = 1; /* Remember to free BEG when finished. */
end = index (beg, '\0');
}
}
else
/* Advance P to the end of this reference. After we are
finished expanding this one, P will be incremented to
continue the scan. */
p = end;
/* This is not a reference to a built-in function and
any variable references inside are now expanded.
Is the resultant text a substitution reference? */
colon = lindex (beg, end, ':');
if (colon != 0)
{
/* This looks like a substitution reference: $(FOO:A=B). */
char *subst_beg, *subst_end, *replace_beg, *replace_end;
subst_beg = colon + 1;
subst_end = index (subst_beg, '=');
if (subst_end == 0)
/* There is no = in sight. Punt on the substitution
reference and treat this as a variable name containing
a colon, in the code below. */
colon = 0;
else
{
replace_beg = subst_end + 1;
replace_end = end;
/* Extract the variable name before the colon
and look up that variable. */
v = lookup_variable (beg, colon - beg);
if (v == 0)
warn_undefined (beg, colon - beg);
if (v != 0 && *v->value != '\0')
{
char *value = (v->recursive ? recursively_expand (v)
: v->value);
char *pattern, *percent;
if (free_beg)
{
*subst_end = '\0';
pattern = subst_beg;
}
else
{
pattern = (char *) alloca (subst_end - subst_beg
+ 1);
bcopy (subst_beg, pattern, subst_end - subst_beg);
pattern[subst_end - subst_beg] = '\0';
}
percent = find_percent (pattern);
if (percent != 0)
{
char *replace;
if (free_beg)
{
*replace_end = '\0';
replace = replace_beg;
}
else
{
replace = (char *) alloca (replace_end
- replace_beg
+ 1);
bcopy (replace_beg, replace,
replace_end - replace_beg);
replace[replace_end - replace_beg] = '\0';
}
o = patsubst_expand (o, value, pattern, replace,
percent, (char *) 0);
}
else
o = subst_expand (o, value,
pattern, replace_beg,
strlen (pattern),
end - replace_beg,
0, 1);
if (v->recursive)
free (value);
}
}
}
if (colon == 0)
/* This is an ordinary variable reference.
Look up the value of the variable. */
o = reference_variable (o, beg, end - beg);
if (free_beg)
free (beg);
}
break;
case '\0':
break;
default:
if (isblank (p[-1]))
break;
/* A $ followed by a random char is a variable reference:
$a is equivalent to $(a). */
{
/* We could do the expanding here, but this way
avoids code repetition at a small performance cost. */
char name[5];
name[0] = '$';
name[1] = '(';
name[2] = *p;
name[3] = ')';
name[4] = '\0';
p1 = allocated_variable_expand (name);
o = variable_buffer_output (o, p1, strlen (p1));
free (p1);
}
break;
}
if (*p == '\0')
break;
else
++p;
}
(void) variable_buffer_output (o, "", 1);
return initialize_variable_output ();
}
/* Expand an argument for an expansion function.
The text starting at STR and ending at END is variable-expanded
into a null-terminated string that is returned as the value.
This is done without clobbering `variable_buffer' or the current
variable-expansion that is in progress. */
char *
expand_argument (str, end)
char *str, *end;
{
char *tmp;
if (*end == '\0')
tmp = str;
else
{
tmp = (char *) alloca (end - str + 1);
bcopy (str, tmp, end - str);
tmp[end - str] = '\0';
}
return allocated_variable_expand (tmp);
}
/* Expand LINE for FILE. Error messages refer to the file and line where
FILE's commands were found. Expansion uses FILE's variable set list. */
char *
variable_expand_for_file (line, file)
char *line;
register struct file *file;
{
char *result;
struct variable_set_list *save;
if (file == 0)
return variable_expand (line);
save = current_variable_set_list;
current_variable_set_list = file->variables;
reading_filename = file->cmds->filename;
reading_lineno_ptr = &file->cmds->lineno;
result = variable_expand (line);
current_variable_set_list = save;
reading_filename = 0;
reading_lineno_ptr = 0;
return result;
}
/* Like variable_expand_for_file, but the returned string is malloc'd.
This function is called a lot. It wants to be efficient. */
char *
allocated_variable_expand_for_file (line, file)
char *line;
struct file *file;
{
char *value;
char *obuf = variable_buffer;
unsigned int olen = variable_buffer_length;
variable_buffer = 0;
value = variable_expand_for_file (line, file);
#if 0
/* Waste a little memory and save time. */
value = xrealloc (value, strlen (value))
#endif
variable_buffer = obuf;
variable_buffer_length = olen;
return value;
}

566
buildtools/windows/source/make/file.c
View File

@ -1,566 +0,0 @@
/* Target file hash table management for GNU Make.
Copyright (C) 1988, 89, 90, 91, 92, 93, 94, 1995 Free Software Foundation, Inc.
This file is part of GNU Make.
GNU Make is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Make is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Make; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "make.h"
#include "commands.h"
#include "dep.h"
#include "file.h"
#include "variable.h"
#include <assert.h>
/* Hash table of files the makefile knows how to make. */
#ifndef FILE_BUCKETS
#define FILE_BUCKETS 1007
#endif
static struct file *files[FILE_BUCKETS];
/* Number of files with the `intermediate' flag set. */
unsigned int num_intermediates = 0;
/* Access the hash table of all file records.
lookup_file given a name, return the struct file * for that name,
or nil if there is none.
enter_file similar, but create one if there is none. */
struct file *
lookup_file (name)
char *name;
{
register struct file *f;
register char *n;
register unsigned int hashval;
if (*name == '\0')
abort ();
/* This is also done in parse_file_seq, so this is redundant
for names read from makefiles. It is here for names passed
on the command line. */
while (name[0] == '.' && name[1] == '/' && name[2] != '\0')
{
name += 2;
while (*name == '/')
/* Skip following slashes: ".//foo" is "foo", not "/foo". */
++name;
}
if (*name == '\0')
/* It was all slashes after a dot. */
name = "./";
hashval = 0;
for (n = name; *n != '\0'; ++n)
HASH (hashval, *n);
hashval %= FILE_BUCKETS;
for (f = files[hashval]; f != 0; f = f->next)
if (streq (f->name, name))
return f;
return 0;
}
struct file *
enter_file (name)
char *name;
{
register struct file *f, *new;
register char *n;
register unsigned int hashval;
if (*name == '\0')
abort ();
hashval = 0;
for (n = name; *n != '\0'; ++n)
HASH (hashval, *n);
hashval %= FILE_BUCKETS;
for (f = files[hashval]; f != 0; f = f->next)
if (streq (f->name, name))
break;
if (f != 0 && !f->double_colon)
return f;
new = (struct file *) xmalloc (sizeof (struct file));
bzero ((char *) new, sizeof (struct file));
new->name = name;
new->update_status = -1;
if (f == 0)
{
/* This is a completely new file. */
new->next = files[hashval];
files[hashval] = new;
}
else
{
/* There is already a double-colon entry for this file. */
new->double_colon = f;
while (f->prev != 0)
f = f->prev;
f->prev = new;
}
return new;
}
/* Rename FILE to NAME. This is not as simple as resetting
the `name' member, since it must be put in a new hash bucket,
and possibly merged with an existing file called NAME. */
void
rename_file (file, name)
register struct file *file;
char *name;
{
char *oldname = file->name;
register unsigned int oldhash;
register char *n;
while (file->renamed != 0)
file = file->renamed;
/* Find the hash values of the old and new names. */
oldhash = 0;
for (n = oldname; *n != '\0'; ++n)
HASH (oldhash, *n);
file_hash_enter (file, name, oldhash, file->name);
}
void
file_hash_enter (file, name, oldhash, oldname)
register struct file *file;
char *name;
unsigned int oldhash;
char *oldname;
{
unsigned int oldbucket = oldhash % FILE_BUCKETS;
register unsigned int newhash, newbucket;
struct file *oldfile;
register char *n;
register struct file *f;
newhash = 0;
for (n = name; *n != '\0'; ++n)
HASH (newhash, *n);
newbucket = newhash % FILE_BUCKETS;
/* Look for an existing file under the new name. */
for (oldfile = files[newbucket]; oldfile != 0; oldfile = oldfile->next)
if (streq (oldfile->name, name))
break;
if (oldhash != 0 && (newbucket != oldbucket || oldfile != 0))
{
/* Remove FILE from its hash bucket. */
struct file *lastf = 0;
for (f = files[oldbucket]; f != file; f = f->next)
lastf = f;
if (lastf == 0)
files[oldbucket] = f->next;
else
lastf->next = f->next;
}
/* Give FILE its new name. */
file->name = name;
for (f = file->double_colon; f != 0; f = f->prev)
f->name = name;
if (oldfile == 0)
{
/* There is no existing file with the new name. */
if (newbucket != oldbucket)
{
/* Put FILE in its new hash bucket. */
file->next = files[newbucket];
files[newbucket] = file;
}
}
else
{
/* There is an existing file with the new name.
We must merge FILE into the existing file. */
register struct dep *d;
if (file->cmds != 0)
{
if (oldfile->cmds == 0)
oldfile->cmds = file->cmds;
else if (file->cmds != oldfile->cmds)
{
/* We have two sets of commands. We will go with the
one given in the rule explicitly mentioning this name,
but give a message to let the user know what's going on. */
if (oldfile->cmds->filename != 0)
makefile_error (file->cmds->filename, file->cmds->lineno,
"Commands were specified for \
file `%s' at %s:%u,",
oldname, oldfile->cmds->filename,
oldfile->cmds->lineno);
else
makefile_error (file->cmds->filename, file->cmds->lineno,
"Commands for file `%s' were found by \
implicit rule search,",
oldname);
makefile_error (file->cmds->filename, file->cmds->lineno,
"but `%s' is now considered the same file \
as `%s'.",
oldname, name);
makefile_error (file->cmds->filename, file->cmds->lineno,
"Commands for `%s' will be ignored \
in favor of those for `%s'.",
name, oldname);
}
}
/* Merge the dependencies of the two files. */
d = oldfile->deps;
if (d == 0)
oldfile->deps = file->deps;
else
{
while (d->next != 0)
d = d->next;
d->next = file->deps;
}
merge_variable_set_lists (&oldfile->variables, file->variables);
if (oldfile->double_colon && !file->double_colon)
fatal ("can't rename single-colon `%s' to double-colon `%s'",
oldname, name);
if (!oldfile->double_colon && file->double_colon)
fatal ("can't rename double-colon `%s' to single-colon `%s'",
oldname, name);
if (file->last_mtime > oldfile->last_mtime)
/* %%% Kludge so -W wins on a file that gets vpathized. */
oldfile->last_mtime = file->last_mtime;
#define MERGE(field) oldfile->field |= file->field
MERGE (precious);
MERGE (tried_implicit);
MERGE (updating);
MERGE (updated);
MERGE (is_target);
MERGE (cmd_target);
MERGE (phony);
#undef MERGE
file->renamed = oldfile;
}
}
/* Remove all nonprecious intermediate files.
If SIG is nonzero, this was caused by a fatal signal,
meaning that a different message will be printed, and
the message will go to stderr rather than stdout. */
void
remove_intermediates (sig)
int sig;
{
register int i;
register struct file *f;
char doneany;
if (question_flag || touch_flag)
return;
if (sig && just_print_flag)
return;
doneany = 0;
for (i = 0; i < FILE_BUCKETS; ++i)
for (f = files[i]; f != 0; f = f->next)
if (f->intermediate && (f->dontcare || !f->precious))
{
int status;
if (f->update_status == -1)
/* If nothing would have created this file yet,
don't print an "rm" command for it. */
continue;
else if (just_print_flag)
status = 0;
else
{
status = unlink (f->name);
if (status < 0 && errno == ENOENT)
continue;
}
if (!f->dontcare)
{
if (sig)
error ("*** Deleting intermediate file `%s'", f->name);
else if (!silent_flag)
{
if (! doneany)
{
fputs ("rm ", stdout);
doneany = 1;
}
else
putchar (' ');
fputs (f->name, stdout);
fflush (stdout);
}
if (status < 0)
perror_with_name ("unlink: ", f->name);
}
}
if (doneany && !sig)
{
putchar ('\n');
fflush (stdout);
}
}
/* For each dependency of each file, make the `struct dep' point
at the appropriate `struct file' (which may have to be created).
Also mark the files depended on by .PRECIOUS and .PHONY. */
void
snap_deps ()
{
register struct file *f, *f2;
register struct dep *d;
register int i;
/* Enter each dependency name as a file. */
for (i = 0; i < FILE_BUCKETS; ++i)
for (f = files[i]; f != 0; f = f->next)
for (f2 = f; f2 != 0; f2 = f2->prev)
for (d = f2->deps; d != 0; d = d->next)
if (d->name != 0)
{
d->file = lookup_file (d->name);
if (d->file == 0)
d->file = enter_file (d->name);
else
free (d->name);
d->name = 0;
}
for (f = lookup_file (".PRECIOUS"); f != 0; f = f->prev)
for (d = f->deps; d != 0; d = d->next)
for (f2 = d->file; f2 != 0; f2 = f2->prev)
f2->precious = 1;
for (f = lookup_file (".PHONY"); f != 0; f = f->prev)
for (d = f->deps; d != 0; d = d->next)
for (f2 = d->file; f2 != 0; f2 = f2->prev)
{
/* Mark this file as phony and nonexistent. */
f2->phony = 1;
f2->last_mtime = (time_t) -1;
}
f = lookup_file (".EXPORT_ALL_VARIABLES");
if (f != 0 && f->is_target)
export_all_variables = 1;
f = lookup_file (".IGNORE");
if (f != 0 && f->is_target)
{
if (f->deps == 0)
ignore_errors_flag = 1;
else
for (d = f->deps; d != 0; d = d->next)
for (f2 = d->file; f2 != 0; f2 = f2->prev)
f2->command_flags |= COMMANDS_NOERROR;
}
f = lookup_file (".SILENT");
if (f != 0 && f->is_target)
{
if (f->deps == 0)
silent_flag = 1;
else
for (d = f->deps; d != 0; d = d->next)
for (f2 = d->file; f2 != 0; f2 = f2->prev)
f2->command_flags |= COMMANDS_SILENT;
}
f = lookup_file (".POSIX");
if (f != 0 && f->is_target)
posix_pedantic = 1;
}
/* Set the `command_state' member of FILE and all its `also_make's. */
void
set_command_state (file, state)
struct file *file;
int state;
{
struct dep *d;
file->command_state = state;
for (d = file->also_make; d != 0; d = d->next)
d->file->command_state = state;
}
/* Print the data base of files. */
static void
print_file (f)
struct file *f;
{
register struct dep *d;
putchar ('\n');
if (!f->is_target)
puts ("# Not a target:");
printf ("%s:%s", f->name, f->double_colon ? ":" : "");
for (d = f->deps; d != 0; d = d->next)
printf (" %s", dep_name (d));
putchar ('\n');
if (f->precious)
puts ("# Precious file (dependency of .PRECIOUS).");
if (f->phony)
puts ("# Phony target (dependency of .PHONY).");
if (f->cmd_target)
puts ("# Command-line target.");
if (f->dontcare)
puts ("# A default or MAKEFILES makefile.");
printf ("# Implicit rule search has%s been done.\n",
f->tried_implicit ? "" : " not");
if (f->stem != 0)
printf ("# Implicit/static pattern stem: `%s'\n", f->stem);
if (f->intermediate)
puts ("# File is an intermediate dependency.");
if (f->also_make != 0)
{
fputs ("# Also makes:", stdout);
for (d = f->also_make; d != 0; d = d->next)
printf (" %s", dep_name (d));
putchar ('\n');
}
if (f->last_mtime == (time_t) 0)
puts ("# Modification time never checked.");
else if (f->last_mtime == (time_t) -1)
puts ("# File does not exist.");
else
printf ("# Last modified %.24s (%ld)\n",
ctime (&f->last_mtime), (long int) f->last_mtime);
printf ("# File has%s been updated.\n",
f->updated ? "" : " not");
switch (f->command_state)
{
case cs_running:
puts ("# Commands currently running (THIS IS A BUG).");
break;
case cs_deps_running:
puts ("# Dependencies commands running (THIS IS A BUG).");
break;
case cs_not_started:
case cs_finished:
switch (f->update_status)
{
case -1:
break;
case 0:
puts ("# Successfully updated.");
break;
case 1:
assert (question_flag);
puts ("# Needs to be updated (-q is set).");
break;
case 2:
puts ("# Failed to be updated.");
break;
default:
puts ("# Invalid value in `update_status' member!");
fflush (stdout);
fflush (stderr);
abort ();
}
break;
default:
puts ("# Invalid value in `command_state' member!");
fflush (stdout);
fflush (stderr);
abort ();
}
if (f->variables != 0)
print_file_variables (f);
if (f->cmds != 0)
print_commands (f->cmds);
}
void
print_file_data_base ()
{
register unsigned int i, nfiles, per_bucket;
register struct file *file;
puts ("\n# Files");
per_bucket = nfiles = 0;
for (i = 0; i < FILE_BUCKETS; ++i)
{
register unsigned int this_bucket = 0;
for (file = files[i]; file != 0; file = file->next)
{
register struct file *f;
++this_bucket;
for (f = file; f != 0; f = f->prev)
print_file (f);
}
nfiles += this_bucket;
if (this_bucket > per_bucket)
per_bucket = this_bucket;
}
if (nfiles == 0)
puts ("\n# No files.");
else
{
printf ("\n# %u files in %u hash buckets.\n", nfiles, FILE_BUCKETS);
#ifndef NO_FLOAT
printf ("# average %.1f files per bucket, max %u files in one bucket.\n",
((double) nfiles) / ((double) FILE_BUCKETS) * 100.0, per_bucket);
#endif
}
}

111
buildtools/windows/source/make/file.h
View File

@ -1,111 +0,0 @@
/* Definition of target file data structures for GNU Make.
Copyright (C) 1988, 89, 90, 91, 92, 93, 94 Free Software Foundation, Inc.
This file is part of GNU Make.
GNU Make is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Make is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Make; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
/* Structure that represents the info on one file
that the makefile says how to make.
All of these are chained together through `next'. */
struct file
{
struct file *next;
char *name;
struct dep *deps;
struct commands *cmds; /* Commands to execute for this target. */
int command_flags; /* Flags OR'd in for cmds; see commands.h. */
char *stem; /* Implicit stem, if an implicit
rule has been used */
struct dep *also_make; /* Targets that are made by making this. */
time_t last_mtime; /* File's modtime, if already known. */
struct file *prev; /* Previous entry for same file name;
used when there are multiple double-colon
entries for the same file. */
/* File that this file was renamed to. After any time that a
file could be renamed, call `check_renamed' (below). */
struct file *renamed;
/* List of variable sets used for this file. */
struct variable_set_list *variables;
/* Immediate dependent that caused this target to be remade,
or nil if there isn't one. */
struct file *parent;
/* For a double-colon entry, this is the first double-colon entry for
the same file. Otherwise this is null. */
struct file *double_colon;
short int update_status; /* Status of the last attempt to update,
or -1 if none has been made. */
enum /* State of the commands. */
{ /* Note: It is important that cs_not_started be zero. */
cs_not_started, /* Not yet started. */
cs_deps_running, /* Dep commands running. */
cs_running, /* Commands running. */
cs_finished /* Commands finished. */
} command_state ENUM_BITFIELD (2);
unsigned int precious:1; /* Non-0 means don't delete file on quit */
unsigned int tried_implicit:1; /* Nonzero if have searched
for implicit rule for making
this file; don't search again. */
unsigned int updating:1; /* Nonzero while updating deps of this file */
unsigned int updated:1; /* Nonzero if this file has been remade. */
unsigned int is_target:1; /* Nonzero if file is described as target. */
unsigned int cmd_target:1; /* Nonzero if file was given on cmd line. */
unsigned int phony:1; /* Nonzero if this is a phony file
i.e., a dependency of .PHONY. */
unsigned int intermediate:1;/* Nonzero if this is an intermediate file. */
unsigned int dontcare:1; /* Nonzero if no complaint is to be made if
this target cannot be remade. */
};
/* Number of intermediate files entered. */
extern unsigned int num_intermediates;
extern struct file *default_goal_file, *suffix_file, *default_file;
extern struct file *lookup_file (), *enter_file ();
extern void remove_intermediates (), snap_deps ();
extern void rename_file (), file_hash_enter ();
extern void set_command_state ();
extern time_t f_mtime ();
#define file_mtime_1(f, v) \
((f)->last_mtime != (time_t) 0 ? (f)->last_mtime : f_mtime ((f), v))
#define file_mtime(f) file_mtime_1 ((f), 1)
#define file_mtime_no_search(f) file_mtime_1 ((f), 0)
/* Modtime value to use for `infinitely new'. We used to get the current time
from the system and use that whenever we wanted `new'. But that causes
trouble when the machine running make and the machine holding a file have
different ideas about what time it is; and can also lose for `force'
targets, which need to be considered newer than anything that depends on
them, even if said dependents' modtimes are in the future.
NOTE: This assumes 32-bit `time_t's, but I cannot think of a portable way
to produce the largest representable integer of a given signed type. */
#define NEW_MTIME ((time_t) 0x7fffffff)
#define check_renamed(file) \
while ((file)->renamed != 0) (file) = (file)->renamed /* No ; here. */

1329
buildtools/windows/source/make/function.c
View File

File diff suppressed because it is too large Load Diff

938
buildtools/windows/source/make/getloadavg.c
View File

@ -1,938 +0,0 @@
/* Get the system load averages.
Copyright (C) 1985, 86, 87, 88, 89, 91, 92, 93, 1994, 1995
Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
/* Compile-time symbols that this file uses:
FIXUP_KERNEL_SYMBOL_ADDR() Adjust address in returned struct nlist.
KERNEL_FILE Pathname of the kernel to nlist.
LDAV_CVT() Scale the load average from the kernel.
Returns a double.
LDAV_SYMBOL Name of kernel symbol giving load average.
LOAD_AVE_TYPE Type of the load average array in the kernel.
Must be defined unless one of
apollo, DGUX, NeXT, or UMAX is defined;
otherwise, no load average is available.
NLIST_STRUCT Include nlist.h, not a.out.h, and
the nlist n_name element is a pointer,
not an array.
NLIST_NAME_UNION struct nlist has an n_un member, not n_name.
LINUX_LDAV_FILE [__linux__]: File containing load averages.
Specific system predefines this file uses, aside from setting
default values if not emacs:
apollo
BSD Real BSD, not just BSD-like.
DGUX
eunice UNIX emulator under VMS.
hpux
NeXT
sgi
sequent Sequent Dynix 3.x.x (BSD)
_SEQUENT_ Sequent DYNIX/ptx 1.x.x (SYSV)
sony_news NEWS-OS (works at least for 4.1C)
UMAX
UMAX4_3
VMS
__linux__ Linux: assumes /proc filesystem mounted.
Support from Michael K. Johnson.
__NetBSD__ NetBSD: assumes /kern filesystem mounted.
In addition, to avoid nesting many #ifdefs, we internally set
LDAV_DONE to indicate that the load average has been computed.
We also #define LDAV_PRIVILEGED if a program will require
special installation to be able to call getloadavg. */
/* This should always be first. */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <sys/types.h>
/* Both the Emacs and non-Emacs sections want this. Some
configuration files' definitions for the LOAD_AVE_CVT macro (like
sparc.h's) use macros like FSCALE, defined here. */
#ifdef unix
#include <sys/param.h>
#endif
/* Exclude all the code except the test program at the end
if the system has its own `getloadavg' function.
The declaration of `errno' is needed by the test program
as well as the function itself, so it comes first. */
#include <errno.h>
#ifndef errno
extern int errno;
#endif
#ifndef HAVE_GETLOADAVG
/* The existing Emacs configuration files define a macro called
LOAD_AVE_CVT, which accepts a value of type LOAD_AVE_TYPE, and
returns the load average multiplied by 100. What we actually want
is a macro called LDAV_CVT, which returns the load average as an
unmultiplied double.
For backwards compatibility, we'll define LDAV_CVT in terms of
LOAD_AVE_CVT, but future machine config files should just define
LDAV_CVT directly. */
#if !defined(LDAV_CVT) && defined(LOAD_AVE_CVT)
#define LDAV_CVT(n) (LOAD_AVE_CVT (n) / 100.0)
#endif
#if !defined (BSD) && defined (ultrix)
/* Ultrix behaves like BSD on Vaxen. */
#define BSD
#endif
#ifdef NeXT
/* NeXT in the 2.{0,1,2} releases defines BSD in <sys/param.h>, which
conflicts with the definition understood in this file, that this
really is BSD. */
#undef BSD
/* NeXT defines FSCALE in <sys/param.h>. However, we take FSCALE being
defined to mean that the nlist method should be used, which is not true. */
#undef FSCALE
#endif
/* Set values that are different from the defaults, which are
set a little farther down with #ifndef. */
/* Some shorthands. */
#if defined (HPUX) && !defined (hpux)
#define hpux
#endif
#if defined(hp300) && !defined(hpux)
#define MORE_BSD
#endif
#if defined(ultrix) && defined(mips)
#define decstation
#endif
#if defined(sun) && defined(SVR4)
#define SUNOS_5
#endif
#if defined (__osf__) && (defined (__alpha) || defined (__alpha__))
#define OSF_ALPHA
#include <sys/table.h>
#endif
#if defined (__osf__) && (defined (mips) || defined (__mips__))
#define OSF_MIPS
#include <sys/table.h>
#endif
/* UTek's /bin/cc on the 4300 has no architecture specific cpp define by
default, but _MACH_IND_SYS_TYPES is defined in <sys/types.h>. Combine
that with a couple of other things and we'll have a unique match. */
#if !defined (tek4300) && defined (unix) && defined (m68k) && defined (mc68000) && defined (mc68020) && defined (_MACH_IND_SYS_TYPES)
#define tek4300 /* Define by emacs, but not by other users. */
#endif
/* VAX C can't handle multi-line #ifs, or lines longer than 256 chars. */
#ifndef LOAD_AVE_TYPE
#ifdef MORE_BSD
#define LOAD_AVE_TYPE long
#endif
#ifdef sun
#define LOAD_AVE_TYPE long
#endif
#ifdef decstation
#define LOAD_AVE_TYPE long
#endif
#ifdef _SEQUENT_
#define LOAD_AVE_TYPE long
#endif
#ifdef sgi
#define LOAD_AVE_TYPE long
#endif
#ifdef SVR4
#define LOAD_AVE_TYPE long
#endif
#ifdef sony_news
#define LOAD_AVE_TYPE long
#endif
#ifdef sequent
#define LOAD_AVE_TYPE long
#endif
#ifdef OSF_ALPHA
#define LOAD_AVE_TYPE long
#endif
#if defined (ardent) && defined (titan)
#define LOAD_AVE_TYPE long
#endif
#ifdef tek4300
#define LOAD_AVE_TYPE long
#endif
#if defined(alliant) && defined(i860) /* Alliant FX/2800 */
#define LOAD_AVE_TYPE long
#endif
#ifdef _AIX
#define LOAD_AVE_TYPE long
#endif
#endif /* No LOAD_AVE_TYPE. */
#ifdef OSF_ALPHA
/* <sys/param.h> defines an incorrect value for FSCALE on Alpha OSF/1,
according to ghazi@noc.rutgers.edu. */
#undef FSCALE
#define FSCALE 1024.0
#endif
#if defined(alliant) && defined(i860) /* Alliant FX/2800 */
/* <sys/param.h> defines an incorrect value for FSCALE on an
Alliant FX/2800 Concentrix 2.2, according to ghazi@noc.rutgers.edu. */
#undef FSCALE
#define FSCALE 100.0
#endif
#ifndef FSCALE
/* SunOS and some others define FSCALE in sys/param.h. */
#ifdef MORE_BSD
#define FSCALE 2048.0
#endif
#if defined(MIPS) || defined(SVR4) || defined(decstation)
#define FSCALE 256
#endif
#if defined (sgi) || defined (sequent)
/* Sometimes both MIPS and sgi are defined, so FSCALE was just defined
above under #ifdef MIPS. But we want the sgi value. */
#undef FSCALE
#define FSCALE 1000.0
#endif
#if defined (ardent) && defined (titan)
#define FSCALE 65536.0
#endif
#ifdef tek4300
#define FSCALE 100.0
#endif
#ifdef _AIX
#define FSCALE 65536.0
#endif
#endif /* Not FSCALE. */
#if !defined (LDAV_CVT) && defined (FSCALE)
#define LDAV_CVT(n) (((double) (n)) / FSCALE)
#endif
/* VAX C can't handle multi-line #ifs, or lines longer that 256 characters. */
#ifndef NLIST_STRUCT
#ifdef MORE_BSD
#define NLIST_STRUCT
#endif
#ifdef sun
#define NLIST_STRUCT
#endif
#ifdef decstation
#define NLIST_STRUCT
#endif
#ifdef hpux
#define NLIST_STRUCT
#endif
#if defined (_SEQUENT_) || defined (sequent)
#define NLIST_STRUCT
#endif
#ifdef sgi
#define NLIST_STRUCT
#endif
#ifdef SVR4
#define NLIST_STRUCT
#endif
#ifdef sony_news
#define NLIST_STRUCT
#endif
#ifdef OSF_ALPHA
#define NLIST_STRUCT
#endif
#if defined (ardent) && defined (titan)
#define NLIST_STRUCT
#endif
#ifdef tek4300
#define NLIST_STRUCT
#endif
#ifdef butterfly
#define NLIST_STRUCT
#endif
#if defined(alliant) && defined(i860) /* Alliant FX/2800 */
#define NLIST_STRUCT
#endif
#ifdef _AIX
#define NLIST_STRUCT
#endif
#endif /* defined (NLIST_STRUCT) */
#if defined(sgi) || (defined(mips) && !defined(BSD))
#define FIXUP_KERNEL_SYMBOL_ADDR(nl) ((nl)[0].n_value &= ~(1 << 31))
#endif
#if !defined (KERNEL_FILE) && defined (sequent)
#define KERNEL_FILE "/dynix"
#endif
#if !defined (KERNEL_FILE) && defined (hpux)
#define KERNEL_FILE "/hp-ux"
#endif
#if !defined(KERNEL_FILE) && (defined(_SEQUENT_) || defined(MIPS) || defined(SVR4) || defined(ISC) || defined (sgi) || defined(SVR4) || (defined (ardent) && defined (titan)))
#define KERNEL_FILE "/unix"
#endif
#if !defined (LDAV_SYMBOL) && defined (alliant)
#define LDAV_SYMBOL "_Loadavg"
#endif
#if !defined(LDAV_SYMBOL) && ((defined(hpux) && !defined(hp9000s300)) || defined(_SEQUENT_) || defined(SVR4) || defined(ISC) || defined(sgi) || (defined (ardent) && defined (titan)) || defined (_AIX))
#define LDAV_SYMBOL "avenrun"
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <stdio.h>
/* LOAD_AVE_TYPE should only get defined if we're going to use the
nlist method. */
#if !defined(LOAD_AVE_TYPE) && (defined(BSD) || defined(LDAV_CVT) || defined(KERNEL_FILE) || defined(LDAV_SYMBOL))
#define LOAD_AVE_TYPE double
#endif
#ifdef LOAD_AVE_TYPE
#ifndef VMS
#ifndef NLIST_STRUCT
#include <a.out.h>
#else /* NLIST_STRUCT */
#include <nlist.h>
#endif /* NLIST_STRUCT */
#ifdef SUNOS_5
#include <fcntl.h>
#include <kvm.h>
#endif
#ifndef KERNEL_FILE
#define KERNEL_FILE "/vmunix"
#endif /* KERNEL_FILE */
#ifndef LDAV_SYMBOL
#define LDAV_SYMBOL "_avenrun"
#endif /* LDAV_SYMBOL */
#else /* VMS */
#ifndef eunice
#include <iodef.h>
#include <descrip.h>
#else /* eunice */
#include <vms/iodef.h>
#endif /* eunice */
#endif /* VMS */
#ifndef LDAV_CVT
#define LDAV_CVT(n) ((double) (n))
#endif /* !LDAV_CVT */
#endif /* LOAD_AVE_TYPE */
#ifdef NeXT
#ifdef HAVE_MACH_MACH_H
#include <mach/mach.h>
#else
#include <mach.h>
#endif
#endif /* NeXT */
#ifdef sgi
#include <sys/sysmp.h>
#endif /* sgi */
#ifdef UMAX
#include <stdio.h>
#include <signal.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <sys/syscall.h>
#ifdef UMAX_43
#include <machine/cpu.h>
#include <inq_stats/statistics.h>
#include <inq_stats/sysstats.h>
#include <inq_stats/cpustats.h>
#include <inq_stats/procstats.h>
#else /* Not UMAX_43. */
#include <sys/sysdefs.h>
#include <sys/statistics.h>
#include <sys/sysstats.h>
#include <sys/cpudefs.h>
#include <sys/cpustats.h>
#include <sys/procstats.h>
#endif /* Not UMAX_43. */
#endif /* UMAX */
#ifdef DGUX
#include <sys/dg_sys_info.h>
#endif
#if defined(HAVE_FCNTL_H) || defined(_POSIX_VERSION)
#include <fcntl.h>
#else
#include <sys/file.h>
#endif
/* Avoid static vars inside a function since in HPUX they dump as pure. */
#ifdef NeXT
static processor_set_t default_set;
static int getloadavg_initialized;
#endif /* NeXT */
#ifdef UMAX
static unsigned int cpus = 0;
static unsigned int samples;
#endif /* UMAX */
#ifdef DGUX
static struct dg_sys_info_load_info load_info; /* what-a-mouthful! */
#endif /* DGUX */
#ifdef LOAD_AVE_TYPE
/* File descriptor open to /dev/kmem or VMS load ave driver. */
static int channel;
/* Nonzero iff channel is valid. */
static int getloadavg_initialized;
/* Offset in kmem to seek to read load average, or 0 means invalid. */
static long offset;
#if !defined(VMS) && !defined(sgi)
static struct nlist nl[2];
#endif /* Not VMS or sgi */
#ifdef SUNOS_5
static kvm_t *kd;
#endif /* SUNOS_5 */
#endif /* LOAD_AVE_TYPE */
/* Put the 1 minute, 5 minute and 15 minute load averages
into the first NELEM elements of LOADAVG.
Return the number written (never more than 3, but may be less than NELEM),
or -1 if an error occurred. */
int
getloadavg (loadavg, nelem)
double loadavg[];
int nelem;
{
int elem = 0; /* Return value. */
#ifdef NO_GET_LOAD_AVG
#define LDAV_DONE
/* Set errno to zero to indicate that there was no particular error;
this function just can't work at all on this system. */
errno = 0;
elem = -1;
#endif
#if !defined (LDAV_DONE) && defined (__linux__)
#define LDAV_DONE
#undef LOAD_AVE_TYPE
#ifndef LINUX_LDAV_FILE
#define LINUX_LDAV_FILE "/proc/loadavg"
#endif
char ldavgbuf[40];
double load_ave[3];
int fd, count;
fd = open (LINUX_LDAV_FILE, O_RDONLY);
if (fd == -1)
return -1;
count = read (fd, ldavgbuf, 40);
(void) close (fd);
if (count <= 0)
return -1;
count = sscanf (ldavgbuf, "%lf %lf %lf",
&load_ave[0], &load_ave[1], &load_ave[2]);
if (count < 1)
return -1;
for (elem = 0; elem < nelem && elem < count; elem++)
loadavg[elem] = load_ave[elem];
return elem;
#endif /* __linux__ */
#if !defined (LDAV_DONE) && defined (__NetBSD__)
#define LDAV_DONE
#undef LOAD_AVE_TYPE
#ifndef NETBSD_LDAV_FILE
#define NETBSD_LDAV_FILE "/kern/loadavg"
#endif
unsigned long int load_ave[3], scale;
int count;
FILE *fp;
fp = fopen (NETBSD_LDAV_FILE, "r");
if (fp == NULL)
return -1;
count = fscanf (fp, "%lu %lu %lu %lu\n",
&load_ave[0], &load_ave[1], &load_ave[2],
&scale);
(void) fclose (fp);
if (count != 4)
return -1;
for (elem = 0; elem < nelem; elem++)
loadavg[elem] = (double) load_ave[elem] / (double) scale;
return elem;
#endif /* __NetBSD__ */
#if !defined (LDAV_DONE) && defined (NeXT)
#define LDAV_DONE
/* The NeXT code was adapted from iscreen 3.2. */
host_t host;
struct processor_set_basic_info info;
unsigned info_count;
/* We only know how to get the 1-minute average for this system,
so even if the caller asks for more than 1, we only return 1. */
if (!getloadavg_initialized)
{
if (processor_set_default (host_self (), &default_set) == KERN_SUCCESS)
getloadavg_initialized = 1;
}
if (getloadavg_initialized)
{
info_count = PROCESSOR_SET_BASIC_INFO_COUNT;
if (processor_set_info (default_set, PROCESSOR_SET_BASIC_INFO, &host,
(processor_set_info_t) &info, &info_count)
!= KERN_SUCCESS)
getloadavg_initialized = 0;
else
{
if (nelem > 0)
loadavg[elem++] = (double) info.load_average / LOAD_SCALE;
}
}
if (!getloadavg_initialized)
return -1;
#endif /* NeXT */
#if !defined (LDAV_DONE) && defined (UMAX)
#define LDAV_DONE
/* UMAX 4.2, which runs on the Encore Multimax multiprocessor, does not
have a /dev/kmem. Information about the workings of the running kernel
can be gathered with inq_stats system calls.
We only know how to get the 1-minute average for this system. */
struct proc_summary proc_sum_data;
struct stat_descr proc_info;
double load;
register unsigned int i, j;
if (cpus == 0)
{
register unsigned int c, i;
struct cpu_config conf;
struct stat_descr desc;
desc.sd_next = 0;
desc.sd_subsys = SUBSYS_CPU;
desc.sd_type = CPUTYPE_CONFIG;
desc.sd_addr = (char *) &conf;
desc.sd_size = sizeof conf;
if (inq_stats (1, &desc))
return -1;
c = 0;
for (i = 0; i < conf.config_maxclass; ++i)
{
struct class_stats stats;
bzero ((char *) &stats, sizeof stats);
desc.sd_type = CPUTYPE_CLASS;
desc.sd_objid = i;
desc.sd_addr = (char *) &stats;
desc.sd_size = sizeof stats;
if (inq_stats (1, &desc))
return -1;
c += stats.class_numcpus;
}
cpus = c;
samples = cpus < 2 ? 3 : (2 * cpus / 3);
}
proc_info.sd_next = 0;
proc_info.sd_subsys = SUBSYS_PROC;
proc_info.sd_type = PROCTYPE_SUMMARY;
proc_info.sd_addr = (char *) &proc_sum_data;
proc_info.sd_size = sizeof (struct proc_summary);
proc_info.sd_sizeused = 0;
if (inq_stats (1, &proc_info) != 0)
return -1;
load = proc_sum_data.ps_nrunnable;
j = 0;
for (i = samples - 1; i > 0; --i)
{
load += proc_sum_data.ps_nrun[j];
if (j++ == PS_NRUNSIZE)
j = 0;
}
if (nelem > 0)
loadavg[elem++] = load / samples / cpus;
#endif /* UMAX */
#if !defined (LDAV_DONE) && defined (DGUX)
#define LDAV_DONE
/* This call can return -1 for an error, but with good args
it's not supposed to fail. The first argument is for no
apparent reason of type `long int *'. */
dg_sys_info ((long int *) &load_info,
DG_SYS_INFO_LOAD_INFO_TYPE,
DG_SYS_INFO_LOAD_VERSION_0);
if (nelem > 0)
loadavg[elem++] = load_info.one_minute;
if (nelem > 1)
loadavg[elem++] = load_info.five_minute;
if (nelem > 2)
loadavg[elem++] = load_info.fifteen_minute;
#endif /* DGUX */
#if !defined (LDAV_DONE) && defined (apollo)
#define LDAV_DONE
/* Apollo code from lisch@mentorg.com (Ray Lischner).
This system call is not documented. The load average is obtained as
three long integers, for the load average over the past minute,
five minutes, and fifteen minutes. Each value is a scaled integer,
with 16 bits of integer part and 16 bits of fraction part.
I'm not sure which operating system first supported this system call,
but I know that SR10.2 supports it. */
extern void proc1_$get_loadav ();
unsigned long load_ave[3];
proc1_$get_loadav (load_ave);
if (nelem > 0)
loadavg[elem++] = load_ave[0] / 65536.0;
if (nelem > 1)
loadavg[elem++] = load_ave[1] / 65536.0;
if (nelem > 2)
loadavg[elem++] = load_ave[2] / 65536.0;
#endif /* apollo */
#if !defined (LDAV_DONE) && defined (OSF_MIPS)
#define LDAV_DONE
struct tbl_loadavg load_ave;
table (TBL_LOADAVG, 0, &load_ave, 1, sizeof (load_ave));
loadavg[elem++]
= (load_ave.tl_lscale == 0
? load_ave.tl_avenrun.d[0]
: (load_ave.tl_avenrun.l[0] / (double) load_ave.tl_lscale));
#endif /* OSF_MIPS */
#if !defined (LDAV_DONE) && defined (OSF_ALPHA)
#define LDAV_DONE
struct tbl_loadavg load_ave;
table (TBL_LOADAVG, 0, &load_ave, 1, sizeof (load_ave));
for (elem = 0; elem < nelem; elem++)
loadavg[elem]
= (load_ave.tl_lscale == 0
? load_ave.tl_avenrun.d[elem]
: (load_ave.tl_avenrun.l[elem] / (double) load_ave.tl_lscale));
#endif /* OSF_ALPHA */
#if !defined (LDAV_DONE) && defined (VMS)
/* VMS specific code -- read from the Load Ave driver. */
LOAD_AVE_TYPE load_ave[3];
static int getloadavg_initialized = 0;
#ifdef eunice
struct
{
int dsc$w_length;
char *dsc$a_pointer;
} descriptor;
#endif
/* Ensure that there is a channel open to the load ave device. */
if (!getloadavg_initialized)
{
/* Attempt to open the channel. */
#ifdef eunice
descriptor.dsc$w_length = 18;
descriptor.dsc$a_pointer = "$$VMS_LOAD_AVERAGE";
#else
$DESCRIPTOR (descriptor, "LAV0:");
#endif
if (sys$assign (&descriptor, &channel, 0, 0) & 1)
getloadavg_initialized = 1;
}
/* Read the load average vector. */
if (getloadavg_initialized
&& !(sys$qiow (0, channel, IO$_READVBLK, 0, 0, 0,
load_ave, 12, 0, 0, 0, 0) & 1))
{
sys$dassgn (channel);
getloadavg_initialized = 0;
}
if (!getloadavg_initialized)
return -1;
#endif /* VMS */
#if !defined (LDAV_DONE) && defined(LOAD_AVE_TYPE) && !defined(VMS)
/* UNIX-specific code -- read the average from /dev/kmem. */
#define LDAV_PRIVILEGED /* This code requires special installation. */
LOAD_AVE_TYPE load_ave[3];
/* Get the address of LDAV_SYMBOL. */
if (offset == 0)
{
#ifndef sgi
#ifndef NLIST_STRUCT
strcpy (nl[0].n_name, LDAV_SYMBOL);
strcpy (nl[1].n_name, "");
#else /* NLIST_STRUCT */
#ifdef NLIST_NAME_UNION
nl[0].n_un.n_name = LDAV_SYMBOL;
nl[1].n_un.n_name = 0;
#else /* not NLIST_NAME_UNION */
nl[0].n_name = LDAV_SYMBOL;
nl[1].n_name = 0;
#endif /* not NLIST_NAME_UNION */
#endif /* NLIST_STRUCT */
#ifndef SUNOS_5
if (
#ifndef _AIX
nlist (KERNEL_FILE, nl)
#else /* _AIX */
knlist (nl, 1, sizeof (nl[0]))
#endif
>= 0)
/* Omit "&& nl[0].n_type != 0 " -- it breaks on Sun386i. */
{
#ifdef FIXUP_KERNEL_SYMBOL_ADDR
FIXUP_KERNEL_SYMBOL_ADDR (nl);
#endif
offset = nl[0].n_value;
}
#endif /* !SUNOS_5 */
#else /* sgi */
int ldav_off;
ldav_off = sysmp (MP_KERNADDR, MPKA_AVENRUN);
if (ldav_off != -1)
offset = (long) ldav_off & 0x7fffffff;
#endif /* sgi */
}
/* Make sure we have /dev/kmem open. */
if (!getloadavg_initialized)
{
#ifndef SUNOS_5
channel = open ("/dev/kmem", 0);
if (channel >= 0)
getloadavg_initialized = 1;
#else /* SUNOS_5 */
/* We pass 0 for the kernel, corefile, and swapfile names
to use the currently running kernel. */
kd = kvm_open (0, 0, 0, O_RDONLY, 0);
if (kd != 0)
{
/* nlist the currently running kernel. */
kvm_nlist (kd, nl);
offset = nl[0].n_value;
getloadavg_initialized = 1;
}
#endif /* SUNOS_5 */
}
/* If we can, get the load average values. */
if (offset && getloadavg_initialized)
{
/* Try to read the load. */
#ifndef SUNOS_5
if (lseek (channel, offset, 0) == -1L
|| read (channel, (char *) load_ave, sizeof (load_ave))
!= sizeof (load_ave))
{
close (channel);
getloadavg_initialized = 0;
}
#else /* SUNOS_5 */
if (kvm_read (kd, offset, (char *) load_ave, sizeof (load_ave))
!= sizeof (load_ave))
{
kvm_close (kd);
getloadavg_initialized = 0;
}
#endif /* SUNOS_5 */
}
if (offset == 0 || !getloadavg_initialized)
return -1;
#endif /* LOAD_AVE_TYPE and not VMS */
#if !defined (LDAV_DONE) && defined (LOAD_AVE_TYPE) /* Including VMS. */
if (nelem > 0)
loadavg[elem++] = LDAV_CVT (load_ave[0]);
if (nelem > 1)
loadavg[elem++] = LDAV_CVT (load_ave[1]);
if (nelem > 2)
loadavg[elem++] = LDAV_CVT (load_ave[2]);
#define LDAV_DONE
#endif /* !LDAV_DONE && LOAD_AVE_TYPE */
#ifdef LDAV_DONE
return elem;
#else
/* Set errno to zero to indicate that there was no particular error;
this function just can't work at all on this system. */
errno = 0;
return -1;
#endif
}
#endif /* ! HAVE_GETLOADAVG */
#ifdef TEST
void
main (argc, argv)
int argc;
char **argv;
{
int naptime = 0;
if (argc > 1)
naptime = atoi (argv[1]);
while (1)
{
double avg[3];
int loads;
errno = 0; /* Don't be misled if it doesn't set errno. */
loads = getloadavg (avg, 3);
if (loads == -1)
{
perror ("Error getting load average");
exit (1);
}
if (loads > 0)
printf ("1-minute: %f ", avg[0]);
if (loads > 1)
printf ("5-minute: %f ", avg[1]);
if (loads > 2)
printf ("15-minute: %f ", avg[2]);
if (loads > 0)
putchar ('\n');
if (naptime == 0)
break;
sleep (naptime);
}
exit (0);
}
#endif /* TEST */

763
buildtools/windows/source/make/getopt.c
View File

@ -1,763 +0,0 @@
/* Getopt for GNU.
NOTE: getopt is now part of the C library, so if you don't know what
"Keep this file name-space clean" means, talk to roland@gnu.ai.mit.edu
before changing it!
Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95
Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
/* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
Ditto for AIX 3.2 and <stdlib.h>. */
#ifndef _NO_PROTO
#define _NO_PROTO
#endif
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#if !defined (__STDC__) || !__STDC__
/* This is a separate conditional since some stdc systems
reject `defined (const)'. */
#ifndef const
#define const
#endif
#endif
#include <stdio.h>
#include <string.h>
/* Comment out all this code if we are using the GNU C Library, and are not
actually compiling the library itself. This code is part of the GNU C
Library, but also included in many other GNU distributions. Compiling
and linking in this code is a waste when using the GNU C library
(especially if it is a shared library). Rather than having every GNU
program understand `configure --with-gnu-libc' and omit the object files,
it is simpler to just do this in the source for each such file. */
#if defined (_LIBC) || !defined (__GNU_LIBRARY__)
/* This needs to come after some library #include
to get __GNU_LIBRARY__ defined. */
#ifdef __GNU_LIBRARY__
/* Don't include stdlib.h for non-GNU C libraries because some of them
contain conflicting prototypes for getopt. */
#include <stdlib.h>
#endif /* GNU C library. */
/* This is for other GNU distributions with internationalized messages.
The GNU C Library itself does not yet support such messages. */
#if HAVE_LIBINTL_H
# include <libintl.h>
#else
# define gettext(msgid) (msgid)
#endif
/* This version of `getopt' appears to the caller like standard Unix `getopt'
but it behaves differently for the user, since it allows the user
to intersperse the options with the other arguments.
As `getopt' works, it permutes the elements of ARGV so that,
when it is done, all the options precede everything else. Thus
all application programs are extended to handle flexible argument order.
Setting the environment variable POSIXLY_CORRECT disables permutation.
Then the behavior is completely standard.
GNU application programs can use a third alternative mode in which
they can distinguish the relative order of options and other arguments. */
#include "getopt.h"
/* For communication from `getopt' to the caller.
When `getopt' finds an option that takes an argument,
the argument value is returned here.
Also, when `ordering' is RETURN_IN_ORDER,
each non-option ARGV-element is returned here. */
char *optarg = NULL;
/* Index in ARGV of the next element to be scanned.
This is used for communication to and from the caller
and for communication between successive calls to `getopt'.
On entry to `getopt', zero means this is the first call; initialize.
When `getopt' returns EOF, this is the index of the first of the
non-option elements that the caller should itself scan.
Otherwise, `optind' communicates from one call to the next
how much of ARGV has been scanned so far. */
/* XXX 1003.2 says this must be 1 before any call. */
int optind = 0;
/* The next char to be scanned in the option-element
in which the last option character we returned was found.
This allows us to pick up the scan where we left off.
If this is zero, or a null string, it means resume the scan
by advancing to the next ARGV-element. */
static char *nextchar;
/* Callers store zero here to inhibit the error message
for unrecognized options. */
int opterr = 1;
/* Set to an option character which was unrecognized.
This must be initialized on some systems to avoid linking in the
system's own getopt implementation. */
int optopt = '?';
/* Describe how to deal with options that follow non-option ARGV-elements.
If the caller did not specify anything,
the default is REQUIRE_ORDER if the environment variable
POSIXLY_CORRECT is defined, PERMUTE otherwise.
REQUIRE_ORDER means don't recognize them as options;
stop option processing when the first non-option is seen.
This is what Unix does.
This mode of operation is selected by either setting the environment
variable POSIXLY_CORRECT, or using `+' as the first character
of the list of option characters.
PERMUTE is the default. We permute the contents of ARGV as we scan,
so that eventually all the non-options are at the end. This allows options
to be given in any order, even with programs that were not written to
expect this.
RETURN_IN_ORDER is an option available to programs that were written
to expect options and other ARGV-elements in any order and that care about
the ordering of the two. We describe each non-option ARGV-element
as if it were the argument of an option with character code 1.
Using `-' as the first character of the list of option characters
selects this mode of operation.
The special argument `--' forces an end of option-scanning regardless
of the value of `ordering'. In the case of RETURN_IN_ORDER, only
`--' can cause `getopt' to return EOF with `optind' != ARGC. */
static enum
{
REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
} ordering;
/* Value of POSIXLY_CORRECT environment variable. */
static char *posixly_correct;
#ifdef __GNU_LIBRARY__
/* We want to avoid inclusion of string.h with non-GNU libraries
because there are many ways it can cause trouble.
On some systems, it contains special magic macros that don't work
in GCC. */
#include <string.h>
#define my_index strchr
#else
/* Avoid depending on library functions or files
whose names are inconsistent. */
char *getenv ();
static char *
my_index (str, chr)
const char *str;
int chr;
{
while (*str)
{
if (*str == chr)
return (char *) str;
str++;
}
return 0;
}
/* If using GCC, we can safely declare strlen this way.
If not using GCC, it is ok not to declare it. */
#ifdef __GNUC__
/* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
That was relevant to code that was here before. */
#if !defined (__STDC__) || !__STDC__
/* gcc with -traditional declares the built-in strlen to return int,
and has done so at least since version 2.4.5. -- rms. */
extern int strlen (const char *);
#endif /* not __STDC__ */
#endif /* __GNUC__ */
#endif /* not __GNU_LIBRARY__ */
/* Handle permutation of arguments. */
/* Describe the part of ARGV that contains non-options that have
been skipped. `first_nonopt' is the index in ARGV of the first of them;
`last_nonopt' is the index after the last of them. */
static int first_nonopt;
static int last_nonopt;
/* Exchange two adjacent subsequences of ARGV.
One subsequence is elements [first_nonopt,last_nonopt)
which contains all the non-options that have been skipped so far.
The other is elements [last_nonopt,optind), which contains all
the options processed since those non-options were skipped.
`first_nonopt' and `last_nonopt' are relocated so that they describe
the new indices of the non-options in ARGV after they are moved. */
static void
exchange (argv)
char **argv;
{
int bottom = first_nonopt;
int middle = last_nonopt;
int top = optind;
char *tem;
/* Exchange the shorter segment with the far end of the longer segment.
That puts the shorter segment into the right place.
It leaves the longer segment in the right place overall,
but it consists of two parts that need to be swapped next. */
while (top > middle && middle > bottom)
{
if (top - middle > middle - bottom)
{
/* Bottom segment is the short one. */
int len = middle - bottom;
register int i;
/* Swap it with the top part of the top segment. */
for (i = 0; i < len; i++)
{
tem = argv[bottom + i];
argv[bottom + i] = argv[top - (middle - bottom) + i];
argv[top - (middle - bottom) + i] = tem;
}
/* Exclude the moved bottom segment from further swapping. */
top -= len;
}
else
{
/* Top segment is the short one. */
int len = top - middle;
register int i;
/* Swap it with the bottom part of the bottom segment. */
for (i = 0; i < len; i++)
{
tem = argv[bottom + i];
argv[bottom + i] = argv[middle + i];
argv[middle + i] = tem;
}
/* Exclude the moved top segment from further swapping. */
bottom += len;
}
}
/* Update records for the slots the non-options now occupy. */
first_nonopt += (optind - last_nonopt);
last_nonopt = optind;
}
/* Initialize the internal data when the first call is made. */
static const char *
_getopt_initialize (optstring)
const char *optstring;
{
/* Start processing options with ARGV-element 1 (since ARGV-element 0
is the program name); the sequence of previously skipped
non-option ARGV-elements is empty. */
first_nonopt = last_nonopt = optind = 1;
nextchar = NULL;
posixly_correct = getenv ("POSIXLY_CORRECT");
/* Determine how to handle the ordering of options and nonoptions. */
if (optstring[0] == '-')
{
ordering = RETURN_IN_ORDER;
++optstring;
}
else if (optstring[0] == '+')
{
ordering = REQUIRE_ORDER;
++optstring;
}
else if (posixly_correct != NULL)
ordering = REQUIRE_ORDER;
else
ordering = PERMUTE;
return optstring;
}
/* Scan elements of ARGV (whose length is ARGC) for option characters
given in OPTSTRING.
If an element of ARGV starts with '-', and is not exactly "-" or "--",
then it is an option element. The characters of this element
(aside from the initial '-') are option characters. If `getopt'
is called repeatedly, it returns successively each of the option characters
from each of the option elements.
If `getopt' finds another option character, it returns that character,
updating `optind' and `nextchar' so that the next call to `getopt' can
resume the scan with the following option character or ARGV-element.
If there are no more option characters, `getopt' returns `EOF'.
Then `optind' is the index in ARGV of the first ARGV-element
that is not an option. (The ARGV-elements have been permuted
so that those that are not options now come last.)
OPTSTRING is a string containing the legitimate option characters.
If an option character is seen that is not listed in OPTSTRING,
return '?' after printing an error message. If you set `opterr' to
zero, the error message is suppressed but we still return '?'.
If a char in OPTSTRING is followed by a colon, that means it wants an arg,
so the following text in the same ARGV-element, or the text of the following
ARGV-element, is returned in `optarg'. Two colons mean an option that
wants an optional arg; if there is text in the current ARGV-element,
it is returned in `optarg', otherwise `optarg' is set to zero.
If OPTSTRING starts with `-' or `+', it requests different methods of
handling the non-option ARGV-elements.
See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
Long-named options begin with `--' instead of `-'.
Their names may be abbreviated as long as the abbreviation is unique
or is an exact match for some defined option. If they have an
argument, it follows the option name in the same ARGV-element, separated
from the option name by a `=', or else the in next ARGV-element.
When `getopt' finds a long-named option, it returns 0 if that option's
`flag' field is nonzero, the value of the option's `val' field
if the `flag' field is zero.
The elements of ARGV aren't really const, because we permute them.
But we pretend they're const in the prototype to be compatible
with other systems.
LONGOPTS is a vector of `struct option' terminated by an
element containing a name which is zero.
LONGIND returns the index in LONGOPT of the long-named option found.
It is only valid when a long-named option has been found by the most
recent call.
If LONG_ONLY is nonzero, '-' as well as '--' can introduce
long-named options. */
int
_getopt_internal (argc, argv, optstring, longopts, longind, long_only)
int argc;
char *const *argv;
const char *optstring;
const struct option *longopts;
int *longind;
int long_only;
{
optarg = NULL;
if (optind == 0)
{
optstring = _getopt_initialize (optstring);
optind = 1; /* Don't scan ARGV[0], the program name. */
}
if (nextchar == NULL || *nextchar == '\0')
{
/* Advance to the next ARGV-element. */
if (ordering == PERMUTE)
{
/* If we have just processed some options following some non-options,
exchange them so that the options come first. */
if (first_nonopt != last_nonopt && last_nonopt != optind)
exchange ((char **) argv);
else if (last_nonopt != optind)
first_nonopt = optind;
/* Skip any additional non-options
and extend the range of non-options previously skipped. */
while (optind < argc
&& (argv[optind][0] != '-' || argv[optind][1] == '\0'))
optind++;
last_nonopt = optind;
}
/* The special ARGV-element `--' means premature end of options.
Skip it like a null option,
then exchange with previous non-options as if it were an option,
then skip everything else like a non-option. */
if (optind != argc && !strcmp (argv[optind], "--"))
{
optind++;
if (first_nonopt != last_nonopt && last_nonopt != optind)
exchange ((char **) argv);
else if (first_nonopt == last_nonopt)
first_nonopt = optind;
last_nonopt = argc;
optind = argc;
}
/* If we have done all the ARGV-elements, stop the scan
and back over any non-options that we skipped and permuted. */
if (optind == argc)
{
/* Set the next-arg-index to point at the non-options
that we previously skipped, so the caller will digest them. */
if (first_nonopt != last_nonopt)
optind = first_nonopt;
return EOF;
}
/* If we have come to a non-option and did not permute it,
either stop the scan or describe it to the caller and pass it by. */
if ((argv[optind][0] != '-' || argv[optind][1] == '\0'))
{
if (ordering == REQUIRE_ORDER)
return EOF;
optarg = argv[optind++];
return 1;
}
/* We have found another option-ARGV-element.
Skip the initial punctuation. */
nextchar = (argv[optind] + 1
+ (longopts != NULL && argv[optind][1] == '-'));
}
/* Decode the current option-ARGV-element. */
/* Check whether the ARGV-element is a long option.
If long_only and the ARGV-element has the form "-f", where f is
a valid short option, don't consider it an abbreviated form of
a long option that starts with f. Otherwise there would be no
way to give the -f short option.
On the other hand, if there's a long option "fubar" and
the ARGV-element is "-fu", do consider that an abbreviation of
the long option, just like "--fu", and not "-f" with arg "u".
This distinction seems to be the most useful approach. */
if (longopts != NULL
&& (argv[optind][1] == '-'
|| (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
{
char *nameend;
const struct option *p;
const struct option *pfound = NULL;
int exact = 0;
int ambig = 0;
int indfound;
int option_index;
for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
/* Do nothing. */ ;
/* Test all long options for either exact match
or abbreviated matches. */
for (p = longopts, option_index = 0; p->name; p++, option_index++)
if (!strncmp (p->name, nextchar, nameend - nextchar))
{
if ((size_t)(nameend - nextchar) == strlen (p->name))
{
/* Exact match found. */
pfound = p;
indfound = option_index;
exact = 1;
break;
}
else if (pfound == NULL)
{
/* First nonexact match found. */
pfound = p;
indfound = option_index;
}
else
/* Second or later nonexact match found. */
ambig = 1;
}
if (ambig && !exact)
{
if (opterr)
fprintf (stderr, gettext ("%s: option `%s' is ambiguous\n"),
argv[0], argv[optind]);
nextchar += strlen (nextchar);
optind++;
return '?';
}
if (pfound != NULL)
{
option_index = indfound;
optind++;
if (*nameend)
{
/* Don't test has_arg with >, because some C compilers don't
allow it to be used on enums. */
if (pfound->has_arg)
optarg = nameend + 1;
else
{
if (opterr)
if (argv[optind - 1][1] == '-')
/* --option */
fprintf (stderr,
gettext ("%s: option `--%s' doesn't allow an argument\n"),
argv[0], pfound->name);
else
/* +option or -option */
fprintf (stderr,
gettext ("%s: option `%c%s' doesn't allow an argument\n"),
argv[0], argv[optind - 1][0], pfound->name);
nextchar += strlen (nextchar);
return '?';
}
}
else if (pfound->has_arg == 1)
{
if (optind < argc)
optarg = argv[optind++];
else
{
if (opterr)
fprintf (stderr,
gettext ("%s: option `%s' requires an argument\n"),
argv[0], argv[optind - 1]);
nextchar += strlen (nextchar);
return optstring[0] == ':' ? ':' : '?';
}
}
nextchar += strlen (nextchar);
if (longind != NULL)
*longind = option_index;
if (pfound->flag)
{
*(pfound->flag) = pfound->val;
return 0;
}
return pfound->val;
}
/* Can't find it as a long option. If this is not getopt_long_only,
or the option starts with '--' or is not a valid short
option, then it's an error.
Otherwise interpret it as a short option. */
if (!long_only || argv[optind][1] == '-'
|| my_index (optstring, *nextchar) == NULL)
{
if (opterr)
{
if (argv[optind][1] == '-')
/* --option */
fprintf (stderr, gettext ("%s: unrecognized option `--%s'\n"),
argv[0], nextchar);
else
/* +option or -option */
fprintf (stderr, gettext ("%s: unrecognized option `%c%s'\n"),
argv[0], argv[optind][0], nextchar);
}
nextchar = (char *) "";
optind++;
return '?';
}
}
/* Look at and handle the next short option-character. */
{
char c = *nextchar++;
char *temp = my_index (optstring, c);
/* Increment `optind' when we start to process its last character. */
if (*nextchar == '\0')
++optind;
if (temp == NULL || c == ':')
{
if (opterr)
{
if (posixly_correct)
/* 1003.2 specifies the format of this message. */
fprintf (stderr, gettext ("%s: illegal option -- %c\n"),
argv[0], c);
else
fprintf (stderr, gettext ("%s: invalid option -- %c\n"),
argv[0], c);
}
optopt = c;
return '?';
}
if (temp[1] == ':')
{
if (temp[2] == ':')
{
/* This is an option that accepts an argument optionally. */
if (*nextchar != '\0')
{
optarg = nextchar;
optind++;
}
else
optarg = NULL;
nextchar = NULL;
}
else
{
/* This is an option that requires an argument. */
if (*nextchar != '\0')
{
optarg = nextchar;
/* If we end this ARGV-element by taking the rest as an arg,
we must advance to the next element now. */
optind++;
}
else if (optind == argc)
{
if (opterr)
{
/* 1003.2 specifies the format of this message. */
fprintf (stderr,
gettext ("%s: option requires an argument -- %c\n"),
argv[0], c);
}
optopt = c;
if (optstring[0] == ':')
c = ':';
else
c = '?';
}
else
/* We already incremented `optind' once;
increment it again when taking next ARGV-elt as argument. */
optarg = argv[optind++];
nextchar = NULL;
}
}
return c;
}
}
int
getopt (argc, argv, optstring)
int argc;
char *const *argv;
const char *optstring;
{
return _getopt_internal (argc, argv, optstring,
(const struct option *) 0,
(int *) 0,
0);
}
#endif /* _LIBC or not __GNU_LIBRARY__. */
#ifdef TEST
/* Compile with -DTEST to make an executable for use in testing
the above definition of `getopt'. */
int
main (argc, argv)
int argc;
char **argv;
{
int c;
int digit_optind = 0;
while (1)
{
int this_option_optind = optind ? optind : 1;
c = getopt (argc, argv, "abc:d:0123456789");
if (c == EOF)
break;
switch (c)
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
if (digit_optind != 0 && digit_optind != this_option_optind)
printf ("digits occur in two different argv-elements.\n");
digit_optind = this_option_optind;
printf ("option %c\n", c);
break;
case 'a':
printf ("option a\n");
break;
case 'b':
printf ("option b\n");
break;
case 'c':
printf ("option c with value `%s'\n", optarg);
break;
case '?':
break;
default:
printf ("?? getopt returned character code 0%o ??\n", c);
}
}
if (optind < argc)
{
printf ("non-option ARGV-elements: ");
while (optind < argc)
printf ("%s ", argv[optind++]);
printf ("\n");
}
exit (0);
}
#endif /* TEST */

129
buildtools/windows/source/make/getopt.h
View File

@ -1,129 +0,0 @@
/* Declarations for getopt.
Copyright (C) 1989, 90, 91, 92, 93, 94 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#ifndef _GETOPT_H
#define _GETOPT_H 1
#ifdef __cplusplus
extern "C" {
#endif
/* For communication from `getopt' to the caller.
When `getopt' finds an option that takes an argument,
the argument value is returned here.
Also, when `ordering' is RETURN_IN_ORDER,
each non-option ARGV-element is returned here. */
extern char *optarg;
/* Index in ARGV of the next element to be scanned.
This is used for communication to and from the caller
and for communication between successive calls to `getopt'.
On entry to `getopt', zero means this is the first call; initialize.
When `getopt' returns EOF, this is the index of the first of the
non-option elements that the caller should itself scan.
Otherwise, `optind' communicates from one call to the next
how much of ARGV has been scanned so far. */
extern int optind;
/* Callers store zero here to inhibit the error message `getopt' prints
for unrecognized options. */
extern int opterr;
/* Set to an option character which was unrecognized. */
extern int optopt;
/* Describe the long-named options requested by the application.
The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector
of `struct option' terminated by an element containing a name which is
zero.
The field `has_arg' is:
no_argument (or 0) if the option does not take an argument,
required_argument (or 1) if the option requires an argument,
optional_argument (or 2) if the option takes an optional argument.
If the field `flag' is not NULL, it points to a variable that is set
to the value given in the field `val' when the option is found, but
left unchanged if the option is not found.
To have a long-named option do something other than set an `int' to
a compiled-in constant, such as set a value from `optarg', set the
option's `flag' field to zero and its `val' field to a nonzero
value (the equivalent single-letter option character, if there is
one). For long options that have a zero `flag' field, `getopt'
returns the contents of the `val' field. */
struct option
{
#if defined (__STDC__) && __STDC__
const char *name;
#else
char *name;
#endif
/* has_arg can't be an enum because some compilers complain about
type mismatches in all the code that assumes it is an int. */
int has_arg;
int *flag;
int val;
};
/* Names for the values of the `has_arg' field of `struct option'. */
#define no_argument 0
#define required_argument 1
#define optional_argument 2
#if defined (__STDC__) && __STDC__
#ifdef __GNU_LIBRARY__
/* Many other libraries have conflicting prototypes for getopt, with
differences in the consts, in stdlib.h. To avoid compilation
errors, only prototype getopt for the GNU C library. */
extern int getopt (int argc, char *const *argv, const char *shortopts);
#else /* not __GNU_LIBRARY__ */
extern int getopt ();
#endif /* __GNU_LIBRARY__ */
extern int getopt_long (int argc, char *const *argv, const char *shortopts,
const struct option *longopts, int *longind);
extern int getopt_long_only (int argc, char *const *argv,
const char *shortopts,
const struct option *longopts, int *longind);
/* Internal only. Users should not call this directly. */
extern int _getopt_internal (int argc, char *const *argv,
const char *shortopts,
const struct option *longopts, int *longind,
int long_only);
#else /* not __STDC__ */
extern int getopt ();
extern int getopt_long ();
extern int getopt_long_only ();
extern int _getopt_internal ();
#endif /* __STDC__ */
#ifdef __cplusplus
}
#endif
#endif /* _GETOPT_H */

180
buildtools/windows/source/make/getopt1.c
View File

@ -1,180 +0,0 @@
/* getopt_long and getopt_long_only entry points for GNU getopt.
Copyright (C) 1987, 88, 89, 90, 91, 92, 1993, 1994
Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "getopt.h"
#if !defined (__STDC__) || !__STDC__
/* This is a separate conditional since some stdc systems
reject `defined (const)'. */
#ifndef const
#define const
#endif
#endif
#include <stdio.h>
/* Comment out all this code if we are using the GNU C Library, and are not
actually compiling the library itself. This code is part of the GNU C
Library, but also included in many other GNU distributions. Compiling
and linking in this code is a waste when using the GNU C library
(especially if it is a shared library). Rather than having every GNU
program understand `configure --with-gnu-libc' and omit the object files,
it is simpler to just do this in the source for each such file. */
#if defined (_LIBC) || !defined (__GNU_LIBRARY__)
/* This needs to come after some library #include
to get __GNU_LIBRARY__ defined. */
#ifdef __GNU_LIBRARY__
#include <stdlib.h>
#else
char *getenv ();
#endif
#ifndef NULL
#define NULL 0
#endif
int
getopt_long (argc, argv, options, long_options, opt_index)
int argc;
char *const *argv;
const char *options;
const struct option *long_options;
int *opt_index;
{
return _getopt_internal (argc, argv, options, long_options, opt_index, 0);
}
/* Like getopt_long, but '-' as well as '--' can indicate a long option.
If an option that starts with '-' (not '--') doesn't match a long option,
but does match a short option, it is parsed as a short option
instead. */
int
getopt_long_only (argc, argv, options, long_options, opt_index)
int argc;
char *const *argv;
const char *options;
const struct option *long_options;
int *opt_index;
{
return _getopt_internal (argc, argv, options, long_options, opt_index, 1);
}
#endif /* _LIBC or not __GNU_LIBRARY__. */
#ifdef TEST
#include <stdio.h>
int
main (argc, argv)
int argc;
char **argv;
{
int c;
int digit_optind = 0;
while (1)
{
int this_option_optind = optind ? optind : 1;
int option_index = 0;
static struct option long_options[] =
{
{"add", 1, 0, 0},
{"append", 0, 0, 0},
{"delete", 1, 0, 0},
{"verbose", 0, 0, 0},
{"create", 0, 0, 0},
{"file", 1, 0, 0},
{0, 0, 0, 0}
};
c = getopt_long (argc, argv, "abc:d:0123456789",
long_options, &option_index);
if (c == EOF)
break;
switch (c)
{
case 0:
printf ("option %s", long_options[option_index].name);
if (optarg)
printf (" with arg %s", optarg);
printf ("\n");
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
if (digit_optind != 0 && digit_optind != this_option_optind)
printf ("digits occur in two different argv-elements.\n");
digit_optind = this_option_optind;
printf ("option %c\n", c);
break;
case 'a':
printf ("option a\n");
break;
case 'b':
printf ("option b\n");
break;
case 'c':
printf ("option c with value `%s'\n", optarg);
break;
case 'd':
printf ("option d with value `%s'\n", optarg);
break;
case '?':
break;
default:
printf ("?? getopt returned character code 0%o ??\n", c);
}
}
if (optind < argc)
{
printf ("non-option ARGV-elements: ");
while (optind < argc)
printf ("%s ", argv[optind++]);
printf ("\n");
}
exit (0);
}
#endif /* TEST */

705
buildtools/windows/source/make/glob.c
View File

@ -1,705 +0,0 @@
/* Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; see the file COPYING.LIB. If
not, write to the Free Software Foundation, Inc., 675 Mass Ave,
Cambridge, MA 02139, USA. */
/* AIX requires this to be the first thing in the file. */
#if defined (_AIX) && !defined (__GNUC__)
#pragma alloca
#endif
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#ifdef NETSCAPE
#include "windir.h"
#endif
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
/* Comment out all this code if we are using the GNU C Library, and are not
actually compiling the library itself. This code is part of the GNU C
Library, but also included in many other GNU distributions. Compiling
and linking in this code is a waste when using the GNU C library
(especially if it is a shared library). Rather than having every GNU
program understand `configure --with-gnu-libc' and omit the object files,
it is simpler to just do this in the source for each such file. */
#if defined (_LIBC) || !defined (__GNU_LIBRARY__)
#ifdef STDC_HEADERS
#include <stddef.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#ifndef POSIX
#ifdef _POSIX_VERSION
#define POSIX
#endif
#endif
#endif
#if !defined(__GNU_LIBRARY__) && !defined(STDC_HEADERS)
extern int errno;
#endif
#ifndef NULL
#define NULL 0
#endif
#if defined (POSIX) || defined (HAVE_DIRENT_H) || defined (__GNU_LIBRARY__)
#include <dirent.h>
#ifndef __GNU_LIBRARY__
#define D_NAMLEN(d) strlen((d)->d_name)
#else /* GNU C library. */
#define D_NAMLEN(d) ((d)->d_namlen)
#endif /* Not GNU C library. */
#else /* Not POSIX or HAVE_DIRENT_H. */
#define direct dirent
#define D_NAMLEN(d) ((d)->d_namlen)
#ifdef HAVE_SYS_NDIR_H
#include <sys/ndir.h>
#endif /* HAVE_SYS_NDIR_H */
#ifdef HAVE_SYS_DIR_H
#include <sys/dir.h>
#endif /* HAVE_SYS_DIR_H */
#ifdef HAVE_NDIR_H
#include <ndir.h>
#endif /* HAVE_NDIR_H */
#endif /* POSIX or HAVE_DIRENT_H or __GNU_LIBRARY__. */
#if defined(NETSCAPE) || defined (POSIX) && !defined (__GNU_LIBRARY__)
/* Posix does not require that the d_ino field be present, and some
systems do not provide it. */
#define REAL_DIR_ENTRY(dp) 1
#else
#define REAL_DIR_ENTRY(dp) (dp->d_ino != 0)
#endif /* POSIX */
#if (defined (STDC_HEADERS) || defined (__GNU_LIBRARY__))
#include <stdlib.h>
#include <string.h>
#define ANSI_STRING
#else /* No standard headers. */
#ifdef HAVE_STRING_H
#include <string.h>
#define ANSI_STRING
#else
#include <strings.h>
#endif
#ifdef HAVE_MEMORY_H
#include <memory.h>
#endif
extern char *malloc (), *realloc ();
extern void free ();
extern void qsort ();
extern void abort (), exit ();
#endif /* Standard headers. */
#ifndef ANSI_STRING
#ifndef bzero
extern void bzero ();
#endif
#ifndef bcopy
extern void bcopy ();
#endif
#define memcpy(d, s, n) bcopy ((s), (d), (n))
#define strrchr rindex
/* memset is only used for zero here, but let's be paranoid. */
#define memset(s, better_be_zero, n) \
((void) ((better_be_zero) == 0 ? (bzero((s), (n)), 0) : (abort(), 0)))
#endif /* Not ANSI_STRING. */
#ifndef HAVE_STRCOLL
#define strcoll strcmp
#endif
#if !defined(__GNU_LIBRARY__) && !defined(NETSCAPE)
#ifdef __GNUC__
__inline
#endif
static char *
my_realloc (p, n)
char *p;
unsigned int n;
{
/* These casts are the for sake of the broken Ultrix compiler,
which warns of illegal pointer combinations otherwise. */
if (p == NULL)
return (char *) malloc (n);
return (char *) realloc (p, n);
}
#define realloc my_realloc
#endif
#if !defined(__alloca) && !defined(__GNU_LIBRARY__)
#ifdef __GNUC__
#undef alloca
#define alloca(n) __builtin_alloca (n)
#else /* Not GCC. */
#if defined (sparc) || defined (HAVE_ALLOCA_H)
#include <alloca.h>
#elif defined(NETSCAPE)
#include <malloc.h>
#else /* Not sparc or HAVE_ALLOCA_H. */
#ifndef _AIX
extern char *alloca ();
#endif /* Not _AIX. */
#endif /* sparc or HAVE_ALLOCA_H. */
#endif /* GCC. */
#define __alloca alloca
#endif
#ifndef __GNU_LIBRARY__
#define __lstat lstat
#ifndef HAVE_LSTAT
#define lstat stat
#endif
#ifdef STAT_MACROS_BROKEN
#undef S_ISDIR
#endif
#ifndef S_ISDIR
#define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)
#endif
#endif
#ifndef STDC_HEADERS
#undef size_t
#define size_t unsigned int
#endif
/* Some system header files erroneously define these.
We want our own definitions from <fnmatch.h> to take precedence. */
#undef FNM_PATHNAME
#undef FNM_NOESCAPE
#undef FNM_PERIOD
#include <fnmatch.h>
/* Some system header files erroneously define these.
We want our own definitions from <glob.h> to take precedence. */
#undef GLOB_ERR
#undef GLOB_MARK
#undef GLOB_NOSORT
#undef GLOB_DOOFFS
#undef GLOB_NOCHECK
#undef GLOB_APPEND
#undef GLOB_NOESCAPE
#undef GLOB_PERIOD
#include <glob.h>
__ptr_t (*__glob_opendir_hook) __P ((const char *directory));
const char *(*__glob_readdir_hook) __P ((__ptr_t stream));
void (*__glob_closedir_hook) __P ((__ptr_t stream));
static int glob_pattern_p __P ((const char *pattern, int quote));
static int glob_in_dir __P ((const char *pattern, const char *directory,
int flags,
int (*errfunc) __P ((const char *, int)),
glob_t *pglob));
static int prefix_array __P ((const char *prefix, char **array, size_t n));
int collated_compare __P ((const void *elem1, const void *elem2));
/* Do glob searching for PATTERN, placing results in PGLOB.
The bits defined above may be set in FLAGS.
If a directory cannot be opened or read and ERRFUNC is not nil,
it is called with the pathname that caused the error, and the
`errno' value from the failing call; if it returns non-zero
`glob' returns GLOB_ABEND; if it returns zero, the error is ignored.
If memory cannot be allocated for PGLOB, GLOB_NOSPACE is returned.
Otherwise, `glob' returns zero. */
int
glob (pattern, flags, errfunc, pglob)
const char *pattern;
int flags;
int (*errfunc) __P ((const char *, int));
glob_t *pglob;
{
const char *filename;
char *dirname;
size_t dirlen;
int status;
int oldcount;
if (pattern == NULL || pglob == NULL || (flags & ~__GLOB_FLAGS) != 0)
{
errno = EINVAL;
return -1;
}
/* Find the filename. */
filename = strrchr (pattern, '/');
if (filename == NULL)
{
filename = pattern;
dirname = (char *) ".";
dirlen = 0;
}
else if (filename == pattern)
{
/* "/pattern". */
dirname = (char *) "/";
dirlen = 1;
++filename;
}
else
{
dirlen = filename - pattern;
dirname = (char *) __alloca (dirlen + 1);
memcpy (dirname, pattern, dirlen);
dirname[dirlen] = '\0';
++filename;
}
if (filename[0] == '\0' && dirlen > 1)
/* "pattern/". Expand "pattern", appending slashes. */
{
int val = glob (dirname, flags | GLOB_MARK, errfunc, pglob);
if (val == 0)
pglob->gl_flags = (pglob->gl_flags & ~GLOB_MARK) | (flags & GLOB_MARK);
return val;
}
if (!(flags & GLOB_APPEND))
{
pglob->gl_pathc = 0;
pglob->gl_pathv = NULL;
}
oldcount = pglob->gl_pathc;
if (glob_pattern_p (dirname, !(flags & GLOB_NOESCAPE)))
{
/* The directory name contains metacharacters, so we
have to glob for the directory, and then glob for
the pattern in each directory found. */
glob_t dirs;
register int i;
status = glob (dirname,
((flags & (GLOB_ERR | GLOB_NOCHECK | GLOB_NOESCAPE)) |
GLOB_NOSORT),
errfunc, &dirs);
if (status != 0)
return status;
/* We have successfully globbed the preceding directory name.
For each name we found, call glob_in_dir on it and FILENAME,
appending the results to PGLOB. */
for (i = 0; i < dirs.gl_pathc; ++i)
{
int oldcount;
#ifdef SHELL
{
/* Make globbing interruptible in the bash shell. */
extern int interrupt_state;
if (interrupt_state)
{
globfree (&dirs);
globfree (&files);
return GLOB_ABEND;
}
}
#endif /* SHELL. */
oldcount = pglob->gl_pathc;
status = glob_in_dir (filename, dirs.gl_pathv[i],
(flags | GLOB_APPEND) & ~GLOB_NOCHECK,
errfunc, pglob);
if (status == GLOB_NOMATCH)
/* No matches in this directory. Try the next. */
continue;
if (status != 0)
{
globfree (&dirs);
globfree (pglob);
return status;
}
/* Stick the directory on the front of each name. */
if (prefix_array (dirs.gl_pathv[i],
&pglob->gl_pathv[oldcount],
pglob->gl_pathc - oldcount))
{
globfree (&dirs);
globfree (pglob);
return GLOB_NOSPACE;
}
}
flags |= GLOB_MAGCHAR;
if (pglob->gl_pathc == oldcount)
/* No matches. */
if (flags & GLOB_NOCHECK)
{
size_t len = strlen (pattern) + 1;
char *patcopy = (char *) malloc (len);
if (patcopy == NULL)
return GLOB_NOSPACE;
memcpy (patcopy, pattern, len);
pglob->gl_pathv
= (char **) realloc (pglob->gl_pathv,
(pglob->gl_pathc +
((flags & GLOB_DOOFFS) ?
pglob->gl_offs : 0) +
1 + 1) *
sizeof (char *));
if (pglob->gl_pathv == NULL)
{
free (patcopy);
return GLOB_NOSPACE;
}
if (flags & GLOB_DOOFFS)
while (pglob->gl_pathc < pglob->gl_offs)
pglob->gl_pathv[pglob->gl_pathc++] = NULL;
pglob->gl_pathv[pglob->gl_pathc++] = patcopy;
pglob->gl_pathv[pglob->gl_pathc] = NULL;
pglob->gl_flags = flags;
}
else
return GLOB_NOMATCH;
}
else
{
status = glob_in_dir (filename, dirname, flags, errfunc, pglob);
if (status != 0)
return status;
if (dirlen > 0)
{
/* Stick the directory on the front of each name. */
if (prefix_array (dirname,
&pglob->gl_pathv[oldcount],
pglob->gl_pathc - oldcount))
{
globfree (pglob);
return GLOB_NOSPACE;
}
}
}
if (flags & GLOB_MARK)
{
/* Append slashes to directory names. glob_in_dir has already
allocated the extra character for us. */
int i;
struct stat st;
for (i = oldcount; i < pglob->gl_pathc; ++i)
if (__lstat (pglob->gl_pathv[i], &st) == 0 &&
S_ISDIR (st.st_mode))
strcat (pglob->gl_pathv[i], "/");
}
if (!(flags & GLOB_NOSORT))
/* Sort the vector. */
#if 0
qsort ((__ptr_t) &pglob->gl_pathv[oldcount],
pglob->gl_pathc - oldcount,
sizeof (char *), collated_compare);
#else
qsort ( &pglob->gl_pathv[oldcount],
(size_t)(pglob->gl_pathc - oldcount),
sizeof (char *), collated_compare);
#endif
return 0;
}
/* Free storage allocated in PGLOB by a previous `glob' call. */
void
globfree (pglob)
register glob_t *pglob;
{
if (pglob->gl_pathv != NULL)
{
register int i;
for (i = 0; i < pglob->gl_pathc; ++i)
if (pglob->gl_pathv[i] != NULL)
free ((__ptr_t) pglob->gl_pathv[i]);
free ((__ptr_t) pglob->gl_pathv);
}
}
/* Do a collated comparison of A and B. */
int
collated_compare (const void *elem1, const void *elem2)
{
const __ptr_t a = (const __ptr_t)elem1;
const __ptr_t b = (const __ptr_t)elem1;
const char *const s1 = *(const char *const * const) a;
const char *const s2 = *(const char *const * const) b;
if (s1 == s2)
return 0;
if (s1 == NULL)
return 1;
if (s2 == NULL)
return -1;
return strcoll (s1, s2);
}
/* Prepend DIRNAME to each of N members of ARRAY, replacing ARRAY's
elements in place. Return nonzero if out of memory, zero if successful.
A slash is inserted between DIRNAME and each elt of ARRAY,
unless DIRNAME is just "/". Each old element of ARRAY is freed. */
static int
prefix_array (dirname, array, n)
const char *dirname;
char **array;
size_t n;
{
register size_t i;
size_t dirlen = strlen (dirname);
if (dirlen == 1 && dirname[0] == '/')
/* DIRNAME is just "/", so normal prepending would get us "//foo".
We want "/foo" instead, so don't prepend any chars from DIRNAME. */
dirlen = 0;
for (i = 0; i < n; ++i)
{
size_t eltlen = strlen (array[i]) + 1;
char *new = (char *) malloc (dirlen + 1 + eltlen);
if (new == NULL)
{
while (i > 0)
free ((__ptr_t) array[--i]);
return 1;
}
memcpy (new, dirname, dirlen);
new[dirlen] = '/';
memcpy (&new[dirlen + 1], array[i], eltlen);
free ((__ptr_t) array[i]);
array[i] = new;
}
return 0;
}
/* Return nonzero if PATTERN contains any metacharacters.
Metacharacters can be quoted with backslashes if QUOTE is nonzero. */
static int
glob_pattern_p (pattern, quote)
const char *pattern;
int quote;
{
register const char *p;
int open = 0;
for (p = pattern; *p != '\0'; ++p)
switch (*p)
{
case '?':
case '*':
return 1;
case '\\':
if (quote)
++p;
break;
case '[':
open = 1;
break;
case ']':
if (open)
return 1;
break;
}
return 0;
}
/* Like `glob', but PATTERN is a final pathname component,
and matches are searched for in DIRECTORY.
The GLOB_NOSORT bit in FLAGS is ignored. No sorting is ever done.
The GLOB_APPEND flag is assumed to be set (always appends). */
static int
glob_in_dir (pattern, directory, flags, errfunc, pglob)
const char *pattern;
const char *directory;
int flags;
int (*errfunc) __P ((const char *, int));
glob_t *pglob;
{
__ptr_t stream;
struct globlink
{
struct globlink *next;
char *name;
};
struct globlink *names = NULL;
size_t nfound = 0;
if (!glob_pattern_p (pattern, !(flags & GLOB_NOESCAPE)))
{
stream = NULL;
flags |= GLOB_NOCHECK;
}
else
{
flags |= GLOB_MAGCHAR;
stream = (__glob_opendir_hook ? (*__glob_opendir_hook) (directory)
: (__ptr_t) opendir (directory));
if (stream == NULL)
{
if ((errfunc != NULL && (*errfunc) (directory, errno)) ||
(flags & GLOB_ERR))
return GLOB_ABEND;
}
else
while (1)
{
const char *name;
size_t len;
if (__glob_readdir_hook)
{
name = (*__glob_readdir_hook) (stream);
if (name == NULL)
break;
len = 0;
}
else
{
struct dirent *d = readdir ((DIR *) stream);
if (d == NULL)
break;
if (! REAL_DIR_ENTRY (d))
continue;
name = d->d_name;
#ifdef HAVE_D_NAMLEN
len = d->d_namlen;
#else
len = 0;
#endif
}
if (fnmatch (pattern, name,
(!(flags & GLOB_PERIOD) ? FNM_PERIOD : 0) |
((flags & GLOB_NOESCAPE) ? FNM_NOESCAPE : 0)) == 0)
{
struct globlink *new
= (struct globlink *) __alloca (sizeof (struct globlink));
if (len == 0)
len = strlen (name);
new->name
= (char *) malloc (len + ((flags & GLOB_MARK) ? 1 : 0) + 1);
if (new->name == NULL)
goto memory_error;
memcpy ((__ptr_t) new->name, name, len);
new->name[len] = '\0';
new->next = names;
names = new;
++nfound;
}
}
}
if (nfound == 0 && (flags & GLOB_NOCHECK))
{
size_t len = strlen (pattern);
nfound = 1;
names = (struct globlink *) __alloca (sizeof (struct globlink));
names->next = NULL;
names->name = (char *) malloc (len + 1);
if (names->name == NULL)
goto memory_error;
memcpy (names->name, pattern, len);
names->name[len] = '\0';
}
pglob->gl_pathv
= (char **) realloc (pglob->gl_pathv,
(pglob->gl_pathc +
((flags & GLOB_DOOFFS) ? pglob->gl_offs : 0) +
nfound + 1) *
sizeof (char *));
if (pglob->gl_pathv == NULL)
goto memory_error;
if (flags & GLOB_DOOFFS)
while (pglob->gl_pathc < pglob->gl_offs)
pglob->gl_pathv[pglob->gl_pathc++] = NULL;
for (; names != NULL; names = names->next)
pglob->gl_pathv[pglob->gl_pathc++] = names->name;
pglob->gl_pathv[pglob->gl_pathc] = NULL;
pglob->gl_flags = flags;
if (stream != NULL)
{
int save = errno;
if (__glob_closedir_hook)
(*__glob_closedir_hook) (stream);
else
(void) closedir ((DIR *) stream);
errno = save;
}
return nfound == 0 ? GLOB_NOMATCH : 0;
memory_error:
{
int save = errno;
if (__glob_closedir_hook)
(*__glob_closedir_hook) (stream);
else
(void) closedir ((DIR *) stream);
errno = save;
}
while (names != NULL)
{
if (names->name != NULL)
free ((__ptr_t) names->name);
names = names->next;
}
return GLOB_NOSPACE;
}
#endif /* _LIBC or not __GNU_LIBRARY__. */

481
buildtools/windows/source/make/glob/COPYING.LIB
View File

@ -1,481 +0,0 @@
GNU LIBRARY GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1991 Free Software Foundation, Inc.
675 Mass Ave, Cambridge, MA 02139, USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
[This is the first released version of the library GPL. It is
numbered 2 because it goes with version 2 of the ordinary GPL.]
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.
This license, the Library General Public License, applies to some
specially designated Free Software Foundation software, and to any
other libraries whose authors decide to use it. You can use it for
your libraries, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if
you distribute copies of the library, or if you modify it.
For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link a program with the library, you must provide
complete object files to the recipients so that they can relink them
with the library, after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.
Our method of protecting your rights has two steps: (1) copyright
the library, and (2) offer you this license which gives you legal
permission to copy, distribute and/or modify the library.
Also, for each distributor's protection, we want to make certain
that everyone understands that there is no warranty for this free
library. If the library is modified by someone else and passed on, we
want its recipients to know that what they have is not the original
version, so that any problems introduced by others will not reflect on
the original authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that companies distributing free
software will individually obtain patent licenses, thus in effect
transforming the program into proprietary software. To prevent this,
we have made it clear that any patent must be licensed for everyone's
free use or not licensed at all.
Most GNU software, including some libraries, is covered by the ordinary
GNU General Public License, which was designed for utility programs. This
license, the GNU Library General Public License, applies to certain
designated libraries. This license is quite different from the ordinary
one; be sure to read it in full, and don't assume that anything in it is
the same as in the ordinary license.
The reason we have a separate public license for some libraries is that
they blur the distinction we usually make between modifying or adding to a
program and simply using it. Linking a program with a library, without
changing the library, is in some sense simply using the library, and is
analogous to running a utility program or application program. However, in
a textual and legal sense, the linked executable is a combined work, a
derivative of the original library, and the ordinary General Public License
treats it as such.
Because of this blurred distinction, using the ordinary General
Public License for libraries did not effectively promote software
sharing, because most developers did not use the libraries. We
concluded that weaker conditions might promote sharing better.
However, unrestricted linking of non-free programs would deprive the
users of those programs of all benefit from the free status of the
libraries themselves. This Library General Public License is intended to
permit developers of non-free programs to use free libraries, while
preserving your freedom as a user of such programs to change the free
libraries that are incorporated in them. (We have not seen how to achieve
this as regards changes in header files, but we have achieved it as regards
changes in the actual functions of the Library.) The hope is that this
will lead to faster development of free libraries.
The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
"work based on the library" and a "work that uses the library". The
former contains code derived from the library, while the latter only
works together with the library.
Note that it is possible for a library to be covered by the ordinary
General Public License rather than by this special one.
GNU LIBRARY GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License Agreement applies to any software library which
contains a notice placed by the copyright holder or other authorized
party saying it may be distributed under the terms of this Library
General Public License (also called "this License"). Each licensee is
addressed as "you".
A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.
The "Library", below, refers to any such software library or work
which has been distributed under these terms. A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term "modification".)
"Source code" for a work means the preferred form of the work for
making modifications to it. For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it). Whether that is true depends on what the Library does
and what the program that uses the Library does.
1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.
You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.
2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) The modified work must itself be a software library.
b) You must cause the files modified to carry prominent notices
stating that you changed the files and the date of any change.
c) You must cause the whole of the work to be licensed at no
charge to all third parties under the terms of this License.
d) If a facility in the modified Library refers to a function or a
table of data to be supplied by an application program that uses
the facility, other than as an argument passed when the facility
is invoked, then you must make a good faith effort to ensure that,
in the event an application does not supply such function or
table, the facility still operates, and performs whatever part of
its purpose remains meaningful.
(For example, a function in a library to compute square roots has
a purpose that is entirely well-defined independent of the
application. Therefore, Subsection 2d requires that any
application-supplied function or table used by this function must
be optional: if the application does not supply it, the square
root function must still compute square roots.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.
In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library. To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License. (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.) Do not make any other change in
these notices.
Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.
4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.
If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.
5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library". Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library". The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.
When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.
If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
6. As an exception to the Sections above, you may also compile or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.
You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License. You must supply a copy of this License. If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License. Also, you must do one
of these things:
a) Accompany the work with the complete corresponding
machine-readable source code for the Library including whatever
changes were used in the work (which must be distributed under
Sections 1 and 2 above); and, if the work is an executable linked
with the Library, with the complete machine-readable "work that
uses the Library", as object code and/or source code, so that the
user can modify the Library and then relink to produce a modified
executable containing the modified Library. (It is understood
that the user who changes the contents of definitions files in the
Library will not necessarily be able to recompile the application
to use the modified definitions.)
b) Accompany the work with a written offer, valid for at
least three years, to give the same user the materials
specified in Subsection 6a, above, for a charge no more
than the cost of performing this distribution.
c) If distribution of the work is made by offering access to copy
from a designated place, offer equivalent access to copy the above
specified materials from the same place.
d) Verify that the user has already received a copy of these
materials or that you have already sent this user a copy.
For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it. However, as a special exception,
the source code distributed need not include anything that is normally
distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.
It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system. Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.
7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:
a) Accompany the combined library with a copy of the same work
based on the Library, uncombined with any other library
facilities. This must be distributed under the terms of the
Sections above.
b) Give prominent notice with the combined library of the fact
that part of it is a work based on the Library, and explaining
where to find the accompanying uncombined form of the same work.
8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License. Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License. However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.
9. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Library or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.
10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all. For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.
If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded. In such case, this License incorporates the limitation as if
written in the body of this License.
13. The Free Software Foundation may publish revised and/or new
versions of the Library General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation. If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.
14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission. For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this. Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.
NO WARRANTY
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.
END OF TERMS AND CONDITIONS
Appendix: How to Apply These Terms to Your New Libraries
If you develop a new library, and you want it to be of the greatest
possible use to the public, we recommend making it free software that
everyone can redistribute and change. You can do so by permitting
redistribution under these terms (or, alternatively, under the terms of the
ordinary General Public License).
To apply these terms, attach the following notices to the library. It is
safest to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least the
"copyright" line and a pointer to where the full notice is found.
<one line to give the library's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
Also add information on how to contact you by electronic and paper mail.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the library, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the
library `Frob' (a library for tweaking knobs) written by James Random Hacker.
<signature of Ty Coon>, 1 April 1990
Ty Coon, President of Vice
That's all there is to it!

28
buildtools/windows/source/make/glob/Makefile
View File

@ -1,28 +0,0 @@
#
# GNU Makefile for building gmake.exe on WIN32
# This makefile compiles the files in the glob subdirectory.
#
CSRCS = fnmatch.c glob.c
OBJS = $(CSRCS:.c=.obj)
CC = cl
CFLAGS = $(CC_SWITCHES) $(INCLUDES) $(DEFINES) $(CC_OUTPUTS)
CC_SWITCHES = -nologo -ML -W3 -O2
INCLUDES = -I. -I..
DEFINES = -DWIN32 -DNDEBUG -D_CONSOLE -DNETSCAPE -DHAVE_CONFIG_H
CC_OUTPUTS = -Fpglob.pch -YX -c
all: $(OBJS)
%.obj: %.c
$(CC) $(CFLAGS) $<
clean:
rm -rf $(OBJS) glob.pch

66
buildtools/windows/source/make/glob/Makefile.in
View File

@ -1,66 +0,0 @@
# Makefile for standalone distribution of libglob.a (fnmatch, glob).
# Copyright (C) 1991, 92, 93, 94, 95 Free Software Foundation, Inc.
# This file is part of the GNU C Library.
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Library General Public License
# as published by the Free Software Foundation; either version 2 of
# the License, or (at your option) any later version.
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Library General Public License for more details.
# You should have received a copy of the GNU Library General Public
# License along with this library; see the file COPYING.LIB. If
# not, write to the Free Software Foundation, Inc., 675 Mass Ave,
# Cambridge, MA 02139, USA.
# Ultrix 2.2 make doesn't expand the value of VPATH.
VPATH = @srcdir@
# This must repeat the value, because configure will remove `VPATH = .'.
srcdir = @srcdir@
CC = @CC@
CPPFLAGS = @CPPFLAGS@
CFLAGS = @CFLAGS@
# Information determined by configure.
DEFS = @DEFS@
# How to invoke ar.
AR = @AR@
ARFLAGS = rv
# How to invoke ranlib.
RANLIB = @RANLIB@
.PHONY: all
all: libglob.a
libglob.a: glob.o fnmatch.o
$(AR) $(ARFLAGS) $@ glob.o fnmatch.o
$(RANLIB) $@
# For some reason, Unix make wants the dependencies on the source files.
# Otherwise it refuses to use an implicit rule!
# And, get this: it doesn't work to use $(srcdir)/foo.c!!
glob.o: $(srcdir)/glob.h $(srcdir)/fnmatch.h glob.c
fnmatch.o: $(srcdir)/fnmatch.h fnmatch.c
.c.o:
$(CC) -I. -I$(srcdir) -c \
$(DEFS) $(CPPFLAGS) $(CFLAGS) $< $(OUTPUT_OPTION)
.PHONY: clean realclean glob-clean glob-realclean distclean
clean glob-clean:
-rm -f libglob.a *.o core
distclean glob-realclean: clean
-rm -f TAGS tags Makefile config.status config.h config.log
realcean: distclean
# For inside the C library.
glob.tar glob.tar.Z:
$(MAKE) -C .. $@

1547
buildtools/windows/source/make/glob/configure vendored
View File

File diff suppressed because it is too large Load Diff

52
buildtools/windows/source/make/glob/configure.bat
View File

@ -1,52 +0,0 @@
@echo off
echo Configuring glob for GO32
rem This batch file assumes a unix-type "sed" program
echo # Makefile generated by "configure.bat"> Makefile
if exist config.sed del config.sed
echo "s/@srcdir@/./ ">> config.sed
echo "s/@CC@/gcc/ ">> config.sed
echo "s/@CFLAGS@/-O2 -g/ ">> config.sed
echo "s/@CPPFLAGS@/-DHAVE_CONFIG_H -I../ ">> config.sed
echo "s/@AR@/ar/ ">> config.sed
echo "s/@RANLIB@/ranlib/ ">> config.sed
echo "s/@LDFLAGS@// ">> config.sed
echo "s/@DEFS@// ">> config.sed
echo "s/@ALLOCA@// ">> config.sed
echo "s/@LIBS@// ">> config.sed
echo "s/@LIBOBJS@// ">> config.sed
echo "s/^Makefile *:/_Makefile:/ ">> config.sed
echo "s/^config.h *:/_config.h:/ ">> config.sed
sed -e "s/^\"//" -e "s/\"$//" -e "s/[ ]*$//" config.sed > config2.sed
sed -f config2.sed Makefile.in >> Makefile
del config.sed
del config2.sed

19
buildtools/windows/source/make/glob/configure.in
View File

@ -1,19 +0,0 @@
dnl Process this file with autoconf to produce a configure script.
AC_INIT(fnmatch.c) dnl A distinctive file to look for in srcdir.
AC_PREREQ(2.1) dnl Minimum Autoconf version required.
AC_PROG_CC
AC_CHECK_PROG(AR, ar, ar, ar)
AC_PROG_RANLIB
AC_PROG_CPP dnl Later checks need this.
dnl These two want to come early.
AC_AIX
AC_MINIX
AC_ISC_POSIX
AC_CONST
AC_HEADER_STDC
AC_CHECK_HEADERS(memory.h unistd.h string.h)
AC_HEADER_DIRENT
AC_FUNC_CLOSEDIR_VOID
AC_FUNC_ALLOCA
AC_FUNC_STRCOLL
AC_OUTPUT(Makefile)

200
buildtools/windows/source/make/glob/fnmatch.c
View File

@ -1,200 +0,0 @@
/* Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; see the file COPYING.LIB. If
not, write to the Free Software Foundation, Inc., 675 Mass Ave,
Cambridge, MA 02139, USA. */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <errno.h>
#include <fnmatch.h>
#include <ctype.h>
/* Comment out all this code if we are using the GNU C Library, and are not
actually compiling the library itself. This code is part of the GNU C
Library, but also included in many other GNU distributions. Compiling
and linking in this code is a waste when using the GNU C library
(especially if it is a shared library). Rather than having every GNU
program understand `configure --with-gnu-libc' and omit the object files,
it is simpler to just do this in the source for each such file. */
#if defined (_LIBC) || !defined (__GNU_LIBRARY__)
#ifndef errno
extern int errno;
#endif
/* Match STRING against the filename pattern PATTERN, returning zero if
it matches, nonzero if not. */
int
fnmatch (pattern, string, flags)
const char *pattern;
const char *string;
int flags;
{
register const char *p = pattern, *n = string;
register char c;
/* Note that this evalutes C many times. */
#define FOLD(c) ((flags & FNM_CASEFOLD) && isupper (c) ? tolower (c) : (c))
while ((c = *p++) != '\0')
{
c = FOLD (c);
switch (c)
{
case '?':
if (*n == '\0')
return FNM_NOMATCH;
else if ((flags & FNM_FILE_NAME) && *n == '/')
return FNM_NOMATCH;
else if ((flags & FNM_PERIOD) && *n == '.' &&
(n == string || ((flags & FNM_FILE_NAME) && n[-1] == '/')))
return FNM_NOMATCH;
break;
case '\\':
if (!(flags & FNM_NOESCAPE))
{
c = *p++;
c = FOLD (c);
}
if (FOLD (*n) != c)
return FNM_NOMATCH;
break;
case '*':
if ((flags & FNM_PERIOD) && *n == '.' &&
(n == string || ((flags & FNM_FILE_NAME) && n[-1] == '/')))
return FNM_NOMATCH;
for (c = *p++; c == '?' || c == '*'; c = *p++, ++n)
if (((flags & FNM_FILE_NAME) && *n == '/') ||
(c == '?' && *n == '\0'))
return FNM_NOMATCH;
if (c == '\0')
return 0;
{
char c1 = (!(flags & FNM_NOESCAPE) && c == '\\') ? *p : c;
c1 = FOLD (c1);
for (--p; *n != '\0'; ++n)
if ((c == '[' || FOLD (*n) == c1) &&
fnmatch (p, n, flags & ~FNM_PERIOD) == 0)
return 0;
return FNM_NOMATCH;
}
case '[':
{
/* Nonzero if the sense of the character class is inverted. */
register int not;
if (*n == '\0')
return FNM_NOMATCH;
if ((flags & FNM_PERIOD) && *n == '.' &&
(n == string || ((flags & FNM_FILE_NAME) && n[-1] == '/')))
return FNM_NOMATCH;
not = (*p == '!' || *p == '^');
if (not)
++p;
c = *p++;
for (;;)
{
register char cstart = c, cend = c;
if (!(flags & FNM_NOESCAPE) && c == '\\')
cstart = cend = *p++;
cstart = cend = FOLD (cstart);
if (c == '\0')
/* [ (unterminated) loses. */
return FNM_NOMATCH;
c = *p++;
c = FOLD (c);
if ((flags & FNM_FILE_NAME) && c == '/')
/* [/] can never match. */
return FNM_NOMATCH;
if (c == '-' && *p != ']')
{
cend = *p++;
if (!(flags & FNM_NOESCAPE) && cend == '\\')
cend = *p++;
if (cend == '\0')
return FNM_NOMATCH;
cend = FOLD (cend);
c = *p++;
}
if (FOLD (*n) >= cstart && FOLD (*n) <= cend)
goto matched;
if (c == ']')
break;
}
if (!not)
return FNM_NOMATCH;
break;
matched:;
/* Skip the rest of the [...] that already matched. */
while (c != ']')
{
if (c == '\0')
/* [... (unterminated) loses. */
return FNM_NOMATCH;
c = *p++;
if (!(flags & FNM_NOESCAPE) && c == '\\')
/* XXX 1003.2d11 is unclear if this is right. */
++p;
}
if (not)
return FNM_NOMATCH;
}
break;
default:
if (c != FOLD (*n))
return FNM_NOMATCH;
}
++n;
}
if (*n == '\0')
return 0;
if ((flags & FNM_LEADING_DIR) && *n == '/')
/* The FNM_LEADING_DIR flag says that "foo*" matches "foobar/frobozz". */
return 0;
return FNM_NOMATCH;
}
#endif /* _LIBC or not __GNU_LIBRARY__. */

67
buildtools/windows/source/make/glob/fnmatch.h
View File

@ -1,67 +0,0 @@
/* Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; see the file COPYING.LIB. If
not, write to the Free Software Foundation, Inc., 675 Mass Ave,
Cambridge, MA 02139, USA. */
#ifndef _FNMATCH_H
#define _FNMATCH_H 1
#ifdef __cplusplus
extern "C" {
#endif
#if defined (__cplusplus) || (defined (__STDC__) && __STDC__)
#undef __P
#define __P(protos) protos
#else /* Not C++ or ANSI C. */
#undef __P
#define __P(protos) ()
/* We can get away without defining `const' here only because in this file
it is used only inside the prototype for `fnmatch', which is elided in
non-ANSI C where `const' is problematical. */
#endif /* C++ or ANSI C. */
/* We #undef these before defining them because some losing systems
(HP-UX A.08.07 for example) define these in <unistd.h>. */
#undef FNM_PATHNAME
#undef FNM_NOESCAPE
#undef FNM_PERIOD
/* Bits set in the FLAGS argument to `fnmatch'. */
#define FNM_PATHNAME (1 << 0) /* No wildcard can ever match `/'. */
#define FNM_NOESCAPE (1 << 1) /* Backslashes don't quote special chars. */
#define FNM_PERIOD (1 << 2) /* Leading `.' is matched only explicitly. */
#if !defined (_POSIX_C_SOURCE) || _POSIX_C_SOURCE < 2 || defined (_GNU_SOURCE)
#define FNM_FILE_NAME FNM_PATHNAME /* Preferred GNU name. */
#define FNM_LEADING_DIR (1 << 3) /* Ignore `/...' after a match. */
#define FNM_CASEFOLD (1 << 4) /* Compare without regard to case. */
#endif
/* Value returned by `fnmatch' if STRING does not match PATTERN. */
#define FNM_NOMATCH 1
/* Match STRING against the filename pattern PATTERN,
returning zero if it matches, FNM_NOMATCH if not. */
extern int fnmatch __P ((const char *__pattern, const char *__string,
int __flags));
#ifdef __cplusplus
}
#endif
#endif /* fnmatch.h */

705
buildtools/windows/source/make/glob/glob.c
View File

@ -1,705 +0,0 @@
/* Copyright (C) 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; see the file COPYING.LIB. If
not, write to the Free Software Foundation, Inc., 675 Mass Ave,
Cambridge, MA 02139, USA. */
/* AIX requires this to be the first thing in the file. */
#if defined (_AIX) && !defined (__GNUC__)
#pragma alloca
#endif
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#ifdef NETSCAPE
#include "windir.h"
#endif
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
/* Comment out all this code if we are using the GNU C Library, and are not
actually compiling the library itself. This code is part of the GNU C
Library, but also included in many other GNU distributions. Compiling
and linking in this code is a waste when using the GNU C library
(especially if it is a shared library). Rather than having every GNU
program understand `configure --with-gnu-libc' and omit the object files,
it is simpler to just do this in the source for each such file. */
#if defined (_LIBC) || !defined (__GNU_LIBRARY__)
#ifdef STDC_HEADERS
#include <stddef.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#ifndef POSIX
#ifdef _POSIX_VERSION
#define POSIX
#endif
#endif
#endif
#if !defined(__GNU_LIBRARY__) && !defined(STDC_HEADERS)
extern int errno;
#endif
#ifndef NULL
#define NULL 0
#endif
#if defined (POSIX) || defined (HAVE_DIRENT_H) || defined (__GNU_LIBRARY__)
#include <dirent.h>
#ifndef __GNU_LIBRARY__
#define D_NAMLEN(d) strlen((d)->d_name)
#else /* GNU C library. */
#define D_NAMLEN(d) ((d)->d_namlen)
#endif /* Not GNU C library. */
#else /* Not POSIX or HAVE_DIRENT_H. */
#define direct dirent
#define D_NAMLEN(d) ((d)->d_namlen)
#ifdef HAVE_SYS_NDIR_H
#include <sys/ndir.h>
#endif /* HAVE_SYS_NDIR_H */
#ifdef HAVE_SYS_DIR_H
#include <sys/dir.h>
#endif /* HAVE_SYS_DIR_H */
#ifdef HAVE_NDIR_H
#include <ndir.h>
#endif /* HAVE_NDIR_H */
#endif /* POSIX or HAVE_DIRENT_H or __GNU_LIBRARY__. */
#if defined(NETSCAPE) || defined (POSIX) && !defined (__GNU_LIBRARY__)
/* Posix does not require that the d_ino field be present, and some
systems do not provide it. */
#define REAL_DIR_ENTRY(dp) 1
#else
#define REAL_DIR_ENTRY(dp) (dp->d_ino != 0)
#endif /* POSIX */
#if (defined (STDC_HEADERS) || defined (__GNU_LIBRARY__))
#include <stdlib.h>
#include <string.h>
#define ANSI_STRING
#else /* No standard headers. */
#ifdef HAVE_STRING_H
#include <string.h>
#define ANSI_STRING
#else
#include <strings.h>
#endif
#ifdef HAVE_MEMORY_H
#include <memory.h>
#endif
extern char *malloc (), *realloc ();
extern void free ();
extern void qsort ();
extern void abort (), exit ();
#endif /* Standard headers. */
#ifndef ANSI_STRING
#ifndef bzero
extern void bzero ();
#endif
#ifndef bcopy
extern void bcopy ();
#endif
#define memcpy(d, s, n) bcopy ((s), (d), (n))
#define strrchr rindex
/* memset is only used for zero here, but let's be paranoid. */
#define memset(s, better_be_zero, n) \
((void) ((better_be_zero) == 0 ? (bzero((s), (n)), 0) : (abort(), 0)))
#endif /* Not ANSI_STRING. */
#ifndef HAVE_STRCOLL
#define strcoll strcmp
#endif
#if !defined(__GNU_LIBRARY__) && !defined(NETSCAPE)
#ifdef __GNUC__
__inline
#endif
static char *
my_realloc (p, n)
char *p;
unsigned int n;
{
/* These casts are the for sake of the broken Ultrix compiler,
which warns of illegal pointer combinations otherwise. */
if (p == NULL)
return (char *) malloc (n);
return (char *) realloc (p, n);
}
#define realloc my_realloc
#endif
#if !defined(__alloca) && !defined(__GNU_LIBRARY__)
#ifdef __GNUC__
#undef alloca
#define alloca(n) __builtin_alloca (n)
#else /* Not GCC. */
#if defined (sparc) || defined (HAVE_ALLOCA_H)
#include <alloca.h>
#elif defined(NETSCAPE)
#include <malloc.h>
#else /* Not sparc or HAVE_ALLOCA_H. */
#ifndef _AIX
extern char *alloca ();
#endif /* Not _AIX. */
#endif /* sparc or HAVE_ALLOCA_H. */
#endif /* GCC. */
#define __alloca alloca
#endif
#ifndef __GNU_LIBRARY__
#define __lstat lstat
#ifndef HAVE_LSTAT
#define lstat stat
#endif
#ifdef STAT_MACROS_BROKEN
#undef S_ISDIR
#endif
#ifndef S_ISDIR
#define S_ISDIR(mode) (((mode) & S_IFMT) == S_IFDIR)
#endif
#endif
#ifndef STDC_HEADERS
#undef size_t
#define size_t unsigned int
#endif
/* Some system header files erroneously define these.
We want our own definitions from <fnmatch.h> to take precedence. */
#undef FNM_PATHNAME
#undef FNM_NOESCAPE
#undef FNM_PERIOD
#include <fnmatch.h>
/* Some system header files erroneously define these.
We want our own definitions from <glob.h> to take precedence. */
#undef GLOB_ERR
#undef GLOB_MARK
#undef GLOB_NOSORT
#undef GLOB_DOOFFS
#undef GLOB_NOCHECK
#undef GLOB_APPEND
#undef GLOB_NOESCAPE
#undef GLOB_PERIOD
#include <glob.h>
__ptr_t (*__glob_opendir_hook) __P ((const char *directory));
const char *(*__glob_readdir_hook) __P ((__ptr_t stream));
void (*__glob_closedir_hook) __P ((__ptr_t stream));
static int glob_pattern_p __P ((const char *pattern, int quote));
static int glob_in_dir __P ((const char *pattern, const char *directory,
int flags,
int (*errfunc) __P ((const char *, int)),
glob_t *pglob));
static int prefix_array __P ((const char *prefix, char **array, size_t n));
int collated_compare __P ((const void *elem1, const void *elem2));
/* Do glob searching for PATTERN, placing results in PGLOB.
The bits defined above may be set in FLAGS.
If a directory cannot be opened or read and ERRFUNC is not nil,
it is called with the pathname that caused the error, and the
`errno' value from the failing call; if it returns non-zero
`glob' returns GLOB_ABEND; if it returns zero, the error is ignored.
If memory cannot be allocated for PGLOB, GLOB_NOSPACE is returned.
Otherwise, `glob' returns zero. */
int
glob (pattern, flags, errfunc, pglob)
const char *pattern;
int flags;
int (*errfunc) __P ((const char *, int));
glob_t *pglob;
{
const char *filename;
char *dirname;
size_t dirlen;
int status;
int oldcount;
if (pattern == NULL || pglob == NULL || (flags & ~__GLOB_FLAGS) != 0)
{
errno = EINVAL;
return -1;
}
/* Find the filename. */
filename = strrchr (pattern, '/');
if (filename == NULL)
{
filename = pattern;
dirname = (char *) ".";
dirlen = 0;
}
else if (filename == pattern)
{
/* "/pattern". */
dirname = (char *) "/";
dirlen = 1;
++filename;
}
else
{
dirlen = filename - pattern;
dirname = (char *) __alloca (dirlen + 1);
memcpy (dirname, pattern, dirlen);
dirname[dirlen] = '\0';
++filename;
}
if (filename[0] == '\0' && dirlen > 1)
/* "pattern/". Expand "pattern", appending slashes. */
{
int val = glob (dirname, flags | GLOB_MARK, errfunc, pglob);
if (val == 0)
pglob->gl_flags = (pglob->gl_flags & ~GLOB_MARK) | (flags & GLOB_MARK);
return val;
}
if (!(flags & GLOB_APPEND))
{
pglob->gl_pathc = 0;
pglob->gl_pathv = NULL;
}
oldcount = pglob->gl_pathc;
if (glob_pattern_p (dirname, !(flags & GLOB_NOESCAPE)))
{
/* The directory name contains metacharacters, so we
have to glob for the directory, and then glob for
the pattern in each directory found. */
glob_t dirs;
register int i;
status = glob (dirname,
((flags & (GLOB_ERR | GLOB_NOCHECK | GLOB_NOESCAPE)) |
GLOB_NOSORT),
errfunc, &dirs);
if (status != 0)
return status;
/* We have successfully globbed the preceding directory name.
For each name we found, call glob_in_dir on it and FILENAME,
appending the results to PGLOB. */
for (i = 0; i < dirs.gl_pathc; ++i)
{
int oldcount;
#ifdef SHELL
{
/* Make globbing interruptible in the bash shell. */
extern int interrupt_state;
if (interrupt_state)
{
globfree (&dirs);
globfree (&files);
return GLOB_ABEND;
}
}
#endif /* SHELL. */
oldcount = pglob->gl_pathc;
status = glob_in_dir (filename, dirs.gl_pathv[i],
(flags | GLOB_APPEND) & ~GLOB_NOCHECK,
errfunc, pglob);
if (status == GLOB_NOMATCH)
/* No matches in this directory. Try the next. */
continue;
if (status != 0)
{
globfree (&dirs);
globfree (pglob);
return status;
}
/* Stick the directory on the front of each name. */
if (prefix_array (dirs.gl_pathv[i],
&pglob->gl_pathv[oldcount],
pglob->gl_pathc - oldcount))
{
globfree (&dirs);
globfree (pglob);
return GLOB_NOSPACE;
}
}
flags |= GLOB_MAGCHAR;
if (pglob->gl_pathc == oldcount)
/* No matches. */
if (flags & GLOB_NOCHECK)
{
size_t len = strlen (pattern) + 1;
char *patcopy = (char *) malloc (len);
if (patcopy == NULL)
return GLOB_NOSPACE;
memcpy (patcopy, pattern, len);
pglob->gl_pathv
= (char **) realloc (pglob->gl_pathv,
(pglob->gl_pathc +
((flags & GLOB_DOOFFS) ?
pglob->gl_offs : 0) +
1 + 1) *
sizeof (char *));
if (pglob->gl_pathv == NULL)
{
free (patcopy);
return GLOB_NOSPACE;
}
if (flags & GLOB_DOOFFS)
while (pglob->gl_pathc < pglob->gl_offs)
pglob->gl_pathv[pglob->gl_pathc++] = NULL;
pglob->gl_pathv[pglob->gl_pathc++] = patcopy;
pglob->gl_pathv[pglob->gl_pathc] = NULL;
pglob->gl_flags = flags;
}
else
return GLOB_NOMATCH;
}
else
{
status = glob_in_dir (filename, dirname, flags, errfunc, pglob);
if (status != 0)
return status;
if (dirlen > 0)
{
/* Stick the directory on the front of each name. */
if (prefix_array (dirname,
&pglob->gl_pathv[oldcount],
pglob->gl_pathc - oldcount))
{
globfree (pglob);
return GLOB_NOSPACE;
}
}
}
if (flags & GLOB_MARK)
{
/* Append slashes to directory names. glob_in_dir has already
allocated the extra character for us. */
int i;
struct stat st;
for (i = oldcount; i < pglob->gl_pathc; ++i)
if (__lstat (pglob->gl_pathv[i], &st) == 0 &&
S_ISDIR (st.st_mode))
strcat (pglob->gl_pathv[i], "/");
}
if (!(flags & GLOB_NOSORT))
/* Sort the vector. */
#if 0
qsort ((__ptr_t) &pglob->gl_pathv[oldcount],
pglob->gl_pathc - oldcount,
sizeof (char *), collated_compare);
#else
qsort ( &pglob->gl_pathv[oldcount],
(size_t)(pglob->gl_pathc - oldcount),
sizeof (char *), collated_compare);
#endif
return 0;
}
/* Free storage allocated in PGLOB by a previous `glob' call. */
void
globfree (pglob)
register glob_t *pglob;
{
if (pglob->gl_pathv != NULL)
{
register int i;
for (i = 0; i < pglob->gl_pathc; ++i)
if (pglob->gl_pathv[i] != NULL)
free ((__ptr_t) pglob->gl_pathv[i]);
free ((__ptr_t) pglob->gl_pathv);
}
}
/* Do a collated comparison of A and B. */
int
collated_compare (const void *elem1, const void *elem2)
{
const __ptr_t a = (const __ptr_t)elem1;
const __ptr_t b = (const __ptr_t)elem1;
const char *const s1 = *(const char *const * const) a;
const char *const s2 = *(const char *const * const) b;
if (s1 == s2)
return 0;
if (s1 == NULL)
return 1;
if (s2 == NULL)
return -1;
return strcoll (s1, s2);
}
/* Prepend DIRNAME to each of N members of ARRAY, replacing ARRAY's
elements in place. Return nonzero if out of memory, zero if successful.
A slash is inserted between DIRNAME and each elt of ARRAY,
unless DIRNAME is just "/". Each old element of ARRAY is freed. */
static int
prefix_array (dirname, array, n)
const char *dirname;
char **array;
size_t n;
{
register size_t i;
size_t dirlen = strlen (dirname);
if (dirlen == 1 && dirname[0] == '/')
/* DIRNAME is just "/", so normal prepending would get us "//foo".
We want "/foo" instead, so don't prepend any chars from DIRNAME. */
dirlen = 0;
for (i = 0; i < n; ++i)
{
size_t eltlen = strlen (array[i]) + 1;
char *new = (char *) malloc (dirlen + 1 + eltlen);
if (new == NULL)
{
while (i > 0)
free ((__ptr_t) array[--i]);
return 1;
}
memcpy (new, dirname, dirlen);
new[dirlen] = '/';
memcpy (&new[dirlen + 1], array[i], eltlen);
free ((__ptr_t) array[i]);
array[i] = new;
}
return 0;
}
/* Return nonzero if PATTERN contains any metacharacters.
Metacharacters can be quoted with backslashes if QUOTE is nonzero. */
static int
glob_pattern_p (pattern, quote)
const char *pattern;
int quote;
{
register const char *p;
int open = 0;
for (p = pattern; *p != '\0'; ++p)
switch (*p)
{
case '?':
case '*':
return 1;
case '\\':
if (quote)
++p;
break;
case '[':
open = 1;
break;
case ']':
if (open)
return 1;
break;
}
return 0;
}
/* Like `glob', but PATTERN is a final pathname component,
and matches are searched for in DIRECTORY.
The GLOB_NOSORT bit in FLAGS is ignored. No sorting is ever done.
The GLOB_APPEND flag is assumed to be set (always appends). */
static int
glob_in_dir (pattern, directory, flags, errfunc, pglob)
const char *pattern;
const char *directory;
int flags;
int (*errfunc) __P ((const char *, int));
glob_t *pglob;
{
__ptr_t stream;
struct globlink
{
struct globlink *next;
char *name;
};
struct globlink *names = NULL;
size_t nfound = 0;
if (!glob_pattern_p (pattern, !(flags & GLOB_NOESCAPE)))
{
stream = NULL;
flags |= GLOB_NOCHECK;
}
else
{
flags |= GLOB_MAGCHAR;
stream = (__glob_opendir_hook ? (*__glob_opendir_hook) (directory)
: (__ptr_t) opendir (directory));
if (stream == NULL)
{
if ((errfunc != NULL && (*errfunc) (directory, errno)) ||
(flags & GLOB_ERR))
return GLOB_ABEND;
}
else
while (1)
{
const char *name;
size_t len;
if (__glob_readdir_hook)
{
name = (*__glob_readdir_hook) (stream);
if (name == NULL)
break;
len = 0;
}
else
{
struct dirent *d = readdir ((DIR *) stream);
if (d == NULL)
break;
if (! REAL_DIR_ENTRY (d))
continue;
name = d->d_name;
#ifdef HAVE_D_NAMLEN
len = d->d_namlen;
#else
len = 0;
#endif
}
if (fnmatch (pattern, name,
(!(flags & GLOB_PERIOD) ? FNM_PERIOD : 0) |
((flags & GLOB_NOESCAPE) ? FNM_NOESCAPE : 0)) == 0)
{
struct globlink *new
= (struct globlink *) __alloca (sizeof (struct globlink));
if (len == 0)
len = strlen (name);
new->name
= (char *) malloc (len + ((flags & GLOB_MARK) ? 1 : 0) + 1);
if (new->name == NULL)
goto memory_error;
memcpy ((__ptr_t) new->name, name, len);
new->name[len] = '\0';
new->next = names;
names = new;
++nfound;
}
}
}
if (nfound == 0 && (flags & GLOB_NOCHECK))
{
size_t len = strlen (pattern);
nfound = 1;
names = (struct globlink *) __alloca (sizeof (struct globlink));
names->next = NULL;
names->name = (char *) malloc (len + 1);
if (names->name == NULL)
goto memory_error;
memcpy (names->name, pattern, len);
names->name[len] = '\0';
}
pglob->gl_pathv
= (char **) realloc (pglob->gl_pathv,
(pglob->gl_pathc +
((flags & GLOB_DOOFFS) ? pglob->gl_offs : 0) +
nfound + 1) *
sizeof (char *));
if (pglob->gl_pathv == NULL)
goto memory_error;
if (flags & GLOB_DOOFFS)
while (pglob->gl_pathc < pglob->gl_offs)
pglob->gl_pathv[pglob->gl_pathc++] = NULL;
for (; names != NULL; names = names->next)
pglob->gl_pathv[pglob->gl_pathc++] = names->name;
pglob->gl_pathv[pglob->gl_pathc] = NULL;
pglob->gl_flags = flags;
if (stream != NULL)
{
int save = errno;
if (__glob_closedir_hook)
(*__glob_closedir_hook) (stream);
else
(void) closedir ((DIR *) stream);
errno = save;
}
return nfound == 0 ? GLOB_NOMATCH : 0;
memory_error:
{
int save = errno;
if (__glob_closedir_hook)
(*__glob_closedir_hook) (stream);
else
(void) closedir ((DIR *) stream);
errno = save;
}
while (names != NULL)
{
if (names->name != NULL)
free ((__ptr_t) names->name);
names = names->next;
}
return GLOB_NOSPACE;
}
#endif /* _LIBC or not __GNU_LIBRARY__. */

97
buildtools/windows/source/make/glob/glob.h
View File

@ -1,97 +0,0 @@
/* Copyright (C) 1991, 1992 Free Software Foundation, Inc.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; see the file COPYING.LIB. If
not, write to the Free Software Foundation, Inc., 675 Mass Ave,
Cambridge, MA 02139, USA. */
#ifndef _GLOB_H
#define _GLOB_H 1
#ifdef __cplusplus
extern "C"
{
#endif
#undef __ptr_t
#if defined (__cplusplus) || (defined (__STDC__) && __STDC__)
#undef __P
#define __P(protos) protos
#define __ptr_t void *
#else /* Not C++ or ANSI C. */
#undef __P
#define __P(protos) ()
#undef const
#define const
#define __ptr_t char *
#endif /* C++ or ANSI C. */
/* Bits set in the FLAGS argument to `glob'. */
#define GLOB_ERR (1 << 0)/* Return on read errors. */
#define GLOB_MARK (1 << 1)/* Append a slash to each name. */
#define GLOB_NOSORT (1 << 2)/* Don't sort the names. */
#define GLOB_DOOFFS (1 << 3)/* Insert PGLOB->gl_offs NULLs. */
#define GLOB_NOCHECK (1 << 4)/* If nothing matches, return the pattern. */
#define GLOB_APPEND (1 << 5)/* Append to results of a previous call. */
#define GLOB_NOESCAPE (1 << 6)/* Backslashes don't quote metacharacters. */
#define GLOB_PERIOD (1 << 7)/* Leading `.' can be matched by metachars. */
#define __GLOB_FLAGS (GLOB_ERR|GLOB_MARK|GLOB_NOSORT|GLOB_DOOFFS| \
GLOB_NOESCAPE|GLOB_NOCHECK|GLOB_APPEND|GLOB_PERIOD)
#if !defined (_POSIX_C_SOURCE) || _POSIX_C_SOURCE < 2 || defined (_BSD_SOURCE)
#define GLOB_MAGCHAR (1 << 8)/* Set in gl_flags if any metachars seen. */
#endif
/* Error returns from `glob'. */
#define GLOB_NOSPACE 1 /* Ran out of memory. */
#define GLOB_ABEND 2 /* Read error. */
#define GLOB_NOMATCH 3 /* No matches found. */
/* Structure describing a globbing run. */
typedef struct
{
int gl_pathc; /* Count of paths matched by the pattern. */
char **gl_pathv; /* List of matched pathnames. */
int gl_offs; /* Slots to reserve in `gl_pathv'. */
int gl_flags; /* Set to FLAGS, maybe | GLOB_MAGCHAR. */
} glob_t;
/* Do glob searching for PATTERN, placing results in PGLOB.
The bits defined above may be set in FLAGS.
If a directory cannot be opened or read and ERRFUNC is not nil,
it is called with the pathname that caused the error, and the
`errno' value from the failing call; if it returns non-zero
`glob' returns GLOB_ABEND; if it returns zero, the error is ignored.
If memory cannot be allocated for PGLOB, GLOB_NOSPACE is returned.
Otherwise, `glob' returns zero. */
extern int glob __P ((const char *__pattern, int __flags,
int (*__errfunc) __P ((const char *, int)),
glob_t *__pglob));
/* Free storage allocated in PGLOB by a previous `glob' call. */
extern void globfree __P ((glob_t *__pglob));
#if !defined (_POSIX_C_SOURCE) || _POSIX_C_SOURCE < 2 || defined (_GNU_SOURCE)
/* If they are not NULL, `glob' uses these functions to read directories. */
extern __ptr_t (*__glob_opendir_hook) __P ((const char *__directory));
extern const char *(*__glob_readdir_hook) __P ((__ptr_t __stream));
extern void (*__glob_closedir_hook) __P ((__ptr_t __stream));
#endif
#ifdef __cplusplus
}
#endif
#endif /* glob.h */

590
buildtools/windows/source/make/implicit.c
View File

@ -1,590 +0,0 @@
/* Implicit rule searching for GNU Make.
Copyright (C) 1988, 89, 90, 91, 92, 93, 94 Free Software Foundation, Inc.
This file is part of GNU Make.
GNU Make is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Make is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Make; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "make.h"
#include "rule.h"
#include "dep.h"
#include "file.h"
static int pattern_search ();
/* For a FILE which has no commands specified, try to figure out some
from the implicit pattern rules.
Returns 1 if a suitable implicit rule was found,
after modifying FILE to contain the appropriate commands and deps,
or returns 0 if no implicit rule was found. */
int
try_implicit_rule (file, depth)
struct file *file;
unsigned int depth;
{
DEBUGPR ("Looking for an implicit rule for `%s'.\n");
/* The order of these searches was previously reversed. My logic now is
that since the non-archive search uses more information in the target
(the archive search omits the archive name), it is more specific and
should come first. */
if (pattern_search (file, 0, depth, 0))
return 1;
#ifndef NO_ARCHIVES
/* If this is an archive member reference, use just the
archive member name to search for implicit rules. */
if (ar_name (file->name))
{
DEBUGPR ("Looking for archive-member implicit rule for `%s'.\n");
if (pattern_search (file, 1, depth, 0))
return 1;
}
#endif
return 0;
}
#define DEBUGP2(msg, a1, a2) \
do { \
if (debug_flag) \
{ print_spaces (depth); printf (msg, a1, a2); fflush (stdout); } \
} while (0)
/* Search the pattern rules for a rule with an existing dependency to make
FILE. If a rule is found, the appropriate commands and deps are put in FILE
and 1 is returned. If not, 0 is returned.
If ARCHIVE is nonzero, FILE->name is of the form "LIB(MEMBER)". A rule for
"(MEMBER)" will be searched for, and "(MEMBER)" will not be chopped up into
directory and filename parts.
If an intermediate file is found by pattern search, the intermediate file
is set up as a target by the recursive call and is also made a dependency
of FILE.
DEPTH is used for debugging messages. */
static int
pattern_search (file, archive, depth, recursions)
struct file *file;
int archive;
unsigned int depth;
unsigned int recursions;
{
/* Filename we are searching for a rule for. */
char *filename = archive ? index (file->name, '(') : file->name;
/* Length of FILENAME. */
unsigned int namelen = strlen (filename);
/* The last slash in FILENAME (or nil if there is none). */
char *lastslash;
/* This is a file-object used as an argument in
recursive calls. It never contains any data
except during a recursive call. */
struct file *intermediate_file = 0;
/* List of dependencies found recursively. */
struct file **intermediate_files
= (struct file **) alloca (max_pattern_deps * sizeof (struct file *));
/* List of the patterns used to find intermediate files. */
char **intermediate_patterns
= (char **) alloca (max_pattern_deps * sizeof (char *));
/* This buffer records all the dependencies actually found for a rule. */
char **found_files = (char **) alloca (max_pattern_deps * sizeof (char *));
/* Number of dep names now in FOUND_FILES. */
unsigned int deps_found;
/* Names of possible dependencies are constructed in this buffer. */
register char *depname = (char *) alloca (namelen + max_pattern_dep_length);
/* The start and length of the stem of FILENAME for the current rule. */
register char *stem;
register unsigned int stemlen;
/* Buffer in which we store all the rules that are possibly applicable. */
struct rule **tryrules
= (struct rule **) alloca (num_pattern_rules * max_pattern_targets
* sizeof (struct rule *));
/* Number of valid elements in TRYRULES. */
unsigned int nrules;
/* The numbers of the rule targets of each rule
in TRYRULES that matched the target file. */
unsigned int *matches
= (unsigned int *) alloca (num_pattern_rules * sizeof (unsigned int));
/* Each element is nonzero if LASTSLASH was used in
matching the corresponding element of TRYRULES. */
char *checked_lastslash
= (char *) alloca (num_pattern_rules * sizeof (char));
/* The index in TRYRULES of the rule we found. */
unsigned int foundrule;
/* Nonzero if should consider intermediate files as dependencies. */
int intermed_ok;
/* Nonzero if we have matched a pattern-rule target
that is not just `%'. */
int specific_rule_matched = 0;
register unsigned int i;
register struct rule *rule;
register struct dep *dep;
char *p;
#ifndef NO_ARCHIVES
if (archive || ar_name (filename))
lastslash = 0;
else
#endif
{
/* Set LASTSLASH to point at the last slash in FILENAME
but not counting any slash at the end. (foo/bar/ counts as
bar/ in directory foo/, not empty in directory foo/bar/.) */
lastslash = rindex (filename, '/');
if (lastslash != 0 && lastslash[1] == '\0')
lastslash = 0;
}
/* First see which pattern rules match this target
and may be considered. Put them in TRYRULES. */
nrules = 0;
for (rule = pattern_rules; rule != 0; rule = rule->next)
{
/* If the pattern rule has deps but no commands, ignore it.
Users cancel built-in rules by redefining them without commands. */
if (rule->deps != 0 && rule->cmds == 0)
continue;
/* If this rule is in use by a parent pattern_search,
don't use it here. */
if (rule->in_use)
{
DEBUGP2 ("Avoiding implicit rule recursion.%s%s\n", "", "");
continue;
}
for (i = 0; rule->targets[i] != 0; ++i)
{
char *target = rule->targets[i];
char *suffix = rule->suffixes[i];
int check_lastslash;
/* Rules that can match any filename and are not terminal
are ignored if we're recursing, so that they cannot be
intermediate files. */
if (recursions > 0 && target[1] == '\0' && !rule->terminal)
continue;
if (rule->lens[i] > namelen)
/* It can't possibly match. */
continue;
/* From the lengths of the filename and the pattern parts,
find the stem: the part of the filename that matches the %. */
stem = filename + (suffix - target - 1);
stemlen = namelen - rule->lens[i] + 1;
/* Set CHECK_LASTSLASH if FILENAME contains a directory
prefix and the target pattern does not contain a slash. */
check_lastslash = lastslash != 0 && index (target, '/') == 0;
if (check_lastslash)
{
/* In that case, don't include the
directory prefix in STEM here. */
unsigned int difference = lastslash - filename + 1;
if (difference > stemlen)
continue;
stemlen -= difference;
stem += difference;
}
/* Check that the rule pattern matches the text before the stem. */
if (check_lastslash)
{
if (stem > (lastslash + 1)
&& strncmp (target, lastslash + 1, stem - lastslash - 1))
continue;
}
else if (stem > filename
&& strncmp (target, filename, stem - filename))
continue;
/* Check that the rule pattern matches the text after the stem.
We could test simply use streq, but this way we compare the
first two characters immediately. This saves time in the very
common case where the first character matches because it is a
period. */
if (*suffix != stem[stemlen]
|| (*suffix != '\0' && !streq (&suffix[1], &stem[(int)stemlen + 1])))
continue;
/* Record if we match a rule that not all filenames will match. */
if (target[1] != '\0')
specific_rule_matched = 1;
/* A rule with no dependencies and no commands exists solely to set
specific_rule_matched when it matches. Don't try to use it. */
if (rule->deps == 0 && rule->cmds == 0)
continue;
/* Record this rule in TRYRULES and the index of the matching
target in MATCHES. If several targets of the same rule match,
that rule will be in TRYRULES more than once. */
tryrules[nrules] = rule;
matches[nrules] = i;
checked_lastslash[nrules] = check_lastslash;
++nrules;
}
}
/* If we have found a matching rule that won't match all filenames,
retroactively reject any non-"terminal" rules that do always match. */
if (specific_rule_matched)
for (i = 0; i < nrules; ++i)
if (!tryrules[i]->terminal)
{
register unsigned int j;
for (j = 0; tryrules[i]->targets[j] != 0; ++j)
if (tryrules[i]->targets[j][1] == '\0')
break;
if (tryrules[i]->targets[j] != 0)
tryrules[i] = 0;
}
/* Try each rule once without intermediate files, then once with them. */
for (intermed_ok = 0; intermed_ok == !!intermed_ok; ++intermed_ok)
{
/* Try each pattern rule till we find one that applies.
If it does, copy the names of its dependencies (as substituted)
and store them in FOUND_FILES. DEPS_FOUND is the number of them. */
for (i = 0; i < nrules; i++)
{
int check_lastslash;
rule = tryrules[i];
/* RULE is nil when we discover that a rule,
already placed in TRYRULES, should not be applied. */
if (rule == 0)
continue;
/* Reject any terminal rules if we're
looking to make intermediate files. */
if (intermed_ok && rule->terminal)
continue;
/* Mark this rule as in use so a recursive
pattern_search won't try to use it. */
rule->in_use = 1;
/* From the lengths of the filename and the matching pattern parts,
find the stem: the part of the filename that matches the %. */
stem = filename
+ (rule->suffixes[matches[i]] - rule->targets[matches[i]]) - 1;
stemlen = namelen - rule->lens[matches[i]] + 1;
check_lastslash = checked_lastslash[i];
if (check_lastslash)
{
stem += lastslash - filename + 1;
stemlen -= (lastslash - filename) + 1;
}
DEBUGP2 ("Trying pattern rule with stem `%.*s'.\n",
(int) stemlen, stem);
/* Try each dependency; see if it "exists". */
deps_found = 0;
for (dep = rule->deps; dep != 0; dep = dep->next)
{
/* If the dependency name has a %, substitute the stem. */
p = index (dep_name (dep), '%');
if (p != 0)
{
register unsigned int i;
if (check_lastslash)
{
/* Copy directory name from the original FILENAME. */
i = lastslash - filename + 1;
bcopy (filename, depname, i);
}
else
i = 0;
bcopy (dep_name (dep), depname + i, p - dep_name (dep));
i += p - dep_name (dep);
bcopy (stem, depname + i, stemlen);
i += stemlen;
strcpy (depname + i, p + 1);
p = depname;
}
else
p = dep_name (dep);
/* P is now the actual dependency name as substituted. */
if (file_impossible_p (p))
{
/* If this dependency has already been ruled
"impossible", then the rule fails and don't
bother trying it on the second pass either
since we know that will fail too. */
DEBUGP2 ("Rejecting impossible %s dependency `%s'.\n",
p == depname ? "implicit" : "rule", p);
tryrules[i] = 0;
break;
}
intermediate_files[deps_found] = 0;
DEBUGP2 ("Trying %s dependency `%s'.\n",
p == depname ? "implicit" : "rule", p);
/* The DEP->changed flag says that this dependency resides in a
nonexistent directory. So we normally can skip looking for
the file. However, if CHECK_LASTSLASH is set, then the
dependency file we are actually looking for is in a different
directory (the one gotten by prepending FILENAME's directory),
so it might actually exist. */
if ((!dep->changed || check_lastslash)
&& (lookup_file (p) != 0 || file_exists_p (p)))
{
found_files[deps_found++] = savestring (p, strlen (p));
continue;
}
/* This code, given FILENAME = "lib/foo.o", dependency name
"lib/foo.c", and VPATH=src, searches for "src/lib/foo.c". */
if (vpath_search (&p, (time_t *) 0))
{
DEBUGP2 ("Found dependency as `%s'.%s\n", p, "");
found_files[deps_found++] = p;
continue;
}
/* We could not find the file in any place we should look.
Try to make this dependency as an intermediate file,
but only on the second pass. */
if (intermed_ok)
{
if (intermediate_file == 0)
intermediate_file
= (struct file *) alloca (sizeof (struct file));
DEBUGP2 ("Looking for a rule with %s file `%s'.\n",
"intermediate", p);
bzero ((char *) intermediate_file, sizeof (struct file));
intermediate_file->name = p;
if (pattern_search (intermediate_file, 0, depth + 1,
recursions + 1))
{
p = savestring (p, strlen (p));
intermediate_patterns[deps_found]
= intermediate_file->name;
intermediate_file->name = p;
intermediate_files[deps_found] = intermediate_file;
intermediate_file = 0;
/* Allocate an extra copy to go in FOUND_FILES,
because every elt of FOUND_FILES is consumed
or freed later. */
found_files[deps_found] = savestring (p, strlen (p));
++deps_found;
continue;
}
/* If we have tried to find P as an intermediate
file and failed, mark that name as impossible
so we won't go through the search again later. */
file_impossible (p);
}
/* A dependency of this rule does not exist.
Therefore, this rule fails. */
break;
}
/* This rule is no longer `in use' for recursive searches. */
rule->in_use = 0;
if (dep != 0)
{
/* This pattern rule does not apply.
If some of its dependencies succeeded,
free the data structure describing them. */
while (deps_found-- > 0)
{
register struct file *f = intermediate_files[deps_found];
free (found_files[deps_found]);
if (f != 0
&& (f->stem < f->name
|| f->stem > f->name + strlen (f->name)))
free (f->stem);
}
}
else
/* This pattern rule does apply. Stop looking for one. */
break;
}
/* If we found an applicable rule without
intermediate files, don't try with them. */
if (i < nrules)
break;
rule = 0;
}
/* RULE is nil if the loop went all the way
through the list and everything failed. */
if (rule == 0)
return 0;
foundrule = i;
/* If we are recursing, store the pattern that matched
FILENAME in FILE->name for use in upper levels. */
if (recursions > 0)
/* Kludge-o-matic */
file->name = rule->targets[matches[foundrule]];
/* FOUND_FILES lists the dependencies for the rule we found.
This includes the intermediate files, if any.
Convert them into entries on the deps-chain of FILE. */
while (deps_found-- > 0)
{
register char *s;
if (intermediate_files[deps_found] != 0)
{
/* If we need to use an intermediate file,
make sure it is entered as a target, with the info that was
found for it in the recursive pattern_search call.
We know that the intermediate file did not already exist as
a target; therefore we can assume that the deps and cmds
of F below are null before we change them. */
struct file *imf = intermediate_files[deps_found];
register struct file *f = enter_file (imf->name);
f->deps = imf->deps;
f->cmds = imf->cmds;
f->stem = imf->stem;
imf = lookup_file (intermediate_patterns[deps_found]);
if (imf != 0 && imf->precious)
f->precious = 1;
f->intermediate = 1;
f->tried_implicit = 1;
for (dep = f->deps; dep != 0; dep = dep->next)
{
dep->file = enter_file (dep->name);
dep->name = 0;
dep->file->tried_implicit |= dep->changed;
}
num_intermediates++;
}
dep = (struct dep *) xmalloc (sizeof (struct dep));
s = found_files[deps_found];
if (recursions == 0)
{
dep->name = 0;
dep->file = lookup_file (s);
if (dep->file == 0)
/* enter_file consumes S's storage. */
dep->file = enter_file (s);
else
/* A copy of S is already allocated in DEP->file->name.
So we can free S. */
free (s);
}
else
{
dep->name = s;
dep->file = 0;
dep->changed = 0;
}
if (intermediate_files[deps_found] == 0 && tryrules[foundrule]->terminal)
{
/* If the file actually existed (was not an intermediate file),
and the rule that found it was a terminal one, then we want
to mark the found file so that it will not have implicit rule
search done for it. If we are not entering a `struct file' for
it now, we indicate this with the `changed' flag. */
if (dep->file == 0)
dep->changed = 1;
else
dep->file->tried_implicit = 1;
}
dep->next = file->deps;
file->deps = dep;
}
if (!checked_lastslash[foundrule])
/* Always allocate new storage, since STEM might be
on the stack for an intermediate file. */
file->stem = savestring (stem, stemlen);
else
{
/* We want to prepend the directory from
the original FILENAME onto the stem. */
file->stem = (char *) xmalloc (((lastslash + 1) - filename)
+ stemlen + 1);
bcopy (filename, file->stem, (lastslash + 1) - filename);
bcopy (stem, file->stem + ((lastslash + 1) - filename), stemlen);
file->stem[((lastslash + 1) - filename) + stemlen] = '\0';
}
file->cmds = rule->cmds;
/* Put the targets other than the one that
matched into FILE's `also_make' member. */
/* If there was only one target, there is nothing to do. */
if (rule->targets[1] != 0)
for (i = 0; rule->targets[i] != 0; ++i)
if (i != matches[foundrule])
{
struct dep *new = (struct dep *) xmalloc (sizeof (struct dep));
new->name = p = (char *) xmalloc (rule->lens[i] + stemlen + 1);
bcopy (rule->targets[i], p,
rule->suffixes[i] - rule->targets[i] - 1);
p += rule->suffixes[i] - rule->targets[i] - 1;
bcopy (stem, p, stemlen);
p += stemlen;
bcopy (rule->suffixes[i], p,
rule->lens[i] - (rule->suffixes[i] - rule->targets[i]) + 1);
new->file = enter_file (new->name);
new->next = file->also_make;
file->also_make = new;
}
return 1;
}

238
buildtools/windows/source/make/install-sh
View File

@ -1,238 +0,0 @@
#! /bin/sh
#
# install - install a program, script, or datafile
# This comes from X11R5.
#
# Calling this script install-sh is preferred over install.sh, to prevent
# `make' implicit rules from creating a file called install from it
# when there is no Makefile.
#
# This script is compatible with the BSD install script, but was written
# from scratch.
#
# set DOITPROG to echo to test this script
# Don't use :- since 4.3BSD and earlier shells don't like it.
doit="${DOITPROG-}"
# put in absolute paths if you don't have them in your path; or use env. vars.
mvprog="${MVPROG-mv}"
cpprog="${CPPROG-cp}"
chmodprog="${CHMODPROG-chmod}"
chownprog="${CHOWNPROG-chown}"
chgrpprog="${CHGRPPROG-chgrp}"
stripprog="${STRIPPROG-strip}"
rmprog="${RMPROG-rm}"
mkdirprog="${MKDIRPROG-mkdir}"
tranformbasename=""
transform_arg=""
instcmd="$mvprog"
chmodcmd="$chmodprog 0755"
chowncmd=""
chgrpcmd=""
stripcmd=""
rmcmd="$rmprog -f"
mvcmd="$mvprog"
src=""
dst=""
dir_arg=""
while [ x"$1" != x ]; do
case $1 in
-c) instcmd="$cpprog"
shift
continue;;
-d) dir_arg=true
shift
continue;;
-m) chmodcmd="$chmodprog $2"
shift
shift
continue;;
-o) chowncmd="$chownprog $2"
shift
shift
continue;;
-g) chgrpcmd="$chgrpprog $2"
shift
shift
continue;;
-s) stripcmd="$stripprog"
shift
continue;;
-t=*) transformarg=`echo $1 | sed 's/-t=//'`
shift
continue;;
-b=*) transformbasename=`echo $1 | sed 's/-b=//'`
shift
continue;;
*) if [ x"$src" = x ]
then
src=$1
else
# this colon is to work around a 386BSD /bin/sh bug
:
dst=$1
fi
shift
continue;;
esac
done
if [ x"$src" = x ]
then
echo "install: no input file specified"
exit 1
else
true
fi
if [ x"$dir_arg" != x ]; then
dst=$src
src=""
if [ -d $dst ]; then
instcmd=:
else
instcmd=mkdir
fi
else
# Waiting for this to be detected by the "$instcmd $src $dsttmp" command
# might cause directories to be created, which would be especially bad
# if $src (and thus $dsttmp) contains '*'.
if [ -f $src -o -d $src ]
then
true
else
echo "install: $src does not exist"
exit 1
fi
if [ x"$dst" = x ]
then
echo "install: no destination specified"
exit 1
else
true
fi
# If destination is a directory, append the input filename; if your system
# does not like double slashes in filenames, you may need to add some logic
if [ -d $dst ]
then
dst="$dst"/`basename $src`
else
true
fi
fi
## this sed command emulates the dirname command
dstdir=`echo $dst | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'`
# Make sure that the destination directory exists.
# this part is taken from Noah Friedman's mkinstalldirs script
# Skip lots of stat calls in the usual case.
if [ ! -d "$dstdir" ]; then
defaultIFS='
'
IFS="${IFS-${defaultIFS}}"
oIFS="${IFS}"
# Some sh's can't handle IFS=/ for some reason.
IFS='%'
set - `echo ${dstdir} | sed -e 's@/@%@g' -e 's@^%@/@'`
IFS="${oIFS}"
pathcomp=''
while [ $# -ne 0 ] ; do
pathcomp="${pathcomp}${1}"
shift
if [ ! -d "${pathcomp}" ] ;
then
$mkdirprog "${pathcomp}"
else
true
fi
pathcomp="${pathcomp}/"
done
fi
if [ x"$dir_arg" != x ]
then
$doit $instcmd $dst &&
if [ x"$chowncmd" != x ]; then $doit $chowncmd $dst; else true ; fi &&
if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dst; else true ; fi &&
if [ x"$stripcmd" != x ]; then $doit $stripcmd $dst; else true ; fi &&
if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dst; else true ; fi
else
# If we're going to rename the final executable, determine the name now.
if [ x"$transformarg" = x ]
then
dstfile=`basename $dst`
else
dstfile=`basename $dst $transformbasename |
sed $transformarg`$transformbasename
fi
# don't allow the sed command to completely eliminate the filename
if [ x"$dstfile" = x ]
then
dstfile=`basename $dst`
else
true
fi
# Make a temp file name in the proper directory.
dsttmp=$dstdir/#inst.$$#
# Move or copy the file name to the temp name
$doit $instcmd $src $dsttmp &&
trap "rm -f ${dsttmp}" 0 &&
# and set any options; do chmod last to preserve setuid bits
# If any of these fail, we abort the whole thing. If we want to
# ignore errors from any of these, just make sure not to ignore
# errors from the above "$doit $instcmd $src $dsttmp" command.
if [ x"$chowncmd" != x ]; then $doit $chowncmd $dsttmp; else true;fi &&
if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dsttmp; else true;fi &&
if [ x"$stripcmd" != x ]; then $doit $stripcmd $dsttmp; else true;fi &&
if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dsttmp; else true;fi &&
# Now rename the file to the real destination.
$doit $rmcmd -f $dstdir/$dstfile &&
$doit $mvcmd $dsttmp $dstdir/$dstfile
fi &&
exit 0

1852
buildtools/windows/source/make/job.c
View File

File diff suppressed because it is too large Load Diff

67
buildtools/windows/source/make/job.h
View File

@ -1,67 +0,0 @@
/* Definitions for managing subprocesses in GNU Make.
Copyright (C) 1992, 1993 Free Software Foundation, Inc.
This file is part of GNU Make.
GNU Make is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Make is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Make; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
/* Structure describing a running or dead child process. */
struct child
{
struct child *next; /* Link in the chain. */
struct file *file; /* File being remade. */
char **environment; /* Environment for commands. */
char **command_lines; /* Array of variable-expanded cmd lines. */
unsigned int command_line; /* Index into above. */
char *command_ptr; /* Ptr into command_lines[command_line]. */
pid_t pid; /* Child process's ID number. */
unsigned int remote:1; /* Nonzero if executing remotely. */
unsigned int noerror:1; /* Nonzero if commands contained a `-'. */
unsigned int good_stdin:1; /* Nonzero if this child has a good stdin. */
unsigned int deleted:1; /* Nonzero if targets have been deleted. */
};
extern struct child *children;
extern void new_job ();
extern void reap_children ();
extern void start_waiting_jobs ();
extern char **construct_command_argv ();
extern void child_execute_job ();
extern void exec_command ();
extern unsigned int job_slots_used;
#ifdef POSIX
extern void unblock_sigs ();
#else
#ifdef HAVE_SIGSETMASK
extern int fatal_signal_mask;
#define unblock_sigs() sigsetmask (0)
#else
#define unblock_sigs()
#endif
#endif
#ifdef NETSCAPE
extern int ns_spawn (char **argv, char **envp, int *exitCode);
#endif

2035
buildtools/windows/source/make/main.c
View File

File diff suppressed because it is too large Load Diff

656
buildtools/windows/source/make/make-stds.texi
View File

@ -1,656 +0,0 @@
@comment This file is included by both standards.texi and make.texinfo.
@comment It was broken out of standards.texi on 1/6/93 by roland.
@node Makefile Conventions
@chapter Makefile Conventions
@comment standards.texi does not print an index, but make.texinfo does.
@cindex makefile, conventions for
@cindex conventions for makefiles
@cindex standards for makefiles
This chapter describes conventions for writing the Makefiles for GNU programs.
@menu
* Makefile Basics::
* Utilities in Makefiles::
* Standard Targets::
* Command Variables::
* Directory Variables::
@end menu
@node Makefile Basics
@section General Conventions for Makefiles
Every Makefile should contain this line:
@example
SHELL = /bin/sh
@end example
@noindent
to avoid trouble on systems where the @code{SHELL} variable might be
inherited from the environment. (This is never a problem with GNU
@code{make}.)
Different @code{make} programs have incompatible suffix lists and
implicit rules, and this sometimes creates confusion or misbehavior. So
it is a good idea to set the suffix list explicitly using only the
suffixes you need in the particular Makefile, like this:
@example
.SUFFIXES:
.SUFFIXES: .c .o
@end example
@noindent
The first line clears out the suffix list, the second introduces all
suffixes which may be subject to implicit rules in this Makefile.
Don't assume that @file{.} is in the path for command execution. When
you need to run programs that are a part of your package during the
make, please make sure that it uses @file{./} if the program is built as
part of the make or @file{$(srcdir)/} if the file is an unchanging part
of the source code. Without one of these prefixes, the current search
path is used.
The distinction between @file{./} and @file{$(srcdir)/} is important
when using the @samp{--srcdir} option to @file{configure}. A rule of
the form:
@smallexample
foo.1 : foo.man sedscript
sed -e sedscript foo.man > foo.1
@end smallexample
@noindent
will fail when the current directory is not the source directory,
because @file{foo.man} and @file{sedscript} are not in the current
directory.
When using GNU @code{make}, relying on @samp{VPATH} to find the source
file will work in the case where there is a single dependency file,
since the @file{make} automatic variable @samp{$<} will represent the
source file wherever it is. (Many versions of @code{make} set @samp{$<}
only in implicit rules.) A makefile target like
@smallexample
foo.o : bar.c
$(CC) -I. -I$(srcdir) $(CFLAGS) -c bar.c -o foo.o
@end smallexample
@noindent
should instead be written as
@smallexample
foo.o : bar.c
$(CC) -I. -I$(srcdir) $(CFLAGS) -c $< -o $@@
@end smallexample
@noindent
in order to allow @samp{VPATH} to work correctly. When the target has
multiple dependencies, using an explicit @samp{$(srcdir)} is the easiest
way to make the rule work well. For example, the target above for
@file{foo.1} is best written as:
@smallexample
foo.1 : foo.man sedscript
sed -e $(srcdir)/sedscript $(srcdir)/foo.man > $@@
@end smallexample
@node Utilities in Makefiles
@section Utilities in Makefiles
Write the Makefile commands (and any shell scripts, such as
@code{configure}) to run in @code{sh}, not in @code{csh}. Don't use any
special features of @code{ksh} or @code{bash}.
The @code{configure} script and the Makefile rules for building and
installation should not use any utilities directly except these:
@example
cat cmp cp echo egrep expr grep
ln mkdir mv pwd rm rmdir sed test touch
@end example
Stick to the generally supported options for these programs. For
example, don't use @samp{mkdir -p}, convenient as it may be, because
most systems don't support it.
The Makefile rules for building and installation can also use compilers
and related programs, but should do so via @code{make} variables so that the
user can substitute alternatives. Here are some of the programs we
mean:
@example
ar bison cc flex install ld lex
make makeinfo ranlib texi2dvi yacc
@end example
Use the following @code{make} variables:
@example
$(AR) $(BISON) $(CC) $(FLEX) $(INSTALL) $(LD) $(LEX)
$(MAKE) $(MAKEINFO) $(RANLIB) $(TEXI2DVI) $(YACC)
@end example
When you use @code{ranlib}, you should make sure nothing bad happens if
the system does not have @code{ranlib}. Arrange to ignore an error
from that command, and print a message before the command to tell the
user that failure of the @code{ranlib} command does not mean a problem.
If you use symbolic links, you should implement a fallback for systems
that don't have symbolic links.
It is ok to use other utilities in Makefile portions (or scripts)
intended only for particular systems where you know those utilities to
exist.
@node Standard Targets
@section Standard Targets for Users
All GNU programs should have the following targets in their Makefiles:
@table @samp
@item all
Compile the entire program. This should be the default target. This
target need not rebuild any documentation files; Info files should
normally be included in the distribution, and DVI files should be made
only when explicitly asked for.
@item install
Compile the program and copy the executables, libraries, and so on to
the file names where they should reside for actual use. If there is a
simple test to verify that a program is properly installed, this target
should run that test.
If possible, write the @code{install} target rule so that it does not
modify anything in the directory where the program was built, provided
@samp{make all} has just been done. This is convenient for building the
program under one user name and installing it under another.
The commands should create all the directories in which files are to be
installed, if they don't already exist. This includes the directories
specified as the values of the variables @code{prefix} and
@code{exec_prefix}, as well as all subdirectories that are needed.
One way to do this is by means of an @code{installdirs} target
as described below.
Use @samp{-} before any command for installing a man page, so that
@code{make} will ignore any errors. This is in case there are systems
that don't have the Unix man page documentation system installed.
The way to install Info files is to copy them into @file{$(infodir)}
with @code{$(INSTALL_DATA)} (@pxref{Command Variables}), and then run
the @code{install-info} program if it is present. @code{install-info}
is a script that edits the Info @file{dir} file to add or update the
menu entry for the given Info file; it will be part of the Texinfo package.
Here is a sample rule to install an Info file:
@comment This example has been carefully formatted for the Make manual.
@comment Please do not reformat it without talking to roland@gnu.ai.mit.edu.
@smallexample
$(infodir)/foo.info: foo.info
# There may be a newer info file in . than in srcdir.
-if test -f foo.info; then d=.; \
else d=$(srcdir); fi; \
$(INSTALL_DATA) $$d/foo.info $@@; \
# Run install-info only if it exists.
# Use `if' instead of just prepending `-' to the
# line so we notice real errors from install-info.
# We use `$(SHELL) -c' because some shells do not
# fail gracefully when there is an unknown command.
if $(SHELL) -c 'install-info --version' \
>/dev/null 2>&1; then \
install-info --infodir=$(infodir) $$d/foo.info; \
else true; fi
@end smallexample
@item uninstall
Delete all the installed files that the @samp{install} target would
create (but not the noninstalled files such as @samp{make all} would
create).
This rule should not modify the directories where compilation is done,
only the directories where files are installed.
@comment The gratuitous blank line here is to make the table look better
@comment in the printed Make manual. Please leave it in.
@item clean
Delete all files from the current directory that are normally created by
building the program. Don't delete the files that record the
configuration. Also preserve files that could be made by building, but
normally aren't because the distribution comes with them.
Delete @file{.dvi} files here if they are not part of the distribution.
@item distclean
Delete all files from the current directory that are created by
configuring or building the program. If you have unpacked the source
and built the program without creating any other files, @samp{make
distclean} should leave only the files that were in the distribution.
@item mostlyclean
Like @samp{clean}, but may refrain from deleting a few files that people
normally don't want to recompile. For example, the @samp{mostlyclean}
target for GCC does not delete @file{libgcc.a}, because recompiling it
is rarely necessary and takes a lot of time.
@item maintainer-clean
Delete almost everything from the current directory that can be
reconstructed with this Makefile. This typically includes everything
deleted by @code{distclean}, plus more: C source files produced by
Bison, tags tables, Info files, and so on.
The reason we say ``almost everything'' is that @samp{make
maintainer-clean} should not delete @file{configure} even if
@file{configure} can be remade using a rule in the Makefile. More
generally, @samp{make maintainer-clean} should not delete anything that
needs to exist in order to run @file{configure} and then begin to build
the program. This is the only exception; @code{maintainer-clean} should
delete everything else that can be rebuilt.
The @samp{maintainer-clean} is intended to be used by a maintainer of
the package, not by ordinary users. You may need special tools to
reconstruct some of the files that @samp{make maintainer-clean} deletes.
Since these files are normally included in the distribution, we don't
take care to make them easy to reconstruct. If you find you need to
unpack the full distribution again, don't blame us.
To help make users aware of this, the commands for
@code{maintainer-clean} should start with these two:
@example
@@echo "This command is intended for maintainers to use;"
@@echo "it deletes files that may require special tools to rebuild."
@end example
@item TAGS
Update a tags table for this program.
@item info
Generate any Info files needed. The best way to write the rules is as
follows:
@smallexample
info: foo.info
foo.info: foo.texi chap1.texi chap2.texi
$(MAKEINFO) $(srcdir)/foo.texi
@end smallexample
@noindent
You must define the variable @code{MAKEINFO} in the Makefile. It should
run the @code{makeinfo} program, which is part of the Texinfo
distribution.
@item dvi
Generate DVI files for all TeXinfo documentation.
For example:
@smallexample
dvi: foo.dvi
foo.dvi: foo.texi chap1.texi chap2.texi
$(TEXI2DVI) $(srcdir)/foo.texi
@end smallexample
@noindent
You must define the variable @code{TEXI2DVI} in the Makefile. It should
run the program @code{texi2dvi}, which is part of the Texinfo
distribution. Alternatively, write just the dependencies, and allow GNU
Make to provide the command.
@item dist
Create a distribution tar file for this program. The tar file should be
set up so that the file names in the tar file start with a subdirectory
name which is the name of the package it is a distribution for. This
name can include the version number.
For example, the distribution tar file of GCC version 1.40 unpacks into
a subdirectory named @file{gcc-1.40}.
The easiest way to do this is to create a subdirectory appropriately
named, use @code{ln} or @code{cp} to install the proper files in it, and
then @code{tar} that subdirectory.
The @code{dist} target should explicitly depend on all non-source files
that are in the distribution, to make sure they are up to date in the
distribution.
@xref{Releases, , Making Releases, standards, GNU Coding Standards}.
@item check
Perform self-tests (if any). The user must build the program before
running the tests, but need not install the program; you should write
the self-tests so that they work when the program is built but not
installed.
@end table
The following targets are suggested as conventional names, for programs
in which they are useful.
@table @code
@item installcheck
Perform installation tests (if any). The user must build and install
the program before running the tests. You should not assume that
@file{$(bindir)} is in the search path.
@item installdirs
It's useful to add a target named @samp{installdirs} to create the
directories where files are installed, and their parent directories.
There is a script called @file{mkinstalldirs} which is convenient for
this; find it in the Texinfo package.@c It's in /gd/gnu/lib/mkinstalldirs.
You can use a rule like this:
@comment This has been carefully formatted to look decent in the Make manual.
@comment Please be sure not to make it extend any further to the right.--roland
@smallexample
# Make sure all installation directories (e.g. $(bindir))
# actually exist by making them if necessary.
installdirs: mkinstalldirs
$(srcdir)/mkinstalldirs $(bindir) $(datadir) \
$(libdir) $(infodir) \
$(mandir)
@end smallexample
This rule should not modify the directories where compilation is done.
It should do nothing but create installation directories.
@end table
@node Command Variables
@section Variables for Specifying Commands
Makefiles should provide variables for overriding certain commands, options,
and so on.
In particular, you should run most utility programs via variables.
Thus, if you use Bison, have a variable named @code{BISON} whose default
value is set with @samp{BISON = bison}, and refer to it with
@code{$(BISON)} whenever you need to use Bison.
File management utilities such as @code{ln}, @code{rm}, @code{mv}, and
so on, need not be referred to through variables in this way, since users
don't need to replace them with other programs.
Each program-name variable should come with an options variable that is
used to supply options to the program. Append @samp{FLAGS} to the
program-name variable name to get the options variable name---for
example, @code{BISONFLAGS}. (The name @code{CFLAGS} is an exception to
this rule, but we keep it because it is standard.) Use @code{CPPFLAGS}
in any compilation command that runs the preprocessor, and use
@code{LDFLAGS} in any compilation command that does linking as well as
in any direct use of @code{ld}.
If there are C compiler options that @emph{must} be used for proper
compilation of certain files, do not include them in @code{CFLAGS}.
Users expect to be able to specify @code{CFLAGS} freely themselves.
Instead, arrange to pass the necessary options to the C compiler
independently of @code{CFLAGS}, by writing them explicitly in the
compilation commands or by defining an implicit rule, like this:
@smallexample
CFLAGS = -g
ALL_CFLAGS = -I. $(CFLAGS)
.c.o:
$(CC) -c $(CPPFLAGS) $(ALL_CFLAGS) $<
@end smallexample
Do include the @samp{-g} option in @code{CFLAGS}, because that is not
@emph{required} for proper compilation. You can consider it a default
that is only recommended. If the package is set up so that it is
compiled with GCC by default, then you might as well include @samp{-O}
in the default value of @code{CFLAGS} as well.
Put @code{CFLAGS} last in the compilation command, after other variables
containing compiler options, so the user can use @code{CFLAGS} to
override the others.
Every Makefile should define the variable @code{INSTALL}, which is the
basic command for installing a file into the system.
Every Makefile should also define the variables @code{INSTALL_PROGRAM}
and @code{INSTALL_DATA}. (The default for each of these should be
@code{$(INSTALL)}.) Then it should use those variables as the commands
for actual installation, for executables and nonexecutables
respectively. Use these variables as follows:
@example
$(INSTALL_PROGRAM) foo $(bindir)/foo
$(INSTALL_DATA) libfoo.a $(libdir)/libfoo.a
@end example
@noindent
Always use a file name, not a directory name, as the second argument of
the installation commands. Use a separate command for each file to be
installed.
@node Directory Variables
@section Variables for Installation Directories
Installation directories should always be named by variables, so it is
easy to install in a nonstandard place. The standard names for these
variables are described below. They are based on a standard filesystem
layout; variants of it are used in SVR4, 4.4BSD, Linux, Ultrix v4, and
other modern operating systems.
These two variables set the root for the installation. All the other
installation directories should be subdirectories of one of these two,
and nothing should be directly installed into these two directories.
@table @samp
@item prefix
A prefix used in constructing the default values of the variables listed
below. The default value of @code{prefix} should be @file{/usr/local}
When building the complete GNU system, the prefix will be empty and
@file{/usr} will be a symbolic link to @file{/}.
@item exec_prefix
A prefix used in constructing the default values of some of the
variables listed below. The default value of @code{exec_prefix} should
be @code{$(prefix)}.
Generally, @code{$(exec_prefix)} is used for directories that contain
machine-specific files (such as executables and subroutine libraries),
while @code{$(prefix)} is used directly for other directories.
@end table
Executable programs are installed in one of the following directories.
@table @samp
@item bindir
The directory for installing executable programs that users can run.
This should normally be @file{/usr/local/bin}, but write it as
@file{$(exec_prefix)/bin}.
@item sbindir
The directory for installing executable programs that can be run from
the shell, but are only generally useful to system administrators. This
should normally be @file{/usr/local/sbin}, but write it as
@file{$(exec_prefix)/sbin}.
@item libexecdir
@comment This paragraph adjusted to avoid overfull hbox --roland 5jul94
The directory for installing executable programs to be run by other
programs rather than by users. This directory should normally be
@file{/usr/local/libexec}, but write it as @file{$(exec_prefix)/libexec}.
@end table
Data files used by the program during its execution are divided into
categories in two ways.
@itemize @bullet
@item
Some files are normally modified by programs; others are never normally
modified (though users may edit some of these).
@item
Some files are architecture-independent and can be shared by all
machines at a site; some are architecture-dependent and can be shared
only by machines of the same kind and operating system; others may never
be shared between two machines.
@end itemize
This makes for six different possibilities. However, we want to
discourage the use of architecture-dependent files, aside from of object
files and libraries. It is much cleaner to make other data files
architecture-independent, and it is generally not hard.
Therefore, here are the variables makefiles should use to specify
directories:
@table @samp
@item datadir
The directory for installing read-only architecture independent data
files. This should normally be @file{/usr/local/share}, but write it as
@file{$(prefix)/share}. As a special exception, see @file{$(infodir)}
and @file{$(includedir)} below.
@item sysconfdir
The directory for installing read-only data files that pertain to a
single machine--that is to say, files for configuring a host. Mailer
and network configuration files, @file{/etc/passwd}, and so forth belong
here. All the files in this directory should be ordinary ASCII text
files. This directory should normally be @file{/usr/local/etc}, but
write it as @file{$(prefix)/etc}.
@c rewritten to avoid overfull hbox --tower
Do not install executables
@c here
in this directory (they probably
belong in @file{$(libexecdir)} or @file{$(sbindir))}. Also do not
install files that are modified in the normal course of their use
(programs whose purpose is to change the configuration of the system
excluded). Those probably belong in @file{$(localstatedir)}.
@item sharedstatedir
The directory for installing architecture-independent data files which
the programs modify while they run. This should normally be
@file{/usr/local/com}, but write it as @file{$(prefix)/com}.
@item localstatedir
The directory for installing data files which the programs modify while
they run, and that pertain to one specific machine. Users should never
need to modify files in this directory to configure the package's
operation; put such configuration information in separate files that go
in @file{datadir} or @file{$(sysconfdir)}. @file{$(localstatedir)}
should normally be @file{/usr/local/var}, but write it as
@file{$(prefix)/var}.
@item libdir
The directory for object files and libraries of object code. Do not
install executables here, they probably belong in @file{$(libexecdir)}
instead. The value of @code{libdir} should normally be
@file{/usr/local/lib}, but write it as @file{$(exec_prefix)/lib}.
@item infodir
The directory for installing the Info files for this package. By
default, it should be @file{/usr/local/info}, but it should be written
as @file{$(prefix)/info}.
@item includedir
@c rewritten to avoid overfull hbox --roland
The directory for installing header files to be included by user
programs with the C @samp{#include} preprocessor directive. This
should normally be @file{/usr/local/include}, but write it as
@file{$(prefix)/include}.
Most compilers other than GCC do not look for header files in
@file{/usr/local/include}. So installing the header files this way is
only useful with GCC. Sometimes this is not a problem because some
libraries are only really intended to work with GCC. But some libraries
are intended to work with other compilers. They should install their
header files in two places, one specified by @code{includedir} and one
specified by @code{oldincludedir}.
@item oldincludedir
The directory for installing @samp{#include} header files for use with
compilers other than GCC. This should normally be @file{/usr/include}.
The Makefile commands should check whether the value of
@code{oldincludedir} is empty. If it is, they should not try to use
it; they should cancel the second installation of the header files.
A package should not replace an existing header in this directory unless
the header came from the same package. Thus, if your Foo package
provides a header file @file{foo.h}, then it should install the header
file in the @code{oldincludedir} directory if either (1) there is no
@file{foo.h} there or (2) the @file{foo.h} that exists came from the Foo
package.
To tell whether @file{foo.h} came from the Foo package, put a magic
string in the file---part of a comment---and grep for that string.
@end table
Unix-style man pages are installed in one of the following:
@table @samp
@item mandir
The directory for installing the man pages (if any) for this package.
It should include the suffix for the proper section of the
manual---usually @samp{1} for a utility. It will normally be
@file{/usr/local/man/man1}, but you should write it as
@file{$(prefix)/man/man1}.
@item man1dir
The directory for installing section 1 man pages.
@item man2dir
The directory for installing section 2 man pages.
@item @dots{}
Use these names instead of @samp{mandir} if the package needs to install man
pages in more than one section of the manual.
@strong{Don't make the primary documentation for any GNU software be a
man page. Write a manual in Texinfo instead. Man pages are just for
the sake of people running GNU software on Unix, which is a secondary
application only.}
@item manext
The file name extension for the installed man page. This should contain
a period followed by the appropriate digit; it should normally be @samp{.1}.
@item man1ext
The file name extension for installed section 1 man pages.
@item man2ext
The file name extension for installed section 2 man pages.
@item @dots{}
Use these names instead of @samp{manext} if the package needs to install man
pages in more than one section of the manual.
@end table
And finally, you should set the following variable:
@table @samp
@item srcdir
The directory for the sources being compiled. The value of this
variable is normally inserted by the @code{configure} shell script.
@end table
For example:
@smallexample
@c I have changed some of the comments here slightly to fix an overfull
@c hbox, so the make manual can format correctly. --roland
# Common prefix for installation directories.
# NOTE: This directory must exist when you start the install.
prefix = /usr/local
exec_prefix = $(prefix)
# Where to put the executable for the command `gcc'.
bindir = $(exec_prefix)/bin
# Where to put the directories used by the compiler.
libexecdir = $(exec_prefix)/libexec
# Where to put the Info files.
infodir = $(prefix)/info
@end smallexample
If your program installs a large number of files into one of the
standard user-specified directories, it might be useful to group them
into a subdirectory particular to that program. If you do this, you
should write the @code{install} rule to create these subdirectories.
Do not expect the user to include the subdirectory name in the value of
any of the variables listed above. The idea of having a uniform set of
variable names for installation directories is to enable the user to
specify the exact same values for several different GNU packages. In
order for this to be useful, all the packages must be designed so that
they will work sensibly when the user does so.

354
buildtools/windows/source/make/make.aux
View File

@ -1,354 +0,0 @@
'xrdef {Overview-title}{Overview of \code {make}}
'xrdef {Overview-pg}{1}
'xrdef {Overview-snt}{Chapter'tie1}
'xrdef {Reading-title}{How to Read This Manual}
'xrdef {Reading-pg}{1}
'xrdef {Reading-snt}{Section'tie1.1}
'xrdef {Bugs-title}{Problems and Bugs}
'xrdef {Bugs-pg}{2}
'xrdef {Bugs-snt}{Section'tie1.2}
'xrdef {Introduction-title}{An Introduction to Makefiles}
'xrdef {Introduction-pg}{5}
'xrdef {Introduction-snt}{Chapter'tie2}
'xrdef {Rule Introduction-title}{What a Rule Looks Like}
'xrdef {Rule Introduction-pg}{5}
'xrdef {Rule Introduction-snt}{Section'tie2.1}
'xrdef {Simple Makefile-title}{A Simple Makefile}
'xrdef {Simple Makefile-pg}{6}
'xrdef {Simple Makefile-snt}{Section'tie2.2}
'xrdef {How Make Works-title}{How \code {make} Processes a Makefile}
'xrdef {How Make Works-pg}{8}
'xrdef {How Make Works-snt}{Section'tie2.3}
'xrdef {Variables Simplify-title}{Variables Make Makefiles Simpler}
'xrdef {Variables Simplify-pg}{9}
'xrdef {Variables Simplify-snt}{Section'tie2.4}
'xrdef {make Deduces-title}{Letting \code {make} Deduce the Commands}
'xrdef {make Deduces-pg}{10}
'xrdef {make Deduces-snt}{Section'tie2.5}
'xrdef {Combine By Dependency-title}{Another Style of Makefile}
'xrdef {Combine By Dependency-pg}{11}
'xrdef {Combine By Dependency-snt}{Section'tie2.6}
'xrdef {Cleanup-title}{Rules for Cleaning the Directory}
'xrdef {Cleanup-pg}{12}
'xrdef {Cleanup-snt}{Section'tie2.7}
'xrdef {Makefiles-title}{Writing Makefiles}
'xrdef {Makefiles-pg}{13}
'xrdef {Makefiles-snt}{Chapter'tie3}
'xrdef {Makefile Contents-title}{What Makefiles Contain}
'xrdef {Makefile Contents-pg}{13}
'xrdef {Makefile Contents-snt}{Section'tie3.1}
'xrdef {Makefile Names-title}{What Name to Give Your Makefile}
'xrdef {Makefile Names-pg}{14}
'xrdef {Makefile Names-snt}{Section'tie3.2}
'xrdef {Include-title}{Including Other Makefiles}
'xrdef {Include-pg}{14}
'xrdef {Include-snt}{Section'tie3.3}
'xrdef {MAKEFILES Variable-title}{The Variable \code {MAKEFILES}}
'xrdef {MAKEFILES Variable-pg}{16}
'xrdef {MAKEFILES Variable-snt}{Section'tie3.4}
'xrdef {Remaking Makefiles-title}{How Makefiles Are Remade}
'xrdef {Remaking Makefiles-pg}{16}
'xrdef {Remaking Makefiles-snt}{Section'tie3.5}
'xrdef {Overriding Makefiles-title}{Overriding Part of Another Makefile}
'xrdef {Overriding Makefiles-pg}{18}
'xrdef {Overriding Makefiles-snt}{Section'tie3.6}
'xrdef {Rules-title}{Writing Rules}
'xrdef {Rules-pg}{19}
'xrdef {Rules-snt}{Chapter'tie4}
'xrdef {Rule Syntax-title}{Rule Syntax}
'xrdef {Rule Syntax-pg}{19}
'xrdef {Rule Syntax-snt}{Section'tie4.1}
'xrdef {Wildcards-title}{Using Wildcard Characters in File Names}
'xrdef {Wildcards-pg}{20}
'xrdef {Wildcards-snt}{Section'tie4.2}
'xrdef {Wildcard Examples-title}{Wildcard Examples}
'xrdef {Wildcard Examples-pg}{21}
'xrdef {Wildcard Examples-snt}{Section'tie4.2.1}
'xrdef {Wildcard Pitfall-title}{Pitfalls of Using Wildcards}
'xrdef {Wildcard Pitfall-pg}{22}
'xrdef {Wildcard Pitfall-snt}{Section'tie4.2.2}
'xrdef {Wildcard Function-title}{The Function \code {wildcard}}
'xrdef {Wildcard Function-pg}{22}
'xrdef {Wildcard Function-snt}{Section'tie4.2.3}
'xrdef {Directory Search-title}{Searching Directories for Dependencies}
'xrdef {Directory Search-pg}{23}
'xrdef {Directory Search-snt}{Section'tie4.3}
'xrdef {General Search-title}{\code {VPATH}: Search Path for All Dependencies}
'xrdef {General Search-pg}{23}
'xrdef {General Search-snt}{Section'tie4.3.1}
'xrdef {Selective Search-title}{The \code {vpath} Directive}
'xrdef {Selective Search-pg}{24}
'xrdef {Selective Search-snt}{Section'tie4.3.2}
'xrdef {Commands/Search-title}{Writing Shell Commands with Directory Search}
'xrdef {Commands/Search-pg}{26}
'xrdef {Commands/Search-snt}{Section'tie4.3.3}
'xrdef {Implicit/Search-title}{Directory Search and Implicit Rules}
'xrdef {Implicit/Search-pg}{27}
'xrdef {Implicit/Search-snt}{Section'tie4.3.4}
'xrdef {Libraries/Search-title}{Directory Search for Link Libraries}
'xrdef {Libraries/Search-pg}{27}
'xrdef {Libraries/Search-snt}{Section'tie4.3.5}
'xrdef {Phony Targets-title}{Phony Targets}
'xrdef {Phony Targets-pg}{28}
'xrdef {Phony Targets-snt}{Section'tie4.4}
'xrdef {Force Targets-title}{Rules without Commands or Dependencies}
'xrdef {Force Targets-pg}{30}
'xrdef {Force Targets-snt}{Section'tie4.5}
'xrdef {Empty Targets-title}{Empty Target Files to Record Events}
'xrdef {Empty Targets-pg}{30}
'xrdef {Empty Targets-snt}{Section'tie4.6}
'xrdef {Special Targets-title}{Special Built-in Target Names}
'xrdef {Special Targets-pg}{31}
'xrdef {Special Targets-snt}{Section'tie4.7}
'xrdef {Multiple Targets-title}{Multiple Targets in a Rule}
'xrdef {Multiple Targets-pg}{32}
'xrdef {Multiple Targets-snt}{Section'tie4.8}
'xrdef {Multiple Rules-title}{Multiple Rules for One Target}
'xrdef {Multiple Rules-pg}{33}
'xrdef {Multiple Rules-snt}{Section'tie4.9}
'xrdef {Static Pattern-title}{Static Pattern Rules}
'xrdef {Static Pattern-pg}{34}
'xrdef {Static Pattern-snt}{Section'tie4.10}
'xrdef {Static Usage-title}{Syntax of Static Pattern Rules}
'xrdef {Static Usage-pg}{34}
'xrdef {Static Usage-snt}{Section'tie4.10.1}
'xrdef {Static versus Implicit-title}{Static Pattern Rules versus Implicit Rules}
'xrdef {Static versus Implicit-pg}{36}
'xrdef {Static versus Implicit-snt}{Section'tie4.10.2}
'xrdef {Double-Colon-title}{Double-Colon Rules}
'xrdef {Double-Colon-pg}{37}
'xrdef {Double-Colon-snt}{Section'tie4.11}
'xrdef {Automatic Dependencies-title}{Generating Dependencies Automatically}
'xrdef {Automatic Dependencies-pg}{37}
'xrdef {Automatic Dependencies-snt}{Section'tie4.12}
'xrdef {Commands-title}{Writing the Commands in Rules}
'xrdef {Commands-pg}{41}
'xrdef {Commands-snt}{Chapter'tie5}
'xrdef {Echoing-title}{Command Echoing}
'xrdef {Echoing-pg}{41}
'xrdef {Echoing-snt}{Section'tie5.1}
'xrdef {Execution-title}{Command Execution}
'xrdef {Execution-pg}{42}
'xrdef {Execution-snt}{Section'tie5.2}
'xrdef {Parallel-title}{Parallel Execution}
'xrdef {Parallel-pg}{42}
'xrdef {Parallel-snt}{Section'tie5.3}
'xrdef {Errors-title}{Errors in Commands}
'xrdef {Errors-pg}{44}
'xrdef {Errors-snt}{Section'tie5.4}
'xrdef {Interrupts-title}{Interrupting or Killing \code {make}}
'xrdef {Interrupts-pg}{45}
'xrdef {Interrupts-snt}{Section'tie5.5}
'xrdef {Recursion-title}{Recursive Use of \code {make}}
'xrdef {Recursion-pg}{46}
'xrdef {Recursion-snt}{Section'tie5.6}
'xrdef {MAKE Variable-title}{How the \code {MAKE} Variable Works}
'xrdef {MAKE Variable-pg}{46}
'xrdef {MAKE Variable-snt}{Section'tie5.6.1}
'xrdef {Variables/Recursion-title}{Communicating Variables to a Sub-\code {make}}
'xrdef {Variables/Recursion-pg}{47}
'xrdef {Variables/Recursion-snt}{Section'tie5.6.2}
'xrdef {Options/Recursion-title}{Communicating Options to a Sub-\code {make}}
'xrdef {Options/Recursion-pg}{50}
'xrdef {Options/Recursion-snt}{Section'tie5.6.3}
'xrdef {-w Option-title}{The \samp {--print-directory} Option}
'xrdef {-w Option-pg}{52}
'xrdef {-w Option-snt}{Section'tie5.6.4}
'xrdef {Sequences-title}{Defining Canned Command Sequences}
'xrdef {Sequences-pg}{52}
'xrdef {Sequences-snt}{Section'tie5.7}
'xrdef {Empty Commands-title}{Using Empty Commands}
'xrdef {Empty Commands-pg}{54}
'xrdef {Empty Commands-snt}{Section'tie5.8}
'xrdef {Using Variables-title}{How to Use Variables}
'xrdef {Using Variables-pg}{55}
'xrdef {Using Variables-snt}{Chapter'tie6}
'xrdef {Reference-title}{Basics of Variable References}
'xrdef {Reference-pg}{55}
'xrdef {Reference-snt}{Section'tie6.1}
'xrdef {Flavors-title}{The Two Flavors of Variables}
'xrdef {Flavors-pg}{56}
'xrdef {Flavors-snt}{Section'tie6.2}
'xrdef {Advanced-title}{Advanced Features for Reference to Variables}
'xrdef {Advanced-pg}{59}
'xrdef {Advanced-snt}{Section'tie6.3}
'xrdef {Substitution Refs-title}{Substitution References}
'xrdef {Substitution Refs-pg}{59}
'xrdef {Substitution Refs-snt}{Section'tie6.3.1}
'xrdef {Computed Names-title}{Computed Variable Names}
'xrdef {Computed Names-pg}{60}
'xrdef {Computed Names-snt}{Section'tie6.3.2}
'xrdef {Values-title}{How Variables Get Their Values}
'xrdef {Values-pg}{63}
'xrdef {Values-snt}{Section'tie6.4}
'xrdef {Setting-title}{Setting Variables}
'xrdef {Setting-pg}{63}
'xrdef {Setting-snt}{Section'tie6.5}
'xrdef {Appending-title}{Appending More Text to Variables}
'xrdef {Appending-pg}{64}
'xrdef {Appending-snt}{Section'tie6.6}
'xrdef {Override Directive-title}{The \code {override} Directive}
'xrdef {Override Directive-pg}{66}
'xrdef {Override Directive-snt}{Section'tie6.7}
'xrdef {Defining-title}{Defining Variables Verbatim}
'xrdef {Defining-pg}{67}
'xrdef {Defining-snt}{Section'tie6.8}
'xrdef {Environment-title}{Variables from the Environment}
'xrdef {Environment-pg}{68}
'xrdef {Environment-snt}{Section'tie6.9}
'xrdef {Conditionals-title}{Conditional Parts of Makefiles}
'xrdef {Conditionals-pg}{71}
'xrdef {Conditionals-snt}{Chapter'tie7}
'xrdef {Conditional Example-title}{Example of a Conditional}
'xrdef {Conditional Example-pg}{71}
'xrdef {Conditional Example-snt}{Section'tie7.1}
'xrdef {Conditional Syntax-title}{Syntax of Conditionals}
'xrdef {Conditional Syntax-pg}{72}
'xrdef {Conditional Syntax-snt}{Section'tie7.2}
'xrdef {Testing Flags-title}{Conditionals that Test Flags}
'xrdef {Testing Flags-pg}{75}
'xrdef {Testing Flags-snt}{Section'tie7.3}
'xrdef {Functions-title}{Functions for Transforming Text}
'xrdef {Functions-pg}{77}
'xrdef {Functions-snt}{Chapter'tie8}
'xrdef {Syntax of Functions-title}{Function Call Syntax}
'xrdef {Syntax of Functions-pg}{77}
'xrdef {Syntax of Functions-snt}{Section'tie8.1}
'xrdef {Text Functions-title}{Functions for String Substitution and Analysis}
'xrdef {Text Functions-pg}{78}
'xrdef {Text Functions-snt}{Section'tie8.2}
'xrdef {Filename Functions-title}{Functions for File Names}
'xrdef {Filename Functions-pg}{81}
'xrdef {Filename Functions-snt}{Section'tie8.3}
'xrdef {Foreach Function-title}{The \code {foreach} Function}
'xrdef {Foreach Function-pg}{83}
'xrdef {Foreach Function-snt}{Section'tie8.4}
'xrdef {Origin Function-title}{The \code {origin} Function}
'xrdef {Origin Function-pg}{85}
'xrdef {Origin Function-snt}{Section'tie8.5}
'xrdef {Shell Function-title}{The \code {shell} Function}
'xrdef {Shell Function-pg}{87}
'xrdef {Shell Function-snt}{Section'tie8.6}
'xrdef {Running-title}{How to Run \code {make}}
'xrdef {Running-pg}{89}
'xrdef {Running-snt}{Chapter'tie9}
'xrdef {Makefile Arguments-title}{Arguments to Specify the Makefile}
'xrdef {Makefile Arguments-pg}{89}
'xrdef {Makefile Arguments-snt}{Section'tie9.1}
'xrdef {Goals-title}{Arguments to Specify the Goals}
'xrdef {Goals-pg}{90}
'xrdef {Goals-snt}{Section'tie9.2}
'xrdef {Instead of Execution-title}{Instead of Executing the Commands}
'xrdef {Instead of Execution-pg}{91}
'xrdef {Instead of Execution-snt}{Section'tie9.3}
'xrdef {Avoiding Compilation-title}{Avoiding Recompilation of Some Files}
'xrdef {Avoiding Compilation-pg}{93}
'xrdef {Avoiding Compilation-snt}{Section'tie9.4}
'xrdef {Overriding-title}{Overriding Variables}
'xrdef {Overriding-pg}{94}
'xrdef {Overriding-snt}{Section'tie9.5}
'xrdef {Testing-title}{Testing the Compilation of a Program}
'xrdef {Testing-pg}{95}
'xrdef {Testing-snt}{Section'tie9.6}
'xrdef {Options Summary-title}{Summary of Options}
'xrdef {Options Summary-pg}{95}
'xrdef {Options Summary-snt}{Section'tie9.7}
'xrdef {Implicit Rules-title}{Using Implicit Rules}
'xrdef {Implicit Rules-pg}{101}
'xrdef {Implicit Rules-snt}{Chapter'tie10}
'xrdef {Using Implicit-title}{Using Implicit Rules}
'xrdef {Using Implicit-pg}{101}
'xrdef {Using Implicit-snt}{Section'tie10.1}
'xrdef {Catalogue of Rules-title}{Catalogue of Implicit Rules}
'xrdef {Catalogue of Rules-pg}{103}
'xrdef {Catalogue of Rules-snt}{Section'tie10.2}
'xrdef {Implicit Variables-title}{Variables Used by Implicit Rules}
'xrdef {Implicit Variables-pg}{106}
'xrdef {Implicit Variables-snt}{Section'tie10.3}
'xrdef {Chained Rules-title}{Chains of Implicit Rules}
'xrdef {Chained Rules-pg}{108}
'xrdef {Chained Rules-snt}{Section'tie10.4}
'xrdef {Pattern Rules-title}{Defining and Redefining Pattern Rules}
'xrdef {Pattern Rules-pg}{109}
'xrdef {Pattern Rules-snt}{Section'tie10.5}
'xrdef {Pattern Intro-title}{Introduction to Pattern Rules}
'xrdef {Pattern Intro-pg}{110}
'xrdef {Pattern Intro-snt}{Section'tie10.5.1}
'xrdef {Pattern Examples-title}{Pattern Rule Examples}
'xrdef {Pattern Examples-pg}{111}
'xrdef {Pattern Examples-snt}{Section'tie10.5.2}
'xrdef {Automatic-title}{Automatic Variables}
'xrdef {Automatic-pg}{112}
'xrdef {Automatic-snt}{Section'tie10.5.3}
'xrdef {Pattern Match-title}{How Patterns Match}
'xrdef {Pattern Match-pg}{114}
'xrdef {Pattern Match-snt}{Section'tie10.5.4}
'xrdef {Match-Anything Rules-title}{Match-Anything Pattern Rules}
'xrdef {Match-Anything Rules-pg}{115}
'xrdef {Match-Anything Rules-snt}{Section'tie10.5.5}
'xrdef {Canceling Rules-title}{Canceling Implicit Rules}
'xrdef {Canceling Rules-pg}{116}
'xrdef {Canceling Rules-snt}{Section'tie10.5.6}
'xrdef {Last Resort-title}{Defining Last-Resort Default Rules}
'xrdef {Last Resort-pg}{116}
'xrdef {Last Resort-snt}{Section'tie10.6}
'xrdef {Suffix Rules-title}{Old-Fashioned Suffix Rules}
'xrdef {Suffix Rules-pg}{117}
'xrdef {Suffix Rules-snt}{Section'tie10.7}
'xrdef {Search Algorithm-title}{Implicit Rule Search Algorithm}
'xrdef {Search Algorithm-pg}{119}
'xrdef {Search Algorithm-snt}{Section'tie10.8}
'xrdef {Archives-title}{Using \code {make} to Update Archive Files}
'xrdef {Archives-pg}{121}
'xrdef {Archives-snt}{Chapter'tie11}
'xrdef {Archive Members-title}{Archive Members as Targets}
'xrdef {Archive Members-pg}{121}
'xrdef {Archive Members-snt}{Section'tie11.1}
'xrdef {Archive Update-title}{Implicit Rule for Archive Member Targets}
'xrdef {Archive Update-pg}{122}
'xrdef {Archive Update-snt}{Section'tie11.2}
'xrdef {Archive Symbols-title}{Updating Archive Symbol Directories}
'xrdef {Archive Symbols-pg}{123}
'xrdef {Archive Symbols-snt}{Section'tie11.2.1}
'xrdef {Archive Pitfalls-title}{Dangers When Using Archives}
'xrdef {Archive Pitfalls-pg}{123}
'xrdef {Archive Pitfalls-snt}{Section'tie11.3}
'xrdef {Archive Suffix Rules-title}{Suffix Rules for Archive Files}
'xrdef {Archive Suffix Rules-pg}{124}
'xrdef {Archive Suffix Rules-snt}{Section'tie11.4}
'xrdef {Features-title}{Features of GNU \code {make}}
'xrdef {Features-pg}{125}
'xrdef {Features-snt}{Chapter'tie12}
'xrdef {Missing-title}{Incompatibilities and Missing Features}
'xrdef {Missing-pg}{129}
'xrdef {Missing-snt}{Chapter'tie13}
'xrdef {Makefile Conventions-title}{Makefile Conventions}
'xrdef {Makefile Conventions-pg}{131}
'xrdef {Makefile Conventions-snt}{Chapter'tie14}
'xrdef {Makefile Basics-title}{General Conventions for Makefiles}
'xrdef {Makefile Basics-pg}{131}
'xrdef {Makefile Basics-snt}{Section'tie14.1}
'xrdef {Utilities in Makefiles-title}{Utilities in Makefiles}
'xrdef {Utilities in Makefiles-pg}{132}
'xrdef {Utilities in Makefiles-snt}{Section'tie14.2}
'xrdef {Standard Targets-title}{Standard Targets for Users}
'xrdef {Standard Targets-pg}{133}
'xrdef {Standard Targets-snt}{Section'tie14.3}
'xrdef {Command Variables-title}{Variables for Specifying Commands}
'xrdef {Command Variables-pg}{136}
'xrdef {Command Variables-snt}{Section'tie14.4}
'xrdef {Directory Variables-title}{Variables for Installation Directories}
'xrdef {Directory Variables-pg}{138}
'xrdef {Directory Variables-snt}{Section'tie14.5}
'xrdef {Quick Reference-title}{Quick Reference}
'xrdef {Quick Reference-pg}{143}
'xrdef {Quick Reference-snt}{Appendix'tie'char65{}}
'xrdef {Complex Makefile-title}{Complex Makefile Example}
'xrdef {Complex Makefile-pg}{149}
'xrdef {Complex Makefile-snt}{Appendix'tie'char66{}}
'xrdef {Concept Index-title}{Index of Concepts}
'xrdef {Concept Index-pg}{155}
'xrdef {Concept Index-snt}{}
'xrdef {Name Index-title}{Index of Functions, Variables, & Directives}
'xrdef {Name Index-pg}{165}
'xrdef {Name Index-snt}{}

701
buildtools/windows/source/make/make.cp
View File

@ -1,701 +0,0 @@
\entry {POSIX}{1}{POSIX}
\entry {IEEE Standard 1003.2}{1}{IEEE Standard 1003.2}
\entry {standards conformance}{1}{standards conformance}
\entry {reporting bugs}{2}{reporting bugs}
\entry {bugs, reporting}{2}{bugs, reporting}
\entry {problems and bugs, reporting}{2}{problems and bugs, reporting}
\entry {makefile}{5}{makefile}
\entry {recompilation}{5}{recompilation}
\entry {editor}{5}{editor}
\entry {rule, introduction to}{5}{rule, introduction to}
\entry {makefile rule parts}{5}{makefile rule parts}
\entry {parts of makefile rule}{5}{parts of makefile rule}
\entry {targets, introduction to}{5}{targets, introduction to}
\entry {dependencies, introduction to}{5}{dependencies, introduction to}
\entry {commands, introduction to}{5}{commands, introduction to}
\entry {tabs in rules}{5}{tabs in rules}
\entry {simple makefile}{6}{simple makefile}
\entry {makefile, simple}{6}{makefile, simple}
\entry {continuation lines}{7}{continuation lines}
\entry {{\tt\indexbackslash } (backslash), for continuation lines}{7}{\code {{\tt\indexbackslash }} (backslash), for continuation lines}
\entry {backslash ({\tt\indexbackslash }), for continuation lines}{7}{backslash (\code {{\tt\indexbackslash }}), for continuation lines}
\entry {quoting newline, in makefile}{7}{quoting newline, in makefile}
\entry {newline, quoting, in makefile}{7}{newline, quoting, in makefile}
\entry {shell command}{8}{shell command}
\entry {clean target}{8}{\code {clean} target}
\entry {rm (shell command)}{8}{\code {rm} (shell command)}
\entry {processing a makefile}{8}{processing a makefile}
\entry {makefile, how make processes}{8}{makefile, how \code {make} processes}
\entry {default goal}{8}{default goal}
\entry {goal, default}{8}{goal, default}
\entry {goal}{8}{goal}
\entry {relinking}{9}{relinking}
\entry {variables}{9}{variables}
\entry {simplifying with variables}{9}{simplifying with variables}
\entry {objects}{9}{\code {objects}}
\entry {OBJECTS}{9}{\code {OBJECTS}}
\entry {objs}{9}{\code {objs}}
\entry {OBJS}{9}{\code {OBJS}}
\entry {obj}{9}{\code {obj}}
\entry {OBJ}{9}{\code {OBJ}}
\entry {deducing commands (implicit rules)}{10}{deducing commands (implicit rules)}
\entry {implicit rule, introduction to}{10}{implicit rule, introduction to}
\entry {rule, implicit, introduction to}{10}{rule, implicit, introduction to}
\entry {combining rules by dependency}{11}{combining rules by dependency}
\entry {cleaning up}{12}{cleaning up}
\entry {removing, to clean up}{12}{removing, to clean up}
\entry {clean target}{12}{\code {clean} target}
\entry {makefile, how to write}{13}{makefile, how to write}
\entry {rule, explicit, definition of}{13}{rule, explicit, definition of}
\entry {explicit rule, definition of}{13}{explicit rule, definition of}
\entry {rule, implicit, definition of}{13}{rule, implicit, definition of}
\entry {implicit rule, definition of}{13}{implicit rule, definition of}
\entry {variable definition}{13}{variable definition}
\entry {directive}{13}{directive}
\entry {comments, in makefile}{13}{comments, in makefile}
\entry {# (comments), in makefile}{13}{\code {#} (comments), in makefile}
\entry {makefile name}{14}{makefile name}
\entry {name of makefile}{14}{name of makefile}
\entry {default makefile name}{14}{default makefile name}
\entry {file name of makefile}{14}{file name of makefile}
\entry {README}{14}{\code {README}}
\entry {-f}{14}{\code {-f}}
\entry {--file}{14}{\code {--file}}
\entry {--makefile}{14}{\code {--makefile}}
\entry {specifying makefile name}{14}{specifying makefile name}
\entry {makefile name, how to specify}{14}{makefile name, how to specify}
\entry {name of makefile, how to specify}{14}{name of makefile, how to specify}
\entry {file name of makefile, how to specify}{14}{file name of makefile, how to specify}
\entry {including other makefiles}{14}{including other makefiles}
\entry {makefile, including}{14}{makefile, including}
\entry {shell file name pattern (in include)}{14}{shell file name pattern (in \code {include})}
\entry {shell wildcards (in include)}{14}{shell wildcards (in \code {include})}
\entry {wildcard, in include}{14}{wildcard, in \code {include}}
\entry {dependencies, automatic generation}{15}{dependencies, automatic generation}
\entry {automatic generation of dependencies}{15}{automatic generation of dependencies}
\entry {generating dependencies automatically}{15}{generating dependencies automatically}
\entry {-I}{15}{\code {-I}}
\entry {--include-dir}{15}{\code {--include-dir}}
\entry {makefile, and MAKEFILES variable}{16}{makefile, and \code {MAKEFILES} variable}
\entry {including (MAKEFILES variable)}{16}{including (\code {MAKEFILES} variable)}
\entry {recursion, and MAKEFILES variable}{16}{recursion, and \code {MAKEFILES} variable}
\entry {updating makefiles}{16}{updating makefiles}
\entry {remaking makefiles}{16}{remaking makefiles}
\entry {makefile, remaking of}{16}{makefile, remaking of}
\entry {overriding makefiles}{18}{overriding makefiles}
\entry {makefile, overriding}{18}{makefile, overriding}
\entry {match-anything rule, used to override}{18}{match-anything rule, used to override}
\entry {writing rules}{19}{writing rules}
\entry {rule, how to write}{19}{rule, how to write}
\entry {target}{19}{target}
\entry {dependency}{19}{dependency}
\entry {default goal}{19}{default goal}
\entry {goal, default}{19}{goal, default}
\entry {rule syntax}{19}{rule syntax}
\entry {syntax of rules}{19}{syntax of rules}
\entry {targets}{19}{targets}
\entry {rule targets}{19}{rule targets}
\entry {commands}{19}{commands}
\entry {tab character (in commands)}{19}{tab character (in commands)}
\entry {dollar sign ($), in rules}{20}{dollar sign (\code {$}), in rules}
\entry {$, in rules}{20}{\code {$}, in rules}
\entry {rule, and $}{20}{rule, and \code {$}}
\entry {dependencies}{20}{dependencies}
\entry {rule dependencies}{20}{rule dependencies}
\entry {wildcard}{20}{wildcard}
\entry {file name with wildcards}{20}{file name with wildcards}
\entry {globbing (wildcards)}{20}{globbing (wildcards)}
\entry {* (wildcard character)}{20}{\code {*} (wildcard character)}
\entry {? (wildcard character)}{20}{\code {?} (wildcard character)}
\entry {[...{}] (wildcard characters)}{20}{\code {[\dots {}]} (wildcard characters)}
\entry {{\tt\char'176} (tilde)}{20}{\code {{\tt\char'176}} (tilde)}
\entry {tilde ({\tt\char'176})}{20}{tilde (\code {{\tt\char'176}})}
\entry {home directory}{20}{home directory}
\entry {rm (shell command)}{21}{\code {rm} (shell command)}
\entry {print target}{21}{\code {print} target}
\entry {lpr (shell command)}{21}{\code {lpr} (shell command)}
\entry {touch (shell command)}{21}{\code {touch} (shell command)}
\entry {wildcard pitfalls}{22}{wildcard pitfalls}
\entry {pitfalls of wildcards}{22}{pitfalls of wildcards}
\entry {mistakes with wildcards}{22}{mistakes with wildcards}
\entry {errors with wildcards}{22}{errors with wildcards}
\entry {problems with wildcards}{22}{problems with wildcards}
\entry {vpath}{23}{vpath}
\entry {search path for dependencies (VPATH)}{23}{search path for dependencies (\code {VPATH})}
\entry {directory search (VPATH)}{23}{directory search (\code {VPATH})}
\entry {%, quoting in vpath}{25}{\code {%}, quoting in \code {vpath}}
\entry {%, quoting with {\tt\indexbackslash } (backslash)}{25}{\code {%}, quoting with \code {{\tt\indexbackslash }} (backslash)}
\entry {{\tt\indexbackslash } (backslash), to quote %}{25}{\code {{\tt\indexbackslash }} (backslash), to quote \code {%}}
\entry {backslash ({\tt\indexbackslash }), to quote %}{25}{backslash (\code {{\tt\indexbackslash }}), to quote \code {%}}
\entry {quoting %, in vpath}{25}{quoting \code {%}, in \code {vpath}}
\entry {shell command, and directory search}{26}{shell command, and directory search}
\entry {directory search (VPATH), and shell commands}{26}{directory search (\code {VPATH}), and shell commands}
\entry {VPATH, and implicit rules}{27}{\code {VPATH}, and implicit rules}
\entry {directory search (VPATH), and implicit rules}{27}{directory search (\code {VPATH}), and implicit rules}
\entry {search path for dependencies (VPATH), and implicit rules}{27}{search path for dependencies (\code {VPATH}), and implicit rules}
\entry {implicit rule, and directory search}{27}{implicit rule, and directory search}
\entry {implicit rule, and VPATH}{27}{implicit rule, and \code {VPATH}}
\entry {rule, implicit, and directory search}{27}{rule, implicit, and directory search}
\entry {rule, implicit, and VPATH}{27}{rule, implicit, and \code {VPATH}}
\entry {link libraries, and directory search}{27}{link libraries, and directory search}
\entry {libraries for linking, directory search}{27}{libraries for linking, directory search}
\entry {directory search (VPATH), and link libraries}{27}{directory search (\code {VPATH}), and link libraries}
\entry {VPATH, and link libraries}{27}{\code {VPATH}, and link libraries}
\entry {search path for dependencies (VPATH), and link libraries}{27}{search path for dependencies (\code {VPATH}), and link libraries}
\entry {-l (library search)}{27}{\code {-l} (library search)}
\entry {phony targets}{28}{phony targets}
\entry {targets, phony}{28}{targets, phony}
\entry {targets without a file}{28}{targets without a file}
\entry {rm (shell command)}{28}{\code {rm} (shell command)}
\entry {force targets}{30}{force targets}
\entry {targets, force}{30}{targets, force}
\entry {FORCE}{30}{\code {FORCE}}
\entry {rule, no commands or dependencies}{30}{rule, no commands or dependencies}
\entry {empty targets}{30}{empty targets}
\entry {targets, empty}{30}{targets, empty}
\entry {recording events with empty targets}{30}{recording events with empty targets}
\entry {print target}{30}{\code {print} target}
\entry {lpr (shell command)}{30}{\code {lpr} (shell command)}
\entry {touch (shell command)}{30}{\code {touch} (shell command)}
\entry {special targets}{31}{special targets}
\entry {built-in special targets}{31}{built-in special targets}
\entry {targets, built-in special}{31}{targets, built-in special}
\entry {precious targets}{31}{precious targets}
\entry {preserving with .PRECIOUS}{31}{preserving with \code {.PRECIOUS}}
\entry {multiple targets}{32}{multiple targets}
\entry {several targets in a rule}{32}{several targets in a rule}
\entry {targets, multiple}{32}{targets, multiple}
\entry {rule, with multiple targets}{32}{rule, with multiple targets}
\entry {multiple rules for one target}{33}{multiple rules for one target}
\entry {several rules for one target}{33}{several rules for one target}
\entry {rule, multiple for one target}{33}{rule, multiple for one target}
\entry {target, multiple rules for one}{33}{target, multiple rules for one}
\entry {static pattern rule}{34}{static pattern rule}
\entry {rule, static pattern}{34}{rule, static pattern}
\entry {pattern rules, static (not implicit)}{34}{pattern rules, static (not implicit)}
\entry {varying dependencies}{34}{varying dependencies}
\entry {dependencies, varying (static pattern)}{34}{dependencies, varying (static pattern)}
\entry {static pattern rule, syntax of}{34}{static pattern rule, syntax of}
\entry {pattern rules, static, syntax of}{34}{pattern rules, static, syntax of}
\entry {target pattern, static (not implicit)}{35}{target pattern, static (not implicit)}
\entry {stem}{35}{stem}
\entry {dependency pattern, static (not implicit)}{35}{dependency pattern, static (not implicit)}
\entry {%, quoting in static pattern}{35}{\code {%}, quoting in static pattern}
\entry {%, quoting with {\tt\indexbackslash } (backslash)}{35}{\code {%}, quoting with \code {{\tt\indexbackslash }} (backslash)}
\entry {{\tt\indexbackslash } (backslash), to quote %}{35}{\code {{\tt\indexbackslash }} (backslash), to quote \code {%}}
\entry {backslash ({\tt\indexbackslash }), to quote %}{35}{backslash (\code {{\tt\indexbackslash }}), to quote \code {%}}
\entry {quoting %, in static pattern}{35}{quoting \code {%}, in static pattern}
\entry {rule, static pattern versus implicit}{36}{rule, static pattern versus implicit}
\entry {static pattern rule, versus implicit}{36}{static pattern rule, versus implicit}
\entry {double-colon rules}{37}{double-colon rules}
\entry {rule, double-colon (::)}{37}{rule, double-colon (\code {::})}
\entry {multiple rules for one target (::)}{37}{multiple rules for one target (\code {::})}
\entry {:: rules (double-colon)}{37}{\code {::} rules (double-colon)}
\entry {dependencies, automatic generation}{37}{dependencies, automatic generation}
\entry {automatic generation of dependencies}{37}{automatic generation of dependencies}
\entry {generating dependencies automatically}{37}{generating dependencies automatically}
\entry {#include}{38}{\code {#include}}
\entry {-M (to compiler)}{38}{\code {-M} (to compiler)}
\entry {make depend}{38}{\code {make depend}}
\entry {-e (shell flag)}{39}{\code {-e} (shell flag)}
\entry {-MM (to GNU compiler)}{39}{\code {-MM} (to GNU compiler)}
\entry {sed (shell command)}{39}{\code {sed} (shell command)}
\entry {.d}{39}{\code {.d}}
\entry {commands, how to write}{41}{commands, how to write}
\entry {rule commands}{41}{rule commands}
\entry {writing rule commands}{41}{writing rule commands}
\entry {comments, in commands}{41}{comments, in commands}
\entry {commands, comments in}{41}{commands, comments in}
\entry {# (comments), in commands}{41}{\code {#} (comments), in commands}
\entry {echoing of commands}{41}{echoing of commands}
\entry {silent operation}{41}{silent operation}
\entry {{\tt\char'100} (in commands)}{41}{\code {{\tt\char'100}} (in commands)}
\entry {commands, echoing}{41}{commands, echoing}
\entry {printing of commands}{41}{printing of commands}
\entry {-n}{41}{\code {-n}}
\entry {--just-print}{41}{\code {--just-print}}
\entry {--dry-run}{41}{\code {--dry-run}}
\entry {--recon}{41}{\code {--recon}}
\entry {-s}{41}{\code {-s}}
\entry {--silent}{41}{\code {--silent}}
\entry {--quiet}{41}{\code {--quiet}}
\entry {commands, execution}{42}{commands, execution}
\entry {execution, of commands}{42}{execution, of commands}
\entry {shell command, execution}{42}{shell command, execution}
\entry {cd (shell command)}{42}{\code {cd} (shell command)}
\entry {commands, backslash ({\tt\indexbackslash }) in}{42}{commands, backslash (\code {{\tt\indexbackslash }}) in}
\entry {commands, quoting newlines in}{42}{commands, quoting newlines in}
\entry {backslash ({\tt\indexbackslash }), in commands}{42}{backslash (\code {{\tt\indexbackslash }}), in commands}
\entry {{\tt\indexbackslash } (backslash), in commands}{42}{\code {{\tt\indexbackslash }} (backslash), in commands}
\entry {quoting newline, in commands}{42}{quoting newline, in commands}
\entry {newline, quoting, in commands}{42}{newline, quoting, in commands}
\entry {environment, SHELL in}{42}{environment, \code {SHELL} in}
\entry {commands, execution in parallel}{42}{commands, execution in parallel}
\entry {parallel execution}{42}{parallel execution}
\entry {execution, in parallel}{42}{execution, in parallel}
\entry {job slots}{42}{job slots}
\entry {-j}{42}{\code {-j}}
\entry {--jobs}{42}{\code {--jobs}}
\entry {broken pipe}{43}{broken pipe}
\entry {standard input}{43}{standard input}
\entry {load average}{43}{load average}
\entry {limiting jobs based on load}{43}{limiting jobs based on load}
\entry {jobs, limiting based on load}{43}{jobs, limiting based on load}
\entry {-l (load average)}{43}{\code {-l} (load average)}
\entry {--max-load}{43}{\code {--max-load}}
\entry {--load-average}{43}{\code {--load-average}}
\entry {errors (in commands)}{44}{errors (in commands)}
\entry {commands, errors in}{44}{commands, errors in}
\entry {exit status (errors)}{44}{exit status (errors)}
\entry {- (in commands)}{44}{\code {-} (in commands)}
\entry {rm (shell command)}{44}{\code {rm} (shell command)}
\entry {-i}{44}{\code {-i}}
\entry {--ignore-errors}{44}{\code {--ignore-errors}}
\entry {-k}{45}{\code {-k}}
\entry {--keep-going}{45}{\code {--keep-going}}
\entry {Emacs (M-x compile)}{45}{Emacs (\code {M-x compile})}
\entry {deletion of target files}{45}{deletion of target files}
\entry {removal of target files}{45}{removal of target files}
\entry {target, deleting on error}{45}{target, deleting on error}
\entry {interrupt}{45}{interrupt}
\entry {signal}{45}{signal}
\entry {deletion of target files}{45}{deletion of target files}
\entry {removal of target files}{45}{removal of target files}
\entry {target, deleting on interrupt}{45}{target, deleting on interrupt}
\entry {killing (interruption)}{45}{killing (interruption)}
\entry {recursion}{46}{recursion}
\entry {subdirectories, recursion for}{46}{subdirectories, recursion for}
\entry {-C}{46}{\code {-C}}
\entry {--directory}{46}{\code {--directory}}
\entry {recursion, and MAKE variable}{46}{recursion, and \code {MAKE} variable}
\entry {cd (shell command)}{47}{\code {cd} (shell command)}
\entry {-t, and recursion}{47}{\code {-t}, and recursion}
\entry {recursion, and -t}{47}{recursion, and \code {-t}}
\entry {--touch, and recursion}{47}{\code {--touch}, and recursion}
\entry {sub-make}{47}{sub-\code {make}}
\entry {environment, and recursion}{47}{environment, and recursion}
\entry {exporting variables}{47}{exporting variables}
\entry {variables, environment}{47}{variables, environment}
\entry {variables, exporting}{47}{variables, exporting}
\entry {recursion, and environment}{47}{recursion, and environment}
\entry {recursion, and variables}{47}{recursion, and variables}
\entry {compatibility in exporting}{49}{compatibility in exporting}
\entry {recursion, level of}{49}{recursion, level of}
\entry {options, and recursion}{50}{options, and recursion}
\entry {recursion, and options}{50}{recursion, and options}
\entry {command line variable definitions, and recursion}{50}{command line variable definitions, and recursion}
\entry {variables, command line, and recursion}{50}{variables, command line, and recursion}
\entry {recursion, and command line variable definitions}{50}{recursion, and command line variable definitions}
\entry {-C, and recursion}{50}{\code {-C}, and recursion}
\entry {-f, and recursion}{50}{\code {-f}, and recursion}
\entry {-o, and recursion}{50}{\code {-o}, and recursion}
\entry {-W, and recursion}{50}{\code {-W}, and recursion}
\entry {--directory, and recursion}{50}{\code {--directory}, and recursion}
\entry {--file, and recursion}{50}{\code {--file}, and recursion}
\entry {--old-file, and recursion}{50}{\code {--old-file}, and recursion}
\entry {--assume-old, and recursion}{50}{\code {--assume-old}, and recursion}
\entry {--assume-new, and recursion}{50}{\code {--assume-new}, and recursion}
\entry {--new-file, and recursion}{50}{\code {--new-file}, and recursion}
\entry {recursion, and -C}{50}{recursion, and \code {-C}}
\entry {recursion, and -f}{50}{recursion, and \code {-f}}
\entry {recursion, and -o}{50}{recursion, and \code {-o}}
\entry {recursion, and -W}{50}{recursion, and \code {-W}}
\entry {-j, and recursion}{50}{\code {-j}, and recursion}
\entry {--jobs, and recursion}{50}{\code {--jobs}, and recursion}
\entry {recursion, and -j}{50}{recursion, and \code {-j}}
\entry {job slots, and recursion}{50}{job slots, and recursion}
\entry {Arg list too long}{51}{Arg list too long}
\entry {E2BIG}{51}{E2BIG}
\entry {POSIX.2}{51}{POSIX.2}
\entry {setting options from environment}{51}{setting options from environment}
\entry {options, setting from environment}{51}{options, setting from environment}
\entry {setting options in makefiles}{51}{setting options in makefiles}
\entry {options, setting in makefiles}{51}{options, setting in makefiles}
\entry {directories, printing them}{52}{directories, printing them}
\entry {printing directories}{52}{printing directories}
\entry {recursion, and printing directories}{52}{recursion, and printing directories}
\entry {-C, and -w}{52}{\code {-C}, and \code {-w}}
\entry {--directory, and --print-directory}{52}{\code {--directory}, and \code {--print-directory}}
\entry {recursion, and -w}{52}{recursion, and \code {-w}}
\entry {-w, and -C}{52}{\code {-w}, and \code {-C}}
\entry {-w, and recursion}{52}{\code {-w}, and recursion}
\entry {--print-directory, and --directory}{52}{\code {--print-directory}, and \code {--directory}}
\entry {--print-directory, and recursion}{52}{\code {--print-directory}, and recursion}
\entry {--no-print-directory}{52}{\code {--no-print-directory}}
\entry {--print-directory, disabling}{52}{\code {--print-directory}, disabling}
\entry {-w, disabling}{52}{\code {-w}, disabling}
\entry {sequences of commands}{52}{sequences of commands}
\entry {commands, sequences of}{52}{commands, sequences of}
\entry {yacc}{53}{\code {yacc}}
\entry {{\tt\char'100}, and define}{53}{{\tt\char'100}, and \code {define}}
\entry {-, and define}{53}{-, and \code {define}}
\entry {{\tt\char43}, and define}{53}{{\tt\char43}, and \code {define}}
\entry {empty commands}{54}{empty commands}
\entry {commands, empty}{54}{commands, empty}
\entry {variable}{55}{variable}
\entry {value}{55}{value}
\entry {recursive variable expansion}{55}{recursive variable expansion}
\entry {simple variable expansion}{55}{simple variable expansion}
\entry {macro}{55}{macro}
\entry {variables, how to reference}{55}{variables, how to reference}
\entry {reference to variables}{55}{reference to variables}
\entry {$, in variable reference}{55}{\code {$}, in variable reference}
\entry {dollar sign ($), in variable reference}{55}{dollar sign (\code {$}), in variable reference}
\entry {flavors of variables}{56}{flavors of variables}
\entry {recursive variable expansion}{56}{recursive variable expansion}
\entry {variables, flavors}{56}{variables, flavors}
\entry {recursively expanded variables}{56}{recursively expanded variables}
\entry {variables, recursively expanded}{56}{variables, recursively expanded}
\entry {=}{56}{=}
\entry {loops in variable expansion}{57}{loops in variable expansion}
\entry {variables, loops in expansion}{57}{variables, loops in expansion}
\entry {simply expanded variables}{57}{simply expanded variables}
\entry {variables, simply expanded}{57}{variables, simply expanded}
\entry {:=}{57}{:=}
\entry {spaces, in variable values}{58}{spaces, in variable values}
\entry {whitespace, in variable values}{58}{whitespace, in variable values}
\entry {variables, spaces in values}{58}{variables, spaces in values}
\entry {reference to variables}{59}{reference to variables}
\entry {modified variable reference}{59}{modified variable reference}
\entry {substitution variable reference}{59}{substitution variable reference}
\entry {variables, modified reference}{59}{variables, modified reference}
\entry {variables, substitution reference}{59}{variables, substitution reference}
\entry {variables, substituting suffix in}{59}{variables, substituting suffix in}
\entry {suffix, substituting in variables}{59}{suffix, substituting in variables}
\entry {nested variable reference}{60}{nested variable reference}
\entry {computed variable name}{60}{computed variable name}
\entry {variables, computed names}{60}{variables, computed names}
\entry {variables, nested references}{60}{variables, nested references}
\entry {variables, $ in name}{60}{variables, \samp {$} in name}
\entry {$, in variable name}{60}{\code {$}, in variable name}
\entry {dollar sign ($), in variable name}{60}{dollar sign (\code {$}), in variable name}
\entry {variables, how they get their values}{63}{variables, how they get their values}
\entry {value, how a variable gets it}{63}{value, how a variable gets it}
\entry {setting variables}{63}{setting variables}
\entry {variables, setting}{63}{variables, setting}
\entry {=}{63}{=}
\entry {:=}{63}{:=}
\entry {{\tt\char43}=}{64}{{\tt\char43}=}
\entry {appending to variables}{64}{appending to variables}
\entry {variables, appending to}{64}{variables, appending to}
\entry {overriding with override}{66}{overriding with \code {override}}
\entry {variables, overriding}{66}{variables, overriding}
\entry {verbatim variable definition}{67}{verbatim variable definition}
\entry {defining variables verbatim}{67}{defining variables verbatim}
\entry {variables, defining verbatim}{67}{variables, defining verbatim}
\entry {variables, environment}{68}{variables, environment}
\entry {environment}{68}{environment}
\entry {conditionals}{71}{conditionals}
\entry {functions}{77}{functions}
\entry {$, in function call}{77}{\code {$}, in function call}
\entry {dollar sign ($), in function call}{77}{dollar sign (\code {$}), in function call}
\entry {arguments of functions}{77}{arguments of functions}
\entry {functions, syntax of}{77}{functions, syntax of}
\entry {functions, for text}{78}{functions, for text}
\entry {%, quoting in patsubst}{78}{\code {%}, quoting in \code {patsubst}}
\entry {%, quoting with {\tt\indexbackslash } (backslash)}{78}{\code {%}, quoting with \code {{\tt\indexbackslash }} (backslash)}
\entry {{\tt\indexbackslash } (backslash), to quote %}{78}{\code {{\tt\indexbackslash }} (backslash), to quote \code {%}}
\entry {backslash ({\tt\indexbackslash }), to quote %}{78}{backslash (\code {{\tt\indexbackslash }}), to quote \code {%}}
\entry {quoting %, in patsubst}{78}{quoting \code {%}, in \code {patsubst}}
\entry {stripping whitespace}{79}{stripping whitespace}
\entry {whitespace, stripping}{79}{whitespace, stripping}
\entry {spaces, stripping}{79}{spaces, stripping}
\entry {searching for strings}{79}{searching for strings}
\entry {finding strings}{79}{finding strings}
\entry {strings, searching for}{79}{strings, searching for}
\entry {filtering words}{80}{filtering words}
\entry {words, filtering}{80}{words, filtering}
\entry {filtering out words}{80}{filtering out words}
\entry {words, filtering out}{80}{words, filtering out}
\entry {sorting words}{80}{sorting words}
\entry {removing duplicate words}{80}{removing duplicate words}
\entry {duplicate words, removing}{80}{duplicate words, removing}
\entry {words, removing duplicates}{80}{words, removing duplicates}
\entry {functions, for file names}{81}{functions, for file names}
\entry {file name functions}{81}{file name functions}
\entry {directory part}{81}{directory part}
\entry {file name, directory part}{81}{file name, directory part}
\entry {file name, nondirectory part}{81}{file name, nondirectory part}
\entry {nondirectory part}{81}{nondirectory part}
\entry {suffix, function to find}{82}{suffix, function to find}
\entry {file name suffix}{82}{file name suffix}
\entry {basename}{82}{basename}
\entry {file name, basename of}{82}{file name, basename of}
\entry {suffix, adding}{82}{suffix, adding}
\entry {file name suffix, adding}{82}{file name suffix, adding}
\entry {prefix, adding}{82}{prefix, adding}
\entry {file name prefix, adding}{82}{file name prefix, adding}
\entry {joining lists of words}{82}{joining lists of words}
\entry {words, joining lists}{82}{words, joining lists}
\entry {words, selecting}{83}{words, selecting}
\entry {selecting words}{83}{selecting words}
\entry {words, finding number}{83}{words, finding number}
\entry {words, extracting first}{83}{words, extracting first}
\entry {wildcard, function}{83}{wildcard, function}
\entry {words, iterating over}{83}{words, iterating over}
\entry {variables, origin of}{85}{variables, origin of}
\entry {origin of variable}{85}{origin of variable}
\entry {commands, expansion}{87}{commands, expansion}
\entry {backquotes}{87}{backquotes}
\entry {shell command, function for}{87}{shell command, function for}
\entry {--file}{89}{\code {--file}}
\entry {--makefile}{89}{\code {--makefile}}
\entry {-f}{89}{\code {-f}}
\entry {goal, how to specify}{90}{goal, how to specify}
\entry {all (standard target)}{91}{\code {all} \r {(standard target)}}
\entry {clean (standard target)}{91}{\code {clean} \r {(standard target)}}
\entry {mostlyclean (standard target)}{91}{\code {mostlyclean} \r {(standard target)}}
\entry {distclean (standard target)}{91}{\code {distclean} \r {(standard target)}}
\entry {realclean (standard target)}{91}{\code {realclean} \r {(standard target)}}
\entry {clobber (standard target)}{91}{\code {clobber} \r {(standard target)}}
\entry {install (standard target)}{91}{\code {install} \r {(standard target)}}
\entry {print (standard target)}{91}{\code {print} \r {(standard target)}}
\entry {tar (standard target)}{91}{\code {tar} \r {(standard target)}}
\entry {shar (standard target)}{91}{\code {shar} \r {(standard target)}}
\entry {dist (standard target)}{91}{\code {dist} \r {(standard target)}}
\entry {TAGS (standard target)}{91}{\code {TAGS} \r {(standard target)}}
\entry {check (standard target)}{91}{\code {check} \r {(standard target)}}
\entry {test (standard target)}{91}{\code {test} \r {(standard target)}}
\entry {execution, instead of}{91}{execution, instead of}
\entry {commands, instead of executing}{91}{commands, instead of executing}
\entry {--just-print}{91}{\code {--just-print}}
\entry {--dry-run}{91}{\code {--dry-run}}
\entry {--recon}{91}{\code {--recon}}
\entry {-n}{91}{\code {-n}}
\entry {--touch}{92}{\code {--touch}}
\entry {touching files}{92}{touching files}
\entry {target, touching}{92}{target, touching}
\entry {-t}{92}{\code {-t}}
\entry {--question}{92}{\code {--question}}
\entry {-q}{92}{\code {-q}}
\entry {question mode}{92}{question mode}
\entry {--what-if}{92}{\code {--what-if}}
\entry {-W}{92}{\code {-W}}
\entry {--assume-new}{92}{\code {--assume-new}}
\entry {--new-file}{92}{\code {--new-file}}
\entry {what if}{92}{what if}
\entry {files, assuming new}{92}{files, assuming new}
\entry {-o}{93}{\code {-o}}
\entry {--old-file}{93}{\code {--old-file}}
\entry {--assume-old}{93}{\code {--assume-old}}
\entry {files, assuming old}{93}{files, assuming old}
\entry {files, avoiding recompilation of}{93}{files, avoiding recompilation of}
\entry {recompilation, avoiding}{93}{recompilation, avoiding}
\entry {overriding variables with arguments}{94}{overriding variables with arguments}
\entry {variables, overriding with arguments}{94}{variables, overriding with arguments}
\entry {command line variables}{94}{command line variables}
\entry {variables, command line}{94}{variables, command line}
\entry {testing compilation}{95}{testing compilation}
\entry {compilation, testing}{95}{compilation, testing}
\entry {-k}{95}{\code {-k}}
\entry {--keep-going}{95}{\code {--keep-going}}
\entry {options}{95}{options}
\entry {flags}{95}{flags}
\entry {switches}{95}{switches}
\entry {-b}{95}{\code {-b}}
\entry {-m}{95}{\code {-m}}
\entry {-C}{95}{\code {-C}}
\entry {--directory}{95}{\code {--directory}}
\entry {-d}{96}{\code {-d}}
\entry {--debug}{96}{\code {--debug}}
\entry {-e}{96}{\code {-e}}
\entry {--environment-overrides}{96}{\code {--environment-overrides}}
\entry {-f}{96}{\code {-f}}
\entry {--file}{96}{\code {--file}}
\entry {--makefile}{96}{\code {--makefile}}
\entry {-h}{96}{\code {-h}}
\entry {--help}{96}{\code {--help}}
\entry {-i}{96}{\code {-i}}
\entry {--ignore-errors}{96}{\code {--ignore-errors}}
\entry {-I}{96}{\code {-I}}
\entry {--include-dir}{96}{\code {--include-dir}}
\entry {-j}{96}{\code {-j}}
\entry {--jobs}{96}{\code {--jobs}}
\entry {-k}{96}{\code {-k}}
\entry {--keep-going}{96}{\code {--keep-going}}
\entry {-l}{97}{\code {-l}}
\entry {--load-average}{97}{\code {--load-average}}
\entry {--max-load}{97}{\code {--max-load}}
\entry {-n}{97}{\code {-n}}
\entry {--just-print}{97}{\code {--just-print}}
\entry {--dry-run}{97}{\code {--dry-run}}
\entry {--recon}{97}{\code {--recon}}
\entry {-o}{97}{\code {-o}}
\entry {--old-file}{97}{\code {--old-file}}
\entry {--assume-old}{97}{\code {--assume-old}}
\entry {-p}{97}{\code {-p}}
\entry {--print-data-base}{97}{\code {--print-data-base}}
\entry {-q}{97}{\code {-q}}
\entry {--question}{97}{\code {--question}}
\entry {-r}{97}{\code {-r}}
\entry {--no-builtin-rules}{97}{\code {--no-builtin-rules}}
\entry {-s}{97}{\code {-s}}
\entry {--silent}{98}{\code {--silent}}
\entry {--quiet}{98}{\code {--quiet}}
\entry {-S}{98}{\code {-S}}
\entry {--no-keep-going}{98}{\code {--no-keep-going}}
\entry {--stop}{98}{\code {--stop}}
\entry {-t}{98}{\code {-t}}
\entry {--touch}{98}{\code {--touch}}
\entry {-v}{98}{\code {-v}}
\entry {--version}{98}{\code {--version}}
\entry {-w}{98}{\code {-w}}
\entry {--print-directory}{98}{\code {--print-directory}}
\entry {--no-print-directory}{98}{\code {--no-print-directory}}
\entry {-W}{98}{\code {-W}}
\entry {--what-if}{98}{\code {--what-if}}
\entry {--new-file}{98}{\code {--new-file}}
\entry {--assume-new}{98}{\code {--assume-new}}
\entry {--warn-undefined-variables}{99}{\code {--warn-undefined-variables}}
\entry {variables, warning for undefined}{99}{variables, warning for undefined}
\entry {undefined variables, warning message}{99}{undefined variables, warning message}
\entry {implicit rule}{101}{implicit rule}
\entry {rule, implicit}{101}{rule, implicit}
\entry {implicit rule, how to use}{101}{implicit rule, how to use}
\entry {rule, implicit, how to use}{101}{rule, implicit, how to use}
\entry {implicit rule, predefined}{103}{implicit rule, predefined}
\entry {rule, implicit, predefined}{103}{rule, implicit, predefined}
\entry {C, rule to compile}{103}{C, rule to compile}
\entry {cc}{103}{\code {cc}}
\entry {gcc}{103}{\code {gcc}}
\entry {.o}{103}{\code {.o}}
\entry {.c}{103}{\code {.c}}
\entry {C{\tt\char43}{\tt\char43}, rule to compile}{103}{C{\tt\char43}{\tt\char43}, rule to compile}
\entry {g{\tt\char43}{\tt\char43}}{103}{\code {g{\tt\char43}{\tt\char43}}}
\entry {.C}{103}{\code {.C}}
\entry {.cc}{103}{\code {.cc}}
\entry {Pascal, rule to compile}{103}{Pascal, rule to compile}
\entry {pc}{103}{\code {pc}}
\entry {.p}{103}{\code {.p}}
\entry {Fortran, rule to compile}{103}{Fortran, rule to compile}
\entry {Ratfor, rule to compile}{103}{Ratfor, rule to compile}
\entry {f77}{103}{\code {f77}}
\entry {.f}{103}{\code {.f}}
\entry {.r}{103}{\code {.r}}
\entry {.F}{103}{\code {.F}}
\entry {Modula-2, rule to compile}{104}{Modula-2, rule to compile}
\entry {m2c}{104}{\code {m2c}}
\entry {.sym}{104}{\code {.sym}}
\entry {.def}{104}{\code {.def}}
\entry {.mod}{104}{\code {.mod}}
\entry {assembly, rule to compile}{104}{assembly, rule to compile}
\entry {as}{104}{\code {as}}
\entry {.s}{104}{\code {.s}}
\entry {.S}{104}{\code {.S}}
\entry {linking, predefined rule for}{104}{linking, predefined rule for}
\entry {ld}{104}{\code {ld}}
\entry {.o}{104}{\code {.o}}
\entry {yacc}{105}{\code {yacc}}
\entry {Yacc, rule to run}{105}{Yacc, rule to run}
\entry {.y}{105}{\code {.y}}
\entry {lex}{105}{\code {lex}}
\entry {Lex, rule to run}{105}{Lex, rule to run}
\entry {.l}{105}{\code {.l}}
\entry {lint}{105}{\code {lint}}
\entry {lint, rule to run}{105}{\code {lint}, rule to run}
\entry {.ln}{105}{\code {.ln}}
\entry {TeX{}, rule to run}{105}{\TeX{}, rule to run}
\entry {Web, rule to run}{105}{Web, rule to run}
\entry {tex}{105}{\code {tex}}
\entry {cweave}{105}{\code {cweave}}
\entry {weave}{105}{\code {weave}}
\entry {tangle}{105}{\code {tangle}}
\entry {ctangle}{105}{\code {ctangle}}
\entry {.dvi}{105}{\code {.dvi}}
\entry {.tex}{105}{\code {.tex}}
\entry {.web}{105}{\code {.web}}
\entry {.w}{105}{\code {.w}}
\entry {.ch}{105}{\code {.ch}}
\entry {Texinfo, rule to format}{105}{Texinfo, rule to format}
\entry {Info, rule to format}{105}{Info, rule to format}
\entry {texi2dvi}{105}{\code {texi2dvi}}
\entry {makeinfo}{105}{\code {makeinfo}}
\entry {.texinfo}{105}{\code {.texinfo}}
\entry {.info}{105}{\code {.info}}
\entry {.texi}{105}{\code {.texi}}
\entry {.txinfo}{105}{\code {.txinfo}}
\entry {RCS, rule to extract from}{105}{RCS, rule to extract from}
\entry {co}{105}{\code {co}}
\entry {,v (RCS file extension)}{105}{\code {,v \r {(RCS file extension)}}}
\entry {SCCS, rule to extract from}{105}{SCCS, rule to extract from}
\entry {get}{105}{\code {get}}
\entry {s. (SCCS file prefix)}{105}{\code {s. \r {(SCCS file prefix)}}}
\entry {.sh}{105}{\code {.sh}}
\entry {flags for compilers}{106}{flags for compilers}
\entry {ar}{107}{\code {ar}}
\entry {as}{107}{\code {as}}
\entry {cc}{107}{\code {cc}}
\entry {g{\tt\char43}{\tt\char43}}{107}{\code {g{\tt\char43}{\tt\char43}}}
\entry {co}{107}{\code {co}}
\entry {f77}{107}{\code {f77}}
\entry {get}{107}{\code {get}}
\entry {lex}{107}{\code {lex}}
\entry {pc}{107}{\code {pc}}
\entry {yacc}{107}{\code {yacc}}
\entry {makeinfo}{107}{\code {makeinfo}}
\entry {tex}{107}{\code {tex}}
\entry {texi2dvi}{107}{\code {texi2dvi}}
\entry {weave}{107}{\code {weave}}
\entry {cweave}{107}{\code {cweave}}
\entry {tangle}{107}{\code {tangle}}
\entry {ctangle}{107}{\code {ctangle}}
\entry {rm}{107}{\code {rm}}
\entry {chains of rules}{108}{chains of rules}
\entry {rule, implicit, chains of}{108}{rule, implicit, chains of}
\entry {intermediate files}{108}{intermediate files}
\entry {files, intermediate}{108}{files, intermediate}
\entry {intermediate files, preserving}{109}{intermediate files, preserving}
\entry {preserving intermediate files}{109}{preserving intermediate files}
\entry {preserving with .PRECIOUS}{109}{preserving with \code {.PRECIOUS}}
\entry {.PRECIOUS intermediate files}{109}{\code {.PRECIOUS} intermediate files}
\entry {pattern rule}{110}{pattern rule}
\entry {rule, pattern}{110}{rule, pattern}
\entry {target pattern, implicit}{110}{target pattern, implicit}
\entry {%, in pattern rules}{110}{\code {%}, in pattern rules}
\entry {dependency pattern, implicit}{110}{dependency pattern, implicit}
\entry {multiple targets, in pattern rule}{110}{multiple targets, in pattern rule}
\entry {target, multiple in pattern rule}{110}{target, multiple in pattern rule}
\entry {pattern rules, order of}{111}{pattern rules, order of}
\entry {order of pattern rules}{111}{order of pattern rules}
\entry {automatic variables}{112}{automatic variables}
\entry {variables, automatic}{112}{variables, automatic}
\entry {variables, and implicit rule}{112}{variables, and implicit rule}
\entry {dependencies, list of changed}{112}{dependencies, list of changed}
\entry {list of changed dependencies}{112}{list of changed dependencies}
\entry {dependencies, list of all}{112}{dependencies, list of all}
\entry {list of all dependencies}{112}{list of all dependencies}
\entry {stem, variable for}{113}{stem, variable for}
\entry {stem}{114}{stem}
\entry {match-anything rule}{115}{match-anything rule}
\entry {terminal rule}{115}{terminal rule}
\entry {last-resort default rules}{116}{last-resort default rules}
\entry {default rules, last-resort}{116}{default rules, last-resort}
\entry {old-fashioned suffix rules}{117}{old-fashioned suffix rules}
\entry {suffix rule}{117}{suffix rule}
\entry {implicit rule, search algorithm}{119}{implicit rule, search algorithm}
\entry {search algorithm, implicit rule}{119}{search algorithm, implicit rule}
\entry {archive}{121}{archive}
\entry {archive member targets}{121}{archive member targets}
\entry {wildcard, in archive member}{121}{wildcard, in archive member}
\entry {{\_}{\_}.SYMDEF}{123}{\code {{\_}{\_}.SYMDEF}}
\entry {updating archive symbol directories}{123}{updating archive symbol directories}
\entry {archive symbol directory updating}{123}{archive symbol directory updating}
\entry {symbol directories, updating archive}{123}{symbol directories, updating archive}
\entry {directories, updating archive symbol}{123}{directories, updating archive symbol}
\entry {archive, and parallel execution}{123}{archive, and parallel execution}
\entry {parallel execution, and archive update}{123}{parallel execution, and archive update}
\entry {archive, and -j}{123}{archive, and \code {-j}}
\entry {-j, and archive update}{123}{\code {-j}, and archive update}
\entry {suffix rule, for archive}{124}{suffix rule, for archive}
\entry {archive, suffix rule for}{124}{archive, suffix rule for}
\entry {library archive, suffix rule for}{124}{library archive, suffix rule for}
\entry {.a (archives)}{124}{\code {.a} (archives)}
\entry {features of GNU make}{125}{features of GNU \code {make}}
\entry {portability}{125}{portability}
\entry {compatibility}{125}{compatibility}
\entry {incompatibilities}{129}{incompatibilities}
\entry {missing features}{129}{missing features}
\entry {features, missing}{129}{features, missing}
\entry {makefile, conventions for}{131}{makefile, conventions for}
\entry {conventions for makefiles}{131}{conventions for makefiles}
\entry {standards for makefiles}{131}{standards for makefiles}

652
buildtools/windows/source/make/make.cps
View File

@ -1,652 +0,0 @@
\initial {#}
\entry {\code {#} (comments), in commands}{41}
\entry {\code {#} (comments), in makefile}{13}
\entry {\code {#include}}{38}
\initial {$}
\entry {\code {$}, in function call}{77}
\entry {\code {$}, in rules}{20}
\entry {\code {$}, in variable name}{60}
\entry {\code {$}, in variable reference}{55}
\initial {%}
\entry {\code {%}, in pattern rules}{110}
\entry {\code {%}, quoting in \code {patsubst}}{78}
\entry {\code {%}, quoting in static pattern}{35}
\entry {\code {%}, quoting in \code {vpath}}{25}
\entry {\code {%}, quoting with \code {{\tt\indexbackslash }} (backslash)}{25, 35, 78}
\initial {*}
\entry {\code {*} (wildcard character)}{20}
\initial {,}
\entry {\code {,v \r {(RCS file extension)}}}{105}
\initial {-}
\entry {\code {-} (in commands)}{44}
\entry {-, and \code {define}}{53}
\entry {\code {--assume-new}}{92, 98}
\entry {\code {--assume-new}, and recursion}{50}
\entry {\code {--assume-old}}{93, 97}
\entry {\code {--assume-old}, and recursion}{50}
\entry {\code {--debug}}{96}
\entry {\code {--directory}}{46, 95}
\entry {\code {--directory}, and \code {--print-directory}}{52}
\entry {\code {--directory}, and recursion}{50}
\entry {\code {--dry-run}}{41, 91, 97}
\entry {\code {--environment-overrides}}{96}
\entry {\code {--file}}{14, 89, 96}
\entry {\code {--file}, and recursion}{50}
\entry {\code {--help}}{96}
\entry {\code {--ignore-errors}}{44, 96}
\entry {\code {--include-dir}}{15, 96}
\entry {\code {--jobs}}{42, 96}
\entry {\code {--jobs}, and recursion}{50}
\entry {\code {--just-print}}{41, 91, 97}
\entry {\code {--keep-going}}{45, 95, 96}
\entry {\code {--load-average}}{43, 97}
\entry {\code {--makefile}}{14, 89, 96}
\entry {\code {--max-load}}{43, 97}
\entry {\code {--new-file}}{92, 98}
\entry {\code {--new-file}, and recursion}{50}
\entry {\code {--no-builtin-rules}}{97}
\entry {\code {--no-keep-going}}{98}
\entry {\code {--no-print-directory}}{52, 98}
\entry {\code {--old-file}}{93, 97}
\entry {\code {--old-file}, and recursion}{50}
\entry {\code {--print-data-base}}{97}
\entry {\code {--print-directory}}{98}
\entry {\code {--print-directory}, and \code {--directory}}{52}
\entry {\code {--print-directory}, and recursion}{52}
\entry {\code {--print-directory}, disabling}{52}
\entry {\code {--question}}{92, 97}
\entry {\code {--quiet}}{41, 98}
\entry {\code {--recon}}{41, 91, 97}
\entry {\code {--silent}}{41, 98}
\entry {\code {--stop}}{98}
\entry {\code {--touch}}{92, 98}
\entry {\code {--touch}, and recursion}{47}
\entry {\code {--version}}{98}
\entry {\code {--warn-undefined-variables}}{99}
\entry {\code {--what-if}}{92, 98}
\entry {\code {-b}}{95}
\entry {\code {-C}}{46, 95}
\entry {\code {-C}, and \code {-w}}{52}
\entry {\code {-C}, and recursion}{50}
\entry {\code {-d}}{96}
\entry {\code {-e}}{96}
\entry {\code {-e} (shell flag)}{39}
\entry {\code {-f}}{14, 89, 96}
\entry {\code {-f}, and recursion}{50}
\entry {\code {-h}}{96}
\entry {\code {-i}}{44, 96}
\entry {\code {-I}}{15, 96}
\entry {\code {-j}}{42, 96}
\entry {\code {-j}, and archive update}{123}
\entry {\code {-j}, and recursion}{50}
\entry {\code {-k}}{45, 95, 96}
\entry {\code {-l}}{97}
\entry {\code {-l} (library search)}{27}
\entry {\code {-l} (load average)}{43}
\entry {\code {-m}}{95}
\entry {\code {-M} (to compiler)}{38}
\entry {\code {-MM} (to GNU compiler)}{39}
\entry {\code {-n}}{41, 91, 97}
\entry {\code {-o}}{93, 97}
\entry {\code {-o}, and recursion}{50}
\entry {\code {-p}}{97}
\entry {\code {-q}}{92, 97}
\entry {\code {-r}}{97}
\entry {\code {-s}}{41, 97}
\entry {\code {-S}}{98}
\entry {\code {-t}}{92, 98}
\entry {\code {-t}, and recursion}{47}
\entry {\code {-v}}{98}
\entry {\code {-w}}{98}
\entry {\code {-W}}{92, 98}
\entry {\code {-w}, and \code {-C}}{52}
\entry {\code {-w}, and recursion}{52}
\entry {\code {-W}, and recursion}{50}
\entry {\code {-w}, disabling}{52}
\initial {.}
\entry {\code {.a} (archives)}{124}
\entry {\code {.c}}{103}
\entry {\code {.C}}{103}
\entry {\code {.cc}}{103}
\entry {\code {.ch}}{105}
\entry {\code {.d}}{39}
\entry {\code {.def}}{104}
\entry {\code {.dvi}}{105}
\entry {\code {.f}}{103}
\entry {\code {.F}}{103}
\entry {\code {.info}}{105}
\entry {\code {.l}}{105}
\entry {\code {.ln}}{105}
\entry {\code {.mod}}{104}
\entry {\code {.o}}{103, 104}
\entry {\code {.p}}{103}
\entry {\code {.PRECIOUS} intermediate files}{109}
\entry {\code {.r}}{103}
\entry {\code {.s}}{104}
\entry {\code {.S}}{104}
\entry {\code {.sh}}{105}
\entry {\code {.sym}}{104}
\entry {\code {.tex}}{105}
\entry {\code {.texi}}{105}
\entry {\code {.texinfo}}{105}
\entry {\code {.txinfo}}{105}
\entry {\code {.w}}{105}
\entry {\code {.web}}{105}
\entry {\code {.y}}{105}
\initial {:}
\entry {\code {::} rules (double-colon)}{37}
\entry {:=}{57, 63}
\initial {=}
\entry {=}{56, 63}
\initial {?}
\entry {\code {?} (wildcard character)}{20}
\initial {[}
\entry {\code {[\dots {}]} (wildcard characters)}{20}
\initial {{\_}}
\entry {\code {{\_}{\_}.SYMDEF}}{123}
\initial {{\tt\char'100}}
\entry {\code {{\tt\char'100}} (in commands)}{41}
\entry {{\tt\char'100}, and \code {define}}{53}
\initial {{\tt\char'176}}
\entry {\code {{\tt\char'176}} (tilde)}{20}
\initial {{\tt\char43}}
\entry {{\tt\char43}, and \code {define}}{53}
\entry {{\tt\char43}=}{64}
\initial {{\tt\indexbackslash }}
\entry {\code {{\tt\indexbackslash }} (backslash), for continuation lines}{7}
\entry {\code {{\tt\indexbackslash }} (backslash), in commands}{42}
\entry {\code {{\tt\indexbackslash }} (backslash), to quote \code {%}}{25, 35, 78}
\initial {A}
\entry {\code {all} \r {(standard target)}}{91}
\entry {appending to variables}{64}
\entry {\code {ar}}{107}
\entry {archive}{121}
\entry {archive member targets}{121}
\entry {archive symbol directory updating}{123}
\entry {archive, and \code {-j}}{123}
\entry {archive, and parallel execution}{123}
\entry {archive, suffix rule for}{124}
\entry {Arg list too long}{51}
\entry {arguments of functions}{77}
\entry {\code {as}}{104, 107}
\entry {assembly, rule to compile}{104}
\entry {automatic generation of dependencies}{15, 37}
\entry {automatic variables}{112}
\initial {B}
\entry {backquotes}{87}
\entry {backslash (\code {{\tt\indexbackslash }}), for continuation lines}{7}
\entry {backslash (\code {{\tt\indexbackslash }}), in commands}{42}
\entry {backslash (\code {{\tt\indexbackslash }}), to quote \code {%}}{25, 35, 78}
\entry {basename}{82}
\entry {broken pipe}{43}
\entry {bugs, reporting}{2}
\entry {built-in special targets}{31}
\initial {C}
\entry {C, rule to compile}{103}
\entry {C{\tt\char43}{\tt\char43}, rule to compile}{103}
\entry {\code {cc}}{103, 107}
\entry {\code {cd} (shell command)}{42, 47}
\entry {chains of rules}{108}
\entry {\code {check} \r {(standard target)}}{91}
\entry {\code {clean} \r {(standard target)}}{91}
\entry {\code {clean} target}{8, 12}
\entry {cleaning up}{12}
\entry {\code {clobber} \r {(standard target)}}{91}
\entry {\code {co}}{105, 107}
\entry {combining rules by dependency}{11}
\entry {command line variable definitions, and recursion}{50}
\entry {command line variables}{94}
\entry {commands}{19}
\entry {commands, backslash (\code {{\tt\indexbackslash }}) in}{42}
\entry {commands, comments in}{41}
\entry {commands, echoing}{41}
\entry {commands, empty}{54}
\entry {commands, errors in}{44}
\entry {commands, execution}{42}
\entry {commands, execution in parallel}{42}
\entry {commands, expansion}{87}
\entry {commands, how to write}{41}
\entry {commands, instead of executing}{91}
\entry {commands, introduction to}{5}
\entry {commands, quoting newlines in}{42}
\entry {commands, sequences of}{52}
\entry {comments, in commands}{41}
\entry {comments, in makefile}{13}
\entry {compatibility}{125}
\entry {compatibility in exporting}{49}
\entry {compilation, testing}{95}
\entry {computed variable name}{60}
\entry {conditionals}{71}
\entry {continuation lines}{7}
\entry {conventions for makefiles}{131}
\entry {\code {ctangle}}{105, 107}
\entry {\code {cweave}}{105, 107}
\initial {D}
\entry {deducing commands (implicit rules)}{10}
\entry {default goal}{8, 19}
\entry {default makefile name}{14}
\entry {default rules, last-resort}{116}
\entry {defining variables verbatim}{67}
\entry {deletion of target files}{45}
\entry {dependencies}{20}
\entry {dependencies, automatic generation}{15, 37}
\entry {dependencies, introduction to}{5}
\entry {dependencies, list of all}{112}
\entry {dependencies, list of changed}{112}
\entry {dependencies, varying (static pattern)}{34}
\entry {dependency}{19}
\entry {dependency pattern, implicit}{110}
\entry {dependency pattern, static (not implicit)}{35}
\entry {directive}{13}
\entry {directories, printing them}{52}
\entry {directories, updating archive symbol}{123}
\entry {directory part}{81}
\entry {directory search (\code {VPATH})}{23}
\entry {directory search (\code {VPATH}), and implicit rules}{27}
\entry {directory search (\code {VPATH}), and link libraries}{27}
\entry {directory search (\code {VPATH}), and shell commands}{26}
\entry {\code {dist} \r {(standard target)}}{91}
\entry {\code {distclean} \r {(standard target)}}{91}
\entry {dollar sign (\code {$}), in function call}{77}
\entry {dollar sign (\code {$}), in rules}{20}
\entry {dollar sign (\code {$}), in variable name}{60}
\entry {dollar sign (\code {$}), in variable reference}{55}
\entry {double-colon rules}{37}
\entry {duplicate words, removing}{80}
\initial {E}
\entry {E2BIG}{51}
\entry {echoing of commands}{41}
\entry {editor}{5}
\entry {Emacs (\code {M-x compile})}{45}
\entry {empty commands}{54}
\entry {empty targets}{30}
\entry {environment}{68}
\entry {environment, and recursion}{47}
\entry {environment, \code {SHELL} in}{42}
\entry {errors (in commands)}{44}
\entry {errors with wildcards}{22}
\entry {execution, in parallel}{42}
\entry {execution, instead of}{91}
\entry {execution, of commands}{42}
\entry {exit status (errors)}{44}
\entry {explicit rule, definition of}{13}
\entry {exporting variables}{47}
\initial {F}
\entry {\code {f77}}{103, 107}
\entry {features of GNU \code {make}}{125}
\entry {features, missing}{129}
\entry {file name functions}{81}
\entry {file name of makefile}{14}
\entry {file name of makefile, how to specify}{14}
\entry {file name prefix, adding}{82}
\entry {file name suffix}{82}
\entry {file name suffix, adding}{82}
\entry {file name with wildcards}{20}
\entry {file name, basename of}{82}
\entry {file name, directory part}{81}
\entry {file name, nondirectory part}{81}
\entry {files, assuming new}{92}
\entry {files, assuming old}{93}
\entry {files, avoiding recompilation of}{93}
\entry {files, intermediate}{108}
\entry {filtering out words}{80}
\entry {filtering words}{80}
\entry {finding strings}{79}
\entry {flags}{95}
\entry {flags for compilers}{106}
\entry {flavors of variables}{56}
\entry {\code {FORCE}}{30}
\entry {force targets}{30}
\entry {Fortran, rule to compile}{103}
\entry {functions}{77}
\entry {functions, for file names}{81}
\entry {functions, for text}{78}
\entry {functions, syntax of}{77}
\initial {G}
\entry {\code {g{\tt\char43}{\tt\char43}}}{103, 107}
\entry {\code {gcc}}{103}
\entry {generating dependencies automatically}{15, 37}
\entry {\code {get}}{105, 107}
\entry {globbing (wildcards)}{20}
\entry {goal}{8}
\entry {goal, default}{8, 19}
\entry {goal, how to specify}{90}
\initial {H}
\entry {home directory}{20}
\initial {I}
\entry {IEEE Standard 1003.2}{1}
\entry {implicit rule}{101}
\entry {implicit rule, and directory search}{27}
\entry {implicit rule, and \code {VPATH}}{27}
\entry {implicit rule, definition of}{13}
\entry {implicit rule, how to use}{101}
\entry {implicit rule, introduction to}{10}
\entry {implicit rule, predefined}{103}
\entry {implicit rule, search algorithm}{119}
\entry {including (\code {MAKEFILES} variable)}{16}
\entry {including other makefiles}{14}
\entry {incompatibilities}{129}
\entry {Info, rule to format}{105}
\entry {\code {install} \r {(standard target)}}{91}
\entry {intermediate files}{108}
\entry {intermediate files, preserving}{109}
\entry {interrupt}{45}
\initial {J}
\entry {job slots}{42}
\entry {job slots, and recursion}{50}
\entry {jobs, limiting based on load}{43}
\entry {joining lists of words}{82}
\initial {K}
\entry {killing (interruption)}{45}
\initial {L}
\entry {last-resort default rules}{116}
\entry {\code {ld}}{104}
\entry {\code {lex}}{105, 107}
\entry {Lex, rule to run}{105}
\entry {libraries for linking, directory search}{27}
\entry {library archive, suffix rule for}{124}
\entry {limiting jobs based on load}{43}
\entry {link libraries, and directory search}{27}
\entry {linking, predefined rule for}{104}
\entry {\code {lint}}{105}
\entry {\code {lint}, rule to run}{105}
\entry {list of all dependencies}{112}
\entry {list of changed dependencies}{112}
\entry {load average}{43}
\entry {loops in variable expansion}{57}
\entry {\code {lpr} (shell command)}{21, 30}
\initial {M}
\entry {\code {m2c}}{104}
\entry {macro}{55}
\entry {\code {make depend}}{38}
\entry {makefile}{5}
\entry {makefile name}{14}
\entry {makefile name, how to specify}{14}
\entry {makefile rule parts}{5}
\entry {makefile, and \code {MAKEFILES} variable}{16}
\entry {makefile, conventions for}{131}
\entry {makefile, how \code {make} processes}{8}
\entry {makefile, how to write}{13}
\entry {makefile, including}{14}
\entry {makefile, overriding}{18}
\entry {makefile, remaking of}{16}
\entry {makefile, simple}{6}
\entry {\code {makeinfo}}{105, 107}
\entry {match-anything rule}{115}
\entry {match-anything rule, used to override}{18}
\entry {missing features}{129}
\entry {mistakes with wildcards}{22}
\entry {modified variable reference}{59}
\entry {Modula-2, rule to compile}{104}
\entry {\code {mostlyclean} \r {(standard target)}}{91}
\entry {multiple rules for one target}{33}
\entry {multiple rules for one target (\code {::})}{37}
\entry {multiple targets}{32}
\entry {multiple targets, in pattern rule}{110}
\initial {N}
\entry {name of makefile}{14}
\entry {name of makefile, how to specify}{14}
\entry {nested variable reference}{60}
\entry {newline, quoting, in commands}{42}
\entry {newline, quoting, in makefile}{7}
\entry {nondirectory part}{81}
\initial {O}
\entry {\code {obj}}{9}
\entry {\code {OBJ}}{9}
\entry {\code {objects}}{9}
\entry {\code {OBJECTS}}{9}
\entry {\code {objs}}{9}
\entry {\code {OBJS}}{9}
\entry {old-fashioned suffix rules}{117}
\entry {options}{95}
\entry {options, and recursion}{50}
\entry {options, setting from environment}{51}
\entry {options, setting in makefiles}{51}
\entry {order of pattern rules}{111}
\entry {origin of variable}{85}
\entry {overriding makefiles}{18}
\entry {overriding variables with arguments}{94}
\entry {overriding with \code {override}}{66}
\initial {P}
\entry {parallel execution}{42}
\entry {parallel execution, and archive update}{123}
\entry {parts of makefile rule}{5}
\entry {Pascal, rule to compile}{103}
\entry {pattern rule}{110}
\entry {pattern rules, order of}{111}
\entry {pattern rules, static (not implicit)}{34}
\entry {pattern rules, static, syntax of}{34}
\entry {\code {pc}}{103, 107}
\entry {phony targets}{28}
\entry {pitfalls of wildcards}{22}
\entry {portability}{125}
\entry {POSIX}{1}
\entry {POSIX.2}{51}
\entry {precious targets}{31}
\entry {prefix, adding}{82}
\entry {preserving intermediate files}{109}
\entry {preserving with \code {.PRECIOUS}}{31, 109}
\entry {\code {print} \r {(standard target)}}{91}
\entry {\code {print} target}{21, 30}
\entry {printing directories}{52}
\entry {printing of commands}{41}
\entry {problems and bugs, reporting}{2}
\entry {problems with wildcards}{22}
\entry {processing a makefile}{8}
\initial {Q}
\entry {question mode}{92}
\entry {quoting \code {%}, in \code {patsubst}}{78}
\entry {quoting \code {%}, in static pattern}{35}
\entry {quoting \code {%}, in \code {vpath}}{25}
\entry {quoting newline, in commands}{42}
\entry {quoting newline, in makefile}{7}
\initial {R}
\entry {Ratfor, rule to compile}{103}
\entry {RCS, rule to extract from}{105}
\entry {\code {README}}{14}
\entry {\code {realclean} \r {(standard target)}}{91}
\entry {recompilation}{5}
\entry {recompilation, avoiding}{93}
\entry {recording events with empty targets}{30}
\entry {recursion}{46}
\entry {recursion, and \code {-C}}{50}
\entry {recursion, and \code {-f}}{50}
\entry {recursion, and \code {-j}}{50}
\entry {recursion, and \code {-o}}{50}
\entry {recursion, and \code {-t}}{47}
\entry {recursion, and \code {-w}}{52}
\entry {recursion, and \code {-W}}{50}
\entry {recursion, and command line variable definitions}{50}
\entry {recursion, and environment}{47}
\entry {recursion, and \code {MAKE} variable}{46}
\entry {recursion, and \code {MAKEFILES} variable}{16}
\entry {recursion, and options}{50}
\entry {recursion, and printing directories}{52}
\entry {recursion, and variables}{47}
\entry {recursion, level of}{49}
\entry {recursive variable expansion}{55, 56}
\entry {recursively expanded variables}{56}
\entry {reference to variables}{55, 59}
\entry {relinking}{9}
\entry {remaking makefiles}{16}
\entry {removal of target files}{45}
\entry {removing duplicate words}{80}
\entry {removing, to clean up}{12}
\entry {reporting bugs}{2}
\entry {\code {rm}}{107}
\entry {\code {rm} (shell command)}{8, 21, 28, 44}
\entry {rule commands}{41}
\entry {rule dependencies}{20}
\entry {rule syntax}{19}
\entry {rule targets}{19}
\entry {rule, and \code {$}}{20}
\entry {rule, double-colon (\code {::})}{37}
\entry {rule, explicit, definition of}{13}
\entry {rule, how to write}{19}
\entry {rule, implicit}{101}
\entry {rule, implicit, and directory search}{27}
\entry {rule, implicit, and \code {VPATH}}{27}
\entry {rule, implicit, chains of}{108}
\entry {rule, implicit, definition of}{13}
\entry {rule, implicit, how to use}{101}
\entry {rule, implicit, introduction to}{10}
\entry {rule, implicit, predefined}{103}
\entry {rule, introduction to}{5}
\entry {rule, multiple for one target}{33}
\entry {rule, no commands or dependencies}{30}
\entry {rule, pattern}{110}
\entry {rule, static pattern}{34}
\entry {rule, static pattern versus implicit}{36}
\entry {rule, with multiple targets}{32}
\initial {S}
\entry {\code {s. \r {(SCCS file prefix)}}}{105}
\entry {SCCS, rule to extract from}{105}
\entry {search algorithm, implicit rule}{119}
\entry {search path for dependencies (\code {VPATH})}{23}
\entry {search path for dependencies (\code {VPATH}), and implicit rules}{27}
\entry {search path for dependencies (\code {VPATH}), and link libraries}{27}
\entry {searching for strings}{79}
\entry {\code {sed} (shell command)}{39}
\entry {selecting words}{83}
\entry {sequences of commands}{52}
\entry {setting options from environment}{51}
\entry {setting options in makefiles}{51}
\entry {setting variables}{63}
\entry {several rules for one target}{33}
\entry {several targets in a rule}{32}
\entry {\code {shar} \r {(standard target)}}{91}
\entry {shell command}{8}
\entry {shell command, and directory search}{26}
\entry {shell command, execution}{42}
\entry {shell command, function for}{87}
\entry {shell file name pattern (in \code {include})}{14}
\entry {shell wildcards (in \code {include})}{14}
\entry {signal}{45}
\entry {silent operation}{41}
\entry {simple makefile}{6}
\entry {simple variable expansion}{55}
\entry {simplifying with variables}{9}
\entry {simply expanded variables}{57}
\entry {sorting words}{80}
\entry {spaces, in variable values}{58}
\entry {spaces, stripping}{79}
\entry {special targets}{31}
\entry {specifying makefile name}{14}
\entry {standard input}{43}
\entry {standards conformance}{1}
\entry {standards for makefiles}{131}
\entry {static pattern rule}{34}
\entry {static pattern rule, syntax of}{34}
\entry {static pattern rule, versus implicit}{36}
\entry {stem}{35, 114}
\entry {stem, variable for}{113}
\entry {strings, searching for}{79}
\entry {stripping whitespace}{79}
\entry {sub-\code {make}}{47}
\entry {subdirectories, recursion for}{46}
\entry {substitution variable reference}{59}
\entry {suffix rule}{117}
\entry {suffix rule, for archive}{124}
\entry {suffix, adding}{82}
\entry {suffix, function to find}{82}
\entry {suffix, substituting in variables}{59}
\entry {switches}{95}
\entry {symbol directories, updating archive}{123}
\entry {syntax of rules}{19}
\initial {T}
\entry {tab character (in commands)}{19}
\entry {tabs in rules}{5}
\entry {\code {TAGS} \r {(standard target)}}{91}
\entry {\code {tangle}}{105, 107}
\entry {\code {tar} \r {(standard target)}}{91}
\entry {target}{19}
\entry {target pattern, implicit}{110}
\entry {target pattern, static (not implicit)}{35}
\entry {target, deleting on error}{45}
\entry {target, deleting on interrupt}{45}
\entry {target, multiple in pattern rule}{110}
\entry {target, multiple rules for one}{33}
\entry {target, touching}{92}
\entry {targets}{19}
\entry {targets without a file}{28}
\entry {targets, built-in special}{31}
\entry {targets, empty}{30}
\entry {targets, force}{30}
\entry {targets, introduction to}{5}
\entry {targets, multiple}{32}
\entry {targets, phony}{28}
\entry {terminal rule}{115}
\entry {\code {test} \r {(standard target)}}{91}
\entry {testing compilation}{95}
\entry {\code {tex}}{105, 107}
\entry {\TeX{}, rule to run}{105}
\entry {\code {texi2dvi}}{105, 107}
\entry {Texinfo, rule to format}{105}
\entry {tilde (\code {{\tt\char'176}})}{20}
\entry {\code {touch} (shell command)}{21, 30}
\entry {touching files}{92}
\initial {U}
\entry {undefined variables, warning message}{99}
\entry {updating archive symbol directories}{123}
\entry {updating makefiles}{16}
\initial {V}
\entry {value}{55}
\entry {value, how a variable gets it}{63}
\entry {variable}{55}
\entry {variable definition}{13}
\entry {variables}{9}
\entry {variables, \samp {$} in name}{60}
\entry {variables, and implicit rule}{112}
\entry {variables, appending to}{64}
\entry {variables, automatic}{112}
\entry {variables, command line}{94}
\entry {variables, command line, and recursion}{50}
\entry {variables, computed names}{60}
\entry {variables, defining verbatim}{67}
\entry {variables, environment}{47, 68}
\entry {variables, exporting}{47}
\entry {variables, flavors}{56}
\entry {variables, how they get their values}{63}
\entry {variables, how to reference}{55}
\entry {variables, loops in expansion}{57}
\entry {variables, modified reference}{59}
\entry {variables, nested references}{60}
\entry {variables, origin of}{85}
\entry {variables, overriding}{66}
\entry {variables, overriding with arguments}{94}
\entry {variables, recursively expanded}{56}
\entry {variables, setting}{63}
\entry {variables, simply expanded}{57}
\entry {variables, spaces in values}{58}
\entry {variables, substituting suffix in}{59}
\entry {variables, substitution reference}{59}
\entry {variables, warning for undefined}{99}
\entry {varying dependencies}{34}
\entry {verbatim variable definition}{67}
\entry {vpath}{23}
\entry {\code {VPATH}, and implicit rules}{27}
\entry {\code {VPATH}, and link libraries}{27}
\initial {W}
\entry {\code {weave}}{105, 107}
\entry {Web, rule to run}{105}
\entry {what if}{92}
\entry {whitespace, in variable values}{58}
\entry {whitespace, stripping}{79}
\entry {wildcard}{20}
\entry {wildcard pitfalls}{22}
\entry {wildcard, function}{83}
\entry {wildcard, in archive member}{121}
\entry {wildcard, in \code {include}}{14}
\entry {words, extracting first}{83}
\entry {words, filtering}{80}
\entry {words, filtering out}{80}
\entry {words, finding number}{83}
\entry {words, iterating over}{83}
\entry {words, joining lists}{82}
\entry {words, removing duplicates}{80}
\entry {words, selecting}{83}
\entry {writing rule commands}{41}
\entry {writing rules}{19}
\initial {Y}
\entry {\code {yacc}}{53, 105, 107}
\entry {Yacc, rule to run}{105}

149
buildtools/windows/source/make/make.fn
View File

@ -1,149 +0,0 @@
\entry {Makefile}{14}{\code {Makefile}}
\entry {GNUmakefile}{14}{\code {GNUmakefile}}
\entry {makefile}{14}{\code {makefile}}
\entry {include}{14}{\code {include}}
\entry {/usr/gnu/include}{15}{\code {/usr/gnu/include}}
\entry {/usr/local/include}{15}{\code {/usr/local/include}}
\entry {/usr/include}{15}{\code {/usr/include}}
\entry {MAKEFILES}{16}{\code {MAKEFILES}}
\entry {wildcard}{22}{\code {wildcard}}
\entry {VPATH}{23}{\code {VPATH}}
\entry {vpath}{23}{\code {vpath}}
\entry {VPATH}{23}{\code {VPATH}}
\entry {vpath}{24}{\code {vpath}}
\entry {.PHONY}{28}{\code {.PHONY}}
\entry {.PHONY}{31}{\code {.PHONY}}
\entry {.SUFFIXES}{31}{\code {.SUFFIXES}}
\entry {.DEFAULT}{31}{\code {.DEFAULT}}
\entry {.PRECIOUS}{31}{\code {.PRECIOUS}}
\entry {.IGNORE}{31}{\code {.IGNORE}}
\entry {.SILENT}{32}{\code {.SILENT}}
\entry {.EXPORT{\_}ALL{\_}VARIABLES}{32}{\code {.EXPORT{\_}ALL{\_}VARIABLES}}
\entry {subst}{33}{\code {subst}}
\entry {$*, and static pattern}{36}{\code {$*\r {, and static pattern}}}
\entry {.SILENT}{41}{\code {.SILENT}}
\entry {SHELL (command execution)}{42}{\code {SHELL \r {(command execution)}}}
\entry {SHELL}{42}{\code {SHELL}}
\entry {.IGNORE}{44}{\code {.IGNORE}}
\entry {.DELETE{\_}ON{\_}ERROR}{45}{\code {.DELETE{\_}ON{\_}ERROR}}
\entry {.PRECIOUS}{46}{\code {.PRECIOUS}}
\entry {MAKE}{46}{\code {MAKE}}
\entry {export}{48}{\code {export}}
\entry {unexport}{48}{\code {unexport}}
\entry {.EXPORT{\_}ALL{\_}VARIABLES}{49}{\code {.EXPORT{\_}ALL{\_}VARIABLES}}
\entry {MAKELEVEL}{49}{\code {MAKELEVEL}}
\entry {MAKEFILES}{50}{\code {MAKEFILES}}
\entry {MAKEFLAGS}{50}{\code {MAKEFLAGS}}
\entry {MAKEOVERRIDES}{51}{\code {MAKEOVERRIDES}}
\entry {.POSIX}{51}{\code {.POSIX}}
\entry {MFLAGS}{51}{\code {MFLAGS}}
\entry {.DEFAULT, and empty commands}{54}{\code {.DEFAULT\r {, and empty commands}}}
\entry {MAKELEVEL}{58}{\code {MAKELEVEL}}
\entry {MAKE}{58}{\code {MAKE}}
\entry {patsubst}{59}{\code {patsubst}}
\entry {override}{66}{\code {override}}
\entry {define}{67}{\code {define}}
\entry {endef}{67}{\code {endef}}
\entry {ifdef}{72}{\code {ifdef}}
\entry {ifeq}{72}{\code {ifeq}}
\entry {ifndef}{72}{\code {ifndef}}
\entry {ifneq}{72}{\code {ifneq}}
\entry {else}{72}{\code {else}}
\entry {endif}{72}{\code {endif}}
\entry {subst}{78}{\code {subst}}
\entry {patsubst}{78}{\code {patsubst}}
\entry {strip}{79}{\code {strip}}
\entry {findstring}{79}{\code {findstring}}
\entry {filter}{80}{\code {filter}}
\entry {filter-out}{80}{\code {filter-out}}
\entry {sort}{80}{\code {sort}}
\entry {dir}{81}{\code {dir}}
\entry {notdir}{81}{\code {notdir}}
\entry {suffix}{82}{\code {suffix}}
\entry {basename}{82}{\code {basename}}
\entry {addsuffix}{82}{\code {addsuffix}}
\entry {addprefix}{82}{\code {addprefix}}
\entry {join}{82}{\code {join}}
\entry {word}{83}{\code {word}}
\entry {words}{83}{\code {words}}
\entry {firstword}{83}{\code {firstword}}
\entry {wildcard}{83}{\code {wildcard}}
\entry {foreach}{83}{\code {foreach}}
\entry {origin}{85}{\code {origin}}
\entry {shell}{87}{\code {shell}}
\entry {OUTPUT{\_}OPTION}{106}{\code {OUTPUT{\_}OPTION}}
\entry {AR}{107}{\code {AR}}
\entry {AS}{107}{\code {AS}}
\entry {CC}{107}{\code {CC}}
\entry {CXX}{107}{\code {CXX}}
\entry {CO}{107}{\code {CO}}
\entry {CPP}{107}{\code {CPP}}
\entry {FC}{107}{\code {FC}}
\entry {GET}{107}{\code {GET}}
\entry {LEX}{107}{\code {LEX}}
\entry {PC}{107}{\code {PC}}
\entry {YACC}{107}{\code {YACC}}
\entry {YACCR}{107}{\code {YACCR}}
\entry {MAKEINFO}{107}{\code {MAKEINFO}}
\entry {TEX}{107}{\code {TEX}}
\entry {TEXI2DVI}{107}{\code {TEXI2DVI}}
\entry {WEAVE}{107}{\code {WEAVE}}
\entry {CWEAVE}{107}{\code {CWEAVE}}
\entry {TANGLE}{107}{\code {TANGLE}}
\entry {CTANGLE}{107}{\code {CTANGLE}}
\entry {RM}{107}{\code {RM}}
\entry {ARFLAGS}{108}{\code {ARFLAGS}}
\entry {ASFLAGS}{108}{\code {ASFLAGS}}
\entry {CFLAGS}{108}{\code {CFLAGS}}
\entry {CXXFLAGS}{108}{\code {CXXFLAGS}}
\entry {COFLAGS}{108}{\code {COFLAGS}}
\entry {CPPFLAGS}{108}{\code {CPPFLAGS}}
\entry {FFLAGS}{108}{\code {FFLAGS}}
\entry {GFLAGS}{108}{\code {GFLAGS}}
\entry {LDFLAGS}{108}{\code {LDFLAGS}}
\entry {LFLAGS}{108}{\code {LFLAGS}}
\entry {PFLAGS}{108}{\code {PFLAGS}}
\entry {RFLAGS}{108}{\code {RFLAGS}}
\entry {YFLAGS}{108}{\code {YFLAGS}}
\entry {${\tt\char'100}}{112}{\code {${\tt\char'100}}}
\entry {{\tt\char'100} (automatic variable)}{112}{\code {{\tt\char'100} \r {(automatic variable)}}}
\entry {$%}{112}{\code {$%}}
\entry {% (automatic variable)}{112}{\code {% \r {(automatic variable)}}}
\entry {${\tt\less}}{112}{\code {${\tt\less}}}
\entry {{\tt\less} (automatic variable)}{112}{\code {{\tt\less} \r {(automatic variable)}}}
\entry {$?}{112}{\code {$?}}
\entry {? (automatic variable)}{112}{\code {? \r {(automatic variable)}}}
\entry {${\tt\hat}}{112}{\code {${\tt\hat}}}
\entry {{\tt\hat} (automatic variable)}{112}{\code {{\tt\hat} \r {(automatic variable)}}}
\entry {${\tt\char43}}{112}{\code {${\tt\char43}}}
\entry {{\tt\char43} (automatic variable)}{112}{\code {{\tt\char43} \r {(automatic variable)}}}
\entry {$*}{112}{\code {$*}}
\entry {* (automatic variable)}{112}{\code {* \r {(automatic variable)}}}
\entry {$({\tt\char'100}D)}{113}{\code {$({\tt\char'100}D)}}
\entry {{\tt\char'100}D (automatic variable)}{113}{\code {{\tt\char'100}D \r {(automatic variable)}}}
\entry {$({\tt\char'100}F)}{113}{\code {$({\tt\char'100}F)}}
\entry {{\tt\char'100}F (automatic variable)}{113}{\code {{\tt\char'100}F \r {(automatic variable)}}}
\entry {$(*D)}{113}{\code {$(*D)}}
\entry {*D (automatic variable)}{113}{\code {*D \r {(automatic variable)}}}
\entry {$(*F)}{113}{\code {$(*F)}}
\entry {*F (automatic variable)}{113}{\code {*F \r {(automatic variable)}}}
\entry {$(%D)}{113}{\code {$(%D)}}
\entry {%D (automatic variable)}{113}{\code {%D \r {(automatic variable)}}}
\entry {$(%F)}{113}{\code {$(%F)}}
\entry {%F (automatic variable)}{113}{\code {%F \r {(automatic variable)}}}
\entry {$({\tt\less}D)}{114}{\code {$({\tt\less}D)}}
\entry {{\tt\less}D (automatic variable)}{114}{\code {{\tt\less}D \r {(automatic variable)}}}
\entry {$({\tt\less}F)}{114}{\code {$({\tt\less}F)}}
\entry {{\tt\less}F (automatic variable)}{114}{\code {{\tt\less}F \r {(automatic variable)}}}
\entry {$({\tt\hat}D)}{114}{\code {$({\tt\hat}D)}}
\entry {{\tt\hat}D (automatic variable)}{114}{\code {{\tt\hat}D \r {(automatic variable)}}}
\entry {$({\tt\hat}F)}{114}{\code {$({\tt\hat}F)}}
\entry {{\tt\hat}F (automatic variable)}{114}{\code {{\tt\hat}F \r {(automatic variable)}}}
\entry {$(?D)}{114}{\code {$(?D)}}
\entry {?D (automatic variable)}{114}{\code {?D \r {(automatic variable)}}}
\entry {$(?F)}{114}{\code {$(?F)}}
\entry {?F (automatic variable)}{114}{\code {?F \r {(automatic variable)}}}
\entry {.DEFAULT}{117}{\code {.DEFAULT}}
\entry {.SUFFIXES}{118}{\code {.SUFFIXES}}
\entry {SUFFIXES}{119}{\code {SUFFIXES}}
\entry {* (automatic variable), unsupported bizarre usage}{129}{\code {* \r {(automatic variable), unsupported bizarre usage}}}

Some files were not shown because too many files have changed in this diff Show More