jam-2.2-215.tar

./src/ 40750    167    454           0  7102105142  10166 5ustar  laurateam./src/Build.com100550    167    454        1267  7102105133  12031 0ustar  laurateam! Bootstrap build script for Jam
$ cc command.c
$ cc compile.c
$ cc expand.c
$ cc execvms.c
$ cc filevms.c
$ cc glob.c
$ cc hash.c
$ cc headers.c
$ cc jambase.c
$ cc lists.c
$ cc make.c
$ cc make1.c
$ cc newstr.c
$ cc option.c
$ cc parse.c
$ cc pathvms.c
$ cc regexp.c
$ cc rules.c
$ cc scan.c
$ cc search.c
$ cc timestamp.c
$ cc variable.c
$ cc jam.c
$ cc jamgram.c
$ link/exe=jam.exe command.obj, compile.obj, execvms.obj, expand.obj, -
    filevms.obj, glob.obj, hash.obj, headers.obj, lists.obj, make.obj, -
    make1.obj, newstr.obj, option.obj, parse.obj, pathvms.obj, regexp.obj, -
    rules.obj, scan.obj, search.obj, timestamp.obj, variable.obj, jam.obj, -
    jamgram.obj, jambase.obj
./src/Build.mpw100440    167    454        6442  7102105133  12054 0ustar  laurateam# These two lines must be set manually to the CodeWarrior Pro 3 installation
# and the CWGUSI 1.8 tree.  Good luck!

set CW "PowerUser HD:Metrowerks:Metrowerks CodeWarrior"
set CWGUSI "PowerUser HD:Perforce:CWGUSI" 

set MWCincludes "{CWGUSI}:include,{CW}:MacOS Support:Headers:Universal Headers,{CW}:Metrowerks Standard Library:MSL C:MSL Common:Public Includes,{CW}:Metrowerks Standard Library:MSL C:MSL Mac:Public Includes" 

mwcppc  -o :bin.mac:command.o  -eol -w off   command.c  
mwcppc  -o :bin.mac:compile.o  -eol -w off   compile.c  
mwcppc  -o :bin.mac:execmac.o  -eol -w off   execmac.c  
mwcppc  -o :bin.mac:filemac.o  -eol -w off   filemac.c  
mwcppc  -o :bin.mac:pathmac.o  -eol -w off   pathmac.c  
mwcppc  -o :bin.mac:jamgram.o  -eol -w off   jamgram.c  
mwcppc  -o :bin.mac:expand.o  -eol -w off   expand.c  
mwcppc  -o :bin.mac:glob.o  -eol -w off   glob.c  
mwcppc  -o :bin.mac:hash.o  -eol -w off   hash.c  
mwcppc  -o :bin.mac:headers.o  -eol -w off   headers.c  
mwcppc  -o :bin.mac:lists.o  -eol -w off   lists.c  
mwcppc  -o :bin.mac:make.o  -eol -w off   make.c  
mwcppc  -o :bin.mac:make1.o  -eol -w off   make1.c  
mwcppc  -o :bin.mac:newstr.o  -eol -w off   newstr.c  
mwcppc  -o :bin.mac:option.o  -eol -w off   option.c  
mwcppc  -o :bin.mac:parse.o  -eol -w off   parse.c  
mwcppc  -o :bin.mac:regexp.o  -eol -w off   regexp.c  
mwcppc  -o :bin.mac:rules.o  -eol -w off   rules.c  
mwcppc  -o :bin.mac:scan.o  -eol -w off   scan.c  
mwcppc  -o :bin.mac:search.o  -eol -w off   search.c  
mwcppc  -o :bin.mac:timestamp.o  -eol -w off   timestamp.c  
mwcppc  -o :bin.mac:variable.o  -eol -w off   variable.c  

mwlinkppc  -library -o :bin.mac:libjam.lib  :bin.mac:command.o :bin.mac:compile.o :bin.mac:execmac.o :bin.mac:filemac.o :bin.mac:pathmac.o :bin.mac:jamgram.o :bin.mac:expand.o :bin.mac:glob.o :bin.mac:hash.o :bin.mac:headers.o :bin.mac:lists.o :bin.mac:make.o :bin.mac:make1.o :bin.mac:newstr.o :bin.mac:option.o :bin.mac:parse.o :bin.mac:regexp.o :bin.mac:rules.o :bin.mac:scan.o :bin.mac:search.o :bin.mac:timestamp.o :bin.mac:variable.o 
mwcppc  -o :bin.mac:mkjambase.o  -eol -w off   mkjambase.c  

mwlinkppc  -o :bin.mac:mkjambase  -mpwtool -warn  :bin.mac:mkjambase.o   "{CWGUSI}:Lib:GUSIMPW.Lib.PPC" "{CWGUSI}:Lib:MSLGUSI.Lib.PPC" "{CW}:MacOS Support:Libraries:MacOS Common:Interfacelib" "{CW}:MacOS Support:Libraries:MacOS PPC:PPCToolLibs.o" "{CW}:MacOS Support:Libraries:MacOS Common:PLStringFuncs Glue:PLStringFuncsPPC.lib" "{CW}:MacOS Support:Libraries:Runtime:Runtime PPC:MSL MPWCRuntime.lib" "{CW}:Metrowerks Standard Library:MSL C:Bin:MSL C.PPC MPW(NL).Lib" "{CW}:MacOS Support:Libraries:MacOS Common:Mathlib" 
mwcppc  -o :bin.mac:jam.o  -eol -w off   jam.c  

:bin.mac:mkjambase  jambase.c  Jambase 

mwcppc  -o :bin.mac:jambase.o  -eol -w off   jambase.c  

mwlinkppc  -o :bin.mac:jam  -mpwtool -warn  :bin.mac:jam.o :bin.mac:jambase.o  :bin.mac:libjam.lib  "{CWGUSI}:Lib:GUSIMPW.Lib.PPC" "{CWGUSI}:Lib:MSLGUSI.Lib.PPC" "{CW}:MacOS Support:Libraries:MacOS Common:Interfacelib" "{CW}:MacOS Support:Libraries:MacOS PPC:PPCToolLibs.o" "{CW}:MacOS Support:Libraries:MacOS Common:PLStringFuncs Glue:PLStringFuncsPPC.lib" "{CW}:MacOS Support:Libraries:Runtime:Runtime PPC:MSL MPWCRuntime.lib" "{CW}:Metrowerks Standard Library:MSL C:Bin:MSL C.PPC MPW(NL).Lib" "{CW}:MacOS Support:Libraries:MacOS Common:Mathlib" 
./src/Jam.html100440    167    454       32503  7102105133  11702 0ustar  laurateam<HTML>
<TITLE>
Jam/MR "jam"
</TITLE>
<BODY>
<CENTER>
<A NAME="TOP">
<H1>
jam 
</H1>
</a>
<P>
The 
<a href=http://www.perforce.com/jam/jam.html>
Jam/MR 
</a>
Executable Program
</CENTER>
<P>
<H2>
USAGE
</H2>
<PRE>
	jam [ -a ] [ -n ] [ -v ] [ -d <I>debug</I> ] [ -f <I>rulesfile</I> ... ] 
	    [ -j <I>jobs</I> ] [ -s <I>var</I>=<I>value</I> ... ] [ -t <I>target</I> ... ] 
	    [  <I>target</I> ... ] [ -o <I>actionsfile</I> ]
</PRE>

<H2>
DESCRIPTION
</H2>
<P>
	<B>jam,</B> the Jam/MR executable program,
       recursively  builds  target files  from source files
       using dependency and build specification rules defined 
       in <i>rulesfile</i>.
	<B>jam</B> parses <i>rulesfile</i> to identify targets
	and sources,
	examines the filesystem to determine which
	targets need updating, and issues OS commands to update
	targets.
<P>
 	Normally, <i>rulesfile</i> is compiled into <B>jam</B>,
	allowing <B>jam</B> to be run as a stand-alone program.
	A base set of build rules is provided in the
	file "Jambase", and is described in
	<a href="Jamfile.html">Using Jamfiles and Jambase</A>
	and the
	<a href="Jambase.html">Jambase Reference</a>.
	For general information, refer to the
	<a href="Jamlang.html">Jam/MR Language</A> document.
<P>
       If <I>target</I> is provided on the command line, <B>jam</B> attempts to
       build <I>target;</I> otherwise <B>jam</B>  attempts  to  build  the
       target 'all'.
<P>
<H2>

OPTIONS
</H2>
<P>
       <b>jam</b> may be invoked with the following options:
<PRE>
       -a     Build all targets anyway, even if they are up-to-date.

       -d&lt;n&gt;  Enable cummulative debugging levels from 1 to &lt;n&gt;.  
	      Interesting values are:

              1 Show actions (the default)
              2 Show "quiet" actions and display all action text
              3 Show dependency analysis, and target/source timestamps/paths 
	      4 Show shell arguments
	      5 Show rule invocations and variable expansions
	      6 Show directory/header file/archive scans
	      7 Show variable settings
	      8 Show variable fetches
	      9 Show variable manipulation, scanner tokens

       -d+&lt;n&gt; Enable debugging level &lt;n&gt;.

       -d0    Turn off all debugging levels.  Only errors are not
              suppressed.

       -f&lt;rulesfile&gt;
              Read &lt;rulesfile&gt; instead of Jambase.

       -j&lt;n&gt;
              Run  up to &lt;n&gt; shell commands concurrently (UNIX
              only).  The default is 1.

       -n     Don't actually execute the updating actions, but do
              everything else.  This changes the debug level default 
	            to -d2.

       -o     Write the updating actions to the specified file instead
              of running them (or outputting them, as on the Mac).

       -s&lt;var&gt;=&lt;value&gt;
              Set  the variable &lt;var&gt; to &lt;value&gt;, overriding both
              internal variables and variables imported from  the
              environment.

       -t&lt;target&gt;
              Rebuild &lt;target&gt;, even if it is up-to-date, and/or build 
              dependencies of &lt;target&gt; as if &lt;target&gt; were newer.

       -v     Print the version of <B>jam</B> and exit.
</PRE>
<P>
<H2>
OPERATION
</H2>
<P>
       <b>jam</b> has three phases of operation: parsing,  binding,  and
       updating.
<H3>
   Parsing
</H3>  
<P>    
	In the parsing phase, <b>jam</b> reads the rules file(s),
	evaluates variables, identifies and invokes rules, 
	identifies targets, and builds the dependency graph.
<P>    
	Which rules files get read depends on 
	the site-specific implementation of <b>jam</b>.
	The normal implementation is this: <b>jam</b> reads the Jambase
	rules file, the text of which is stored inside the <b>jam</b>
	executable itself. Jambase may "include" other rules files, and
	the last rule invoked from Jambase is
	"include Jamfile", which reads file "Jamfile" from the current
	directory. Jamfile is expected to specify which targets get
	built from the source files in the current directory.
	(All of this is explained in detail in
	<a href="Jamfile.html">Using Jamfiles and Jambase</a>.)
	If there's no Jamfile in the current directory, <b>jam</b>
	emits a message and exits.
<P>    
	Environment variable settings are imported into Jam/MR variables.
	To pass a value to a variable on the <b>jam</b> command line,
	overriding the variable's environment value, use the -s option.
	To see variable assignments made during <b>jam</b>'s execution,
	use the -d+7 option.
<P>
	Rules are defined in rules files using the Jam/MR language,
	and are invoked in rules files after they are defined.
	Targets are identified by rule invocations. At the completion
	of the parsing phase, all targets are uniquely identified
	and a dependency graph is constructed.
<P>
<H3>
   Binding
</H3>  
<P>    
       After parsing, <B>jam</B>  recursively  descends  the  dependency
       graph and binds every file target with a location in the filesystem.
       The existence and modification times of the bound files are 
       used to determine which targets need 
       updating.  If <B>jam</B> detects a  circular
       dependency in the graph, it issues a warning.
<P>
	A file target is bound with a location as follows:

	<UL>
	<LI>If $(LOCATE) is set, the target is bound
	    to the path described by the first element in $(LOCATE). 
	    <P>

	<LI>If $(LOCATE) is not set, and the target has any updating
	    actions associated with it, the target is bound to the
	    current directory of the <b>jam</b> invocation.
	    <P>

	<LI>If $(LOCATE) is not set, and the target has no updating
	    actions associated with it, 
	    and $(SEARCH) is set,
	    <b>jam</b> searches the directories in the $(SEARCH) list.
	    The first directory in the list in which the target is
	    found becomes the target's bound path. If the target is
	    not found, it is bound to the current directory of the
	    <b>jam</b> invocation.
	    <P>

        <LI>If neither $(SEARCH) nor $(LOCATE) are set, the target
	    is bound to the current directory of the <b>jam</b> invocation.
	    <P>

	<LI>If the target's identifier contains a rooted pathname,
		none of the above applies, and the target's bound
		location is that path.
		<P>

	<LI>Unrooted pathnames used in $(SEARCH), $(LOCATE), or
		target identifiers are relative to the 
		current directory where <B>jam</B> was invoked.
		<P>

	<LI>Target-specific values of $(SEARCH) and $(LOCATE)
	    always have precedence over global values in binding.
	    <P>

	</UL>


<P>
       After binding each target, <B>jam</B> determines whether the target  
       needs updating, and marks the target if necessary for
       the updating phase.  A target is marked for  updating  for
       any of these three reasons:
<UL>
<LI>
              It is missing.
<LI>
              Its  filesystem modification time is older than any
              of its sources.
<LI>
              Any of its sources are marked for updating.
</UL>
<P>
       For targets of the built-in rules ALWAYS, LEAVES,
       NOCARE, TEMPORARY, NOTFILE, and NOUPDATE, <b>jam</b>'s updating
       behavior is slightly different:
<P>
<BLOCKQUOTE>
<DL>
<DT>
              ALWAYS 
<DD>
		The target is always updated.
<DT>
              LEAVES 
<DD>
		The  target is only updated if it is missing
                     or if its  leaf  sources  are  newer.   Leaf
                     sources are those dependencies of the target
                     that have no dependencies themselves.
<DT>
              NOCARE 
<DD>
		The target is ignored if it is  missing  and
                     has  no  updating  actions.   Normally,  <B>jam</B>
                     issues a warning  and  skips  other  targets
                     that   depend  on  missing  targets  without
                     updating actions.
<DT>
              TEMPORARY
<DD>
                     If the target is missing, then its  source's
                     modification  time  is  used  when comparing
                     against dependencies.
<DT>
              NOTFILE
<DD>
                     The target is only updated  if  any  of  its
                     sources are marked for updating.
<DT>
              NOUPDATE
<DD>
                     The target is only updated if it is missing.
                     Also, if it exists, it will appear eternally
                     old;  that  is,  older  than  anything  that
                     depends on it.
</DL>
</BLOCKQUOTE>
<P>
       If $(HDRSCAN) is set on a file target,
       <B>jam</B>  scans  the file for header file include lines.
       It scans the file by matching each  line  against  a  
       regexp(3) pattern that has ()'s surrounding the included file
       name.  The pattern is provided by  the  user  through  the
       special variable $(HDRSCAN) (see HDRPATTERN in Jambase for
       an example).  The result of the scan is formed into a rule
       invocation,  with  the  scanned file as the target and the
       found included  file  names  as  the  sources.   The  rule
       invoked  is named by the special variable $(HDRRULE).  <b>jam</b>
       only scans files if $(HDRSCAN) is set, and  $(HDRSCAN)  is
       normally set target-specific.
<P>
       Between  binding and updating, <B>jam</B> announces the number of
       targets to be updated.
<P>
<H3>
   Updating
</H3>  
<P>    
       After binding, <B>jam</B> again recursively descends  the  dependency  graph,  this  time executing the update actions for
       each target marked for update during  the  binding  phase.
       If  a  target's  updating  actions  fail, then all targets
       which depend on it are skipped.
<P>
       The -j flag instructs <B>jam</B> to build more than
       one  target at a time.  If there are multiple actions on a
       single target, they are run sequentially.
<P>
       The special variable $(JAMSHELL) gives <B>jam</B> a
       command  execution  shell  to  be used instead of /bin/sh.
       This variable's value must be a multi-element list, 
       corresponding to the argument vector for the command shell.  An
       element "%" is replaced with the command  string  to  execute.   
       An  element  "!" is replaced with the multiprocess
       slot number, which is (inclusively) between 1 and the maximum  
       number of concurrent jobs specified with the -j flag
       (default 1).  If no element of the list is "%",  the  command  
       string  is  tacked  on  as  the  last argument.  The
       default value is: "/bin/sh -c %".
<P>
<H2>
DIAGNOSTICS
</H2>  
<P>    
       In addition to generic error messages, <B>jam</B> may emit one of
       the following:
<PRE>
       warning: unknown rule X

              A  rule  was invoked that has not been defined with
              an "actions" or "rule" statement.

       using N temp target(s)

              Targets marked as being temporary (but  nonetheless
              present) have been found.

       updating N target(s)

              Targets are out-of-date and will be updated.

       can't find N target(s)

              Source  files  can't  be  found  and  there  are no
              actions to create them.

       can't make N target(s)

              Due to sources not being found, other targets  cannot be made.

       warning: X depends on itself

              A  target  depends  on  itself  either  directly or
              through its sources.

       don't know how to make X

              A target is not present and no  actions  have  been
              defined to create it.

       X skipped for lack of Y

              A  source failed to build, and thus a target cannot
              be built.

       warning: using independent target X

              A target that does is not a dependency of any other
              target is being referenced with $(&lt;) or $(&gt;).

       X removed

              <b>jam</b>  removed  a  partially built target after being
              interrupted.
</PRE>
<P>
<H2>
BUGS, LIMITATIONS
</H2>
<P>
	The -j flag can cause <B>jam</B> to get confused when
	single actions update more than
	one target at a time. <B>jam</B> may try to execute
	actions to build those targets' dependencies before
	the targets themselves have all been built.
<P>
       With the -j flag, errors  from  failed  commands  can  get
       staggeringly  mixed up.  Also, because targets tend to get
       built in a quickest-first ordering, dependency information
       must  be  quite  exact.   Finally, beware of parallelizing
       commands that drop  fixed-named  files  into  the  current
       directory, like yacc(1) does.
<P>
       A  poorly  set  $(JAMSHELL)  is likely to result in silent
       failure.
<P>
<H2>
SEE ALSO
</H2>
<P>
<UL>
<LI>
	<a href="Jambase.html">Using Jamfiles and Jambase</a>
<LI>
	<a href="Jambase.html">Jambase Reference</a>
<LI>
	<a href="Jamlang.html">The Jam/MR Language</A>
</UL>
Jam/MR documentation and source are available from the
<A HREF=http://public.perforce.com/public/index.html>Perforce Public Depot</a>.
<P>    
<H2>
AUTHOR
</H2>  
<P>   
       Jam/MR's author is Christopher Seiwald (<a href="mailto:seiwald@perforce.com">seiwald@perforce.com)</A>.
	Documentation is provided by 
	<A HREF="http://www.perforce.com">Perforce Software, Inc.</A>

<P>   
<HR>   
<A HREF="#TOP">Back to top.</A>
<P>
        Copyright 1997, 1999 Perforce Software, Inc.
        <BR>
        Comments to <A HREF="mailto:info@perforce.com">info@perforce.com</A>
        <BR>
        Last updated: Jan 27, 1999
</BODY> 
</HTML>

./src/Jambase100440    167    454      113006  7102105134  11611 0ustar  laurateam#
# /+\
# +\	Copyright 1993, 1995 Christopher Seiwald.
# \+/
#
# This file is part of Jam - see jam.c for Copyright information.
#

#
# JAMBASE - jam 2.1 ruleset providing make(1)-like functionality
#
# Supports UNIX, NT, and VMS.
#
# 12/27/93 (seiwald) - purturb library sources with SOURCE_GRIST
# 04/18/94 (seiwald) - use 'default =' when setting OS specific vars
# 04/21/94 (seiwald) - do RmTemps together
# 05/05/94 (seiwald) - all supported C compilers support -o: relegate
#		       RELOCATE as an option; set Ranlib to "" to disable it
# 06/01/94 (seiwald) - new 'actions existing' to do existing sources
# 08/25/94 (seiwald) - new ObjectCcFlags rule to append to per-target CCFLAGS
# 08/29/94 (seiwald) - new ObjectHdrs rule to append to per-target HDRS
# 09/19/94 (seiwald) - LinkLibraries and Undefs now append
#		     - Rule names downshifted.
# 10/06/94 (seiwald) - Dumb yyacc stuff moved into Jamfile.
# 10/14/94 (seiwald) - (Crude) support for .s, .C, .cc, .cpp, and .f files.
# 01/08/95 (seiwald) - Shell now handled with awk, not sed
# 01/09/95 (seiwald) - Install* now take dest directory as target
# 01/10/95 (seiwald) - All entries sorted.
# 01/10/95 (seiwald) - NT support moved in, with LauraW's help.  
# 01/10/95 (seiwald) - VMS support moved in.
# 02/06/95 (seiwald) - ObjectC++Flags and SubDirC++Flags added.
# 02/07/95 (seiwald) - Iron out when HDRSEARCH uses "" or SEARCH_SOURCE.
# 02/08/95 (seiwald) - SubDir works on VMS.
# 02/14/95 (seiwald) - MkDir and entourage.
# 04/30/95 (seiwald) - Use install -c flag so that it copies, not moves.
# 07/10/95 (taylor) - Support for Microsoft C++.
# 11/21/96 (peterk) - Support for BeOS
# 07/19/99 (sickel) - Support for Mac OS X Server (and maybe client)

# Special targets defined in this file:
#
# all		- parent of first, shell, files, lib, exe
# first		- first dependent of 'all', for potential initialization
# shell		- parent of all Shell targets 
# files		- parent of all File targets
# lib		- parent of all Library targets
# exe		- parent of all Main targets
# dirs		- parent of all MkDir targets
# clean		- removes all Shell, File, Library, and Main targets
# uninstall	- removes all Install targets
#	

# Rules defined by this file:
#
# as obj.o : source.s ;			.s -> .o
# Bulk dir : files ;			populate directory with many files
# Cc obj.o : source.c ;			.c -> .o
# C++ obj.o : source.cc ;		.cc -> .o
# Clean clean : sources ;		remove sources with 'jam clean'
# File dest : source ;			copy file
# Fortran obj.o : source.f ;		.f -> .o
# GenFile source.c : program args ;	make custom file
# Hardlink target : source ;		make link from source to target
# HdrRule source : headers ;		handle #includes
# InstallInto dir : sources ;		install any files
# InstallBin dir : sources ;		install binaries
# InstallLib dir : sources ;		install files
# InstallFile dir : sources ;		install files
# InstallMan dir : sources ;		install man pages
# InstallShell dir : sources ;		install shell scripts
# Lex source.c : source.l ;		.l -> .c
# Library lib : source ;		archive library from compiled sources
# LibraryFromObjects lib : objects ;	archive library from objects
# LinkLibraries images : libraries ;	bag libraries onto Mains
# Main image : source ;			link executable from compiled sources
# MainFromObjects image : objects ;	link executable from objects
# MkDir dir ;				make a directory, if not there
# Object object : source ;		compile object from source
# ObjectCcFlags source : flags ;	add compiler flags for object
# ObjectC++Flags source : flags ;	add compiler flags for object
# ObjectHdrs source : dirs ;		add include directories for object
# Objects sources ;			compile sources
# RmTemps target : sources ;		remove temp sources after target made
# Setuid images ;			mark executables Setuid
# SubDir TOP d1 d2 ... ;		start a subdirectory Jamfile
# SubDirCcFlags flags ;			add compiler flags until next SubDir
# SubDirC++Flags flags ;		add compiler flags until next SubDir
# SubDirHdrs dirs ;			add include dirs until next SubDir
# SubInclude TOP d1 d2 ... ;		include a subdirectory Jamfile
# Shell exe : source ;			make a shell executable
# Undefines images : symbols ;		save undef's for linking
# UserObject object : source ;		handle unknown suffixes for Object
# Yacc source.c : source.y ;		.y -> .c
#
# Utility rules that have no side effects:
#
# makeSubDir var : d1 d2 ... ;		$(var) = path to root
# addDirName var : d1 d2 ... ;		$(var) += path from root to dir
# makeDirName var : d1 d2 ... ;		$(var) = path from root to dir
# makeGrist var : d1 d2 ... ;		$(var) = grist form of dir
# makeGristedName var : value ;		$(var) = $(value:G=$(SOURCE_GRIST))
# makeCommon var1 : var2 ;		strip common initial elements
# makeRelPath var d1 : d2 ;		$(var) = rel path from d1 to d2
# makeSuffixed var $(SUF) : f1 f2 ... ; $(var) = $(>) with suffixes
# makeString var : value ... ;          $(var) = contatenated values
#

# Brief review of the jam language:
#
# Statements:
#	rule RULE - statements to process a rule
#	actions RULE - system commands to carry out target update
#
# Modifiers on actions:
#	together - multiple instances of same rule on target get executed
#		   once with their sources ($(>)) concatenated
#	updated - refers to updated sources ($(>)) only
#	ignore - ignore return status of command
#	quietly - don't trace its execution unless verbose
#	piecemeal - iterate command each time with a small subset of $(>)
#	existing - refers to currently existing sources ($(>)) only
#
# Special rules:
#	ALWAYS - always build a target
#	DEPENDS - builds the dependency graph
#	ECHO - blurt out targets on stdout
#	EXIT - blurt out targets and exit
#	INCLUDES - marks sources as headers for target (a codependency)
#	NOCARE - don't panic if the target can't be built
#	NOUPDATE - create the target if needed but never update it 
#	NOTFILE - ignore the timestamp of the target (it's not a file)
#	TEMPORARY - target need not be present if sources haven't changed
#
# Special variables set by jam:
#	$(<) - targets of a rule (to the left of the :)
#	$(>) - sources of a rule (to the right of the :)
#	$(UNIX) - true on UNIX
#	$(VMS) - true on VMS
#	$(NT) - true on NT
#	$(OS) - name of OS - varies wildly
#	$(JAMVERSION) - version number (2.1)
#
# Special variables used by jam:
#	SEARCH - where to find something (used during binding and actions)
#	LOCATE - where to plop something not found with SEARCH
#	HDRRULE - rule to call to handle include files
#	HDRSCAN - egrep regex to extract include files
#
# Special targets:
#	all - default if none given on command line
#

# Initialize variables
#
# "default =" - set only if unset

OSFULL = $(OS)$(OSPLAT)$(OSVER) $(OS)$(OSPLAT) $(OS)$(OSVER) $(OS) ;

#
# OS specific variable settings
#

switch $(OS)
{
case AIX :	LINKLIBS default = -lbsd ;
case DGUX :	RANLIB default = "" ; RELOCATE = true ;
case HPUX :	RANLIB default = "" ;
		INSTALL default = "" ;
case INTERIX :	RANLIB default = "" ;
		JAMSHELL default = "sh -c" ;
		CC default = gcc ;
case IRIX :	RANLIB default = "" ;
		INSTALL default = "" ;
case MVS :	RANLIB default = "" ; 
case NEXT :	AR default = libtool -o ;
		RANLIB default = "" ;
case MACOSX : AR default = libtool -o ;
              RANLIB default = "" ;
              C++ default = c++ ;
              MANDIR default = /usr/local/share/man ;
case NCR :	RANLIB default = "" ;
		INSTALL default = "" ;
case PTX :	RANLIB default = "" ;
case QNX :	INSTALL default = "" ;
case SCO :	RANLIB default = "" ;
		INSTALL default = "" ; RELOCATE = true ;
case SINIX :	RANLIB default = "" ;
case SOLARIS :	RANLIB default = "" ;
		INSTALL default = "install" ;
		AR default = "/usr/ccs/bin/ar ru" ;
case UNIXWARE :	RANLIB default = "" ; RELOCATE = true ;
}

#if $(OS) = SUNOS && $(TZ)
#{
#	Echo Warning: you are running the SunOS jam on Solaris. ;
#}

if $(UNIX)
{
	if $(OS) = QNX 
	{
	AR		default = wlib ;
	CC		default = cc ;
	CCFLAGS		default = -Q ;	# quiet
	C++		default = $(CC) ;
	C++FLAGS	default = -Q ;	# quiet
	LINK		default = $(CC) ;
	LINKFLAGS	default = -Q ;	# quiet
	NOARSCAN	default = true ;
	RANLIB		default = "" ;
	}
	else if $(OS) = BEOS && $(METROWERKS)
	{
	AR		default = mwld -xml -o ;
	BINDIR		default = /boot/bin ;
	CC		default = mwcc ;
	CCFLAGS		default = -nosyspath ;
	C++		default = $(CC) ;
	C++FLAGS	default = -nosyspath ;
	FORTRAN		default = "" ;
	LIBDIR		default = /boot/develop/libraries ;
	LINK		default = mwld ;
	LINKFLAGS	default = "" ;
	LEX		default = "" ;
	MANDIR		default = /boot/documentation/"Shell Tools"/HTML ;
	NOARSCAN	default = true ;
	RANLIB		default = "" ;	
	STDHDRS		default = /boot/develop/headers/posix ;
	YACC		default = "" ;
	YACCFLAGS	default = "" ;
	YACCFILES	default = "" ;
	}
	else if $(OS) = BEOS 
	{
	BINDIR		default = /boot/bin ;
	CC		default = gcc ;
	C++		default = $(CC) ;
	FORTRAN		default = "" ;
	LIBDIR		default = /boot/develop/libraries ;
	LINK		default = gcc ;
	LINKLIBS	default = -lnet ;
	LEX		default = "" ;
	NOARSCAN	default = true ;
	RANLIB		default = "" ;	
	STDHDRS		default = /boot/develop/headers/posix ;
	YACC		default = "" ;
	YACCFLAGS	default = "" ;
	YACCFILES	default = "" ;
	}
	else if $(OS) = AMIGA
	{
	CC				default = gcc ;
	YACC			default = bison ;
	YACCFLAGS	default = -d ;
	YACCFILES	default = y.tab ;
	}

	AR		default = ar ru ;
	AS		default = as ;
	AWK		default = awk ;
	ASFLAGS		default = ;
	BINDIR		default = /usr/local/bin ;
	C++		default = gcc ;
	C++FLAGS	default = ;
	CC		default = cc ;
	CCFLAGS		default = ;
	CP		default = cp ;
	CHMOD		default = chmod ;
	DOT		default	= . ;
	DOTDOT		default	= .. ;
	EXEMODE		default = 711 ;
	FILEMODE	default = 644 ;
	FORTRAN		default = f77 ;
	FORTRANFLAGS	default = ;
	HDRS		default = ;
	INSTALL		default = install -c ;
	LEX		default = lex ;
	LIBDIR		default = /usr/local/lib ;
	LINK		default = $(CC) ;
	LINKFLAGS	default = $(CCFLAGS) ;
	LINKLIBS	default = ;
	LN		default = ln ;
	MANDIR		default = /usr/local/man ;
	MKDIR		default = mkdir ;
	MV		default = mv -f ;
	OPTIM		default = -O ;
	RANLIB		default = ranlib ;
	RCP		default = rcp ;
	RSH		default = rsh ;
	RM		default = rm -f ;
	SED		default = sed ;
	SHELLHEADER	default = "#!/bin/sh" ;
	SHELLMODE	default = 755 ;
	SLASH		default = / ;
	STDHDRS		default = /usr/include ;
	SUFLIB		default = .a ;
	SUFOBJ		default = .o ;
	SUFEXE		default = "" ;
	UNDEFFLAG	default = "-u _" ;
	YACC		default = yacc ;
	YACCFLAGS	default = -d ;
	YACCFILES	default = y.tab ;
}
else if $(NT)
{
	AWK		default = awk ;
	CHMOD		default = chmod ;
    	CP		default = copy ;
	DOT		default	= . ;
	DOTDOT		default	= .. ;
	EXEMODE		default = 711 ;
	FILEMODE	default = 644 ;
	MKDIR		default = mkdir ;
	MV		default = mv -f ;
	OS			= NT ;		# replace Windows_NT
	RCP		default = rcp ;
	RSH		default = rsh ;
    	RM		default = del /f/q ;
	SED		default = sed ;
    	SLASH		default = \\ ;
    	SUFLIB		default = .lib ;
    	SUFOBJ		default = .obj ;
    	SUFEXE		default = .exe ;
     
    if $(BCCROOT)
    {
	ECHO "Compiler is Borland C++" ;

	AR		default = tlib ;
	ARFLAGS		default = /C /P64 ;
	CC		default = bcc32 ;
	CCFLAGS		default = -v -w- -DNT ;
	C++		default = bcc32 ;
	C++FLAGS	default = -v -w- ;
	LINK		default = $(CC) ;
	LINKFLAGS	default = $(CCFLAGS) ;
	STDLIBPATH	default = $(BCCROOT)\\lib ;
	STDHDRS		default = $(BCCROOT)\\include ;
	NOARSCAN	default = true ;
    }
    else if $(MSVC)
    {
	ECHO "Compiler is Microsoft Visual C++ 16 bit" ;

	AR		default = lib /nologo ;
	CC		default = cl /nologo ;
	CCFLAGS		default = /D \"WIN\" ;
	C++		default = $(CC) ;
	C++FLAGS	default = $(CCFLAGS) ;
	LINK		default = $(CC) ;
	LINKFLAGS	default = $(CCFLAGS) ;
	LINKLIBS	default = 
				#$(MSVC)\\lib\\advapi32.lib
				#$(MSVC)\\lib\\libcmt.lib
				$(MSVC)\\lib\\mlibce.lib
				#$(MSVC)\\lib\\slibce.lib
				$(MSVC)\\lib\\oldnames.lib
				#$(MSVC)\\lib\\kernel32.lib 
				;
	LINKLIBS	default = ;
	NOARSCAN	default = true ;
	OPTIM		default =  ;
	STDHDRS		default = $(MSVC)\\include ;
	UNDEFFLAG	default = "/u _" ;
    }
    else if $(MSVCNT)
    {
	ECHO "Compiler is Microsoft Visual C++" ;

	AR		default = lib ;
	AS		default = masm386 ;
	CC		default = cl /nologo ;
	CCFLAGS		default = ;
	C++		default = $(CC) ;
	C++FLAGS	default = $(CCFLAGS) ;
	LINK		default = link ;
	LINKFLAGS	default = ;
	LINKLIBS	default = $(MSVCNT)\\lib\\advapi32.lib
				$(MSVCNT)\\lib\\libc.lib
				$(MSVCNT)\\lib\\oldnames.lib
				$(MSVCNT)\\lib\\kernel32.lib ;
	OPTIM		default =  ;
	STDHDRS		default = $(MSVCNT)\\include ;
	UNDEFFLAG	default = "/u _" ;
    }
    else
    {
	EXIT On NT, set BCCROOT, MSVCNT, or MSVC to the root of the
		Borland or Microsoft directories. ;
    }

}
else if $(OS2)
{
	WATCOM		default = $(watcom) ;
	
    	CP		default = copy ;
	DOT		default	= . ;
	DOTDOT		default	= .. ;
	MKDIR		default = mkdir ;
    	MV		default = move ;
    	RM		default = del /f ;
	SED		default = sed ;
    	SLASH		default = \\ ;
    	SUFLIB		default = .lib ;
    	SUFOBJ		default = .obj ;
    	SUFEXE		default = .exe ;
     
    if ! $(WATCOM)
    {
	EXIT On OS2, set WATCOM to the root of the Watcom directory. ;
    }

	ECHO "OS2 compiler is Watcom." ;

	AR		default = wlib ;
	CC		default = wcc386 ;
	CCFLAGS		default = /zq /DOS2 /I$(WATCOM)\\h ; # zq=quiet
	C++		default = wpp386 ;
	C++FLAGS	default = $(CCFLAGS) ;
	LINK		default = wcl386 ;
	LINKFLAGS	default = /zq ; # zq=quiet
	LINKLIBS	default = ;
	NOARSCAN	default = true ;
	OPTIM		default = ;
	STDHDRS		default = $(WATCOM)\\h ;
	UNDEFFLAG	default = "/u _" ;
}
else if $(VMS)
{
	AS		default = as ;
	CC		default = cc ;
	CCFLAGS		default = ;
	CP		default = copy/replace ;
	CRELIB		default = true ;
	DOT		default	= [] ;
	DOTDOT		default	= [-] ;
	EXEMODE		default = (w:e) ;
	FILEMODE	default = (w:r) ;
	HDRS		default = ;
	LEX		default = lex ;
	LINK		default = link ;
	LINKFLAGS	default = ;
	LINKLIBS	default = ;
	MV		default = rename ;
	OPTIM		default = ;
	RM		default = delete ;
	RUNVMS		default = mcr ;
	SED		default = sed ;
	SHELLMODE	default = (w:er) ;
	SLASH		default = . ;
	STDHDRS		default = decc$library_include ;
	SUFLIB		default = .olb ;
	SUFOBJ		default = .obj ;
	SUFEXE		default = .exe ;

	switch $(OS) 
	{
	case OPENVMS : CCFLAGS default = /stand=vaxc ;
	case VMS     : LINKLIBS default = sys$library:vaxcrtl.olb/lib ;
	}
}
else if $(MAC)
{
	CW		default = "{CW}" ;
	CWMAC		default = "$(CW):MacOS Support" ;
	CWMSL		default = "$(CW):Metrowerks Standard Library" ;
	CWGUSI		default = "{CWGUSI}" ;

	CC		default = mwcppc ;
	CCFLAGS		default = -eol -w off ;
	C++		default = mwcppc ;
	C++FLAGS	default = -eol -w off ;
	CP		default = copy ;
	DOT		default = ":" ;
	DOTDOT		default = "::" ;
	HDRS		default = "$(CWGUSI):include"
				  "$(CWMAC):Headers:Universal Headers"
				  "$(CWMAC):Headers:System Extras Headers:MPW Extras"
				  "$(CWMSL):MSL C:MSL Common:Public Includes"
				  "$(CWMSL):MSL C:MSL Mac:Public Includes" ;
				  
	LINK		default = mwlinkppc ;
	LINKFLAGS	default = -mpwtool -warn ;
	LINKLIBS	default = "$(CWGUSI):Lib:GUSIMPW.Lib.PPC"
				  "$(CWGUSI):Lib:MSLGUSI.Lib.PPC"
				  "$(CWMAC):Libraries:MacOS Common:Interfacelib"
				  "$(CWMAC):Libraries:MacOS PPC:PPCToolLibs.o"
				  "$(CWMAC):Libraries:MacOS Common:PLStringFuncs Glue:PLStringFuncsPPC.lib"
				  "$(CWMAC):Libraries:Runtime:Runtime PPC:MSL MPWCRuntime.lib"
				  "$(CWMSL):MSL C:Bin:MSL C.PPC MPW(NL).Lib"
				  "$(CWMAC):Libraries:MacOS Common:Mathlib" ;
				
	MKDIR		default = newfolder ;
	MV		default = rename ;
	NOARSCAN	default = true ;
	OPTIM		default = ;
	RM		default = delete ;
	SLASH		default = ":" ;
	STDHDRS		default = ; #$(MWCIncludes) ;
	SUFLIB		default = .lib ;
	SUFOBJ		default = .o ;
	SUFEXE		default = "" ;
	NOARSCAN	default = true ;
}

# 
# Define some MS-specific commands for MS-specific actions (which
# are not yet added to Jambase)
#

if $(NT) || $(OS2)
{
	MSLIB 		default = lib ;
	MSLINK		default = link ;
	MSIMPLIB 	default = implib ;
	MSRC		default = rc ;
}

JAMFILE		default = Jamfile ;
JAMRULES	default = Jamrules ;

HDRPATTERN = "^[ 	]*#[ 	]*include[ 	]*[<\"](.*)[\">].*$" ;

#
# Base dependencies - first for "bootstrap" kinds of rules
#

DEPENDS all : shell files lib exe obj ;
DEPENDS all shell files lib exe obj : first ;
NOTFILE all first shell files lib exe obj dirs clean uninstall ;
ALWAYS clean uninstall ;

#
# Rules
#

rule As
{
	DEPENDS $(<) : $(>) ;
	ASFLAGS on $(<) += $(ASFLAGS) $(SUBDIRASFLAGS) ;
}

rule Bulk
{
	local i ;

	for i in $(>)
	{
	    File $(i:D=$(<)) : $(i) ;
	}
}

rule Cc
{
	local _h ;

	DEPENDS $(<) : $(>) ;

	# Just to clarify here: this sets the per-target CCFLAGS to
	# be the current value of (global) CCFLAGS and SUBDIRCCFLAGS.

	CCFLAGS on $(<) += $(CCFLAGS) $(SUBDIRCCFLAGS) ;

	# If the compiler's -o flag doesn't work, relocate the .o

	if $(RELOCATE)
	{
	    CcMv $(<) : $(>) ;
	}

	_h = $(SEARCH_SOURCE) $(HDRS) $(SUBDIRHDRS) ;

	if $(VMS) && $(_h)
	{
	    SLASHINC on $(<) = "/inc=(" $(_h[1]) ,$(_h[2-]) ")" ;
	}
	else if $(MAC) && $(_h)
	{
	    local _i _j ;
	    _j = $(_h[1]) ;
	    for _i in $(_h[2-])
	    {
	    	_j = $(_j),$(_i) ;
	    }
	    MACINC on $(<) = \"$(_j)\" ;
	}
}

rule C++
{
	local _h ;

	DEPENDS $(<) : $(>) ;
	C++FLAGS on $(<) += $(C++FLAGS) $(SUBDIRC++FLAGS) ;

	if $(RELOCATE)
	{
	    CcMv $(<) : $(>) ;
	}

	_h = $(SEARCH_SOURCE) $(HDRS) $(SUBDIRHDRS) ;

	if $(VMS) && $(_h)
	{
	    SLASHINC on $(<) = "/inc=(" $(_h[1]) ,$(_h[2-]) ")" ;
	}
	else if $(MAC) && $(_h)
	{
	    local _i _j ;
	    _j = $(_h[1]) ;
	    for _i in $(_h[2-])
	    {
	    	_j = $(_j),$(_i) ;
	    }
	    MACINC on $(<) = \"$(_j)\" ;
	}
}

rule File
{
	DEPENDS files : $(<) ;
	DEPENDS $(<) : $(>) ;
	SEARCH on $(>) = $(SEARCH_SOURCE) ;
	MODE on $(<) = $(FILEMODE) ;
	Chmod $(<) ;
}

rule Fortran
{
	DEPENDS $(<) : $(>) ;
}

rule GenFile 
{
	local s ;
	makeGristedName s : $(<) ;
	Depends $(s) : $(>[1]:S=$(SUFEXE)) $(>[2-]) ;
	GenFile1 $(s) : $(>[1]:S=$(SUFEXE)) $(>[2-]) ;
	Clean clean : $(s) ;
}

rule GenFile1
{
	MakeLocate $(<) : $(LOCATE_SOURCE) ;
	SEARCH on $(>) = $(SEARCH_SOURCE) ;
}

rule HardLink
{
	DEPENDS files : $(<) ;
	DEPENDS $(<) : $(>) ;
	SEARCH on $(>) = $(SEARCH_SOURCE) ;
}

rule HdrRule
{
	# HdrRule source : headers ;

	# N.B.	This rule is called during binding, potentially after
	# the fate of many targets has been determined, and must be
	# used with caution: don't add dependencies to unrelated
	# targets, and don't set variables on $(<).

	# Tell Jam that anything depending on $(<) also depends on $(>),
	# set SEARCH so Jam can find the headers, but then say we don't
	# care if we can't actually find the headers (they may have been
	# within ifdefs),

	local s ;

	if $(HDRGRIST) 
	{ 
	    s = $(>:G=$(HDRGRIST)) ;
	} else { 
	    s = $(>) ; 
	}

	INCLUDES $(<) : $(s) ;
	SEARCH on $(s) = $(HDRSEARCH) ;
	NOCARE $(s) ;

	# Propagate on $(<) to $(>)

	HDRSEARCH on $(s) = $(HDRSEARCH) ;
	HDRSCAN on $(s) = $(HDRSCAN) ;
	HDRRULE on $(s) = $(HDRRULE) ;
	HDRGRIST on $(s) = $(HDRGRIST) ;
}

rule InstallInto
{
	local i t ;

	t = $(>:G=installed) ;

	DEPENDS install : $(t) ;
	DEPENDS $(t) : $(>) ;
	SEARCH on $(>) = $(SEARCH_SOURCE) ;
	MakeLocate $(t) : $(<) ;

	# Arrange for jam uninstall

	Clean uninstall : $(t) ;

	for i in $(>)
	{
	    Install $(i:G=installed) : $(i) ;
	}

	if ! $(INSTALL)
	{
	    Chmod $(t) ;

	    if $(OWNER) { Chown $(t) ; OWNER on $(t) = $(OWNER) ; }
	    if $(GROUP) { Chgrp $(t) ; GROUP on $(t) = $(GROUP) ; }
	}
}

rule InstallBin
{
	InstallInto $(<) : $(>) ;
	MODE on $(>:G=installed) = $(EXEMODE) ;
}

rule InstallFile
{
	InstallInto $(<) : $(>) ;
	MODE on $(>:G=installed) = $(FILEMODE) ;
}

rule InstallLib
{
	InstallInto $(<) : $(>) ;
	MODE on $(>:G=installed) = $(FILEMODE) ;
}

rule InstallMan
{
	# Really this just strips the . from the suffix

	local i s d ;

	for i in $(>)
	{
	    switch $(i:S)
	    {
	    case .1 : s = 1 ; case .2 : s = 2 ; case .3 : s = 3 ;
	    case .4 : s = 4 ; case .5 : s = 5 ; case .6 : s = 6 ;
	    case .7 : s = 7 ; case .8 : s = 8 ; case .l : s = l ;
	    case .n : s = n ; case .man : s = 1 ;
	    }

	    d = man$(s) ;

	    InstallInto $(d:R=$(<)) : $(i) ;
	}

	MODE on $(>:G=installed) = $(FILEMODE) ;
}

rule InstallShell
{
	InstallInto $(<) : $(>) ;
	MODE on $(>:G=installed) = $(SHELLMODE) ;
}

rule Lex
{
	DEPENDS $(<) : $(>) ;
	MakeLocate $(<) : $(LOCATE_SOURCE) ;
	Clean clean : $(<) ;
}

rule Library
{
	LibraryFromObjects $(<) : $(>:S=$(SUFOBJ)) ;
	Objects $(>) ;
}

rule LibraryFromObjects
{
	local i l s ;

	# Add grist to file names

	makeGristedName s : $(>) ;

	# library depends on its member objects

	l = $(<:S=$(SUFLIB)) ;

	if $(KEEPOBJS)
	{
	    DEPENDS obj : $(s) ;
	}
	else
	{
	    DEPENDS lib : $(l) ;
	}

	# Set LOCATE for the library and its contents.  The bound
	# value shows up as $(NEEDLIBS) on the Link actions.
	# For compatibility, we only do this if the library doesn't
	# already have a path.

	if ! $(l:D)
	{
	    MakeLocate $(l) $(l)($(s:BS)) : $(LOCATE_TARGET) ;
	}

	if $(NOARSCAN) 
	{ 
	    # If we can't scan the library to timestamp its contents,
	    # we have to just make the library depend directly on the
	    # on-disk object files.  

	    DEPENDS $(l) : $(s) ;
	}
	else
	{
	    # If we can scan the library, we make the library depend
	    # on its members and each member depend on the on-disk
	    # object file.

	    DEPENDS $(l) : $(l)($(s:BS)) ;

	    for i in $(s)
	    {
		DEPENDS $(l)($(i:BS)) : $(i) ;
	    }
	}

	Clean clean : $(l) ;

	if $(CRELIB) { CreLib $(l) : $(s[1]) ; }

	Archive $(l) : $(s) ;

	if $(RANLIB) { Ranlib $(l) ; }

	# If we can't scan the library, we have to leave the .o's around.

	if ! ( $(NOARSCAN) || $(KEEPOBJS) ) { RmTemps $(l) : $(s) ; }
}

rule Link
{
	MODE on $(<) = $(EXEMODE) ;
	Chmod $(<) ;
}

rule LinkLibraries
{
	local t ;

	# make library dependencies of target
	# set NEEDLIBS variable used by 'actions Main'

	if $(<:S)
	{
	    t = $(<) ;
	} else {
	    t = $(<:S=$(SUFEXE)) ;
	}

	DEPENDS $(t) : $(>:S=$(SUFLIB)) ;
	NEEDLIBS on $(t) += $(>:S=$(SUFLIB)) ;
}

rule Main
{
	MainFromObjects $(<) : $(>:S=$(SUFOBJ)) ;
	Objects $(>) ;
}

rule MainFromObjects
{
	local s t ;

	# Add grist to file names

	makeGristedName s : $(>) ;

	makeSuffixed t $(SUFEXE) : $(<) ;

	if $(t) != $(<)
	{
	    DEPENDS $(<) : $(t) ;
	    NOTFILE $(<) ;
	}

	# make compiled sources a dependency of target

	DEPENDS exe : $(t) ;
	DEPENDS $(t) : $(s) ;
	MakeLocate $(t) : $(LOCATE_TARGET) ;

	Clean clean : $(t) ;

	Link $(t) : $(s) ;
}

rule MakeLocate
{
	if $(>)
	{
	    LOCATE on $(<) = $(>) ;
	    Depends $(<) : $(>[1]) ;
	    MkDir $(>[1]) ;
	}
}

rule MkDir
{
	if $(<) != $(DOT) && ! $($(<)-mkdir) 
	{
	    local s ;

	    # Cheesy gate to prevent multiple invocations on same dir
	    # MkDir1 has the actions 
	    # If dir exists, don't update it
	    # Arrange for jam dirs

	    $(<)-mkdir = true ;
	    MkDir1 $(<) ;
	    NOUPDATE $(<) ;
	    Depends dirs : $(<) ;

	    # Recursively make parent directories.
	    # $(<:P) = $(<)'s parent, & we recurse until root

	    s = $(<:P) ;

	    if $(NT)
	    {
	        switch $(s)
		{
		case *:   : s = ;
		case *:\\ : s = ;
		}
	    }

	    if $(s) && $(s) != $(<)
	    {
		Depends $(<) : $(s) ;
		MkDir $(s) ;
	    }
	    else if $(s)
	    {
	        NOTFILE $(s) ;
	    }

	}
}

rule Object
{
	local h ;

	# locate object and search for source, if wanted

	Clean clean : $(<) ;

	MakeLocate $(<) : $(LOCATE_TARGET) ;
	SEARCH on $(>) = $(SEARCH_SOURCE) ;

	# Save HDRS for -I$(HDRS) on compile.
	# We shouldn't need -I$(SEARCH_SOURCE) as cc can find headers
	# in the .c file's directory, but generated .c files (from
	# yacc, lex, etc) are located in $(LOCATE_TARGET), possibly
	# different from $(SEARCH_SOURCE).

	HDRS on $(<) = $(SEARCH_SOURCE) $(HDRS) $(SUBDIRHDRS) ;

	# handle #includes for source: Jam scans for headers with
	# the regexp pattern $(HDRSCAN) and then invokes $(HDRRULE)
	# with the scanned file as the target and the found headers
	# as the sources.  HDRSEARCH is the value of SEARCH used for
	# the found header files.  Finally, if jam must deal with 
	# header files of the same name in different directories,
	# they can be distinguished with HDRGRIST.

	# $(h) is where cc first looks for #include "foo.h" files.
	# If the source file is in a distant directory, look there.
	# Else, look in "" (the current directory).

	if $(SEARCH_SOURCE)
	{
	    h = $(SEARCH_SOURCE) ;
	}
	else
	{
	    h = "" ;
	}

	HDRRULE on $(>) = HdrRule ;
	HDRSCAN on $(>) = $(HDRPATTERN) ;
	HDRSEARCH on $(>) = $(HDRS) $(SUBDIRHDRS) $(h) $(STDHDRS) ;
	HDRGRIST on $(>) = $(HDRGRIST) ;

	# if source is not .c, generate .c with specific rule

	switch $(>:S)
	{
	    case .asm : As $(<) : $(>) ;
	    case .c :	Cc $(<) : $(>) ;
	    case .C :	C++ $(<) : $(>) ;
	    case .cc :	C++ $(<) : $(>) ;
	    case .cpp : C++ $(<) : $(>) ;
	    case .f :	Fortran $(<) : $(>) ;
	    case .l :	Cc $(<) : $(<:S=.c) ;
			Lex $(<:S=.c) : $(>) ;
	    case .s :	As $(<) : $(>) ;
	    case .y :	Cc $(<) : $(<:S=.c) ;
			Yacc $(<:S=.c) : $(>) ;
	    case * :	UserObject $(<) : $(>) ;
	}
}

rule ObjectCcFlags
{
	local s ;

	# Add grist to file names

	makeGristedName s : $(<:S=$(SUFOBJ)) ;

	CCFLAGS on $(s) += $(>) ;
}

rule ObjectC++Flags
{
	local s ;

	# Add grist to file names

	makeGristedName s : $(<:S=$(SUFOBJ)) ;

	C++FLAGS on $(s) += $(>) ;
}

rule ObjectHdrs
{
	local s ;

	# Add grist to file names

	makeGristedName s : $(<:S=$(SUFOBJ)) ;

	HDRS on $(s) += $(>) ;
}

rule Objects
{
	local i s ;

	# Add grist to file names

	makeGristedName s : $(<) ;

	for i in $(s)
	{
		Object $(i:S=$(SUFOBJ)) : $(i) ;
		DEPENDS obj : $(i:S=$(SUFOBJ)) ;
	}
}

rule RmTemps
{
	TEMPORARY $(>) ;
}

rule Setuid
{
	local t ;

	if $(<:S)
	{
	    t = $(<) ;
	} else {
	    t = $(<:S=$(SUFEXE)) ;
	}

	MODE on $(t) = 4711 ;
}

rule Shell
{
	DEPENDS shell : $(<) ;
	DEPENDS $(<) : $(>) ;
	SEARCH on $(>) = $(SEARCH_SOURCE) ;
	MODE on $(<) = $(SHELLMODE) ;
	Clean clean : $(<) ;
	Chmod $(<) ;
}

rule SubDir
{
	local r s ;

	#
	# SubDir TOP d1 [ ... ]
	#
	# This introduces a Jamfile that is part of a project tree 
	# rooted at $(TOP).  It (only once) includes the project-specific
	# rules file $(TOP)/Jamrules and then sets search & locate stuff.
	#
	# If the variable $(TOPRULES) is set (where TOP is the first arg 
	# to SubDir), that file is included instead of $(TOP)/Jamrules.
	#
	# d1 ... are the directory elements that lead to this directory 
	# from $(TOP).  We construct the system dependent path from these
	# directory elements in order to set search&locate stuff.
	# 

	if ! $($(<[1]))
	{
	    if ! $(<[1])
	    {
		EXIT SubDir syntax error ;
	    }

	    makeSubDir $(<[1]) : $(<[2-]) ;
	}

	#
	# If $(TOP)/Jamrules hasn't been included, do so.
	#

	if ! $($(<[1])-included)
	{
	    # Gated entry.

	    $(<[1])-included = TRUE ;

	    # File is $(TOPRULES) or $(TOP)/Jamrules.

	    r = $($(<[1])RULES) ;

	    if ! $(r)
	    {
		r = $(JAMRULES:R=$($(<[1]))) ;
	    }

	    # Include it.

	    include $(r) ;
	}

	# Get path to current directory from root using makeSubDir.
	# Save dir tokens for other potential uses.

	makeDirName s : $(<[2-]) ;
	SUBDIR = $(s:R=$($(<[1]))) ;
        SUBDIR_TOKENS = $(<[2-]) ;

	# Now set up SEARCH_SOURCE, LOCATE_TARGET, SOURCE_GRIST
	# These can be reset if needed.	 For example, if the source
	# directory should not hold object files, LOCATE_TARGET can
	# subsequently be redefined.

	SEARCH_SOURCE = $(SUBDIR) ;
	LOCATE_SOURCE = $(ALL_LOCATE_TARGET) $(SUBDIR) ;
	LOCATE_TARGET = $(ALL_LOCATE_TARGET) $(SUBDIR) ;
	makeGrist SOURCE_GRIST : $(<[2-]) ;

	# Reset per-directory ccflags, hdrs

	SUBDIRCCFLAGS = ;
	SUBDIRC++FLAGS = ;
	SUBDIRHDRS = ;
}

rule SubDirCcFlags
{
	SUBDIRCCFLAGS += $(<) ;
}

rule SubDirC++Flags
{
	SUBDIRC++FLAGS += $(<) ;
}

rule SubDirHdrs
{
	SUBDIRHDRS += $(<) ;
}

rule SubInclude
{
	local s ;

	# That's
	#	SubInclude TOP d1 [ d2 [ d3 [ d4 ] ] ]
	#
	# to include a subdirectory's Jamfile.

	if ! $($(<[1]))
	{
	    EXIT Top level of source tree has not been set with $(<[1]) ;
	}

	makeDirName s : $(<[2-]) ;
	
	include $(JAMFILE:D=$(s):R=$($(<[1]))) ;
}

rule Undefines
{
	local t ;

	if $(<:S)
	{
	    t = $(<) ;
	} else {
	    t = $(<:S=$(SUFEXE)) ;
	}

	UNDEFS on $(t) += $(UNDEFFLAG)$(>) ;
}

rule UserObject
{
	EXIT "Unknown suffix on" $(>) "- see UserObject rule in Jamfile(5)." ;
}

rule Yacc
{
	local h ;

	h = $(<:BS=.h) ;

	# Some places don't have a yacc.

	MakeLocate $(<) $(h) : $(LOCATE_SOURCE) ;

	if $(YACC)
	{
	    DEPENDS $(<) $(h) : $(>) ;
	    Yacc1 $(<) $(h) : $(>) ;
	    Clean clean : $(<) $(h) ;
	}

	# make sure someone includes $(h) else it will be
	# a deadly independent target

	INCLUDES $(<) : $(h) ;
}

#
# Utility rules; no side effects on these
#

rule makeString
{
	local _t ;

	$(<) = $(>[1]) ;
	for _t in $(>[2-])
	{
		$(<) = $($(<))$(_t) ;
	}
}

rule makeSubDir
{
	local _i _d ;

	# If $(>) is the path to the current directory, compute the
	# path (using ../../ etc) back to that root directory.
	# Sets result in $(<)

	if ! $(>[1]) 
	{
	    _d = $(DOT) ;
	} 
	else
	{
	    _d = $(DOTDOT) ;

	    for _i in $(>[2-])
	    {
		_d = $(_d:R=$(DOTDOT)) ;
	    }
	}

	$(<) = $(_d) ;
}

rule addDirName
{
	local _s _i ;

	# Turn individual elements in $(>) into a usable path.
	# Add result to $(<).

	if ! $(>)
	{
	    _s = $(DOT) ;
	}
	else if $(VMS)
	{
	    # This handles the following cases:
	    # 	a -> [.a]
	    # 	a b c -> [.a.b.c]
	    # 	x: -> x:
	    # 	x: a -> x:[a]
	    # 	x:[a] b -> x:[a.b]

	    switch $(>[1])
	    {
	    case *:* : _s = $(>[1]) ;
	    case \\[*\\] : _s = $(>[1]) ;
	    case * : _s = [.$(>[1])] ;
	    }

	    for _i in [.$(>[2-])]
	    {
		_s = $(_i:R=$(_s)) ;
	    }
	}
	else if $(MAC)
	{
	    _s = $(DOT) ;
	    
	    for _i in $(>)
	    {
	    	_s = $(_i:R=$(_s)) ;
	    }
	}
	else
	{
	    _s = $(>[1]) ; 

	    for _i in $(>[2-])
	    {
		_s = $(_i:R=$(_s)) ;
	    }
	}

	$(<) += $(_s) ;
}

rule makeDirName
{
	$(<) = ; addDirName $(<) : $(>) ;
}

rule makeGrist
{
	local _g _i ;

	# Turn individual elements in $(>) into grist.
	# Return result in $(<)

	_g = $(>[1]) ;

	for _i in $(>[2-])
	{
	    _g = $(_g)!$(_i) ;
	}

	$(<) = $(_g) ;
}

rule makeGristedName
{
	local _i _o ;

	# Produce name with grist in it, if SOURCE_GRIST is set.

	if ! $(SOURCE_GRIST)
	{
	    $(<) = $(>) ;
	}
	else 
	{
	    _o = ;
	    for _i in $(>)
	    {
		switch $(_i)
		{
		case *.h :	_o += $(_i) ;
		case * : 	_o += $(_i:G=$(SOURCE_GRIST)) ;
		}
	    }
	    $(<) = $(_o) ;
	}
}

rule makeCommon
{
	if $($(<)[1]) && $($(<)[1]) = $($(>)[1])
	{
	    $(<) = $($(<)[2-]) ;
	    $(>) = $($(>)[2-]) ;
	    makeCommon $(<) : $(>) ;
	}
}

rule makeRelPath 
{
	local _l _r ;

	# first strip off common parts

	_l = $(<[2-]) ;
	_r = $(>) ;

	makeCommon _l : _r ;

	# now make path to root and path down

	makeSubDir _l : $(_l) ;
	makeDirName _r : $(_r) ;

	# Concatenate and save

	# XXX This should be better

	if $(_r) = $(DOT) {
	    $(<[1]) = $(_l) ;
	} else {
	    $(<[1]) = $(_r:R=$(_l)) ;
	}
}

rule makeSuffixed
{
   # E.g., "makeSuffixed s_exe $(SUFEXE) : yacc lex foo.bat ;"
   # sets $(s_exe) to (yacc,lex,foo.bat) on Unix and 
   # (yacc.exe,lex.exe,foo.bat) on NT.

	if $(<[2])
	{
	    local _i ;

	    $(<[1]) = ;

	    for _i in $(>)
	    {
		if $(_i:S)
		{
		    $(<[1]) += $(_i) ;
		}
		else
		{
		    $(<[1]) += $(_i:S=$(<[2])) ;
		}
	    }
	}
	else
	{
	    $(<[1]) = $(>) ;
	}
}

rule unmakeDir
{
    if $(>[1]:D) && $(>[1]:D) != $(>[1]) && $(>[1]:D) != \\\\ 
    {
        unmakeDir $(<) : $(>[1]:D) $(>[1]:BS) $(>[2-]) ;
    }
    else
    {
        $(<) = $(>) ;
    }
}

#
# Actions
#

if $(UNIX)
{
    if $(OS) = QNX 
    {
	actions together piecemeal Archive
	{
	$(AR) $(<) +-$(>) 
	}
    }
    else if $(OS) = BEOS && $(METROWERKS)
    {
	actions together Archive
	{
	$(AR) $(<) $(>)
	}
    }
    else
    {
	actions updated together piecemeal Archive
	{
	$(AR) $(<) $(>)
	}
    }

    actions As
    {
	$(AS) $(ASFLAGS) -I$(HDRS) -o $(<) $(>)
    }

    if $(RELOCATE)
    {
	actions C++
	{
	$(C++) -c $(C++FLAGS) $(OPTIM) -I$(HDRS) $(>)
	}
    }
    else
    {
	actions C++
	{
	$(C++) -c $(C++FLAGS) $(OPTIM) -I$(HDRS) -o $(<) $(>)
	}
    }

    actions Cc
    {
	$(CC) -c $(CCFLAGS) $(OPTIM) -I$(HDRS) -o $(<) $(>)
    }

    if $(RELOCATE)
    {
	actions Cc
	{
	$(CC) -c $(CCFLAGS) $(OPTIM) -I$(HDRS) $(>)
	}
    }

    actions ignore CcMv
    {
	[ $(<) != $(>:BS=$(SUFOBJ)) ] && $(MV) $(>:BS=$(SUFOBJ)) $(<)
    }

    actions Chgrp
    {
	chgrp $(GROUP) $(<)
    }

    actions Chmod
    {
	chmod $(MODE) $(<)
    }

    actions Chown
    {
	chown $(OWNER) $(<)
    }

    actions piecemeal together existing Clean
    {
	$(RM) $(>)
    }

    actions File
    {
	$(RM) $(<)
	$(CP) $(>) $(<)
    }

    actions GenFile1
    {
	$(>[1]) $(<) $(>[2-])
    }

    actions Fortran
    {
	$(FORTRAN) $(FORTRANFLAGS) -o $(<) $(>)
    }

    actions HardLink
    {
	$(RM) $(<) && $(LN) $(>) $(<)
    }

    if $(INSTALL)
    {
	actions Install
	{
	$(INSTALL) -m$(MODE) -o$(OWNER) -g$(GROUP) $(>) $(<)
	}
    }
    else
    {
	actions Install
	{
	$(CP) $(>) $(<) 
	}
    }

    actions Lex
    {
	$(LEX) $(>) && $(MV) lex.yy.c $(<)
    }

    actions Link bind NEEDLIBS
    {
	$(LINK) $(LINKFLAGS) -o $(<) $(UNDEFS) $(>) $(NEEDLIBS) $(LINKLIBS) 
    }

    actions MkDir1
    {
	$(MKDIR) $(<)
    }

    actions together Ranlib
    {
	$(RANLIB) $(<)
    }

    actions quietly updated piecemeal together RmTemps
    {
	$(RM) $(>)
    }

    actions Shell
    {
	$(AWK) '
		NR == 1 { print "$(SHELLHEADER)" }
		NR == 1 && /^[#:]/ { next }
		/^##/ { next }
		{ print }
	' < $(>) > $(<)
    }

    actions Yacc1
    {
	$(YACC) $(YACCFLAGS) $(>) &&
	{
	    $(MV) $(YACCFILES).c $(<[1])
	    $(MV) $(YACCFILES).h $(<[2])
	}
    }
}
else if $(NT) || $(OS2)
{
    if $(BCCROOT)
    {

	actions C++
	{
	$(C++) -c $(C++FLAGS) $(OPTIM) -I$(HDRS) -o$(<) $(>)
	}

	actions Link bind NEEDLIBS
	{
	$(LINK) -e$(<) $(LINKFLAGS) $(UNDEFS) -L$(LINKLIBS) $(NEEDLIBS) $(>)
	}

	actions updated together piecemeal Archive
	{
	$(AR) $(ARFLAGS) $(<) -+$(>)
	}

	actions Cc
	{
	$(CC) -c $(CCFLAGS) $(OPTIM) -I$(HDRS) -o$(<) $(>)
        }
    }
    else if $(MSVC) 
    {
	actions updated together piecemeal Archive
	{
	$(AR) $(<) -+$(>) ;
	}

	actions Cc
	{
	$(CC) /c $(CCFLAGS) $(OPTIM) /Fo$(<) /I$(HDRS) $(>)
	}

	actions C++
	{
	$(C++) /c $(C++FLAGS) $(OPTIM) /Fo$(<) /I$(HDRS) /Tp$(>)
	}

	actions Link bind NEEDLIBS
	{
	$(LINK) $(LINKFLAGS) /out:$(<) $(UNDEFS) $(>) $(NEEDLIBS) $(LINKLIBS)
	}
    }
    else if $(MSVCNT)
    {
	actions updated together piecemeal Archive
	{
	if exist $(<) set _$(<:B)_=$(<)
	$(AR) /out:$(<) %_$(<:B)_% $(>)
	}

	actions As
	{
	$(AS) /Ml /p /v /w2 $(>) $(<) ,nul,nul;
	}

	actions Cc
	{
	$(CC) /c $(CCFLAGS) $(OPTIM) /Fo$(<) /I$(HDRS) /I$(STDHDRS) $(>)
	}

	actions C++
	{
	$(C++) /c $(C++FLAGS) $(OPTIM) /Fo$(<) /I$(HDRS) /I$(STDHDRS) /Tp$(>)
	}

	actions Link bind NEEDLIBS
	{
	$(LINK) $(LINKFLAGS) /out:$(<) $(UNDEFS) $(>) $(NEEDLIBS) $(LINKLIBS)
	}
    }
    else if $(WATCOM)
    {
	actions together piecemeal Archive
	{
	$(AR) $(<) +-$(>) 
	}

	actions Cc
	{
	$(CC) $(CCFLAGS) $(OPTIM) /Fo=$(<) /I$(HDRS) $(>)
	}

	actions C++
	{
	$(C++) $(C++FLAGS) $(OPTIM) /Fo=$(<) /I$(HDRS) $(>)
	}

	actions Link bind NEEDLIBS
	{
	$(LINK) $(LINKFLAGS) /Fe=$(<) $(UNDEFS) $(>) $(NEEDLIBS) $(LINKLIBS)
	}
    }

    actions Chmod
    {
    }

    actions piecemeal together existing Clean
    {
	$(RM) $(>)
    }

    actions File
    {
	copy $(>) $(<)
    }

    actions GenFile1
    {
	$(>[1]) $(<) $(>[2-])
    }

    actions Install
    {
	copy $(>) $(<)
    }

    actions MkDir1
    {
	$(MKDIR) $(<)
    }

    actions quietly updated piecemeal together RmTemps
    {
	$(RM) $(>)
    }

    actions Shell
    {
	copy $(>) $(<)
    }
}
else if $(VMS)
{

    actions updated together piecemeal Archive 
    {
	lib/replace $(<) $(>[1]) ,$(>[2-])
    }

    actions Cc
    { 
	cc/obj=$(<) $(CCFLAGS) $(OPTIM) $(SLASHINC) $(>) 
    }

    actions C++
    { 
	cxx/obj=$(<) $(C++FLAGS) $(OPTIM) $(SLASHINC) $(>) 
    }

    actions Chmod
    {
	set file/prot=$(MODE) $(<)
    }

    actions piecemeal together existing Clean
    {
	$(RM) $(>[1]);* ,$(>[2-]);*
    }

    actions together quietly CreLib
    {
       if f$search("$(<)") .eqs. "" then lib/create $(<)
    }

    actions File
    {
	copy $(>) $(<)
    }

    actions GenFile1
    {
	mcr $(>[1]) $(<) $(>[2-])
    }

    actions Install
    {
	copy $(>) $(<)
    }

    actions Lex
    {
	$(LEX) $(>) 
	$(MV) lex.yy.c $(<)
    }

    actions Link bind NEEDLIBS
    {
	$(LINK)/exe=$(<) $(LINKFLAGS) $(>[1]) ,$(>[2-]) ,$(NEEDLIBS)/lib ,$(LINKLIBS)
    }

    actions MkDir1
    {
	create/dir $(<)
    }

    actions quietly updated piecemeal together RmTemps
    {
	$(RM) $(>[1]);* ,$(>[2-]);*
    }

    actions Shell
    {
	copy $(>) $(<)
    }

    actions Yacc1
    {
	$(YACC) $(YACCFLAGS) $(>)
	$(MV) $(YACCFILES).c $(<[1])
	$(MV) $(YACCFILES).h $(<[2])
    }
}
else if $(MAC)
{
    SP = " " ;

    actions together Archive 
    {
	$(LINK) -library -o $(<) $(>)
    }

    actions Cc
    {
	set MWCincludes $(MACINC)
	$(CC) -o $(<) $(CCFLAGS) $(OPTIM) $(>) 
    }

    actions C++
    { 
	set MWCincludes $(MACINC)
	$(CC) -o $(<) $(C++FLAGS) $(OPTIM) $(>) 
    }

    rule Chmod
    {
	# no chmod on mac - could setfile -l/-L to make rw/ro
    }

    actions piecemeal together existing Clean
    {
	$(RM) $(>)
    }

    actions File
    {
	copy $(>) $(<)
    }

    actions GenFile1
    {
	$(>[1]) $(<) $(>[2-])
    }

    actions Install
    {
	copy $(>) $(<)
    }

    actions Link bind NEEDLIBS
    {
	$(LINK) -o $(<) $(LINKFLAGS) $(>) $(NEEDLIBS) "$(LINKLIBS)"
    }

    actions MkDir1
    {
	$(MKDIR) $(<)
    }

    actions quietly updated piecemeal together RmTemps
    {
	$(RM) $(>)
    }

    actions Shell
    {
	copy $(>) $(<)
    }
}


#
# Backwards compatibility with jam 1, where rules were uppercased.
#

rule BULK { Bulk $(<) : $(>) ; }
rule FILE { File $(<) : $(>) ; }
rule HDRRULE { HdrRule $(<) : $(>) ; }
rule INSTALL { Install $(<) : $(>) ; }
rule LIBRARY { Library $(<) : $(>) ; }
rule LIBS { LinkLibraries $(<) : $(>) ; }
rule LINK { Link $(<) : $(>) ; }
rule MAIN { Main $(<) : $(>) ; }
rule SETUID { Setuid $(<) ; }
rule SHELL { Shell $(<) : $(>) ; }
rule UNDEFINES { Undefines $(<) : $(>) ; }

# Old INSTALL* didn't take dest directory.

rule INSTALLBIN { InstallBin $(BINDIR) : $(<) ; }
rule INSTALLLIB { InstallLib $(LIBDIR) : $(<) ; }
rule INSTALLMAN { InstallMan $(MANDIR) : $(<) ; }

#
# Now include the user's Jamfile.
#

{
    if $(JAMFILE) { include $(JAMFILE) ; }
}
./src/Jambase.html100440    167    454       52230  7102105134  12535 0ustar  laurateam<HTML>
<TITLE>
Jambase Reference
</TITLE>
<BODY>
<CENTER>
<a href=http://www.perforce.com/jam/jam.html>
Jam/MR
</a>
<H1>
<A NAME="TOP">
Jambase Reference
</A>
</H1>
</CENTER>
<P>
       Jambase is a base set of Jam/MR rules which
       provide roughly make(1)-like functionality for 
       <a href="Jam.html"><b>jam</b></A>, the Jam/MR executable program.
       This document, which started out as the Jambase(5) man page, 
       is a reference guide to the 
       <A href="#RULES">rules</A>,
       <A href="#PSEUDOTARGETS">pseudotargets</A>,
       and <A href="#VARS">variables</A> 
       defined in Jambase for use in Jamfiles.
<P>
	For further information see:
<UL>
<LI>
	<a href="Jamfile.html">Using Jamfiles and Jambase</A>
<LI>
	<a href="Jam.html">The Jam/MR Executable Program</A>
<LI>
       <a href="Jamlang.html">The Jam/MR Language</A>
</UL>
<P>
Jam/MR documentation and source are available from the
<A HREF=http://public.perforce.com/public/index.html>Perforce Public Depot</a>.
For detailed information about any of the rules summarized below,
see the 
<A HREF=http://public.perforce.com/public/jam/src/Jambase>Jambase</a> 
file itself.
<HR>
<H2>
<A NAME="RULES">
Jambase Rules
</A>
</H2>
<P>
       <B>As</B> <I>obj.o</I> : <I>source.s</I> ;
<BLOCKQUOTE>
              Assemble the file <I>source.s.</I>  Called by  the  Object
              rule.
</BLOCKQUOTE>
       <B>Bulk</B> <I>directory</I> : <I>sources</I> ;
<BLOCKQUOTE>
              Copies  <I>sources</I>  into  <I>directory.</I>
</BLOCKQUOTE>
       <B>Cc</B> <I>object</I> : <I>source</I> ;
<BLOCKQUOTE>
              Compile the file <I>source</I> into <I>object,</I>  using  the  C
              compiler  $(CC), its flags $(CCFLAGS) and $(OPTIM),
              and the header file directories $(HDRS).  Called by
              the Object rule.
</BLOCKQUOTE>
       <B>C++</B> <I>obj.o</I> : <I>source.cc</I> ;
<BLOCKQUOTE>
              Compile  the  C++ source file <I>source.cc.</I>  Called by
              the Object rule.
</BLOCKQUOTE>
	<B>Chmod</B> <I>target</I> ;
<BLOCKQUOTE>
		<I>(Unix and VMS only.)</I>
		Change file permissions on <I>target</I> to
		target-specific $(MODE) value set by Link, File,
		Install*, and Shell rules.
</BLOCKQUOTE>

       <B>Clean</B> <I>clean</I> : <I>targets</I> ;
<BLOCKQUOTE>
              Removes  existing  <I>targets</I>  when  <I>clean</I>  is  built.
              clean is not a dependency of all, and must be built
              explicitly for targets to be removed.
</BLOCKQUOTE>
       <B>File</B> <I>target</I> : <I>source</I> ;
<BLOCKQUOTE>
              Copies <I>source</I> into <I>target.</I>
</BLOCKQUOTE>
       <B>Fortran</B> <I>obj.o</I> : <I>source.f</I> ;
<BLOCKQUOTE>
              Compile the Fortran source file  <I>source.f.</I>   Called
              by the Object rule.
</BLOCKQUOTE>
<P>
	<B>GenFile</B> <I>target</I> : <I>image</I> <I>sources</I> ;
<BLOCKQUOTE>
		Runs the command "<I>image</I> <I>target</I> <I>sources</I>"
		to create <I>target</I> from <I>sources</I> and
		<I>image</I>. (where <I>image</I> is an
		executable built by the Main rule.)
</BLOCKQUOTE>
       <B>HardLink</B> <I>target</I> : <I>source</I> ;
<BLOCKQUOTE>
              Makes <I>target</I> a hard link to <I>source,</I> if it isn't one
              already. (Unix only.)
</BLOCKQUOTE>
       <B>HdrRule</B> <I>source</I> : <I>headers</I> ;
<BLOCKQUOTE>
              Arranges the  proper  dependencies  when  the  file
              <I>source</I>  includes  the  files  <I>headers</I>  through  the
              "#include" C preprocessor  directive.   
	      <P>
	      This rule is not intended to be called explicitly.
	      It is called automatically during header scanning on
	      sources handled by the Object rule (e.g., sources in
	      Main or Library rules).
</BLOCKQUOTE>
       <B>InstallBin</B> <I>dir</I> : <I>sources</I> ; <BLOCKQUOTE>
	      Copy <I>sources</I> into <I>dir</I> with mode
	      $(EXEMODE).  
</BLOCKQUOTE>
       <B>InstallLib</B> <I>dir</I> : <I>sources</I> ; <BLOCKQUOTE>
	      Copy  <I>sources</I>  into  <I>dir</I>  with  mode
	      $(FILEMODE).  
</BLOCKQUOTE>
       <B>InstallMan</B> <I>dir</I> : <I>sources</I> ; <BLOCKQUOTE>
	      Copy  <I>sources</I>  into the appropriate subdirectory
	      of <I>dir</I> with mode  $(FILEMODE).   The  subdirectory
	      is man<I>s,</I>  where  <I>s</I>  is  the suffix of
	      each of sources.  
</BLOCKQUOTE>
       <B>InstallShell</B> <I>dir</I> : <I>sources</I> ; <BLOCKQUOTE>
	      Copy  <I>sources</I>  into  <I>dir</I>  with  mode
	      $(SHELLMODE).  
</BLOCKQUOTE>
       <B>Lex</B> <I>source.c</I> : <I>source.l</I> ; <BLOCKQUOTE>
	      Process  the lex(1) source file <I>source.l</I> and
	      rename the lex.yy.c to <I>source.c.</I>   Called  by
	      the  Object rule.
</BLOCKQUOTE>
       <B>Library</B> <I>library</I> : <I>sources</I> ; <BLOCKQUOTE>
	      Compiles  <I>sources</I>  and  archives them into
	      <I>library.</I> The  intermediate  <I>objects</I>
	      are   deleted.    Calls Objects and LibraryFromObjects.
	      <P>
	      If Library is invoked with no suffix on <I>library</I>,
	      the $(SUFLIB) suffix is used.
</BLOCKQUOTE>
       <B>LibraryFromObjects</B> <I>library</I> : <I>objects</I> ; 
<BLOCKQUOTE>
	      Archives <I>objects</I> into  <I>library.</I>   The
	      <I>objects</I>  are then deleted.  
	      <P>
	      If <I>library</I> has no suffix, the $(SUFLIB) suffix is used.
</BLOCKQUOTE>
	<B>Link</B> <I>image</I> : <I>objects</I> ;
<BLOCKQUOTE>
		Links <I>image</I> from <I>objects</I> and sets
		permissions on <I>image</I> to $(EXEMODE). 
		 <I>Image</I> must be actual filename; suffix is not
		 supplied.
		Called by Main.
	
</BLOCKQUOTE>
       <B>LinkLibraries</B> <I>image</I> : <I>libraries</I> ;
<BLOCKQUOTE>
	      Makes  <I>image</I>  depend on <I>libraries</I> and
	      includes them during the linking.
	      <P>
	      <I>Image</I> may be referenced without a suffix in this
	      rule invocation; LinkLibraries supplies the suffix.
</BLOCKQUOTE>
       <B>Main</B> <I>image</I> : <I>sources</I> ; 
<BLOCKQUOTE>
	      Compiles <I>sources</I> and links them into <I>image.</I>
	      Calls Objects and MainFromObjects.  
	      <P>
	      <I>Image</I> may be referenced without a suffix in this
	      rule invocation; Main supplies the suffix.
</BLOCKQUOTE>
       <B>MainFromObjects</B> <I>image</I> : <I>objects</I> ;
<BLOCKQUOTE>
	      Links <I>objects</I> into <I>image.</I>  Dependency
	      of exe. MainFromObjects supplies the suffix on <I>image</I>
	      filename.
</BLOCKQUOTE>
	<B>MakeLocate</B> <I>target</I> : <I>dir</I> ;
<BLOCKQUOTE>
	Creates <I>dir</I> and causes <I>target</I> to be built
	into <I>dir</I>.
</BLOCKQUOTE>
	<B>MkDir</B> <I>dir</I> ;
<BLOCKQUOTE>
	Creates <I>dir</I> and its parent directories.
</BLOCKQUOTE>
       <B>Object</B> <I>object</I> : <I>source</I> ; 
<BLOCKQUOTE>
	      Compiles  a  <I>single</I> source file source into
	      <I>object.</I> The Main and Library rules use
	      this rule to compile source files.
	      <P>
	      Causes <I>source</I> to be scanned for "#include" 
	      directives and calls HdrRule to make all included
	      files dependedencies of <I>object</I>.
<P>
	      Calls one of the following rules to do the actual
	      compiling, depending on the suffix of source:
<PRE>
		     *.c:   Cc 
		     *.cc:  C++ 
		     *.cpp: C++
		     *.C:   C++ 
		     *.l:   Lex 
		     *.y:   Yacc
		     *.*:   UserObject
</PRE>
</BLOCKQUOTE>
       <B>ObjectC++Flags</B> <I>source</I> : <I>flags</I> ; 
       <BR>
       <B>ObjectCcFlags</B> <I>source</I> : <I>flags</I> ; 
<BLOCKQUOTE>
	      Add   <I>flags</I>   to   the   source-specific
	      value  of $(CCFLAGS) or $(C++FLAGS) when compiling <I>source.</I>
	      Any file  suffix on <I>source</I> is ignored.
</BLOCKQUOTE>
       <B>ObjectHdrs</B> <I>source</I> : <I>dirs</I> ; <BLOCKQUOTE>
	      Add  <I>dirs</I>  to  the source-specific value of
	      $(HDRS) when scanning and compiling <I>source.</I>
	      Any file  suffix on <I>source</I> is ignored.
</BLOCKQUOTE>
       <B>Objects</B> <I>sources</I> ; <BLOCKQUOTE>
	      For  each  source  file in <I>sources,</I> calls
	      Object to compile the source  file  into  a  similarly
	      named object file.
</BLOCKQUOTE>
       <B>RmTemps</B> <I>targets</I> : <I>sources</I> ; <BLOCKQUOTE>
	      Marks <I>sources</I> as temporary with the TEMPORARY
	      rule, and deletes <I>sources</I> once <I>targets</I>
	      are  built.  Must be  the  last rule invoked on
	      <I>targets.</I>  Used internally by LibraryFromObjects rule.
</BLOCKQUOTE>
       <B>Setuid</B> <I>images</I> ; <BLOCKQUOTE>
	      Sets the setuid bit on each of <I>images</I>  after
	      linking. (Unix only.)

</BLOCKQUOTE>
	<B>SubDir</B> <I>VAR d1 ... dn</I> ;
<BLOCKQUOTE>
		Sets up housekeeping for the source files located
		in <I><CODE>$(VAR)/d1/.../dn</CODE></I>:
		<UL>
		<LI>Reads in rules file associated with <I>VAR</I>,
		    if it hasn't already been read.
		<LI>Initializes variables for search paths, 
		    output directories, compiler
		    flags, and grist, using <I>d1 ... dn</I> tokens.
		</UL>
		<P>
		<I>VAR</I> is the name of a variable; 
		<I>d1</I> thru <I>dn</I> are elements
		of a directory path.
</BLOCKQUOTE>
	<B>SubDirC++Flags</B> <I>flags</I> ;
	<BR>
	<B>SubDirCcFlags</B> <I>flags</I> ;
<BLOCKQUOTE>
	Adds <I>flags</I> to the compiler flags for source files
	in SubDir's directory.
</BLOCKQUOTE>
	<B>SubDirHdrs</B> <I>paths</I> ;
<BLOCKQUOTE>
	Adds <I>paths</I> to the header search paths for source files
	in SubDir's directory.
</BLOCKQUOTE>
	<B>SubInclude</B> <I>VAR d1 ... dn</I> ;
<BLOCKQUOTE>
	Reads the Jamfile in <I><CODE>$(VAR)/d1/.../dn/</CODE></I>. 
</BLOCKQUOTE>
       <B>Shell</B> <I>image</I> : <I>source</I> ; <BLOCKQUOTE>
	      Copies  <I>source</I>  into  the  executable  sh(1)
	      script <I>image.</I>  Ensures that the first line of
	      the  script is  $(SHELLHEADER) (default #!/bin/sh).
</BLOCKQUOTE>
       <B>Undefines</B> <I>images</I> : <I>symbols</I> ; <BLOCKQUOTE>
		Adds flags to mark <I>symbols</I> as undefined
		on link command for <I>images</I>.
		<I>Images</I> may be referenced unsuffixed; the
		Undefines rule supplies the suffix.
</BLOCKQUOTE>
       <B>UserObject</B> <I>object</I> : <I>source</I> ; <BLOCKQUOTE>
	      This rule is called by Object for source
	      files with unknown  suffixes,  and  should  be defined
	      in Jamrules
	      with a user-provided rule to handle the source file
	      types not handled by the Object rule.
	      The Jambase UserObject rule merely issues a
	      complaint when it encounters <I>source</I> with
	      files suffixes it does not recognize.
</BLOCKQUOTE>
       <B>Yacc</B> <I>source.c</I> : <I>source.y</I> ; <BLOCKQUOTE>
	      Process  the  yacc(1) file <I>source.y</I> and renamed
	      the resulting y.tab.c and y.tab.h  to  <I>source.c.</I>
	      Produces a y.tab.h and renames it to <I>source.h.</I>
	      Called by the <B>Object</B> rule.
</BLOCKQUOTE> 
<P> 
<HR>   
<A NAME="PSEUDOTARGETS">
<H3>
Jambase Pseudotargets
</H3>
</A>
<P>
There are two kinds of Jam/MR targets: file targets and pseudotargets.
File targets are objects that can be found in the filesystem.
Pseudotargets are symbolic, and usually represent other targets.
Most Jambase rules that define file targets also define pseudotargets
which are dependent on types of file targets. The Jambase pseudotargets
are:
<CENTER>
<TABLE CELLPADDING=5%>
<TR><TD>exe
	<TD>Executables linked by the Main or MainFromObjects rules

<TR><TD>lib
	<TD>Libraries created by the Library or LibraryFromObjects rules

<TR><TD>obj
	<TD>Compiled objects used to create Main or Library targets

<TR><TD>dirs
	<TD>Directories where target files are written

<TR><TD>file
	<TD>Files copied by File and Bulk rules

<TR><TD>shell
	<TD>Files copied by Shell rule

<TR><TD>clean
	<TD>Removal of built targets (except files copied by Install* rules)

<TR><TD>install
	<TD>Files copied by Install* rules

<TR><TD>uninstall
	<TD>Removal of targets copied by Install* rules

</TABLE>
</CENTER>
<P> 
In addition, Jambase makes the <b>jam</b> default target "all"
depend on "exe", "lib", "obj", "files", and "shell".
<P> 

<HR>
<A NAME="VARS">
<H3>
Jambase Variables 
</H3> 
</A>
<P>
	Most of the following variables have default values for
	each platform; refer to the Jambase file to see what those
	defaults are.
<P>
	ALL_LOCATE_TARGET
<BLOCKQUOTE>
		Alternative location of built targets. By default,
		Jambase rules locate built targets in the source
		tree. By setting $(ALL_LOCATE_TARGET)
		in Jamrules, you can cause <b>jam</b>
		to write built targets to a location outside
		the source tree.
</BLOCKQUOTE>

       AR

<BLOCKQUOTE>
              The archive command used to update Library
	      and LibraryFromObjects targets.
</BLOCKQUOTE>
       AS
<BLOCKQUOTE>
              The assembler for As rule targets.
</BLOCKQUOTE>

       ASFLAGS

<BLOCKQUOTE>
              Flags handed to the assembler for As.
</BLOCKQUOTE>

       AWK

<BLOCKQUOTE>
              The  name  of  awk interpreter, used when copying a
              shell script for the Shell rule.
</BLOCKQUOTE>

	BCCROOT
<BLOCKQUOTE>
		Selects Borland compile and link actions on NT.
</BLOCKQUOTE>


       BINDIR

<BLOCKQUOTE>
              Not longer used. 
	      (I.e., used only for backward compatibility with the
	      obsolete INSTALLBIN rule.)
</BLOCKQUOTE>

       CC

<BLOCKQUOTE>
              C compiler used for Cc rule targets.
</BLOCKQUOTE>

       CCFLAGS

<BLOCKQUOTE>
		Compile flags for Cc rule targets.
		The Cc rule sets target-specific $(CCFLAGS)
		values on its targets.
</BLOCKQUOTE>

       C++

<BLOCKQUOTE>
              C++ compiler used for C++ rule targets.
</BLOCKQUOTE>

       C++FLAGS

<BLOCKQUOTE>
		Compile flags for C++ rule targets.
		The C++ rule sets target-specific $(C++FLAGS)
		values on its targets.
</BLOCKQUOTE>

       CP

<BLOCKQUOTE>
              The file copy program, used by File and Install* rules.
</BLOCKQUOTE>

       EXEMODE

<BLOCKQUOTE>
              Permissions for executables linked with Link, Main,
	      and MainFromObjects, on platforms with a Chmod action.
</BLOCKQUOTE>

       FILEMODE

<BLOCKQUOTE>
              Permissions for files copied by File or Bulk,
	      on platforms with a Chmod action.
</BLOCKQUOTE>

       FORTRAN

<BLOCKQUOTE>
              The Fortran compiler used by Fortran rule.
</BLOCKQUOTE>

       FORTRANFLAGS

<BLOCKQUOTE>
              Fortran compiler flags for Fortran rule targets.
</BLOCKQUOTE>

       GROUP

<BLOCKQUOTE>
		<I>(Unix only.)</I>
              The  group  owner  for Install* rule targets.
</BLOCKQUOTE>

       HDRPATTERN

<BLOCKQUOTE>
              A  regular expression  pattern that matches
	      C preprocessor "#include" directives in source files
	      and returns the name of the included file.
</BLOCKQUOTE>

       HDRRULE

<BLOCKQUOTE>
              Name of the rule to invoke with the results of header file
              scanning. Default is "HdrRule".
	      <P>
	      This is a jam-special variable. If both HDRRULE and HDRSCAN
	      are set on a target,
	      that target will be scanned for lines
	      matching $(HDRSCAN), and $(HDDRULE) will be
	      invoked on included files found in the matching $(HDRSCAN) lines.
</BLOCKQUOTE>

       HDRSCAN

<BLOCKQUOTE>
		Regular expression pattern to use for header file
		scanning. The Object rule sets this to $(HDRPATTERN).
              This is a jam-special variable; see HDRRULE.
</BLOCKQUOTE>

       HDRS

<BLOCKQUOTE>
              Directories to be  searched  for  header  files.
	      This is used by the Object rule to:
	      <UL>
	      <LI>set up search paths for finding files returned
		  by header scans
	      <LI>add -I flags on compile commands
	      </UL>
	      (See STDHDRS.)
</BLOCKQUOTE>

       INSTALL

<BLOCKQUOTE>
              The file copying program for the Install* rules.   If
              not set, $(CP) is used. On Unix, the $(INSTALL) default
	      is "install".
</BLOCKQUOTE>

       JAMFILE

<BLOCKQUOTE>
		Default is "Jamfile"; the name of the user-written
		rules file found in each source directory.
</BLOCKQUOTE>

       JAMRULES

<BLOCKQUOTE>
		Default is "Jamrules"; the name of a rule definition
		file to be read in at the first SubDir rule invocation.
</BLOCKQUOTE>

       LEX

<BLOCKQUOTE>
              The lex(1) command and flags.
</BLOCKQUOTE>

       LIBDIR

<BLOCKQUOTE>
              Not longer used. 
	      (I.e., used only for backward compatibility with the
	      obsolete INSTALLLIB rule.)
</BLOCKQUOTE>

       LINK

<BLOCKQUOTE>
              The linker. Defaults to $(CC).
</BLOCKQUOTE>

       LINKFLAGS

<BLOCKQUOTE>
              Flags handed to the linker. Defaults to $(CCFLAGS).
</BLOCKQUOTE>

       LINKLIBS

<BLOCKQUOTE>
              List of external libraries to link with.  The target  image
              does not depend on these libraries.
</BLOCKQUOTE>

	LOCATE_SOURCE
<BLOCKQUOTE>
		Used to set the  location of generated source files.
		The Yacc, Lex, and GenFile rules set LOCATE on
		their targets to $(LOCATE_SOURCE).
		$(LOCATE_SOURCE) is initialized by the SubDir rule
		to the source directory itself.
		(Also, see ALL_LOCATE_TARGET.)
</BLOCKQUOTE>

       LOCATE_TARGET
<BLOCKQUOTE>
		Used to set the  location of built binary targets. 
	      The Object rule, and hence the Main and Library rules,
	      set LOCATE on their targets to $(LOCATE_TARGET).
		$(LOCATE_TARGET) is initialized by the
		SubDir rule to the source directory itself.
		(See ALL_LOCATE_TARGET.)
</BLOCKQUOTE>

       
       LN

<BLOCKQUOTE>
              The hard link command for HardLink rule.
</BLOCKQUOTE>

       MANDIR

<BLOCKQUOTE>
              Not longer used. 
	      (I.e., used only for backward compatibility with the
	      obsolete INSTALLMAN rule.)
</BLOCKQUOTE>

       MKDIR

<BLOCKQUOTE>
              The  'create directory' command used for the MkDir
              rule.
</BLOCKQUOTE>

       MODE

<BLOCKQUOTE>
              The target-specific file mode (permissions) for targets 
	      of the Shell, Setuid, Link, and Install* rules.
	      Used by the Chmod action; hence relevant to NT and VMS
	      only.
</BLOCKQUOTE>
	
	MSVC
<BLOCKQUOTE>
		Selects Microsoft Visual C 16-bit compile & link
		actions on NT.
</BLOCKQUOTE>

	MSVCNT
<BLOCKQUOTE>
		Selects Microsoft Visual C NT compile & link
		actions on NT.
</BLOCKQUOTE>


       MV

<BLOCKQUOTE>
              The file rename command and options.
</BLOCKQUOTE>

       OPTIM

<BLOCKQUOTE>
              The C compiler flag for optimization, used by Cc and C++
	      rules.
</BLOCKQUOTE>

       OWNER

<BLOCKQUOTE>
              The owner of installed files.  Used by Install* rules.
</BLOCKQUOTE>

       RANLIB

<BLOCKQUOTE>
		The name of the ranlib command. If set, causes
		the Ranlib action to be applied after the
		Archive action to targets of the Library rule.
</BLOCKQUOTE>

       RELOCATE

<BLOCKQUOTE>
              If set, tells the Cc rule to move the output object
              file to its target directory because the cc command
              has a broken -o option.
</BLOCKQUOTE>

       RM

<BLOCKQUOTE>
              The command and options to remove a file.
</BLOCKQUOTE>

       SEARCH_SOURCE

<BLOCKQUOTE>
              The  directory  to  find  sources listed with Main,
              Library, Object,  Bulk,  File,  Shell,  InstallBin,
              InstallLib,  and  InstallMan  rules.  This works by
              setting the  jam-special  variable  SEARCH  to  the
              value  of  $(SEARCH_SOURCE)  for each of the rules'
              sources. The SubDir rule initializes SEARCH_SOURCE
	      for each directory.
</BLOCKQUOTE>

       SHELLHEADER

<BLOCKQUOTE>
              A string inserted to the first line of  every  file
              created by the Shell rule.
</BLOCKQUOTE>

       SHELLMODE

<BLOCKQUOTE>
              Permissions for files installed by Shell rule.
</BLOCKQUOTE>

      SOURCE_GRIST
              
<BLOCKQUOTE>
	      Set by the SubDir  to  a  value  derived  from  the
              directory  name,  and  used  by Objects and related
              rules as 'grist' to perturb file names.
</BLOCKQUOTE>

       STDHDRS

<BLOCKQUOTE>
              Directories where  headers  can  be  found  without
              resorting to using the flag to the C compiler.
	      The $(STDHDRS) directories are used to find
	      headers during scanning, but are not passed to the
	      compiler commands as -I paths.
</BLOCKQUOTE>

       SUFEXE

<BLOCKQUOTE>
              The  suffix for executable files, if none provided.
              Used by the Main rule.
</BLOCKQUOTE>

       SUFLIB

<BLOCKQUOTE>
              The suffix for libraries.  Used by the Library  and
              related rules.
</BLOCKQUOTE>

       SUFOBJ

<BLOCKQUOTE>
              The  suffix  for object files.  Used by the Objects
              and related rules.
</BLOCKQUOTE>

       UNDEFFLAG

<BLOCKQUOTE>
              The flag prefixed to each symbol for the  Undefines
              rule (i.e., the compiler flag for undefined symbols).
</BLOCKQUOTE>

	WATCOM
<BLOCKQUOTE>
		Selects Watcom compile and link actions on OS2.
</BLOCKQUOTE>

       YACC

<BLOCKQUOTE>
              The yacc(1) command and flags.
</BLOCKQUOTE>
<P>
<HR>
<A HREF="#TOP">Back to top.</A>
<P>
	Copyright 1997, 1999 Perforce Software, Inc.
	<BR>
	Comments to <A HREF="mailto:info@perforce.com">info@perforce.com</A>
	<BR>
	Last updated: Jan 27, 1999
</BODY>
</HTML>
./src/Jamfile100440    167    454        6415  7102105134  11563 0ustar  laurateam#
# Jamfile to build Jam (a make(1)-like program)
#
# There are no user-serviceable parts in this file.
#
# Put executables in platform-specific  subdirectory.
# If $(OSVER) isn't set, second value is used.

if $(VMS) {	LOCATE_TARGET ?= [.binvms] ; }
else if $(MAC) { LOCATE_TARGET ?= :bin.mac ; }
else { 		LOCATE_TARGET ?= bin.$(OSFULL[1]:L) ; }

# Leave generated source in current directory; it would be nice to use
# these lines below to build the source into the platform-specific
# directory, but getting scan.c to include the right jambase.h is
# hard: with ""'s, it always gets the bootstrap version; with <>'s,
# it won't find the bootstrap version.

# SEARCH_SOURCE ?= $(LOCATE_TARGET) $(DOT) ;
# LOCATE_SOURCE ?= $(LOCATE_TARGET) ;

#
# We have some different files for UNIX, VMS, and NT.
#

if $(NT) 	{ code = execunix.c filent.c pathunix.c ; } 
else if $(OS2)	{ code = execunix.c fileos2.c pathunix.c ; } 
else if $(VMS) 	{ code = execvms.c filevms.c pathvms.c ; } 
else if $(MAC)	{ code = execmac.c filemac.c pathmac.c ; }
else 		{ code = execunix.c fileunix.c pathunix.c ; }

if $(UNIX) 	{ code += jamgram.y ; }
else            { code += jamgram.c ; }


if $(OS) = NT { CCFLAGS += /DNT ; }
if $(OS) = MVS { CCFLAGS += -DMVS ; }
if $(OS)$(OSVER) = AIX41 { CCFLAGS += -D_AIX41 ; }

#
# How to build the compiled in jambase.
#

Main		mkjambase : mkjambase.c ;

#
# The guts of the Jamfile: how to build Jam
#

Main 		jam : jam.c jambase.c ;
LinkLibraries 	jam : libjam.a ;
GenFile 	jambase.c : mkjambase Jambase ;

Library         libjam.a : 
		    command.c compile.c $(code) expand.c glob.c
		    hash.c headers.c lists.c make.c make1.c newstr.c
		    option.c parse.c regexp.c rules.c scan.c search.c
		    timestamp.c variable.c ;

#
# On UNIX, we install this stuff for easy use.
#

if $(UNIX)
{
	InstallBin $(BINDIR) : jam ;
}

#### --- cut

if $(UNIX) 
{
	GenFile jamgram.y jamgramtab.h : yyacc jamgram.yy ;
}

rule TempCopy
{
	DEPENDS $(<) : $(>) ;
}

actions TempCopy
{
	cp $(>) $(<)
}

ALLSOURCE =
	Build.com Build.mpw Jam.html Jambase Jambase.html Jamfile
	Jamfile.html Jamlang.html Makefile Porting README RELNOTES
	command.c command.h compile.c compile.h execcmd.h execmac.c
	execunix.c execvms.c expand.c expand.h filemac.c filent.c
	fileos2.c filesys.h fileunix.c filevms.c glob.c hash.c
	hash.h headers.c headers.h jam.c jam.h jambase.c jambase.h
	jamgram.c jamgram.h jamgram.y jamgramtab.h lists.c lists.h
	make.c make.h make1.c mkjambase.c newstr.c newstr.h option.c
	option.h parse.c parse.h patchlevel.h pathmac.c pathunix.c
	pathvms.c regexp.c regexp.h rules.c rules.h scan.c scan.h
	search.c search.h timestamp.c timestamp.h variable.c
	variable.h ;

rule Ball
{
	NotFile balls ;
	Depends balls : $(<) ;

	DEPENDS $(<) : $(>) ;

	PreBall $(<) ;

	switch $(<) 
	{
	case *.tar : Tar $(<) : $(>) ;
	case *.shar : Shar $(<) : $(>) ;
	case *.zip : Zip $(<) : $(>) ;
	}

	PostBall $(<) ;
}

actions PreBall 
{
	mv Jamfile Jamfile.sav
	sed '/--- cut/,$d' Jamfile.sav > Jamfile
}

actions PostBall 
{
	mv Jamfile.sav Jamfile
}

VERSION = jam-2.2 ;

actions Tar
{
	ln -s . $(VERSION)
	tar cvhf $(<) $(VERSION)/$(>)
	rm $(VERSION)
}

actions Shar
{
	shar $(>) > $(<)
}

actions Zip
{
	zip $(<) $(>) 
}

Ball $(VERSION).shar : $(ALLSOURCE) ;
Ball $(VERSION).tar : $(ALLSOURCE) ;
Ball $(VERSION).zip : $(ALLSOURCE) ;


./src/Jamfile.html100440    167    454      141776  7102105135  12601 0ustar  laurateam<HTML>
<TITLE>
Jamfiles and Jambase
</TITLE>
<BODY>
<CENTER>
<A HREF=http://www.perforce.com/jam/jam.html>
Jam/MR
</a>
<A NAME="TOP">
<H2>
Using Jamfiles and Jambase
</H2>
</A>
</CENTER>
<P>
This document describes how to write Jamfiles using the Jam/MR Jambase 
rules to build software products. 
Related documents of interest are:
<UL>
<LI>
	<a href="Jam.html">The Jam/MR Executable Program</A>,
	which describes using the <b>jam</b> command
<LI>
	<A href="Jambase.html">Jambase Reference</A>,
	which summarizes the Jambase rules and variables
<LI>
	<a href="Jamlang.html">The Jam/MR Language</A>,
	which explains the syntax used in Jambase
</UL>
<P>
Jam/MR documentation and source are available from the
<A HREF=http://public.perforce.com/public/index.html>Perforce Public Depot</a>.
<HR>
<P>
<H2>
Overview
</H2>
<P>
        <B>jam,</B> the Jam/MR executable program,
       recursively  builds  target files  from source files
       using dependency and build specifications defined
       in Jam/MR rules files.
        <B>jam</B> parses the rules files to identify targets
        and sources,
        examines the filesystem to determine which
        targets need updating, and issues OS commands to update
        targets.
<P>
        A base rules file called "Jambase" is provided with the 
	Jam/MR distribution. 
	The Jambase file defines rules and variables which support
	standard software build operations, like compiling, linking,
	etc.
<P>
	When the Jambase rules are used,
	<B>jam</B> reads Jambase, then reads a file called
	"Jamfile" in the current directory.
	The Jamfile describes what to do with the source files in 
	its directory. It may also cause
	Jamfiles in other directories to be read. 
	<P>
	Under certain circumstances, the first Jamfile read
	also causes a site-specific "Jamrules" file to be read.
	The Jamrules file is an optional set of rule and variable
	definitions used to define site-specific processing.
<P>
<H4>
The Basic Jamfile
</H4>
<P>
Jamfiles contain rule invocations, which usually look like:
<PRE>
	<I>RuleName</I> <I>targets</I> : <I>targets</I> ;
</PRE>
The target(s) to the left of the colon usually indicate
what gets built, and the target(s) to the right of the
colon usually indicate what it is built from.
<P>
<P>
A Jamfile can be as simple as this:
<PRE>
	Main myprog : main.c util.c ;
</PRE>
This specifies that there is a main.c and util.c file in the same
directory as the Jamfile, and that those source files should be
compiled and linked into an executable called myprog.
If you cd to the directory where this Jamfile lives,
you can see the exactly how <b>jam</b> would 
build myprog with:
<PRE>
	jam -n
</PRE>
Or, you can actually build myprog with the command:
<PRE>
	jam
</PRE>

<P>
<H4>
Whitespace
</H4>
Jamfile elements are delimited by whitespace (blanks, tabs, or
newlines). Elements to be delimited include rule names, targets,
colons, and semicolons. A common mistake users make is to forget the
whitespace, e.g.,
<PRE>
	Main myprog: main.c util.c ; #<I>WRONG!</I>
</PRE>
Jam/MR doesn't distinguish between a typo and a target called "myprog:", 
so if you get strange results, the first thing
you should check for in your Jamfile is missing whitespace.
<P>
<H4>
Filenames, Target Identifiers, and Buildable Targets
</H4>
<P>
Consider this Jamfile:
<PRE>
	Main myprog : main.c util.c ;                   
	LinkLibraries myprog : libtree ;     
	Library libtree : treemake.c treetrav.c ;    
</PRE>
<P>
The Main rule specifies that an executable called myprog will be built.
The compiled main.c and util.c objects will be linked to produce
myprog. 
The LinkLibraries rule specifies that libtree will
be linked into myprog as well.
The Library rule specifies which source files will be compiled and
archived into the libtree library.
<P>
The Jamfile above refers to targets like "myprog" and "libtree". 
However, depending on the platform you're building on, the actual
filenames of those targets could be "myprog.exe" and "libtree.lib".
Most Jambase rules supply the actual filenames of targets,
so that Jamfiles themselves need not make any
platform-specific filename references.
<P>
The <b>jam</b> program builds up a list of unique target identifiers.
Unless you are using the SubDir rules (described later),
the default identifier for a file target is its filename. In the above
example, the target identifiers are the filenames: myprog.exe,
libtree.lib, main.obj, etc.
<P>
While all Jambase rules refer to "targets",
not all targets are buildable.
There are two kinds of buildable targets: 
file targets and pseudotargets.
File targets are objects that can be found in the filesystem.
Pseudotargets are symbolic, and represent other targets.
<P>
You can use any buildable target on the <b>jam</b> command line to
build a subset of defined targets. For example:
<PRE>
        jam libtree.a 
</PRE>
on Unix builds the libtree library and all the compiled objects
that go in it.
<P>
<H4>
Pseudotargets
</H4>
<P>
Most Jambase rules that define file targets also define pseudotargets
which are dependent on types of file targets.
For example, Jambase defines a pseudotarget called "lib", which 
is dependent on file targets created by the Library rule. So 
the command:  
<PRE>
        jam lib
</PRE> 
used with the above example would cause the libtree library to be built.
Also, there is one pseudotarget built into <b>jam</b> itself, called
"all". Jambase sets "all" dependent on (almost) all other targets.
<P>
In the unfortunate case where you have a buildable target whose name
is the same as one of the Jambase pseudotargets, you'll have problems
with the conflicting target name.
Your workaround choices are:
<P>
<ol>
<lI>Change the name of your buildable file or directory that conflicts.
<p>
<li>Modify your Jambase and change the name of the conflicting pseudotarget.
(Pseudotargets are defined in Jambase using the NOTFILE rule.)
<p>
<li>Use grist on the conflicting target name in your Jamfile. E.g., instead
    of
    <PRE>
    File lib : libfoo.a ;
    </PRE>
    try
    <PRE>
    File &lt;dir&gt;lib : libfoo.a ;
    </PRE>
</ol>
<P>

<H4>
Dependencies
</H4>
<P>
Jambase rules set dependencies on targets, so that if you update a
source file, all the file targets that depend on that source
file, and only the ones that depend on that source file, 
will be updated (rebuilt) the next time you run <b>jam</b>. 
<P>
Here are some of the dependencies 
that get set when <b>jam</b> runs on NT using the example Jamfile above:
<CENTER>
<TABLE> 
<TR><TD><B>Target</B><TD>&nbsp;&nbsp;&nbsp;<TD><B>Depends on</B></TD>
<TR><TD>myprog.exe<TD><TD>main.obj, util.obj, libtree.lib
<TR><TD>libtree.lib<TD><TD>treemake.obj, treetrav.obj
<TR><TD>treetrav.obj<TD><TD>treetrav.c
</TABLE>
</CENTER>
<P>
Furthermore, the Main and Library rules set up recursive
header scanning on their source targets.
So after <b>jam</b> has finished parsing the Jamfile and
setting the rule-driven dependencies, it scans the source 
files for "#include" lines. All #include files found during
this scan become dependencies of the compiled object.
E.g., all header files used to compile treetrav.c would
be made dependencies of treetrav.obj.
<P>
As a result, when you run <b>jam</b>, it will rebuild targets
if either the source files change or the 
header files change. You can't tell by looking at a Jamfile
which header files are dependencies, but you can easily
display those dependencies with:
<PRE>
	jam -nd+3
</PRE>
<H4>
Rule Ordering
</H4>
<P>
Rules which specify dependencies, like the Main, Library, and
LinkLibrary rules, can be invoked in any order. <b>jam</b>
figures out the order in which targets are built from 
their dependencies.
<P>
Some rules, however, set variables which are used by subsequent
rule invocations, and their ordering is important. 
For example, the SubDir* rules (discussed
later) must be invoked in a particular order.

<P>
<H4>
Detailed Jambase Specifications
</H4>
<P>
This document describes how to use various Jambase rules
from a functional point of view.
You can see the summary of available Jambase rules in the
<a href="Jambase.html">Jambase Reference</A>.
The detailed specifications for any Jambase rule
can be found by reading the rule definition itself
in the Jambase file.
<P>

<HR>
<H2>
Handling Directory Trees
</H2>
       The SubDir* rules are used to
       define source code directory hierarchies.
       With SubDir and SubInclude, you can use <b>jam</b>
       to build software from source files and Jamfiles spread
       across many directories, as is typical for large projects.
       The SubDir* rules unify an entire
       source code tree so that <b>jam</b> can read in
       all the Jamfiles in one pass and 
       compute dependencies across the entire project.
<P>
	To use the SubDir* rules, you must:
<P>
<OL>
       <LI>     Preface the Jamfile in each directory with an invocation 
       of the SubDir rule.
<P>
       <LI>     Place  at  the  root  of the tree a file named Jamrules.  
	      This file could be empty,  but  in
              practice  it contains user-provided rules and variable 
	      definitions that  are  shared  throughout  the
              tree.   Examples  of  such  definitions are library
              names,  header  directories,  install  directories,
              compiler  flags,  etc.  This file is good candidate
              for automatic customizing with autoconf(GNU).
<P>
	<LI> 	Optionally, set an environment variable pointing
		to the root directory of the srouce tree. The
		variable's name is left up to you, but in these
		examples, we use TOP.
</OL>
<P>
<H4>
   SubDir Rule
</H4>
<P>
       The  SubDir  rule  must  be  invoked before any rules that
       refer to the contents of the directory - it is best to put
       it at the top of each Jamfile.  For example:
<PRE>
	# Jamfile in $(TOP)/src/util directory.

	SubDir TOP src util ;

	Main myprog : main.c util.c ;                   
	LinkLibraries myprog : libtree ;     
	Library libtree : treemake.c treetrav.c ;    
</PRE>
       This  compiles  four  files  in  $(TOP)/src/util, archives
       two of the objects into libtree, and links  the  whole
       thing into myprog. 
       Outputs are placed in the $(TOP)/src/util
       directory. 
       <P>
       This doesn't appear to be any different from 
       the previous example that didn't have a SubDir rule,
       but two things are happening behind the scenes:
       <OL>
       <LI>The SubDir rule causes <b>jam</b> to read
	   in the $(TOP)/Jamrules file. 
           (The Jamrules file can alternately be named by  the
              variable  $(xxxRULES), where xxx is the name of the
              root variable, e.g., $(TOPRULES)).  
	      <P>
	   The Jamrules file can contain variable definitions
	   and rule definitions specific to your codeline.
	   It allows you to completely customize your build 
	   environment without having to rewrite Jambase.
	   Jamrules is only read
	   in once, at the first SubDir invocation.
	   <P>
	<LI>
	   The SubDir rule initializes a set of variables
	   that are used by Main and other rules to 
	   uniquely identify the source files in this
	   directory and assign locations to the targets
	   built from files in this directory.
	   <P>
	   When you have set a root variable, e.g., $(TOP),
	   SubDir constructs path names rooted with $(TOP),
	   e.g., $(TOP)/src/util.
	   Otherwise, SubDir constructs relative pathnames
	   to the root directory, computed from the number
	   of arguments to the first SubDir rule, e.g.,
	   ../../src/util. In either case, the SubDir
	   rule constructs the path names that locate source
	   files.
	   You'll see how this is useful later.
	<P>
       </UL>

<P>
       The SubDir rule takes  as  its  first  argument  the  root
       variable's  name  and  takes  as  subsequent arguments the
       directory names leading from the root to the directory  of
       the  current Jamfile.  Note that the name of the subdirectory 
       is given as individual  elements:   the  SubDir  rule
       does not use system-specific directory name syntax.
<P>
<P>
<H4>
   SubInclude Rule
</H4>
	The SubInclude rule is used in a Jamfile to cause another
	Jamfile to be read in.
       Its arguments are in  the  same  format  as
       SubDir's.
<P>
       The  recommended  practice is only to include one level of
       subdirectories at a time, and let the Jamfile in each subdirectory  
       include  its own subdirectories.  This allows a
       user to sit in any arbitrary directory of the source  tree
       and build that subtree.  For example:
<PRE>
       # This is $(TOP)/Jamfile, top level Jamfile for mondo project.

       SubInclude TOP src ;
       SubInclude TOP man ;
       SubInclude TOP misc ;
       SubInclude TOP util ;
</PRE>
       If  a directory has both subdirectories of its own as well
       as files that need building,  the  SubIncludes  should  be
       either before the SubDir rule or be at the end of the Jamfile 
       - not between the SubDir and other rule  invocations.
       For example:
<PRE>
	# This is $(TOP)/src/Jamfile:

	SubDir TOP src ;

	Main mondo : mondo.c ;
	LinkLibraries mondo : libmisc libutil ;
	
	SubInclude TOP src misc ;
	SubInclude TOP src util ;
</PRE>
<P>
	(<b>jam</b> processes all the Jamfiles it reads as if
	it were reading one single, large Jamfile. 
	Build rules like Main and LinkLibraries rely on the
	preceding SubDir rule to set up source file and
	output file locations, and SubIncludes rules read in
	Jamfiles that contain SubDir rules. So if you put
	a SubIncludes rule between a SubDir and a Main
	rule, <b>jam</b> will try to find the source files
	for the Main rule in the wrong directory.)
<P>
<H4>
   Variables Used to Handle Directory Trees
</H4>
       The  following  variables are set by the SubDir rule
       and used by the Jambase rules that define file targets:
<P>
<CENTER>
<TABLE>
<TR><TD VALIGN=TOP>
              SEARCH_SOURCE
	      <TD><TD>The SubDir targets (e.g., "TOP src util")
	      are used to construct a pathname (e.g., $(TOP)/src/util),
	      and that pathname is assigned to $(SEARCH_SOURCE). 
	      Rules like Main and Library use $(SEARCH_SOURCE)
	      to set search paths on source files.
<TR><TD VALIGN=TOP>
              LOCATE_SOURCE
	      <TD><TD>Initialized by the SubDir rule to the same
	      value as $(SEARCH_SOURCE), unless ALL_LOCATE_TARGET
	      is set.
	      $(LOCATE_SOURCE) is used by rules that build
	      generated source files (e.g., Yacc and Lex) to
	      set location of output files.
	      Thus the default location of built source files
	      is the directory of the Jamfile that defines them.
<TR><TD VALIGN=TOP>
              LOCATE_TARGET
	      <TD><TD>Initalized by the SubDir rule to the same
	      value as $(SEARCH_SOURCE), unless ALL_LOCATE_TARGET
	      is set.
	      $(LOCATE_TARGET) is used by rules that build
	      binary objects (e.g., Main and Library) to
	      set location of output files.
	      Thus the default location of built binaray files
	      is the directory of the Jamfile that defines them.
<TR><TD VALIGN=TOP>
              ALL_LOCATE_TARGET
	      <TD><TD>
	      If $(ALL_LOCATE_TARGET) is set, LOCATE_SOURCE
	      and and LOCATE_TARGET are set to  $(ALL_LOCATE_TARGET)
	      instead of to $(SEARCH_SOURCE). This can be used to
	      direct built files to be written to a location outside
	      of the source tree, and enables building from read-only
	      source trees.
<TR><TD VALIGN=TOP>
              SOURCE_GRIST
	      <TD><TD>The SubDir targets are formed into a string
	      like "src!util" and that string is assigned to 
	      SOURCE_GRIST. Rules that define file targets
	      use $(SOURCE_GRIST) to set the "grist" attribute
	      on targets. This is used to assure uniqueness 
	      of target identifiers where filenames themselves
	      are not unique.
	      For example, the target identifiers of 
	      $(TOP)/src/client/main.c and $(TOP)/src/server/main.c
	      would be &lt;src!client&gt;main.c and &lt;src!server&gt;main.c.
</TABLE>
</CENTER>
<P>
       The $(LOCATE_TARGET) and  $(SEARCH_SOURCE)  variables are used
       extensively by rules in Jambase: most rules that  generate
       targets  (like  Main,  Object,  etc.)  set $(LOCATE) to 
       $(LOCATE_TARGET) for the targets they generate, and  rules
       that  use  sources  (most all of them) set $(SEARCH) to be
       $(SEARCH_SOURCE) for the sources they use.
<P>
       $(LOCATE) and $(SEARCH) are better  explained  in  
       <A HREF="Jam.html">The Jam/MR Executable Program</A>
       but in brief they tell <B>jam</B> where to create new targets and
       where to find existing ones, respectively.
<P>
       Note that you can reset these variables
       after SubDir sets them. For example, this Jamfile builds
       a program called gensrc, then runs it to create a source file
       called new.c: 
       <PRE>
       SubDir TOP src util ;
       Main gensrc : gensrc.c ;
       LOCATE_SOURCE = $(NEWSRC) ;
       GenFile new.c : gensrc ;
       </PRE>
       By default, new.c would be written into the
       $(TOP)/src/util directory, but resetting LOCATE_SOURCE causes
       it to be written to the $(NEWSRC) directory. ($(NEWSRC) is assumed
       to have been set elsewhere, e.g., in Jamrules.)
<P>
<H4>
   VMS Notes
</H4>
       On VMS, the logical name table is not imported as  is  the
       environment on UNIX.  To use the SubDir and related rules,
       you must set the value of the variable that names the root
       directory.  For example:
<PRE>
              TOP = USR_DISK:[JONES.SRC] ;

              SubInclude TOP util ;
</PRE>
       The variable must have a value that looks like a directory
       or device.  If you choose, you can use a  concealed  logical.  
       For example:
<PRE>
              TOP = TOP: ;

              SubInclude TOP util ;
</PRE>
       The  :  at  the  end of TOP makes the value of $(TOP) look
       like a device name, which jam respects as a directory name
       and  will  use when trying to access files.  TOP must then
       be defined from DCL:
<PRE>
              $ define/job/translation=concealed TOP DK100:[USERS.JONES.SRC.]
</PRE>
       Note three things: the concealed  translation  allows  the
       logical  to  be  used as a device name; the device name in
       the logical (here DK100) cannot itself be concealed  logical  
       (VMS  rules, man); and the directory component of the
       definition must end in a period (more VMS rules).
<P>
<H2>
Building Executables and Libraries
</H2>
<P>
The rules that build executables and libraries are: Main, Library,
and LinkLibraries.
<H4>
   Main Rule
</H4>
       The Main rule compiles source files and links the  resulting 
       objects into an executable.  For example:
<PRE>
              Main myprog : main.c util.c ;
</PRE>
       This  compiles  main.c  and  util.c  and  links main.o and
       util.o into myprog. The object files and resulting 
       executable are named appropriately for the platform.
<P>
	Main can also be used to build shared libraries and/or
	dynamic link libraries, since those are also linked
	objects. E.g.:
	<PRE>
		Main driver$(SUFSHR) : driver.c ;
	</PRE>
	Normally, Main uses $(SUFEXE) to determine the suffix on
	the filename of the built target. To override it,
	you can supply a suffix explicity.
	In this case,
	$(SUFSHR) is assumed to be the OS-specific shared library
	suffix, defined in Jamrules with something
	like:
	<PRE>
		if $(UNIX)      { SUFSHR = .so ; }
		else if $(NT)   { SUFSHR = .dll ; }
	</PRE>
	<P>
	Main uses the Objects rule to compile source targets. 

<H4>
   Library Rule
</H4>
       The Library  rule  compiles  source  files,  archives  the
       resulting  object  files  into a library, and then deletes
       the object files.  For example:
<PRE>
              Library libstring : strcmp.c strcpy.c strlen.c ;
              Library libtree : treemake.c treetrav.c ;
</PRE>
       This compiles five source files,  archives  three  of  the
       object  files into libstring and the other two into libtree.  
       Actual library filenames are formed with the $(SUFLIB) suffix.
       Once the objects are safely in the libraries, the
       objects are deleted.
       <P>
       Library uses the Objects rule to compile source files.
<P>
<H4>
   LinkLibraries Rule
</H4>
       To link executables with built libraries, use
       the LinkLibraries rule.  For example:
<PRE>
              Main myprog : main.c util.c ;
              LinkLibraries myprog : libstring libtree ;
</PRE>
       The LinkLibraries rule  does  two  things:  it  makes  the
       libraries dependencies of the executable, so that they get
       built first; and it makes the libraries  show  up  on  the
       command  line  that links the executable.  The ordering of
       the lines above is not important, because <b>jam</b> builds  targets 
       in the order that they are needed.
<P>
       You  can  put multiple libraries on a single invocation of
       the LinkLibraries rule, or you can provide them in  multiple  
       invocations.   In both cases, the libraries appear on
       the link command line in the  order  in  which  they  were
       encountered.  You can also provide multiple executables to
       the LinkLibraries rule, if they need the same libraries,
       e.g.:
       <PRE>
		LinkLibraries prog1 prog2 prog3 : libstring libtree ;
       </PRE>
<P>
<H4>
   Variables Used in Building Executables and Libraries
</H4>
<CENTER>
<TABLE>
<TR><TD>
              AR           
	      <TD><TD>Archive command, used for Library targets.
<TR><TD>
              SUFEXE         
	      <TD>*<TD>Suffix on filenames of executables referenced
		by Main and LinkLibraries.
<TR><TD>
              LINK           
	      <TD><TD>Link command, used for Main targets.
<TR><TD>
              LINKFLAGS       
	      <TD><TD>Linker flags.
<TR><TD>
              LINKLIBS        
	      <TD><TD>Link libraries that aren't dependencies. (See note
		below.)
<TR><TD>
              EXEMODE         
	      <TD>*<TD>File permissions on Main targets.
<TR><TD>
              MODE            
	      <TD><TD>Target-specific file permissions on Main targets
		(set from $(EXEMODE))
<TR><TD>
              RANLIB          
	      <TD><TD>Name of ranlib program, if any.
</TABLE>
</CENTER>

<P>
	Variables above marked with "*" are used by the Main,
	Library, and LinkLibraries rules. Their values at the 
	time the rules are invoked are used to set target-specific
	variables.
	<P>
	All other variables listed above are globally defined,
	and are used in actions that update Main and Library
	targets. This means that the global values of those
	variables are used, uness target-specific values have
	been set. 
	(For instance, a target-specific MODE value is set by 
	the Main rule.)
	The target-specific values always override
	global values.
<P>
	Note that there are two ways to specify link libraries for
	executables: 
	<UL>
	<LI>Use the LinkLibraries rule 
	to specify built libraries; i.e., libraries
	that are built by Library rules. This assures that
	these libraries are built first, and that Main targets are 
	rebuilt when the libraries are updated.
	<P>
	<LI>Use the LINKLIBS variable to specify external
	 libraries; e.g., system libraries or third-party libraries.
	 The LINKLIBS variable must be set to the the actual
	 link command flag that specifies the libraries.
	 <P>
	 </UL>
	 <P>
	 For example:
<PRE>
	<I>#In Jamrules:</I>
              if $(UNIX) { X11LINKLIBS = -lXext -lX11 ; }
              if $(NT)   { X11LINKLIBS = libext.lib libX11.lib ; }

	<I>#In Jamfile:</I>
              Main xprog : xprog.c ;
              LINKLIBS on xprog$(SUFEXE) = $(X11LINKLIBS) ;
              LinkLibraries xprog : libxutil ;
              Library libxutil : xtop.c xbottom.c xutil.c ;
</PRE>
       This  example  uses the Jam/MR syntax "variable on target" to
       set a target-specific variable.  In this way,  only  xprog
       will  be linked with this special $(X11LINKLIBS), 
       even if other executables were going to  be  built
       by  the  same Jamfile. Note that when you set a variable
       on a target, you have to specify the target identifer
       exactly, which in this case is the suffixed filename of
       the executable.
       The actual link command line on Unix, for example, would
       look something like this:
<PRE>
              cc -o xprog xprog.o libxutil.a -lXext -lX11
</PRE>
<H2>
Compiling
</H2>
       Compiling of source files occurs normally as  a  byproduct
       of  the Main or Library rules, which call the rules 
       described here. These rules may also be called explicitly
       if the Main and Library behavior doesn't satisfy your
       requirements.
<P>
<H4>
   Objects Rule
</H4>
       The Main and Library rules call the Objects rule on source files.
       Compiled object files built by
       the Objects rule are a dependency of the <I>obj</i>
       pseudotarget, so "jam obj" will build object files used in 
       Main and Library rules.
       <P>
       Target identifiers created by the Objects rule have grist
       set to $(SOURCE_GRIST). So given this Jamfile:
       <PRE>
		SubDir TOP src lock ;
		Main locker : lock.c ;
       </PRE>
       the object file created is lock.o (or lock.obj) and
       its target identifier is &lt;src!lock&gt;lock.o 
       (or &lt;src!lock&gt;lock.obj).

       <P>
       You can also call  Objects  directly.  For example:
<PRE>
              Objects a.c b.c c.c ;
</PRE>
       This compiles a.c into a.o, b.c into b.o, etc. The object
       file suffix is supplied by the Objects rule.
<P>
<H4>
   Object Rule
</H4>
       Objects  gets  its work done by calling the Object rule on
       each of the source files.
       You could use the Object rule directly.
       For example, on Unix, you could use:
<PRE>
              Object foo.o : foo.c ;
</PRE>
	However, the Object rule does not provide suffixes, and
	it does not provide the grist needed to construct target
	identifiers if you are using the SubDir* rules.
	A portable and robust Jamfile would need to invoke Object thus:
	<PRE>
	      Object &lt;src!util&gt;foo$(SUFOBJ) : &lt;src!util&gt;foo.c ;
	</PRE>
	which is inelegant and clearly shows why using Objects
	is better than using Object.
	<P>
	If there's any advantage to the Object rule, it's
       that it doesn't require that the object name bear
       any relationship to the source.  It is  thus  possible  to
       compile  the  same file into different objects.  For example:

<PRE>
              Object a.o : foo.c ;
              Object b.o : foo.c ;
              Object c.o : foo.c ;
</PRE>
       This compiles foo.c (three times) into a.o, b.o, and  c.o.
       Later examples show how this is useful.
<P>
       The Object rule looks at the suffix of the source file and
       calls the appropriate rules to do  the  actual  preprocessing
       (if any) and compiling needed to produce the output object file.
       The Object rule is
       capable of the generating of an object file from  any
       type of source.  For example:
<PRE>
              Object grammar$(SUFOBJ) : grammar.y ;
              Object scanner$(SUFOBJ) : scanner.l ;
              Object fastf$(SUFOBJ) : fastf.f ;
              Object util$(SUFOBJ) : util.c ;
</PRE>
	An even more elegant way to get the same result is to let the
	Objects rule call Object:
	<PRE>
              Objects grammar.y scanner.l fastf.f util.c ;
	</PRE>
	<P>
       In  addition to calling the compile rules, Object sets up
       a bunch of variables specific to  the  source  and  target
       files.  (See Variables Used in Compiling, below.)
<P>
<H4>
   Cc, C++, Yacc, Lex, Fortran, As, etc. Rules
</H4>
<P>
       The Object rule calls compile rules specific to the suffix of
       the source file.  (You can see which suffixes are supported
       by looking at the Object rule definition in Jambase.)
       Because  the  extra  work  done  by  the
       Object rule, it is not always useful to call the compile
       rules directly.  But the adventurous  user  might  attempt
       it.  For example:
<PRE>
              Yacc grammar.c : grammar.y ;
              Lex scan.c : scan.l ;
              Cc prog.o : prog.c ;
</PRE>
       These examples individually run yacc(1), lex(1), and the C
       compiler on their sources.
<P>
<H4>
   UserObject Rule
</H4>
       Any files with suffixes not understood by the Object  rule
       are passed to the UserObject rule.  The default definition
       of UserObject simply emits a warning that  the  suffix  is
       not  understood.   This  Jambase rule definition is intended to be
       overridden in Jamrules with one that recognizes the project-specific
       source file suffixes. For  example:

<PRE>
	#In Jamrules:

              rule UserObject
              {
                  switch $(&gt;)
                  {
                  case *.rc   : ResourceCompiler $(&lt;) : $(&gt;) ;
                  case *      : ECHO "unknown suffix on" $(&gt;) ;
                  }
              }

              rule ResourceCompiler
              {
                  DEPENDS $(&lt;) : $(&gt;) ;
		  Clean clean : $(<) ;
              }

              actions ResourceCompiler
              {
                  rc /fo $(&lt;) $(RCFLAGS) $(&gt;)
              }


	#In Jamfile:

              Library liblock : lockmgr.c ;
	      if $(NT) { Library liblock : lock.rc ; }
</PRE>
<P>
	In this example, the UserObject definition in Jamrules
	allows *.rc files to be handle as regular Main and Library
	sources. The lock.rc file is compiled into lock.obj
	by the "rc" command, and lock.obj is archived into a library
	with other compiled objects.
<H4>
   LibraryFromObjects Rule
</H4>
       Sometimes the Library rule's straightforward compiling  of
       source  into  object modules to be archived isn't flexible
       enough.  The LibraryFromObjects rule  does  the  archiving
       (and  deleting)  job of the Library rule, but not the compiling.  
       The user can make use of the  Objects  or  Object
       rule for that.  For example:
<PRE>
              LibraryFromObjects libfoo.a : max.o min.o ;
              Object max.o : maxmin.c ;
              Object min.o : maxmin.c ;
              ObjectCcFlags max.o : -DUSEMAX ;
              ObjectCcFlags min.o : -DUSEMIN ;
</PRE>
       This  Unix-specific example compiles  the  same  source  file into 
       two different
       objects, with different compile flags, and archives  them.
       (The ObjectCcFlags rule is described shortly.)
       Unfortunately, the portable and robust implementation of the
       above example is not as pleasant to read:
       <PRE>
	      SubDir TOP foo bar ;
              LibraryFromObjects libfoo$(SUFLIB) : &lt;foo!bar&gt;max$(SUFOBJ) 
			                           &lt;foo!bar&gt;min$(SUFOBJ) ;
              Object &lt;foo!bar&gt;min$(SUFOBJ) : &lt;foo!bar&gt;maxmin.c ;
              Object &lt;foo!bar&gt;max$(SUFOBJ) : &lt;foo!bar&gt;maxmin.c ;
	      ObjectCcFlags &lt;foo!bar&gt;min$(SUFOBJ) : -DUSEMIN ;
	      ObjectCcFlags &lt;foo!bar&gt;max$(SUFOBJ) : -DUSEMAX ;
       </PRE>
       Note that, among other things, you must supply the library
       file suffix when using the LibraryFromObjects rule.
<P>
<H4>
   MainFromObjects Rule
</H4>
       Similar  to  LibraryFromObjects,  MainFromObjects does the
       linking part of the Main rule, but not the compiling.
       MainFromObjects  can be used when  there  are no
       objects at all,  and  everything  is  to  be  loaded  from
       libraries.  For example:
<PRE>
              MainFromObjects testprog ;
              LinkLibraries testprog : libprog ;
              Library libprog : main.c util.c ;
</PRE>
       On Unix, say, this generates a link command that looks like:
<PRE>
              cc -o testprog libprog.a
</PRE>
       Linking  purely  from  libraries is something that doesn't
       work everywhere: it depends on  the  symbol  "main"  being
       undefined when the linker encounters the library that contains 
       the definition of "main".
<P>
<H4>
   Variables Used in Compiling
</H4>
       The following variables control the  compiling  of  source
       files:
<P>
<CENTER>
<TABLE>
<TR><TD VALIGN=TOP>
              C++              
	      <TD><TD>The C++ compiler command
<TR><TD VALIGN=TOP>
              CC               
	      <TD><TD>The C compiler command
<TR><TD VALIGN=TOP>
              C++FLAGS       
	      <BR>
              CCFLAGS        
	      <TD VALIGN=TOP><TD VALIGN=TOP>Compile flags, used to
		 create or update compiled objects
<TR><TD>
              SUBDIRC++FLAGS 
	      <BR>
              SUBDIRCCFLAGS  
	      <TD VALIGN=TOP><TD VALIGN=TOP>Additonal compile flags
		for source files in this directory.
<TR><TD VALIGN=TOP>
              OPTIM            
	      <TD><TD>Compiler optimization flag. The Cc and C++ 
		actions use this as well as C++FLAGS or CCFLAGS.
<TR><TD VALIGN=TOP>
              HDRS           
	      <TD VALIGN=TOP><TD>Non-standard header directories; i.e.,
		the directories the compiler will not look in 
		by default and which therefore must be supplied
		to the compile command. These directories are
		also used by <b>jam</b> to scan for include files.
<TR><TD VALIGN=TOP>
              STDHDRS        
	      <TD VALIGN=TOP><TD>Standard header directories, i.e., the
		directories the compiler searches automatically.
		These are not passed to the compiler, but they
		are used by <b>jam</b> to scan for include files.
<TR><TD>
              SUBDIRHDRS     
	      <TD><TD>Additional paths to add to HDRS for source files
		in this directory.
<TR><TD>
              LEX              
	      <TD><TD>The lex(1) command 
<TR><TD>
              YACC             
	      <TD><TD>The yacc(1) command 
</TABLE>
</CENTER>
<P>
       The  Cc rule sets a target-specific $(CCFLAGS) to the current 
       value of $(CCFLAGS) and $(SUBDIRCCFLAGS).   Similarly
       for  the C++ rule.  The Object rule sets a target-specific
       $(HDRS) to  the  current  value  of  $(HDRS)  and  $(SUBDDIRHDRS).

<P>
       $(CC),  $(C++),  $(CCFLAGS),  $(C++FLAGS),  $(OPTIM),  and
       $(HDRS) all affect the  compiling  of  C  and  C++  files.
       $(OPTIM)  is  separate  from $(CCFLAGS) and $(C++FLAGS) so
       they can be set independently.
<P>
       $(HDRS) lists the directories to search for header  files,
       and  it  is used in two ways: first, it is passed to the C
       compiler (with the flag -I prepended); second, it is  used
       by  HdrRule  to  locate  the header files whose names were
       found when scanning source files.   $(STDHDRS)  lists  the
       header  directories  that  the  C  compiler  already knows
       about.  It does not need passing to the C compiler, but is
       used by HdrRule.
<P>
       Note that these variables, if set as target-specific variables, 
       must be set on the target,  not  the  source  file.
       The target file in this case is the object file to be generated.  
       For example:
<PRE>
              Library libximage : xtiff.c xjpeg.c xgif.c ;

              HDRS on xjpeg$(SUFOBJ) = /usr/local/src/jpeg ;
              CCFLAGS on xtiff$(SUFOBJ) = -DHAVE_TIFF ;
</PRE>
       This can be done more easily with the rules that follow.
<P>
<H4>
   ObjectCcFlags, ObjectC++Flags, ObjectHdrs Rules
</H4>
       $(CCFLAGS), $(C++FLAGS) and  $(HDRS)  can  be  set on object file
       targets
       directly, but  there are rules that allow these variables
       to be set by referring to the original source  file  name,
       rather  than  to  the  derived object file name.  ObjectCcFlags 
       adds object-specific flags to the $(CCFLAGS)  variable,  
       ObjectC++Flags  adds  object-specific  flags to the
       $(C++FLAGS) variable, and ObjectHdrs  add  object-specific
       directories to the $(HDRS) variable.  For example:
<PRE>
	#In Jamrules:
		if $(NT) { CCFLAGS_X = /DXVERSION ;	
			   HDRS_X = \\\\SPARKY\\X11\\INCLUDE\\X11 ;
		         }

	#In Jamfile:
              Main xviewer : viewer.c ;
              ObjectCcFlags viewer.c : $(CCFLAGS_X) ;
              ObjectHdrs viewer.c : $(HDRS_X) ;
</PRE>
	The ObjectCcFlags and ObjectHdrs rules take .c files
	as targets, but actually set $(CCFLAGS) and $(HDRS) values
	on the .obj (or .o) files. As a result, the action
	that updates the target .obj file uses the target-specific
	values of $(CCFLAGS) and $(HDRS).
<P>
<H4>
   SubDirCcFlags, SubDirC++Flags, SubDirHdrs Rules
</H4>
       These rules set the  values  of  $(SUBDIRCCFLAGS),  $(SUBDIRC++FLAGS)  
       and $(SUBDIRHDRS), which are used by the Cc,
       C++, and Object rules  when  setting  the  target-specific
       values  for $(CCFLAGS), $(C++FLAGS) and $(HDRS).  The SubDir 
       rule clears these variables out, and thus they provide
       directory-specific  values of $(CCFLAGS), $(C++FLAGS)  and
       $(HDRS).  For example:
<PRE>
	#In Jamrules:
              GZHDRS = $(TOP)/src/gz/include ;
	      GZFLAG = -DGZ ;
		
	#In Jamfile:
              SubDir TOP src gz utils ;

              SubDirHdrs $(GZHDRS) ;
              SubDirCcFlags $(GZFLAG) ;

	      Library libgz : gizmo.c ;
	      Main gizmo : main.c ;
	      LinkLibraries gizmo : libgz ;
</PRE>
	All .c files in this directory files will be compiled with
	$(GZFLAG) as well as the default $(CCFLAG), and the include
	paths used on the compile command will be $(GZHDRS) as well
	as the default $(HDRS).
<H2>
Header File Processing
</H2>
       One of the functions of the Object rule is set up 
       scanning of source
       files  for (C style) header file inclusions.  To do so, it
       sets the special variables $(HDRSCAN)  and  $(HDRRULE)
       as  target-specific  variables  on  the source file.  The
       presence of these variables triggers a  special  mechanism
       in  <B>jam</B> for scanning a file for header file inclusions and
       invoking a  rule  with  the  results  of  the  scan.   The
       $(HDRSCAN)  variable  is  set  to an egrep(1) pattern that
       matches "#include" statements in C source files,  and  the
       $(HDRRULE)  variable  is  set to the name of the rule that
       gets invoked as such:
<PRE>
              $(HDRRULE) source-file : included-files ;
</PRE>
       This rule is supposed to set up the  dependencies  between
       the  source  file and the included files.  The Object rule
       uses HdrRule  to  do  the  job.   HdrRule  itself  expects
       another  variable,  $(HDRSEARCH), to be set to the list of
       directories where the included files can be found.  Object
       does  this  as  well,  setting $(HDRSEARCH) to $(HDRS) and
       $(STDHDRS).
<P>
       The header file scanning occurs during the "file  binding"
       phase   of  <b>jam</b>,  which  means  that  the  target-specific
       variables (for the source file) are in effect.  To accomodate 
       nested includes, one of the HdrRule's jobs is to pass
       the target-specific values of $(HDRRULE), $(HDRSCAN),  and
       $(HDRSEARCH) onto the included files, so that they will be
       scanned as well.
<P>
<H4>
   HdrRule Rule
</H4>
	Normally, HdrRule is not invoked directly; the Object rule
	(called by Main and Library) invokes it.
	<P>
	If there are special dependencies that need to be set,
	and which are not set by HdrRule itself, you can define
	another rule and let it invoke HdrRule.  For example:

<PRE>
	#In Jamrules:
              rule BuiltHeaders
              {
                      DEPENDS $(&gt;) : mkhdr$(SUFEXE) ;
                      HdrRule $(&lt;) : $(&gt;) ;
              }

	#In Jamfile:
              Main mkhdr : mkhdr.c ;
              Main ugly : ugly.c ;

              HDRRULE on ugly.c = BuiltHeaders ;

</PRE>
       This example just says that the files included by "ugly.c"
       are  generated  by the program "mkhdr", which can be built
       from "mkhdr.c".  During the binding phase, <b>jam</b> will
       scan ugly.c, and if it finds an include file, ughdr.h,
       for example, it will automatically invoke the rule:
       <PRE>
              BuiltHeaders ugly.c : ughdr.h ;
       </PRE>
       By calling HdrRule at the end  of  BuiltHeaders,  
       all  the gadgetry of HdrRule takes effect and it
       doesn't need to be duplicated.
<P>
<H4>
   Variables Used for Header Scanning
</H4>
<CENTER>
<TABLE>
<TR><TD VALIGN=TOP>
              HDRPATTERN    
	      <TD><TD>Default scan pattern for "include" lines.
<TR><TD VALIGN=TOP>
              HDRSCAN         
	      <TD><TD>Scan pattern to use. 
		This is a special variable: during binding, if
		both HDRSCAN and HDRRULE are set, scanning is activated
		on the target being bound.
		The HdrRule and Object rules sets this
		to $(HDRPATTERN) on their source targets.
<TR><TD VALIGN=TOP>
              HDRRULE         
	      <TD><TD>Name of rule to invoked on files found in header
		scan. The HdrRule and Object rules set this to "HdrRule"
		on their source targets. This is also a special variable;
		it's the only <b>jam</b> variable that can hold the
		name of a rule to be invoked.
<TR><TD VALIGN=TOP>
              HDRSEARCH       
	      <TD><TD>Search paths for files found during header scanning.
		This is set from $(HDRS) and $(STDHDRS), which are 
		described in the Compiling section.
		<b>jam</b> will search $(HDRSEARCH) directories for
		the files found by header scans. 
</TABLE>
</CENTER>
<P>
       The  Object rule sets HDRRULE and HDRSCAN specifically for
       the source files to be scanned, rather than globally.   If
       they  were  set  globally,  jam  would attempt to scan all
       files, even library archives and executables,  for  header
       file  inclusions.   That  would  be  slow and probably not
       yield desirable results.
<P>
<H2>
Copying Files
</H2>
<H4>
   File Rule
</H4>
       The File rule copies one file to another.  The target name
       needn't  be the same as the source name.  For
       example:
<PRE>
	switch $(OS)
	{
           case NT*  : File config.h : confignt.h ;
	   case *    : File config.h : configunix.h ;
	}
	LOCATE on config.h = $(LOCATE_SOURCE) ;
</PRE>
	This creates a config.h file from either confignt.h or
	configunix.h, depending on the current build platform.
<P>
	The File rule does not
	use the LOCATE_SOURCE variable set by the
	SubDir rule (although it does use SEARCH_SOURCE), which
	means you have to set the copied file's output directory
	yourself. That's done by setting the special
	LOCATE variable on the target, as shown above,
	or with the MakeLocate rule described below.
<H4>
   Bulk Rule
</H4>
       The Bulk rule is a shorthand for many invocations  of  the
       File  rule when all files are going to the same directory.
       For example:
<PRE>
	#In Jamrules:
              DISTRIB_GROB = d:\\distrib\\grob ;

	#In Jamfile:
              Bulk $(DISTRIB_GROB) : grobvals.txt grobvars.txt ;
</PRE>
	This causes gobvals.txt and grobvars.txt to be copied
	into the $(DISTRIB_GROB) directory.
<H4>
   HardLink Rule
</H4>
       The Unix-only HardLink rule makes a hard link (using ln(1)) from the
       source  to  the  target,  if there isn't one already.  For
       example:
<PRE>
              HardLink config.h : configunix.h ;
</PRE>
<H4>
   Shell Rule
</H4>
       The Shell rule is like the File rule, except that on Unix it makes
       sure  the first line of the target is "#!/bin/sh" and sets
       the permission to make the file executable.  For example:
<PRE>
              Shell /usr/local/bin/add : add.sh ;
</PRE>
<P>
	You can also use $(SHELLHEADER) to dictate
	what the first line of the copied file will be.
       For
       example:
<PRE>
              Shell /usr/local/bin/add : add.awk ;
              SHELLHEADER on /usr/local/bin/add = "#!/bin/awk -f" ;
</PRE>
       This installs an awk(1) script.
<P>
<H4>
   Variables Used When Copying Files
</H4>
<CENTER>
<TABLE>
<TR><TD VALIGN=TOP>
              FILEMODE      
	      <TD><TD>Default file permissions for copied files
<TR><TD VALIGN=TOP>
              SHELLMODE     
	      <TD><TD>Default file permissions for Shell rule targets
<TR><TD VALIGN=TOP>
              MODE            
	      <TD><TD>File permissions set on files copied by
		File, Bulk, and Shell rules. 
       		File and Shell sets a target-specific MODE to the  current
       		value  of  $(FILEMODE) or $(SHELLMODE), respectively.  
<TR><TD VALIGN=TOP>
              SHELLHEADER     
	      <TD><TD>String to write in first line of Shell targets 
	      (default is #!/bin/sh).

</TABLE>
</CENTER>
<P>

<H2>
Installing Files
</H2>
Jambase provides a set of Install* rules to copy files
into an destination directory and set permissions on them.
On Unix, the install(1) program is used.
If the destination directory does not exist, <b>jam</b>
creates it first.
<P>
All files copied with the Install* rules are dependencies
of the <i>install</i> pseudotarget, which means that the
command "jam install" will cause the installed copies to
be updated. Also, "jam uninstall" will cause the installed
copies to be removed.
<P>
The Install* rules are:
<CENTER>
<TABLE>
<TR><TD VALIGN=TOP><B>InstallBin</B>
    <TD VALIGN=TOP>Copies file and sets its permission to $(EXEMODE).
		   You must specify the suffixed executable name. E.g.:
    <PRE>InstallBin $(BINDIR) : thing$(SUFEXE) ;
		   </PRE>

<TR><TD VALIGN=TOP><B>InstallFile</B>
    <TD VALIGN=TOP>Copies file and sets its permission to $(FILEMODE). E.g.:
    <PRE>InstallFile $(DESTDIR) : readme.txt ;
		   </PRE>

<TR><TD VALIGN=TOP><B>InstallLib</B>
    <TD VALIGN=TOP>Copies file and sets its permission to $(FILEMODE).
		   You must specify the suffixed library name. E.g.:
    <PRE>InstallLib $(LIBDIR) : libzoo$(SUFLIB) ;
		   </PRE>

<TR><TD VALIGN=TOP><B>InstallMan</B>
    <TD VALIGN=TOP>Copies file into the man<i>n</i>
		   subdirectory of the target directory
		   and sets its permission to $(FILEMODE). E.g.,
		   this copies foo.5 into the $(DESTDIR)/man5 directory:
    <PRE>InstallMan $(DESTDIR) : foo.5 ;
		   </PRE>

<TR><TD VALIGN=TOP><B>InstallShell</B>
    <TD VALIGN=TOP>Copies file and sets its permission to $(SHELLMODE). E.g.:
    <PRE>InstallShell $(DESTDIR) : startup ;
		   </PRE>

</TABLE>
</CENTER>
<P>
<P>
<H4>
   Variables
</H4>
       The following variables control the installation rules:
<P>
<CENTER>
<TABLE>
<TR><TD>
              INSTALL        
	      <TD><TD>The install program (Unix only)
<TR><TD>
              FILEMODE     
	      <TD><TD>Default file permissions on readable files. 
<TR><TD>
              EXEMODE      
	      <TD><TD>Default file permission executable files.
<TR><TD>
              SHELLMODE    
	      <TD><TD>Default file permission on shell script files.
<TR><TD>
              MODE           
	      <TD><TD>Target-specific file permissions
</TABLE>
</CENTER>
<P>
<P>
       The  Install  rules set a target-specific MODE to the current 
       value of $(FILEMODE),  $(EXEMODE),  or  $(SHELLMODE),
       depending on which Install rule was invoked.
<P>
       The  directory variables are just defined for convenience:
       they must be passed  as  the  target  to  the  appropriate
       Install  rule.   The $(INSTALL) and mode variables must be
       set (globally) before calling the Install rules  in  order
       to take effect.
<P>
<H2>
Miscellaneous Rules
</H2>
<H4>
Clean Rule
</H4>
<P>
The Clean rule defines files to be removed when you run "jam clean".
Any site-specific build rules defined in your Jamrules should invoke
Clean so that outputs can be removed. E.g.,
<PRE>
	rule ResourceCompiler
	{
	   DEPENDS $(<) : $(>) ;
	   Clean clean : $(<) ;
	}
</PRE>
<P>
<P>
Most Jambase rules invoke the Clean rule on their built targets,
so "jam clean" will remove all compiled objects, libraries,
executables, etc.
<P>
<H4>
MakeLocate Rule
</H4>
      MakeLocate is a single convenient rule that creates a directory,
      sets LOCATE on a target to that directory, and makes the directory
      a dependency of the target. It is used by many Jambase rules,
      and can be invoked directly, e.g.:
      <PRE>
		GenFile data.tbl : hxtract data.h ;
		MakeLocate data.tbl : $(TABLEDIR) ;
      </PRE>
      In this example, the File rule creates data.tbl from data.h.
      The MakeLocate causes data.tbl to be written into the $(TABLEDIR)
      directory; and if the directory doesn't exist, it is created first.
      <P>
      The MakeLocate rule invokes another Jambase rule, MkDir,
      to (recursively) create
      directories. MkDir uses the $(MKDIR) variable to determine the
      platform-specific command that creates directories.
<P>
<H4>
RmTemps Rule
</H4>
	Some intermediate files are meant to be temporary. 
	The RmTemps rule can be used to cause 
	<b>jam</b> to delete them after they are used. 
	<P>
	RmTemps must be:
	<UL>
	<LI>
	the last rule 
	invoked on the permanent file that uses
	the temporary file(s) 
	<LI>
	invoked with the permanent file as the output
	target and the temporary file(s) as the input target
	<LI>
	invoked with the exact target identifiers of
	the permanent file and the temporary file(s)
	</UL>
	For
	example: 
	<PRE>
		SubDir TOP src big ;
		GenFile big.y : joinfiles part1.y part2.y part3.y ;
		Main bigworld : main.c big.y ;
		RmTemps bigworld$(SUFEXE) : &lt;src!big&gt;big.y ;
	</PRE>
	This causes big.y to be deleted after it has been used to create
	the bigworld executable. 
	The exact target identifier of big.y is  &lt;src!big&gt;big.y
	(the GenFile and Main rules tack on the grist automatically);
	the exact target identifier of the bigworld executable
	is bigworld$(SUFEXE).
<P>
<HR>   
<A HREF="#TOP">Back to top.</A>
<P>
        Copyright 1997, 1999 Perforce Software, Inc.
        <BR>
        Comments to <A HREF="mailto:info@perforce.com">info@perforce.com</A>
        <BR>
        Last updated: Jan 27, 1999
</BODY> 
</HTML>
./src/Jamlang.html100440    167    454       71352  7102105135  12553 0ustar  laurateam<HTML>
<HEAD>
<TITLE>
Jam/MR Language
</TITLE>
</HEAD>
</BODY>
<CENTER>
<a href=http://www.perforce.com/jam/jam.html>
Jam/MR
</a>
<A NAME="TOP">
<H1> The Jam/MR Language
</H1>
</A>
</CENTER>
<P>
	This document describes the Jam/MR language, used
	to defines rules and dependencies for <b>jam</b>,
	the Jam/MR executable program.
	For additional information, please see:
	<UL>
	<LI><a href="Jam.html">The Jam/MR Executable Program</A>
	<LI><a href="Jamfile.html">Using Jamfiles and Jambase</A>
	<LI><A href="Jambase.html">Jambase Reference</A>
	</UL>
<P>
	Also, the 
<A HREF=http://public.perforce.com/public/jam/src/Jambase>Jambase</a>
	source file itself
	is an excellent source of Jam/MR language examples.
	Jam/MR documentation and source are available from the
<A HREF=http://public.perforce.com/public/index.html>Perforce Public Depot</a>.
<HR>
<H3> Lexical Features
</H3>
<P>
       Jam/MR treats its input files as whitespace-separated tokens,
       with two exceptions: double quotes (") can enclose whitespace  to embed it into a token, and everything between the
       matching curly braces ({}) in the  definition  of  a  rule
       action is treated as a single string.  A backslash (\) can
       escape a double quote.
<P>
       Jam/MR requires whitespace (blanks,  tabs,  or  newlines)  to
       surround all tokens, including the colon (:) and semicolon
       (;) tokens.  This is because <b>jam</b> runs  on  many  platforms
       and  no  characters,  save whitespace, are uncommon in the
       file names on all of those platforms.
<p>
<H4> Reserved Words
</h4>
<P>
	Certain tokens are recognized as reserved words, and unless they
	are used in expected context they will cause syntax errors.
	You can quote reserved words to use them in other contexts. 
	For example, "switch" is a reserved word, so:
	<PRE>
	Echo "switch" ;
	</pre>
	is allowed, but:
	<PRE>
	Echo switch ;
	</PRE>
	will get a syntax error.
	Words likely to be reserved are any keywords used in
	defining rules, flow of control, or variable definition.
<P>
<H3> Targets
</H3>
<P>
	The essential Jam/MR data entity is a target.
       Built targets are files to be updated. Source targets are the  files
       used  in  updating  those targets. Pseudotargets are
       symbols which represent dependencies on other targets.
       Built targets and source targets are collectively referred
       to as file targets; pseudotargets are not file targets.
       <P>
       Each target has a unique identifier, which, in the case
       of file targets, is its filename optionally qualified
       with grist (a string value used to
       assure uniqueness) and/or a pathname,
       either rooted or relative to the directory of 
       <b>jam</b>'s
       invocation.  
       A file target with an identifier of the form
       <I>file(member)</I> is an
       an ar(1) library member.
<P>
<H3> Rules
</H3>
<P>
       Jam/MR's basic language entity is called a  rule,  which  is  used  
       primarily to
       relate built targets to their source targets. A rule is defined in two
       parts: the Jam/MR statements to  execute  when  the  rule 
       invocation is parsed, and the actions
       (shell commands) to execute when updating the built targets
       of  the  rule.   A  rule  may have a procedure definition,
       an action definition, or both.
<P>
       The Jam/MR statements for defining and invoking rules are  as
       follows:
       <PRE>
	rule <I>rulename</I> { <I>statements</I> }

	actions [ <I>modifiers</I> ] <I>rulename</I> { <I>commands</I> }

	<I>rulename field1 </I>:<I> field2 </I>:<I> ... </I>:<I> fieldN ;</I>
	</PRE>

<P>
       The  first  form  defines  a  rule's procedure; the second
       defines the rule's updating actions; the third invokes the
       rule.   Redefining  a rule's procedure or actions replaces
       the previous definition.
<P>
	A rule is invoked with values in <I>field1</I> through
	<I>fieldN</I>, which are referenced in the procedure
	definition <I>statements</I> as 
	variables named $(1) through $(<I>N</I>).
	A rule defined with a procedure definition and no action
	definition is just a procedure call.
<P>
	When a rule is invoked, its action definition, if any,
	is automatically the first updating action to be associated
	with targets.
	Any other actions invoked from a rule's procedure definition
	<I>statements</I>
	will be executing during updating in the order
	in which they were invoked.
	Updating actions are associated with the targets in <I>field1</I>.
<P>
	Built targets and source targets are passed to an updating
	action through <I>field1</I> and <I>field2</I>, and
	are refenced in the action's <I>commands</I> as
	$(1) and $(2) respectively.
	$(1) and $(2) may also be referenced as $(<) and $(>)
	in action <I>commands</I> and 
	procedure definition <I>statements</I>. 
	During updating, <I>commands</I> are passed to the OS, with
	$(1) and $(2) replaced by bound targets. (See "Binding" 
	in the <a href="Jam.html">The Jam/MR Executable Program</A>.) 
<P>
<H4> Action Modifiers
</H4>
<P>
       The following action <i>modifiers</i> are understood:
<PRE>
              actions bind <I>vars</I>
                     $(vars) will be replaced with bound values.
			
              actions existing
                     $(>) includes only source targets currently  existing.

              actions ignore
                     The  return  status of the <I>commands</I> is
                     ignored.

              actions piecemeal
                     <I>commands</I>  are  repeatedly  invoked
                     with a subset of $(>) small enough to fit in
                     the command buffer on this OS.

              actions quietly
                     The action is not  echoed  to  the  standard
                     output.

              actions together
                     The $(>) from multiple invocations of the same
                     action  on  the  same  built target  are   glommed
                     together.

              actions updated
                     $(>) includes only source targets themselves
		     marked for updating.
</PRE>
<H4> Built-in Rules
</H4>
<P>
       Jam/MR has ten built-in rules, none of  which  have  updating
       actions:
<PRE>

              ALWAYS <I>targets</I> ;
                     Rebuilds  <I>targets</I>, even if they are up-to-date.

              DEPENDS <I>targets1</I> : <I>targets2</I> ;
                     Makes <I>targets1</I> dependencies of <I>targets2</I>.

              ECHO <i>args</I> ;
                     Blurts out the message <i>args</I> to stdout.

              EXIT <i>args</I> ;
                     Blurts out the message <i>args</I> to stdout  and
                     then exits with a failure status.

              INCLUDES <I>targets1</I> : <I>targets2</I> ;
                     Makes  <I>targets2</I> dependencies of anything of which 
		     <I>targets1</I> are dependencies.

              LEAVES <I>targets</I> ;
                     Makes each of <I>targets</I> depend only  on  its leaf  
		     sources,  and  not on any intermediate targets. Its leaf 
		     sources are those  source targets without any 
		     dependencies themselves.

              NOCARE <I>targets</I> ;
                     Marks <I>targets</I> as possibly being not needed. If a 
		     <I>target</I> is present, its timestamp is used to compute 
		     dependencies; if it is not present, it is not considered a
		     dependency.

              NOTFILE <I>targets</I> ;
                     Marks <I>targets</I> as pseudotargets, not files.

              NOUPDATE <I>targets</I> ;
                     Causes the timestamps  of  <I>targets</I>  to  be ignored: 
		     either  <I>target</I> exists  or it doesn't. If it  exists,
		     it is  considered eternally old.

              TEMPORARY <I>targets</I> ;
                     Marks <I>targets</I> as temporary; causes <I>targets</I> to be removed 
		     when all their dependencies have been updated.
</PRE>
<P>
       The  ALWAYS, LEAVES, NOCARE, NOTFILE, NOUPDATE, and TEMPORARY affect only the binding phase (q.v.).
<P>
<H3> Flow-of-Control
</H3>
<P>
       Jam/MR has several simple flow-of-control statements:
<PRE>
	      local <i>vars</I> [ = <i>values</i> ] ;

              include <I>file</I> ;

              for <I>var</I> in <I>list</I> { <I>statements</I> }

              switch <I>value</I> 
			{ case <I>pattern1</I> : <I>statements</I> ; 
			  case <I>pattern2</I> : <I>statements</I> ; 
			  ... 
			}

              if  <I>cond</I> 
			{ <I>statements</I> } 
	 	 [ else { <I>statements</I> } ]
</PRE>
<UL>
<LI>
       The local statement instantiates new <i>vars</i> inside
       the current {} block. Variables of the same name outside
       of the {} block or before the local statement are unaffected 
       and inaccessible. local may appear anywhere in a block.
       The <i>vars</i> are initialized to <i>values</i>, if present.
       <P>
<LI>
       The include statement causes <b>jam</b> to read
       the named <i>file</i>.   The  file
       is  bound  like  regular targets (see Binding, below), but
       unlike regular targets the include file cannot be built.
       <P>
       The include file is inserted into the input stream during
       the parsing phase. The primary
       input file and all the included file(s) are treated as a
       single file; that is, <b>jam</b> infers no scope boundaries
       from included files.
       <P>
<LI>
       The for loop  executes  <i>statements</i>  for  each  element  in
       <i>list</i>, setting the variable <i>var</i> to the element value.
       <P>
<LI>
       The  switch statement executes zero or one of the enclosed
       <i>statements</i>, depending on which, if any, is the first
       case whose <i>pattern</I> matches <i>value</i>. The
       <i>pattern</I>  values are not variable-expanded.  
       The <i>pattern</I>  values may
       include the following wildcards:
<CENTER>
<TABLE>
<TR><TD>
              ?         
<TD>		match any single character
<TR><TD>
              *         
<TD>		match zero or more characters
<TR><TD>
              [<i>chars</i>] 
<TD>		match any single character in <i>chars</i>

</TABLE>
</CENTER>
<P>
<LI>
       The if statement does the  obvious;  the  else  clause  is
       optional.  <i>cond</i> is built of:
<P>
<CENTER>
<TABLE> 
<TR><TD>
              <CODE><I>a</I></CODE>
<TD>		true if any <I>a</I> element is a non-zero-length string
<TR><TD>
              <CODE><I>a</I> = <I>b</I></CODE> 
<TD>		list <I>a</I> matches list <I>b</I> string-for-string
<TR><TD>
              <CODE><I>a</I> != <I>b</I>     </CODE>
<TD>		list <I>a</I> does not match list <I>b</I>
<TR><TD>
              <CODE><I>a</I> &lt; <I>b</I> </CODE>
<TD>		<I>a[i]</I> string is less than <I>b[i]</I>
                string, where <i>i</i> is first mismatched element
		in lists <I>a</I> and <I>b</I>
<TR><TD>
              <CODE><I>a</I> &lt;= <I>b</I>     </CODE>
<TD>		every <I>a</I> string is less than or equal to
		its <I>b</I> counterpart
<TR><TD>
              <CODE><I>a</I> &gt; <I>b</I> </CODE>
<TD>		<I>a[i]</I> string is greater than <I>b[i]</I>
		string, where <i>i</i> is first mismatched element
<TR><TD>
              <CODE><I>a</I> &gt;= <I>b</I>     </CODE>
<TD>		every <I>a</I> string is greater than or equal to
		its <I>b</I> counterpart
<TR><TD>      
              <CODE><I>a</I> in <I>b</I>     </CODE>
<TD>		true if all elements of <I>a</I> can be found
                in <I>b</I>, or if <I>a</I> has no elements
<TR><TD>
              <CODE>! <I>cond</I>       </CODE>
<TD>		condition not true
<TR><TD>
              <CODE><I>cond</I> && <I>cond</I> </CODE>   
<TD>		conjunction
<TR><TD>
              <CODE><I>cond</I> || <I>cond</I>    </CODE>
<TD>		disjunction
<TR><TD>
              <CODE>( <I>cond</I> )          </CODE>
<TD>		precedence grouping
</TABLE>
</CENTER>
<P>
</UL>
<H3> Variables
</H3>
<P>
       Jam/MR variables are lists of zero or more elements, 
       with each element being a string value.
       An undefined variable is indistinguishable from  a
       variable  with an empty list, however, a defined
       variable may have one more elements which are null strings.
       <P>
       Variables are
       either global or target-specific.  All variables are  referenced as $(VARIABLE).
<P>
       A variable is defined with:
<PRE>
              <I>variable</I> = <I>elements</I> ;

              <I>variable</I> += <I>elements</I> ;

              <I>variable</I> on <I>targets</I> = <I>elements</I> ;

              <I>variable</I> on <I>targets</I> += <I>elements</I> ;

              <I>variable</I> default = <I>elements</I> ;
              <I>variable</I>        ?= <I>elements</I> ;
</PRE>
<P>
       The  first  two  forms set <I>variable</I> globally.  The third
       and forth forms  set  a  target-specific  variable,  where
       <I>variable</I>  takes  on  a value only during the binding and
       updating <I>targets</I>.  The = operator replaces any  previous
       elements  of  <I>variable</I>  with  <I>elements</I>;  the  +=  operation
       adds <I>elements</I> to <I>variable</I>'s list of elements.   
       The  final  two forms do the same thing,
       set  <I>variable</I>  globally,  but only if it was previously
       unset.
<P>
       On program start-up, <b>jam</b> imports environment  variable
       settings  into  Jam/MR  variables.  Environment variables are
       split at blanks with each word becoming an element in the
       variable's  list of values.  Environment variables whose names
       end in PATH are split at $(SPLITPATH) characters (e.g., ":" for
       Unix).  Environment  variable values can be overridden on the command line with the
       -s flag.  
       Jam/MR variables are not re-exported to  the  shell
       that  executes  the  updating  actions,  but  the updating
       actions can reference Jam/MR variables with $(<I>variable</I>).
       <P>
       Variables referenced in updating commands will be replaced
       with their values; target-specific values take precedence over global
       values. Variables passed as arguments to actions
       are replaced with their bound values; the "bind" modifier can be used
       on actions to cause other variables to be replaced with bound
       values.
<P>
<H4> Variable Expansion
</H4>
<P>
       During parsing, Jam/MR performs variable expansion  on  each  
       token  that is not a keyword or rule name.
       Such tokens with embedded variable references are replaced
       with  zero or more tokens.  Variable references are of the
       form $(<I>v</I>) or $(<I>vm</I>), where <i>v</i> is the variable  
       name,  and  <I>m</I> are optional modifiers.
<P>
       Variable expansion in a rule's actions is similar to 
       variable expansion  in  statements,  except  that  the  action
       string is tokenized at whitespace regardless of quoting.
<P>
       The  result  of  a  token  after variable expansion is the
       product of the components of the token, where each  component is a literal substring or a list substituting a variable reference.  For example:
<PRE>
              $(X)      -> a b c
              t$(X)     -> ta tb tc
              $(X)z     -> az bz cz
              $(X)-$(X) -> a-a a-b a-c b-a b-b b-c c-a c-b c-c
</PRE>
<P>
       The variable name and modifiers can themselves  contain  a
       variable  reference,  and  this partakes of the product as
       well:
<PRE>
              $(X)      -> a b c
              $(Y)      -> 1 2
              $(Z)      -> X Y
              $($(Z))   -> a b c 1 2
</PRE>
<P>
       Because of this product expansion, 
       if any variable  reference  in a token is undefined, 
       the result of the expansion is an empty list.
       If any variable element is a null string,
       the result propagates the non-null elements: 

<PRE>
              $(X)        -> a ""
              $(Y)        -> "" 1
	      $(Z)	  -> 
	      *$(X)$(Y)*  -> *a* *a1* ** *1*
	      *$(X)$(Z)*  ->
</PRE>

<P>
       A variable element's string value can be parsed into
       grist and filename-related components.
       Modifiers to a variable are used to select elements,
       select components, and replace components. The modifiers
       are:
<CENTER>
<TABLE>
<TR><TD>
       [<I>n</I>]     
       <TD>Select element number <I>n</I> (starting at 1).  If
              the variable contains fewer than <I>n</I> elements,  the
              result is a zero-element list.
<TR><TD>
       [<I>n</I>-<I>m</I>]   
       <TD>Select elements number <I>n</I> through <I>m</I>.
<TR><TD>
       [<I>n</I>-]    
       <TD>Select elements number <I>n</I> through the last.
<TR><TD>
       :B      
       <TD>Select filename base.
<TR><TD>
       :S      
       <TD>Select (last) filename suffix.
<TR><TD>
       :M      
       <TD>Select archive member name.
<TR><TD>
       :D      
       <TD>Select directory path.
<TR><TD>
       :P      
       <TD>Select parent directory.
<TR><TD>
       :G      
       <TD>Select grist.
<TR><TD>
       :U      
       <TD>Replace lowercase characters with uppercase.
<TR><TD>	
       :L      
       <TD>Replace uppercase characters with lowercase.
<TR><TD>
       :<i>chars</I>   
       <TD>Select the components listed in <i>chars</i>.
<TR><TD>
       :G=<I>grist</I>
              
	      <TD>Replace grist with <I>grist</I>.
<TR><TD>
       :D=<I>path</I>
               
	       <TD>Replace  directory with <I>path</I>.
<TR><TD>
       :B=<I>base</I>
               
	       <TD>Replace the base part of file name with <I>base</I>.
<TR><TD>
       :S=<I>suf</I>
             
	     <TD>Replace the suffix of file name with <I>suf</I>.
<TR><TD>
       :M=<I>mem</I>
             
	     <TD>Replace the archive member name with <I>mem</I>.
<TR><TD>
       :R=<I>root</I>
              
	      <TD>Prepend <I>root</I> to  the  whole  file  name,  if  not
               already rooted.
</TABLE>
</CENTER>

<P>
	On VMS, $(var:P) is the parent directory of $(var:D);
	on Unix and NT, $(var:P) and $(var:D) are the same.
<P>
<H3> Built-in Rules and Variables
</H3>
       This section discusses Jam/MR's built-in rules and variables.
       These built-in rules, along with  the
       other  Jam/MR  syntax for manipulating variables, provide the
       foundation upon which the Jambase is built.  A Jamfile, or
       (more  likely)  a  Jamrules  (q.v.), can make use of these
       built-in rules and variables as well.
<P>
<H4> DEPENDS, INCLUDES Rules
</H4>

       Two rules build  the  dependency  graph.   DEPENDS  simply
       makes  its  sources dependencies of its targets.  INCLUDES
       makes its sources dependencies of anything  of  which  its
       targets  are dependencies.  This reflects the dependencies
       that arise when one  source  file  includes  another:  the
       object  built  from  the  source  file depends both on the
       original and included source file,  but  the  two  sources
       files don't depend on each other.  For example:
<PRE>
              DEPENDS foo.o : foo.c ;
              INCLUDES foo.c : foo.h ;
</PRE>
       Both "foo.c" and "foo.h" become dependencies of "foo.o" in
       this example.
<P>
<H4> ALWAYS, LEAVES, NOCARE, NOTFILE, NOUPDATE, TEMPORARY Rules
</H4>
       Six rules mark targets so that <b>jam</b> treats them differently
       during  its  target binding and updating phase.  Normally,
       <b>jam</b> updates a target if it is missing, if  its  filesystem
       modification  time  is  older than any of its dependencies
       (recursively), or if any of  its  dependencies  are  being
       updated.   This  basic behavior can be changed by invoking
       the following rules with the target  name  as  the  rule's
       target:
<P>
       The  ALWAYS  rule causes its targets to be always updated.
       This is used for the clean and uninstall targets, as  they
       have  no  dependencies and would otherwise appear never to
       need building.  It is best applied  to  targets  that  are
       also  NOTFILE  targets, but it can also be used to force a
       real file to be updated as well.
<P>
       The NOCARE rule causes <b>jam</b> to ignore its targets  if  they
       can't  be  found  and have no updating actions.  Normally,
       <b>jam</b> issues a warning about a target that  can't  be  built
       and  then  refuses  to build anything that depends on that
       target.  The HdrRule in Jambase uses NOCARE on the header file  names
       found  during  header  file scanning, to let <b>jam</b> know that
       the included files may  not  exist.   For  example,  if  a
       #include  is  within  an #ifdef, the included file may not
       actually be around.
<P>
       The NOTFILE rule marks its targets as  being  pseudotargets,  
       that  is,  targets  that  aren't really files.  The
       actions on such a target are only executed if the target's
       dependencies  are updated, or if the target is also marked
       with ALWAYS.  The default <b>jam</b> target "all" is a 
       pseudotarget. In Jambase, NOTFILE is used to define 
       several addition convenient pseudotargets.
<P>
       The  NOUPDATE  rule  causes <b>jam</b> to ignore the modification
       time of the target.  This has two  effects:   first,  once
       the target has been created it will never be updated; second, 
       manually updating target will not cause other targets
       to be updated.  In Jambase, for example, this rule is applied 
       to directories by the
       MkDir rule, because  MkDir  only  cares  that  the  target
       directory exists, not when it has last been updated.
<P>
       The  TEMPORARY rule allows for targets to be deleted after
       they are generated.  If <b>jam</b> sees that a  temporary  target
       is  missing,  it  will use the target's parent's time when
       determining if the target needs  updating.   Jambase uses
       TEMPORARY to mark object  files
       that are archived in a library after they are built, so
       that they can be deleted after they are archived.
<P>
       The LEAVES rule makes each of the targets depend  only  on
       its  "leaf"  dependencies.   This  makes  it immune to its
       dependencies being updated, as the "leaf" dependencies are
       those  without their own dependencies and without updating
       actions.  This allows a target to be updated only if original 
       source files change.
<P>
<H4> ECHO, EXIT Rules
</H4>
       These  two  rules are are used only in <b>jam</b>'s parsing phase.
       The ECHO rule just echoes its targets to the standard output.   
       The EXIT rule does the same and then does a brutal,
       fatal exit of <b>jam</b>.
<P>
<H4> SEARCH, LOCATE Variables
</H4>
       These two variables control the binding of target names to
       real  files:  they  indicate  what  path  name  is  to  be
       prepended to the target name when substituting values for
       variables referenced in action definitions.
       (See "Binding" in
       <a href="Jam.html">The Jam/MR Executable Program</A>.)
       <P>

       $(SEARCH)  provides  a list of directories along which <b>jam</b>
       scans  looking  for   a   target.    $(LOCATE)   overrides
       $(SEARCH),  indicating the directory where the target must
       be.  Normally, $(SEARCH) is set for existing targets while
       $(LOCATE) is set for the targets which <b>jam</b> must build.  
       Only the first element in $(LOCATE) is used for binding.
       If neither $(SEARCH) nor $(LOCATE) are set, or if the name of
       the  target  is a rooted file name (e.g., on UNIX beginning
       with "/"), then the file name is assumed to be the  target
       name.
<P>
       Both $(SEARCH) and $(LOCATE) should be set target-specific
       and not globally.  If they were set  globally,  <b>jam</b>  would
       use  the same paths for all file binding, which is  
       not likely to produce  sane  results.
       When writing your own rules,  especially  ones  not  built
       upon  those  in  Jambase, you may need to set $(SEARCH) or
       $(LOCATE) directly. 
       Almost all of the rules defined in Jambase
       set $(SEARCH) and $(LOCATE) to  sensible  values
       for  sources they are looking for and targets they create,
       respectively. 
<P>
<P>
<H4> HDRSCAN, HDRRULE Variables
</H4>
       These two variable  control  header  file  scanning.   The
       first  is  an  egrep(1) pattern, with ()'s surrounding the
       file name, used  to  find  file  inclusion  statements  in
       source  files.  The second is the name of a rule to invoke
       with the results of the scan: the scanned file is the target,  
       the  found  files are the sources.  This is the only
       place where <b>jam</b> invokes a rule through a variable setting.
<P>
       Both $(HDRSCAN) and $(HDRRULE) must be set for header file
       scanning to take place, and they should be set target-specific  
       and  not  globally.  If they were set globally, all
       files,  including  executables  and  libraries,  would  be
       scanned for header file include statements.
<P>
       The  scanning for header file inclusions is not exact, but
       it is at least dynamic, so there is no need to  run
       something  like  makedepend(GNU) to create a static dependency 
       file. The scanning mechanism errs on the side of robustness 
       (i.e., it is more likely to return filenames that are not actually
       used by the compiler than to miss include files) 
       because it can't tell if #include lines are inside #ifdefs or
       other conditional logic. 
       In Jambase, HdrRule  applies the NOCARE rule to each header file 
       found during scanning so that if the file isn't present and isn't
       needed during compilation, <b>jam</b> doesn't skip its dependencies.
       <P>
       Also, scanning for regular expressions only  works
       where  the  included  file name is literally in the source
       file.  It can't handle languages  that  allow  including
       files using variable names (as the Jam/MR language itself does).
<P>
<H4> Platform Identifier Variables
</H4>
<P>
	A number of Jam/MR built-in variables can be used to 
	identify runtime platform:
	<CENTER>
	<TABLE>
	<TR><TD>UNIX<TD>true on Unix platforms
	<TR><TD>NT<TD>true on NT platforms
	<TR><TD>VMS<TD>true on VMS platforms
	<TR><TD>MAC<TD>true on MAC platforms
	<TR><TD>OS2<TD>true on OS2 platforms
	<TR><TD>OS<TD>OS identifier string 
	<TR><TD>OSVER<TD>OS version, when applicable
	<TR><TD>OSPLAT<TD>Underlying architecture, when applicable
	<TR><TD>JAMVERSION<TD><b>jam</b> version, currently "2.2"
	<TR><TD>JAMUNAME<TD>Ouput of runtime <b>uname</b> command (Unix only)
	</TABLE>
	</CENTER>
<P>
<H4> JAMDATE Variable
</H4>
	Initialized to time and date at <b>jam</b> startup.

<P>
<H4> JAMSHELL Variable
</H4>
       When  <b>jam</b>  executes  a  rule's  action block, it forks and
       execs a shell, passing the action block as an argument  to
       the  shell.   The invocation of the shell can be controlled by
       $(JAMSHELL). On Unix, for example:
<PRE>
              JAMSHELL = /bin/sh -c % ;
</PRE>
       The % is replaced with the text of the action block.
<P>
       <b>jam</b> can build targets in parallel, as long as  the
       dependencies  among  files  are  properly  spelled out and
       actions don't create fixed  named  files  in  the  current
       directory.   (If  either  of those two provisions are violated, 
       <B>jam</B> can trip over itself when building in  parallel
       things  which just happen to build OK sequentially.)  When
       building in parallel, <b>jam</b> simply forks off more  than  one
       shell at a time.
<P>
       <b>jam</b>  does not directly support building in parallel across
       multiple hosts, since that is  heavily  dependent  on  the
       local  environment.   To build in parallel across multiple
       hosts, you need to write  your  own  shell  that  provides
       access  to the multiple hosts.  You then reset $(JAMSHELL)
       to reference it.
<P>
       Just as <b>jam</b> expands a % to  be  the  text  of  the  rule's
       action  block, it expands a ! to be the multi-process slot
       number.  The slot number varies between 1 and  the  number
       of  concurrent  jobs permitted by the -j flag given on the
       command line.  Armed with this, it is possible to write  a
   multiple host shell.  For example:
<PRE>
	  #!/bin/sh

	  # This sample JAMSHELL uses the SunOS on(1) command to execute
	  # a command string with an identical environment on another host.
	  #
	  # Set JAMSHELL = jamshell ! %
	  #
	  # where jamshell is the name of this shell file.
	  #
	  # This version handles up to -j6; after that they get executed
	  # locally.

	  case $1 in
	  1|4) on winken sh -c "$2";;
	  2|5) on blinken sh -c "$2";;
	  3|6) on nod sh -c "$2";;
	  *)   eval "$2";;
	  esac
</PRE>
<HR>
<A HREF="#TOP">Back to top.</A>
<P>  
        Copyright 1997, 1999 Perforce Software, Inc.
        <BR>
        Comments to <A HREF="mailto:info@perforce.com">info@perforce.com</A>
        <BR>
        Last updated: Jan 27, 1999
</BODY>
</HTML>     
./src/Makefile100440    167    454        2145  7102105135  11726 0ustar  laurateam# Makefile for jam

CC = cc
TARGET = -o jam0
CFLAGS = 

# Special flavors - uncomment appropriate lines

# NCR seems to have a broken readdir() -- use gnu
#CC = gcc

# AIX needs -lbsd, and has no identifying cpp symbol
# Use _AIX41 if you're not on 3.2 anymore.
#LINKLIBS = -lbsd
#CFLAGS = -D_AIX
#CFLAGS = -D_AIX41

# NT (with Microsoft compiler)
# Use FATFS if building on a DOS FAT file system
#Lib = $(MSVCNT)/lib
#Include = $(MSVCNT)/include
#CC = cl /nologo
#CFLAGS = -I $(Include) -DNT 
#TARGET = /Fejam0
#LINKLIBS = $(Lib)/oldnames.lib $(Lib)/kernel32.lib $(Lib)/libc.lib

# BeOS - Metroworks CodeWarrior
#CC = mwcc
#Include = /NewDisk/develop/headers/posix
#CFLAGS = -I $(Include)

# BeOS - gcc
#CC = gcc
#LINKLIBS = -lnet

# Interix - gcc
#CC = gcc

SOURCES = \
	command.c compile.c execunix.c execvms.c expand.c \
	filent.c fileos2.c fileunix.c filevms.c glob.c hash.c \
	headers.c jam.c jambase.c jamgram.c lists.c make.c make1.c \
	newstr.c option.c parse.c pathunix.c pathvms.c regexp.c \
	rules.c scan.c search.c timestamp.c variable.c

all: jam0
	jam0

jam0:
	$(CC) $(TARGET) $(CFLAGS) $(SOURCES) $(LINKLIBS)
./src/Porting100440    167    454        4300  7102105135  11626 0ustar  laurateamNotes on porting Jam - revised 11/11/97

1) Working out system dependencies in the Jam code.

    Jam's OS footprint is fairly small.  For OS independent work Jam
    liberally uses standard libc functions like stdio, malloc, and
    string.  The OS dependent interfaces are:

	From filesys.h:

	    file_parse() - split a file name into dir/base/suffix/member
	    file_build() - build a filename given dir/base/suffix/member
	    file_dirscan() - scan a directory for files
	    file_archscan() - scan an archive for files
	    file_time() - get the timestamp of a file, if not already 
			  done by file_dirscan().

	From execcmd.h:

	    execcmd() - execute a shell script
	    execwait() - wait for any outstanding execcmd()'s.

    The current implementations are:

	    filemac.c - mac MPW 
	    filent.c - NT 
	    fileos2.c - OS/2 
	    fileunix.c - all UNIX
	    filevms.c - VMS

	    execmac.c - mac MPW
	    execunix.c - UNIX, OS/2, NT
	    execvms.c - VMS

2) Defining OTHERSYMS in jam.h

    So that the Jambase and Jamfile know their host, Jam defines $(OS)
    to be something useful for each platform.  Make sure that there is
    code in jam.h to generate a useful value for $(OS), and key it off 
    the platform specific C-preprocessor symbol.   If the C-preprocessor 
    doesn't itself defines such a symbol, add a define to the Makefile.

    In addition to $(OS), you can also set $(OSPLAT) if the OS runs on
    multiple platforms (like Linux or NT), or $(OSVER) if the OS has
    multiple, incompatible releases, like HPUX 9 and 10 and AIX 3 and 4.

3) Working out system dependencies in the Jambase

    With the value of $(OS) available, the Jambase can be extended to
    support special variables or rules for new platforms.   See the
    current support for VMS, NT, and Mac.

4) Yacc troubles

    The generated files jamgram.h and jamgram.c are distributed for the 
    poor souls without yacc.

5) Known problematic systems:

    - Pyramid has no malloc.h, memory.h

    - Encore has no stdlib.h

    - Bull DPX has sys/file.h problems

6) Send the results back.

    If you do porting work, the result can be integrated into future
    releases if you send it back to the author's address in the README.
./src/README100440    167    454        7537  7102105135  11160 0ustar  laurateamJam/MR (formerly "jam - make(1) redux") 

    /+\
    +\	Copyright 1993, 1997 Christopher Seiwald.
    \+/

    This is Release 2.2 of Jam/MR, a make-like program.

    License is hereby granted to use this software and distribute it
    freely, as long as this copyright notice is retained and modifications 
    are clearly marked.

    ALL WARRANTIES ARE HEREBY DISCLAIMED.

FEATURES

   ->	Jam/MR is a make(1) replacement that makes building simple things
	simple and building complicated things manageable.

   ->	Jam/MR's language is expressive, making Jamfiles (c.f. Makefiles) 
	compact.  Here's a sample:

	    Main smail : main.c map.c resolve.c deliver.c
			 misc.c parser.y alias.c pw.c headers.c
			 scanner.l getpath.c str.c ;

	This builds "smail" from a dozen source files.  Jam/MR handles 
	header file dependencies automatically and on-the-fly.

   ->	Jam/MR is very portable: it runs on UNIX, VMS, and NT.  Most
	Jamfiles themselves are portable, like the sample above.

   ->   Jam/MR is unintrusive: it is small, it has negligible CPU 
	overhead, and it doesn't create any of its own funny files
	(c.f. Odin, nmake, SunOS make).

   ->	Jam/MR can build large projects spread across many directories
	in one pass, without recursing, tracking the relationships
	among all files. Jam/MR can do this with multiple, concurrent 
	processes.

   ->   Jam/MR isn't under the blinkin GNU copyright, so you can 
	incorporate it into commercial products.


INFORMATION GUIDE

    Jam.html		jam command usage

    Jambase.html	Reference for the Jambase boilerplate file.

    Jamfile.html	Easy reading on creating a Jamfile and using jam.

    Jamlang.html	The JamMR language description.

    RELNOTES		Release 2.2 release notes.

    Porting		Notes on porting jam to wildcat platforms.

    README		This file.  Includes installation instructions.

    jam.c		Contains the jam command's main() as well as an 
			introduction to the code, for serious hackers.


INSTALLING

    The Makefile (UNIX, NT), build.com (VMS), Build.mpw (Mac MPW) are 
    for bootstrapping.  Once jam is built, it can rebuild itself.

    UNIX

	Build jam with make(1) on:

	    Platform		$(OS) 
	    -------------------------
	    AIX			AIX		*	
	    BSD/386 1.0		BSDI
	    COHERENT/386	COHERENT
	    DGUX 5.4		DGUX
	    FreeBSD		FREEBSD
	    HPUX 9.0		HPUX
	    IRIX 5.0		IRIX
	    Linux		LINUX
	    NEXTSTEP 3.2	NEXT
	    OSF/1		OSF
	    PTX V2.1.0		PTX
	    Solaris 2		SOLARIS		*
	    SunOS4.1		SUNOS
	    Ultrix 4.2		ULTRIX
	    BeOS		BEOS		*

	    * requires editing Makefile

    Windows

	Build jam with nmake on:

	    Platform		$(OS)
	    -------------------------
	    NT			NT		*
	    OS/2		OS2		*

	The NT MAXLINE (command line length) is still set in jam.h to
	996, which was apparently the NT 3.5 limit. On 4.0, the limit 
	is somewhere around 10K. For now, you can increase MAXLINE in 
	jam.h so that a jam running on 4.0 will use the full command
	line length, but that jam.exe will fail miserably on the older OS.

	On NT, a variable must be set before invoking jam to tell
	it where the C compiler lives.  The name of this variable
	depends on which compiler you are using:

	    BCCROOT:	The Borland C compiler
	    MSVCNT:	The Microsoft Compiler 5.0 (for NT)
	    MSVC:	The Microsoft Compiler 1.5 (for Windows)

	Only MSVCNT has really been tested and is known to work.

    Macintosh

	Build jam with Build.mpw on:

	    Platform		$(OS)
	    -------------------------
	    Macintosh		MAC		

	You'll need to edit Build.mpw to set CWGUSI and CWMAC.  Jam
	requires GUSI and Mac specific stuff to build (sorry).

    VMS

    	Build jam with @build.com on:

	    Platform		$(OS)
	    -------------------------
	    VMS 5.4		VMS
	    OPENVMS		OPENVMS

Comments to the author!

November, 1993 - release 1.0
March, 1995 - release 2.0 
February, 1996 - release 2.1
November, 1997 - release 2.2

Christopher Seiwald

seiwald@perforce.com
./src/RELNOTES100440    167    454       44554  7102105135  11476 0ustar  laurateam
Release notes for Jam/MR 2.2 
(formerly Jam - make(1) redux)

0.  Changes since 2.2

	AmigaOS (with gcc) supported, courtesy of Alain Penders
	(Patchlevel 2).

	The HDRPATTERN variable now allows for leading blanks before
	the #include, to keep up with ANSI (Patchlevel 3).

	On NT, always create tmp .bat file for actions if JAMSHELL is set.
	That way, if JAMSHELL is a .bat file itself, it can handle
	single-command actions with more than 9 cmd line args.

	Added: Lynx, Rhapsody. Upgraded to latest metrowerks on Beos.
	Miscellaneous improvements to platform variant handling.

	$JAMUNAME is set on UNIX.  (Patchlevel 4).

	Mac OS X Server support from Jeff_Sickel@sickel.com (Jeff Sickel)
	(Patchlevel 5).

1.  Release info:

	Jam/MR 2.2
	October 22, 1997
	VERSION 2.2
	PATCHLEVEL 1

1.1 Bug fixes since 2.2 patchlevel 0

	The NT handle leak in execunix.c has been fixed, thanks to
	Gurusamy Sarathy.  (Patchlevel 1).

2. Compatibility

	Jam/MR 2.2 is a roll-up of 'Jam - make(1) redux' release 2.1+.
	Most of the changes described below were available before this,
	in the jam.2.1.plus.tar ball.

	The Jam/MR 2.2 language is a superset of the 2.1 language;
	Jamfiles, Jambase, and other rulesets used in 2.1 can be used
	with the 2.2 language support.

	See 'Jambase Changes', below, to see if your Jamfiles need any
	changes to work with the 2.2 Jambase.


3. Changes Since 2.1

	New product name: Jam/MR. (Executable program is still named 'jam'.)

	Documentation rewritten; HTML versions supplied.


3.1 Changes to Jam/MR Language (See Jamlang.html)

	Rules may now have more fields than just $(<) and $(>).

	Local variables are now supported.

	The expression 'if $(A) in $(B)' is now supported.

	New variable modifiers :U and :L result in uppercased or lowercased
	values.

	New variable modifier :P reliably results in parent directory
	of either a file or directory. (Previously, :D was used, but on VMS
	:D of a directory name is just the directory name.)

	The :S variable modifier now results in the _last_ suffix if a 
	filename has more than one dot (.) in it.

	New predefined $(JAMDATE) variable is initialized at runtime for 
	simple date stamping.

	New predefined variables $(OSVER) and $(OSPLAT) are used to 
	distinguish among operating system versions and hardware platforms,
	when possible.

	New 'bind' qualifier on action definitions allows variables
	other than $(<) and $(>) to be bound with SEARCH and LOCATE paths.

	Action buffer size is no longer limited by MAXCMD. Instead, each 
	line in an action is limited by MAXLINE, defined for each OS, and 
	the entire action size is limited by CMDBUF.


3.2 Jambase Changes (See Jamfile.html)

	Jambase has been reworked to incorporate new language features.

	A handful of new utility rules has been added: makeString,
	makeDirName, etc.

	New HDRGRIST variable in Jambase allows for headers with the same
	name to be distinguished.

	LOCATE_TARGET now has a new flavor, LOCATE_SOURCE, that is used by
	rules that generate source files (e.g., Yacc and Lex).

	Header file includes now happen in the proper order. The limit of
	10 include files has been eliminated.

	The old "Install" rule is no longer available.  Use InstallBin, 
	InstallFile, InstallLib, InstallMan, or InstallShell instead.


3.3 'jam' Changes (See Jam.html)

	'jam' can now be built as a stand-alone program, with Jambase 
	compiled into the executable. An external or alternate Jambase can 
	still be referenced explicitly with -f.

	On command failure, 'jam' now emits the text of the command that 
	failed.  This is a compromise between the normal -d1 behavior (where 
	commands were never seen) and -d2 (where commands are always seen).

	'jam' now exits non-zero if it doesn't have a total success.  A parse
	error, sources that can't be found, and targets that can't be built
	all generate non-zero exit status.
	
	The debugging levels (-d flags) have been slightly redefined.

	The supplied Jamfile now builds 'jam' into a platform specific 
	subdirectory. This lets you use the same source directory to
	build 'jam' for more than one platform.

	The supplied Jamfile does not rebuild generated source files by 
	default. (They are supplied with the distribution.) See Jamfile
	for more information.


4.  Fixed Bugs

	The 'include' bug has finally been fixed, so that include
	statements take effect exactly when they are executed,
	rather than after the current statement block.  This also
	corrects the problem where an 'include' within an 'if'
	block would wind up including the file one token after the
	'if' block's closing brace.  Credit goes to Thomas Woods
	for suggesting that the parse tree generation and parse
	tree execution be paired in their own loop, rather than
	having the parser execute the tree directly.

	The setting and extracting of grist has been regularized:
	normally, if you set a component of a filename (using the
	:DBSMG= modifiers), you are supposed to include the delimiters
	that set off the component:  that is, you say "$(x:S=.suffix)",
	including the ".".  But with grist it was inconsistent
	between setting and getting: setting grist required no
	<>'s, while getting grist included them.   Getting grist
	continues to return the <>'s, but now setting grist can
	either include them (the new way) or not (the old way).

	'actions together' now suppresses duplicate sources from
	showing up in $(>).

	Accessing variables whose names contained ['s (as happens with
	MkDir on VMS) wasn't working, because it treated the [ as an
	array subscript. Now [ and ] are, like :, handled specially so 
	that they can appear in variable values.

	The 'if' statement now compares all elements in expressions;
	previously, it only compared the first element of each list.

	If a command line in an action is longer than MAXLINE (formerly
	MAXCMD), 'jam' now issues an error and exits rather than dumping 
	core.

	If a Jamfile ended without a trailing newline, jam dumped core.
	This has been fixed.


5.  Porting

	See jam.h for the definitive list of supported platforms.
	Since 2.1, support has been added for:

	    Macintosh MPW
	    Alpha VMS
	    Alpha NT
	    NT PowerPC
	    BeOS
	    MVS OE
	    UNIXWARE
	    QNX
	    SINIX (Nixdorf)
	    OS/2
	    Interactive UNIX (ISC), courtesy of Matthew Newhook


5.1 NT Support Fixes

	The NT command executor now handles multiple line actions, by writing
	multi-line actions to a batch file and executing that.
	
	Targets are universally lowercased on NT. (Matthew Newhook)

	Concurrent process support is fully enabled for NT.
	(Gurusamy Sarathy <gsar@engin.umich.edu>)
	
	Path handling: Jam/MR now knows that the directory component of "D:\"
	is "D:\", just as on unix it knows that the directory component of
	"/" is "/".  It also now successfully gets the timestamp for "D:\"
	or just plain "\".


5.2 VMS Support Fixes

	VMS support is much, much better now.  The path name manipulation
	routines (in pathvms.c) were more or less rewritten, and they now
	handle the vagaries of combining directory and file names properly.

	Targets are universally lowercased on VMS.

	Multi-line command blocks on VMS are now executed in a single system()
	call rather than separate ones for each line, so that actions can
	be DCL scripts.


Release notes for Jam 2.1.

1.  Release info:
	Jam 2.1
	February 1, 1996
	VERSION 2.1
	PATCHLEVEL 0

2.  Porting

	Linux is now supported.

	FREEBSD is now supported.

	SCO ("M_XENIX") now supported.

	NCR now supported.

	NEXT support from karthy@dannug.dk (Karsten Thygesen)

	DECC support from zinser@axp614.gsi.de (Martin P.J. Zinser)

	I have changes for OS/2, but no way to test them.  Volunteers?
	I have VMS multiprocess support, but no way to test it.  Volunteers?

2.1.  NT Support fixes.

	The NT support is considerably more real than it was in 2.0.
	Filent.c had its syntax error corrected, it no longer skips the
	first entry when scanning directories, and it handles string
	tables in archives (for long object file names).

	The Jambase was changed a bit to support the various C/C++
	compilers on NT, although it has only been thorougly tested
	with MSVC20.

	You still need to set MSVCNT or BCCROOT to the root of the 
	the compiler's directory tree, and you'll get an error if you
	don't set it (rather than getting a pile of mysterious errors).

2.2.  Other porting fixes.

	SPLITPATH now set up for UNIX (:), NT (;), VMS (,)

	Jambase support for Solaris works better now: the location of
	AR is hardwired to /usr/ccs/bin/ar and it knowns "install"
	doesn't take -c.  Solaris -- how the mighty have fallen.

	To handle Linux's wacko yacc, jamgram.h is now included after
	scan.h so that YYSTYPE is define.

3.  Jambase Changes (see Jamfile.html)

	SubDir now computes the root directory for the source tree, if
	the variable naming the root directory isn't set in the environment.
	It counts the number of directory elements leading from the root
	to the current directory (as passed to SubDir) and uses that many
	"../"'s to identify the root.  This means that to use SubDir you
	no longer have to have anything special set in the environment.

	InstallFile is now an alias for InstallLib.

	'first' is now dependency of all pseudo-targets (all, files, 
	exe, lib, shell), so that jamming any of these pseudo-targets
	also builds any dependencies of 'first'.

	The File rule definition in the Jambase was missing an &.

	The File rule now calls the Clean rule, so that installed files
	get cleaned.

4.  Jam changes (see Jam.html)

	Variables may now be set on the command line with -svar=value.

	Targets marked with NOUPDATE are now immune to the -a (anyhow) 
	flag.  Previously, the MkDir rule would try to recreate directories
	that already exist when jam was invoked with -a.

	A new variable, $(JAMVERSION), joins the small list of built-in 
	variables.  It it set to the release of jam, currently "2.1".

	If an actions fails, jam now deletes the target(s).  It won't
	delete libraries or other targets that are composites.  This is
	now consistent with jam's behavior on interrupts (it deletes the
	targets).

	Jam had a nasty bug when setting multiple variables to the same
	value:  if the first two variable names were the same, the variable
	value got trashed.  This also affected "on target" variables if
	the first two targets were the same.  For example:

		FOO on bar.c bar.c foo.c = a b c ;

	This would mangle the value of FOO for bar.c and foo.c.  This has
	been fixed.

	Jam would generate bogus numbers when reporting the number of
	targets updated after an interrupt.  It now is more careful about
	counting.

	The debugging flag -d has been extended.  In addition to supporting
	-dx (turn on debugging for all levels up to x) there is also now
	-d+x (turn on debugging at only level x).  The default output
	level is -d1 (-or d2 if -n is given); this can be turned off with
	-d0.   The debug levels are listed in jam.1 and jam.h.

	The parsing debug output now uses indenting to indicate when
	one rule invokes another.


Release notes for Jam 2.0.

1.  Release info:
	Jam 2.0 
	March 10, 1994
	VERSION 2.0
	PATCHLEVEL 5

2.  Porting

	Windows/NT is now (crudely) supported, courtesy of Brett Taylor
	and Laura Wingerd.  

	COHERENT/386 is now supported, courtesy of Fred Smith.

	Solaris archive string table for long archive names is now
	supported, thanks to Mike Matrigali.

3.  Compatibility

	Jam 2.0 syntax is a superset of Jam 1.0 syntax, and thus it can
	interpret a Jam 1.0 Jambase.

	The Jam 2.0 Jambase is a superset of the Jam 1.0 Jambase, and
	thus it can include a Jamfile written for Jam 1.0.

4.  Changes from Jam 1.0 to Jam 2.0

4.1.  Documentation changes

	New Jamfile.5 manual page, with lots of examples and easy
	reading.  It replaces both the old "Examples" file as well as
	the old Jambase.5 manual page.

	jam.1 edited by Stephen W. Liddle and Diane Holt.

4.2.  Jambase Changes (see Jamfile.5)

4.2.1.  New rules:

	There are new rules to make handling subdirectories easier:
	SubDir, SubInclude, SubDirCcFlags, SubDirHdrs.

	There are new rules to handle file-specific CCFLAGS and HDRS:
	ObjectCcFlags and ObjectHdrs.

	Misc new rules: HardLink, InstallShell, MkDir.

	New rule "clean" that deletes exactly what jam has built, and
	"uninstall" that deletes exactly what was installed.

	New rules for handling suffixes .s, .f, .cc, .cpp, .C.

4.2.2.  Old rules:

	The InstallBin, Lib, Man, and the new Shell rules now take the
	destination directory as the target and the files to be copied
	as sources.  These rules formerly took the files to be copied
	as targets, and used built-in destination directories of
	$(BINDIR), $(LIBDIR), $(MANDIR), and $(BINDIR).

	The InstallBin, Lib, Man, and Shell rules use the install(1)
	program now, instead of doing their own copying.

	The Cc rule now uses -o when possible, rather than moving the
	result.  Some platforms (Pyramid?) have a broken -o.

	Jambase rules taking libraries, objects, and executables now
	all ignore the suffixes provided and use the one defined in the
	Jambase for the platform.

	Stupid yyacc support moved out of Jambase, as jam is its only
	likely user.

	Jambase now purturbs library sources with a "grist" of
	SOURCE_GRIST.

4.2.3.  Misc:

	The names of the default rules defined in Jambase have been
	lowercased and un-abbreviated, to be more imake(1) like.

	The Jambase has been reorganized and sorted, with VMS and NT
	support moved in from their own files.

	The Jambase has been relocated on UNIX from /usr/local/lib/jam
	to /usr/local/lib.

4.3.  Jam changes (see jam.1)

4.3.1.   Flags:

	New -a (anyhow) flag: means build everything.

	New -j<x> flag: run jobs in parallel.

	Old -t now rebuilds the touched target, rather that just the
	target's parents.

	-n now implies -d2, so that you see what's happening.  The
	debug level can be subsequently overridden.

	New -v to dump version.

4.3.2.  Rules:

	New ALWAYS rule behaves like -t: always builds target.

	New EXIT rule makes it possible to raise a fatal error.

	New LEAVES rule which say target depends only on the update
	times of the leaf sources.

	New NOUPDATE rule says built targets only if they don't exist.

	NOTIME has been renamed NOTFILE, to more accurately reflect its
	meaning (it says a target is not to be bound to a file).

4.3.3.  Variables:

	New special variable JAMSHELL: argv template for command execution 
	shell.

	Variables, both normal and target-specific, can have their
	value appended with the syntax "var += value" or "var on target
	+= value".

	"?=" is now synonymous with "default =".

	Imported enviroment variable values are now split at blanks
	(:'s if the variable name ends in PATH), so that they become
	proper list values.

4.3.4.  Misc:

	Files to be sourced with "include" are now bound first, so
	$(SEARCH) and $(LOCATE) affect them.  They still can't be
	built, though.

	New modifier on "actions": "existing" causes $(>) to expand
	only those files that currently exist.

4.3.5.  Bug fixes:

	When scanning tokens known to be argument lists (such as the
	arguments to rule invocations and variable assignment), the
	parser now tells the scanner to ignore alphabetic keywords, as
	all such lists terminate with punctuation keywords (like : or
	;).  This way, alphabetic keywords don't need to be quoted when
	they appear as arguments.

	The scanner has been fixed to handle oversized tokens,
	unterminated quotes, unterminated action blocks, and tokens
	abutting EOF (i.e. a token with no white space before EOF).

	The progress report "...on xth target..." used to count all
	targets, rather than just those with updating actions.  Since
	the original pronouncement of targets to be udpated included
	only those with updating actions, the progress report has been
	changed to match.

	'If' conditionals now must be single arguments.  Previously,
	they could be zero or more arguments, which didn't make much
	sense, and made things like 'foo == bar' true.  The comparison
	operator is '=', and '==' just looked like the second of three
	arguments in the unary "non-empty argument list" conditional.

	Header files indirectly including themselves were mistakenly
	reported as being dependent on themselves.  Recursing through
	header file dependencies is now done after determining the fate
	of the target.

	The variable expansion support was expanding $(X)$(UNDEF) as if
	it were $(X).  It now expands to an empty list, like it
	should.

	The UNIX version of file_build() didn't handle "dir/.suffix"
	right.  Now it does.

	The VMS command buffer was assumed to be as large as 1024 bytes,
	which isn't the case everywhere as it is related to some weird
	quota.  It has been lowered to 256.

	$(>) and $(<) wouldn't expand in action blocks if the targets
	were marked with NOTIME.  Now they expand properly.

	Malloc() return values are now checked.

	The variable expansion routine var_expand() is now a little
	faster, by taking a few often needed shortcuts.

	The VMS version of file_build() used the wrong length when
	re-rooting file names that already had directory compoents.
	This was fixed.

	Various tracing adjustments were made.

5.  Limitations/Known Bugs

	The new Windows/NT support has only been marginally tested.  It
	is dependent on certain variables being set depending on which
	compiler you are using.  You'll need to look in the file
	Jambase and see what variables are expected to be set.

	The VMS support has been tested, courtesy of the DEC guest
	machine, but has not been hammered fully in release 2.0.  It
	was used quite a bit in Jam 1.0.

	Jam clean when there is nothing to clean claims it is updating
	a target.

	Because the include statement works by pushing a new file in
	the input stream of the scanner rather than recursively
	invoking the parser on the new file, multiple include
	statements in a rule's procedure causes the files to be
	included in reverse order.

	If the include statement appears inside an if block, the
	parser's attempt to find the else will cause the text of the
	included file to appear after the first token following the
	statement block.  This is rarely what is intended.

	In a rule's actions, only $(<) and $(>) refer to the bound file
	names:  all other variable references get the unbound names.
	This is a pain for $(NEEDLIBS), because it means that library
	path can't be bound using $(SEARCH) and $(LOCATE).

	With the -j flag, errors from failed commands can get
	staggeringly mixed up.  Also, because targets tend to get built
	in a quickest-first ordering, dependency information must be
	quite exact.  Finally, beware of parallelizing commands that
	drop fixed-named files into the current directory, like yacc(1)
	does.

	A poorly set $(JAMSHELL) is likely to result in silent
	failure.
./src/command.c100440    167    454        3322  7102105135  12046 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

/*
 * command.c - maintain lists of commands
 *
 * Each target has a list of actions that are to be applied to it, but due
 * to modifications on the actions they do not map one-to-one to the commands
 * that are the be executed against the target.  The CMD datatype holds
 * a single command that is to be executed against a target, and they can
 * chain together to represent the full collection of commands used to
 * update a target.
 *
 * External routines:
 *	cmd_new() - make a new CMD and chain it
 *	cmd_free() - free a CMD
 *
 * Macros:
 *	cmd_next() - follow chain of CMDs	
 */

# include "jam.h"

# include "lists.h"
# include "parse.h"
# include "variable.h"
# include "rules.h"

# include "command.h"

/*
 * cmd_new() - make a new CMD and chain it
 */

CMD *
cmd_new( chain, rule, targets, sources, shell, chunk )
CMD	*chain;
RULE	*rule;
LIST	*targets;
LIST	*sources;
LIST	*shell;
int	chunk;
{
	int     len;

	CMD *cmd = (CMD *)malloc( sizeof( CMD ) );

	cmd->rule = rule;
	cmd->shell = shell;

	lol_init( &cmd->args );
	lol_add( &cmd->args, targets );
	lol_add( &cmd->args, sources );

	len = var_string( rule->actions, cmd->buf, CMDBUF, &cmd->args );
	
	if( len < 0 )
	{
	    if ( chunk == 1 ) {
		printf( "fatal error: %s command block too long (max %d)\n", 
			rule->name, CMDBUF );
		exit( EXITBAD );
	    }
	    free( cmd );
	    return NULL;
	}

	if( !chain ) chain = cmd;
	else chain->tail->next = cmd;
	chain->tail = cmd;
	cmd->next = 0;

	return chain;
}

/*
 * cmd_free() - free a CMD
 */

void
cmd_free( cmd )
CMD	*cmd;
{
	lol_free( &cmd->args );
	list_free( cmd->shell );
	free( (char *)cmd );
}
./src/command.h100440    167    454        1776  7102105136  12067 0ustar  laurateam/*
 * Copyright 1994 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

/*
 * command.h - the CMD structure and routines to manipulate them
 *
 * Both ACTION and CMD contain a rule, targets, and sources.  An
 * ACTION describes a rule to be applied to the given targets and
 * sources; a CMD is what actually gets executed by the shell.  The
 * differences are due to:
 *
 *	ACTIONS must be combined if 'actions together' is given.
 *	ACTIONS must be split if 'actions piecemeal' is given.
 *	ACTIONS must have current sources omitted for 'actions updated'.
 */

/*
 * CMD - an action, ready to be formatted into a buffer and executed
 */

typedef struct _cmd CMD;

struct _cmd
{
	CMD	*next;
	CMD	*tail;		/* valid on in head */
	RULE	*rule;		/* rule->actions contains shell script */
	LIST	*shell;		/* $(SHELL) value */
	LOL	args;		/* LISTs for $(<), $(>) */
	char	buf[ CMDBUF ];	/* actual commands */
} ;

CMD 	*cmd_new();
void	cmd_free();

# define cmd_next( c ) ((c)->next)
./src/compile.c100440    167    454       41652  7102105136  12111 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

# include "jam.h"

# include "lists.h"
# include "parse.h"
# include "compile.h"
# include "variable.h"
# include "rules.h"
# include "newstr.h"
# include "make.h"
# include "search.h"

/*
 * compile.c - compile parsed jam statements
 *
 * External routines:
 *
 *	compile_foreach() - compile the "for x in y" statement
 *	compile_if() - compile 'if' rule
 *	compile_include() - support for 'include' - call include() on file
 *	compile_local() - declare (and set) local variables
 *	compile_null() - do nothing -- a stub for parsing
 *	compile_rule() - compile a single user defined rule
 *	compile_rules() - compile a chain of rules
 *	compile_set() - compile the "set variable" statement
 *	compile_setcomp() - support for `rule` - save parse tree 
 *	compile_setexec() - support for `actions` - save execution string 
 *	compile_settings() - compile the "on =" (set variable on exec) statement
 *	compile_switch() - compile 'switch' rule
 *
 * Internal routines:
 *
 *	debug_compile() - printf with indent to show rule expansion.
 *
 *	evaluate_if() - evaluate if to determine which leg to compile
 *
 *	builtin_depends() - DEPENDS/INCLUDES rule
 *	builtin_echo() - ECHO rule
 *	builtin_exit() - EXIT rule
 *	builtin_flags() - NOCARE, NOTFILE, TEMPORARY rule
 *
 * 02/03/94 (seiwald) -	Changed trace output to read "setting" instead of 
 *			the awkward sounding "settings".
 * 04/12/94 (seiwald) - Combined build_depends() with build_includes().
 * 04/12/94 (seiwald) - actionlist() now just appends a single action.
 * 04/13/94 (seiwald) - added shorthand L0 for null list pointer
 * 05/13/94 (seiwald) - include files are now bound as targets, and thus
 *			can make use of $(SEARCH)
 * 08/23/94 (seiwald) - Support for '+=' (append to variable)
 * 12/20/94 (seiwald) - NOTIME renamed NOTFILE.
 * 01/22/95 (seiwald) - Exit rule.
 * 02/02/95 (seiwald) - Always rule; LEAVES rule.
 * 02/14/95 (seiwald) - NoUpdate rule.
 */

static void debug_compile();

static int evaluate_if();

static void builtin_depends();
static void builtin_echo();
static void builtin_exit();
static void builtin_flags();

int glob();



/*
 * compile_builtin() - define builtin rules
 */

# define P0 (PARSE *)0
# define C0 (char *)0

void
compile_builtins()
{
    bindrule( "Always" )->procedure = 
    bindrule( "ALWAYS" )->procedure = 
	parse_make( builtin_flags, P0, P0, C0, C0, L0, L0, T_FLAG_TOUCHED );

    bindrule( "Depends" )->procedure = 
    bindrule( "DEPENDS" )->procedure = 
	parse_make( builtin_depends, P0, P0, C0, C0, L0, L0, T_DEPS_DEPENDS );

    bindrule( "Echo" )->procedure = 
    bindrule( "ECHO" )->procedure = 
	parse_make( builtin_echo, P0, P0, C0, C0, L0, L0, 0 );

    bindrule( "Exit" )->procedure = 
    bindrule( "EXIT" )->procedure = 
	parse_make( builtin_exit, P0, P0, C0, C0, L0, L0, 0 );

    bindrule( "Includes" )->procedure = 
    bindrule( "INCLUDES" )->procedure = 
	parse_make( builtin_depends, P0, P0, C0, C0, L0, L0, T_DEPS_INCLUDES );

    bindrule( "Leaves" )->procedure = 
    bindrule( "LEAVES" )->procedure = 
	parse_make( builtin_flags, P0, P0, C0, C0, L0, L0, T_FLAG_LEAVES );

    bindrule( "NoCare" )->procedure = 
    bindrule( "NOCARE" )->procedure = 
	parse_make( builtin_flags, P0, P0, C0, C0, L0, L0, T_FLAG_NOCARE );

    bindrule( "NOTIME" )->procedure = 
    bindrule( "NotFile" )->procedure = 
    bindrule( "NOTFILE" )->procedure = 
	parse_make( builtin_flags, P0, P0, C0, C0, L0, L0, T_FLAG_NOTFILE );

    bindrule( "NoUpdate" )->procedure = 
    bindrule( "NOUPDATE" )->procedure = 
	parse_make( builtin_flags, P0, P0, C0, C0, L0, L0, T_FLAG_NOUPDATE );

    bindrule( "Temporary" )->procedure = 
    bindrule( "TEMPORARY" )->procedure = 
	parse_make( builtin_flags, P0, P0, C0, C0, L0, L0, T_FLAG_TEMP );
}

/*
 * compile_foreach() - compile the "for x in y" statement
 *
 * Compile_foreach() resets the given variable name to each specified
 * value, executing the commands enclosed in braces for each iteration.
 *
 *	parse->string	index variable
 *	parse->left	rule to compile
 *	parse->llist	variable values
 */

void
compile_foreach( parse, args )
PARSE		*parse;
LOL		*args;
{
	LIST	*nv = var_list( parse->llist, args );
	LIST	*l;

	/* Call var_set to reset $(parse->string) for each val. */

	for( l = nv; l; l = list_next( l ) )
	{
	    LIST *val = list_new( L0, copystr( l->string ) );

	    var_set( parse->string, val, VAR_SET );

	    (*parse->left->func)( parse->left, args );
	}

	list_free( nv );
}

/*
 * compile_if() - compile 'if' rule
 *
 *	parse->left		condition tree
 *	parse->right->left	then tree
 *	parse->right->right	else tree
 */

void
compile_if( parse, args )
PARSE		*parse;
LOL		*args;
{
	if( evaluate_if( parse->left, args ) )
	{
	    (*parse->right->left->func)( parse->right->left, args );
	}
	else
	{
	    (*parse->right->right->func)( parse->right->right, args );
	}
}

/*
 * evaluate_if() - evaluate if to determine which leg to compile
 *
 * Returns:
 *	!0	if expression true - compile 'then' clause
 *	0	if expression false - compile 'else' clause
 */

static int
evaluate_if( parse, args )
PARSE		*parse;
LOL		*args;
{
	int	status;

	if( parse->num <= COND_OR )
	{
	    /* Handle one of the logical operators */

	    switch( parse->num )
	    {
	    case COND_NOT:
		status = !evaluate_if( parse->left, args );
		break;

	    case COND_AND:
		status = evaluate_if( parse->left, args ) &&
			 evaluate_if( parse->right, args );
		break;

	    case COND_OR:
		status = evaluate_if( parse->left, args ) ||
			 evaluate_if( parse->right, args );
		break;

	    default:
		status = 0;	/* can't happen */
	    }
	}
	else
	{
	    /* Handle one of the comparison operators */
	    /* Expand targets and sources */

	    LIST *nt, *ns;
	    nt = var_list( parse->llist, args );
	    ns = var_list( parse->rlist, args );

	    /* "a in b" make sure each of a is equal to something in b. */
	    /* Otherwise, step through pairwise comparison. */

	    if( parse->num == COND_IN )
	    {
		LIST *s, *t;

		/* Try each t until failure. */

		for( status = 1, t = nt; status && t; t = list_next( t ) )
		{
		    int stat1;

		    /* Try each s until success */

		    for( stat1 = 0, s = ns; !stat1 && s; s = list_next( s ) )
			stat1 = !strcmp( t->string, s->string );

		    status = stat1;
		}
	    }
	    else
	    {
		LIST *s = ns, *t = nt;

		status = 0;

		while( !status && ( t || s ) )
		{
		    char *st = t ? t->string : "";
		    char *ss = s ? s->string : "";

		    status = strcmp( st, ss );

		    t = t ? list_next( t ) : t;
		    s = s ? list_next( s ) : s;
		}
	    }

	    switch( parse->num )
	    {
	    case COND_EXISTS:	status = status > 0 ; break;
	    case COND_EQUALS:	status = !status; break;
	    case COND_NOTEQ:	status = status != 0; break;
	    case COND_LESS:	status = status < 0; break;
	    case COND_LESSEQ:	status = status <= 0; break;
	    case COND_MORE:	status = status > 0; break;
	    case COND_MOREEQ:	status = status >= 0; break;
	    case COND_IN:	/* status = status */ break;
	    }

	    if( DEBUG_IF )
	    {
		debug_compile( 0, "if" );
		list_print( nt );
		printf( "(%d)", status );
		list_print( ns );
		printf( "\n" );
	    }

	    list_free( nt );
	    list_free( ns );

	}

	return status;
}

/*
 * compile_include() - support for 'include' - call include() on file
 *
 * 	parse->llist	list of files to include (can only do 1)
 */

void
compile_include( parse, args )
PARSE		*parse;
LOL		*args;
{
	LIST	*nt = var_list( parse->llist, args );

	if( DEBUG_COMPILE )
	{
	    debug_compile( 0, "include" );
	    list_print( nt );
	    printf( "\n" );
	}

	if( nt )
	{
	    TARGET *t = bindtarget( nt->string );

	    /* Bind the include file under the influence of */
	    /* "on-target" variables.  Though they are targets, */
	    /* include files are not built with make(). */

	    pushsettings( t->settings );
	    t->boundname = search( t->name, &t->time );
	    popsettings( t->settings );

	    parse_file( t->boundname );
	}

	list_free( nt );
}

/*
 * compile_local() - declare (and set) local variables
 *
 *	parse->llist	list of variables
 *	parse->rlist	list of values
 *	parse->left	rules to execute
 */

void
compile_local( parse, args )
PARSE		*parse;
LOL		*args;
{
	LIST *l;
	SETTINGS *s = 0;
	LIST	*nt = var_list( parse->llist, args );
	LIST	*ns = var_list( parse->rlist, args );

	if( DEBUG_COMPILE )
	{
	    debug_compile( 0, "local" );
	    list_print( nt );
	    printf( " = " );
	    list_print( ns );
	    printf( "\n" );
	}

	/* Initial value is ns */

	for( l = nt; l; l = list_next( l ) )
	    s = addsettings( s, 0, l->string, list_copy( (LIST*)0, ns ) );

	list_free( ns );
	list_free( nt );

	/* Note that callees of the current context get this "local" */
	/* variable, making it not so much local as layered. */

	pushsettings( s );
	(*parse->left->func)( parse->left, args );
	popsettings( s );

	freesettings( s );
}

/*
 * compile_null() - do nothing -- a stub for parsing
 */

void
compile_null( parse, args )
PARSE		*parse;
LOL		*args;
{
}

/*
 * compile_rule() - compile a single user defined rule
 *
 *	parse->string	name of user defined rule
 *	parse->left	parameters (list of lists) to rule, recursing left
 */

void
compile_rule( parse, args )
PARSE		*parse;
LOL		*args;
{
	RULE	*rule = bindrule( parse->string );
	LOL	nargs[1];
	PARSE	*p;

	/* Build up the list of arg lists */

	lol_init( nargs );

	for( p = parse->left; p; p = p->left )
	    lol_add( nargs, var_list( p->llist, args ) );

	if( DEBUG_COMPILE )
	{
	    debug_compile( 1, parse->string );
	    lol_print( nargs );
	    printf( "\n" );
	}

	/* Check traditional targets $(<) and sources $(>) */

	if( !lol_get( nargs, 0 ) )
	    printf( "warning: no targets on rule %s %s\n",
		    rule->name, parse->llist ? parse->llist->string : "" );

	if( !rule->actions && !rule->procedure )
	    printf( "warning: unknown rule %s\n", rule->name );

	/* If this rule will be executed for updating the targets */
	/* then construct the action for make(). */

	if( rule->actions )
	{
	    TARGETS	*t;
	    ACTION	*action;

	    /* The action is associated with this instance of this rule */

	    action = (ACTION *)malloc( sizeof( ACTION ) );
	    memset( (char *)action, '\0', sizeof( *action ) );

	    action->rule = rule;
	    action->targets = targetlist( (TARGETS *)0, lol_get( nargs, 0 ) );
	    action->sources = targetlist( (TARGETS *)0, lol_get( nargs, 1 ) );

	    /* Append this action to the actions of each target */

	    for( t = action->targets; t; t = t->next )
		t->target->actions = actionlist( t->target->actions, action );
	}

	/* Now recursively compile any parse tree associated with this rule */

	if( rule->procedure )
	    (*rule->procedure->func)( rule->procedure, nargs );

	lol_free( nargs );

	if( DEBUG_COMPILE )
	    debug_compile( -1, 0 );
}

/*
 * compile_rules() - compile a chain of rules
 *
 *	parse->left	more compile_rules() by left-recursion
 *	parse->right	single rule
 */

void
compile_rules( parse, args )
PARSE		*parse;
LOL		*args;
{
	(*parse->left->func)( parse->left, args );
	(*parse->right->func)( parse->right, args );
}

/*
 * compile_set() - compile the "set variable" statement
 *
 *	parse->llist	variable names
 *	parse->rlist	variable values
 *	parse->num	ASSIGN_SET/APPEND/DEFAULT
 */

void
compile_set( parse, args )
PARSE		*parse;
LOL		*args;
{
	LIST	*nt = var_list( parse->llist, args );
	LIST	*ns = var_list( parse->rlist, args );
	LIST	*l;
	int	setflag;
	char	*trace;

	switch( parse->num )
	{
	case ASSIGN_SET:	setflag = VAR_SET; trace = "="; break;
	case ASSIGN_APPEND:	setflag = VAR_APPEND; trace = "+="; break;
	case ASSIGN_DEFAULT:	setflag = VAR_DEFAULT; trace = "?="; break;
	default:		setflag = VAR_SET; trace = ""; break;
	}

	if( DEBUG_COMPILE )
	{
	    debug_compile( 0, "set" );
	    list_print( nt );
	    printf( " %s ", trace );
	    list_print( ns );
	    printf( "\n" );
	}

	/* Call var_set to set variable */
	/* var_set keeps ns, so need to copy it */
	/* avoid copy if just setting one variable. */

	for( l = nt; l; l = list_next( l ) )
	    var_set( l->string, 
		list_next( l ) ? list_copy( (LIST*)0, ns ) : ns,
		setflag );

	if( !nt )
	    list_free( ns );

	list_free( nt );
}

/*
 * compile_setcomp() - support for `rule` - save parse tree 
 *
 *	parse->string	rule name
 *	parse->left	rules for rule
 */

void
compile_setcomp( parse, args )
PARSE		*parse;
LOL		*args;
{
	RULE	*rule = bindrule( parse->string );

	/* Free old one, if present */

	if( rule->procedure )
	    parse_free( rule->procedure );

	rule->procedure = parse->left;

	/* we now own this parse tree */
	/* don't let parse_free() release it */

	parse->left = 0;	
}

/*
 * compile_setexec() - support for `actions` - save execution string 
 *
 *	parse->string	rule name
 *	parse->string1	OS command string
 *	parse->num	flags
 *	parse->llist	`bind` variables
 *
 * Note that the parse flags (as defined in compile.h) are transfered
 * directly to the rule flags (as defined in rules.h).
 */

void
compile_setexec( parse, args )
PARSE		*parse;
LOL		*args;
{
	RULE	*rule = bindrule( parse->string );
	
	/* Free old one, if present */

	if( rule->actions )
	{
	    freestr( rule->actions );
	    list_free( rule->bindlist );
	}

	rule->actions = copystr( parse->string1 );
	rule->bindlist = list_copy( L0, parse->llist );
	rule->flags |= parse->num; /* XXX translate this properly */
}

/*
 * compile_settings() - compile the "on =" (set variable on exec) statement
 *
 *	parse->llist		target names
 *	parse->left->llist	variable names
 *	parse->left->rlist	variable values
 *	parse->num		ASSIGN_SET/APPEND	
 */

void
compile_settings( parse, args )
PARSE		*parse;
LOL		*args;
{
	LIST	*nt = var_list( parse->left->llist, args );
	LIST	*ns = var_list( parse->left->rlist, args );
	LIST	*targets, *ts;
	int	append = parse->num == ASSIGN_APPEND;

	/* Reset targets */

	targets = var_list( parse->llist, args );

	if( DEBUG_COMPILE )
	{
	    debug_compile( 0, "set" );
	    list_print( nt );
	    printf( "on " );
	    list_print( targets );
	    printf( " %s ", append ? "+=" : "=" );
	    list_print( ns );
	    printf( "\n" );
	}

	/* Call addsettings to save variable setting */
	/* addsettings keeps ns, so need to copy it */
	/* Pass append flag to addsettings() */

	for( ts = targets; ts; ts = list_next( ts ) )
	{
	    TARGET 	*t = bindtarget( ts->string );
	    LIST	*l;

	    for( l = nt; l; l = list_next( l ) )
		t->settings = addsettings( t->settings, append, 
				l->string, list_copy( (LIST*)0, ns ) );
	}

	list_free( ns );
	list_free( nt );
	list_free( targets );
}

/*
 * compile_switch() - compile 'switch' rule
 *
 *	parse->llist	switch value (only 1st used)
 *	parse->left	cases
 *
 *	cases->left	1st case
 *	cases->right	next cases
 *
 *	case->string	argument to match
 *	case->left	parse tree to execute
 */

void
compile_switch( parse, args )
PARSE		*parse;
LOL		*args;
{
	LIST	*nt;

	nt = var_list( parse->llist, args );

	if( DEBUG_COMPILE )
	{
	    debug_compile( 0, "switch" );
	    list_print( nt );
	    printf( "\n" );
	}

	/* Step through cases */

	for( parse = parse->left; parse; parse = parse->right )
	{
	    if( !glob( parse->left->string, nt ? nt->string : "" ) )
	    {
		/* Get & exec parse tree for this case */
		parse = parse->left->left;
		(*parse->func)( parse, args );
		break;
	    }
	}

	list_free( nt );
}



/*
 * builtin_depends() - DEPENDS/INCLUDES rule
 *
 * The DEPENDS builtin rule appends each of the listed sources on the 
 * dependency list of each of the listed targets.  It binds both the 
 * targets and sources as TARGETs.
 */

static void
builtin_depends( parse, args )
PARSE		*parse;
LOL		*args;
{
	LIST *targets = lol_get( args, 0 );
	LIST *sources = lol_get( args, 1 );
	int which = parse->num;
	LIST *l;

	for( l = targets; l; l = list_next( l ) )
	{
	    TARGET *t = bindtarget( l->string );
	    t->deps[ which ] = targetlist( t->deps[ which ], sources );
	}
}

/*
 * builtin_echo() - ECHO rule
 *
 * The ECHO builtin rule echoes the targets to the user.  No other 
 * actions are taken.
 */

static void
builtin_echo( parse, args )
PARSE		*parse;
LOL		*args;
{
	list_print( lol_get( args, 0 ) );
	printf( "\n" );
}

/*
 * builtin_exit() - EXIT rule
 *
 * The EXIT builtin rule echoes the targets to the user and exits
 * the program with a failure status.
 */

static void
builtin_exit( parse, args )
PARSE		*parse;
LOL		*args;
{
	list_print( lol_get( args, 0 ) );
	printf( "\n" );
	exit( EXITBAD ); /* yeech */
}

/*
 * builtin_flags() - NOCARE, NOTFILE, TEMPORARY rule
 *
 * Builtin_flags() marks the target with the appropriate flag, for use
 * by make0().  It binds each target as a TARGET.
 */

static void
builtin_flags( parse, args )
PARSE		*parse;
LOL		*args;
{
	LIST *l = lol_get( args, 0 );

	for( ; l; l = list_next( l ) )
	    bindtarget( l->string )->flags |= parse->num;
}

/*
 * debug_compile() - printf with indent to show rule expansion.
 */

static void
debug_compile( which, s )
int which;
char *s;
{
	static int level = 0;
	static char indent[36] = ">>>>|>>>>|>>>>|>>>>|>>>>|>>>>|>>>>|";
	int i = ((1+level) * 2) % 35;

	if( which >= 0 )
	    printf( "%*.*s ", i, i, indent );

	if( s )
	    printf( "%s ", s );

	level += which;
}
./src/compile.h100440    167    454        3065  7102105136  12072 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

/*
 * compile.h - compile parsed jam statements
 *
 * 06/01/94 (seiwald) - new 'actions existing' does existing sources
 * 08/23/94 (seiwald) - Support for '+=' (append to variable)
 */

void compile_builtins();
void compile_foreach();
void compile_if();
void compile_include();
void compile_local();
void compile_null();
void compile_rule();
void compile_rules();
void compile_set();
void compile_setcomp();
void compile_setexec();
void compile_settings();
void compile_switch();

/* Flags for compile_set(), etc */

# define ASSIGN_SET	0x00	/* = assign variable */
# define ASSIGN_APPEND	0x01	/* += append variable */
# define ASSIGN_DEFAULT	0x02	/* set only if unset */

/* Flags for compile_setexec() */

# define EXEC_UPDATED	0x01	/* executes updated */
# define EXEC_TOGETHER	0x02	/* executes together */
# define EXEC_IGNORE	0x04	/* executes ignore */
# define EXEC_QUIETLY	0x08	/* executes quietly */
# define EXEC_PIECEMEAL	0x10	/* executes piecemeal */
# define EXEC_EXISTING	0x20	/* executes existing */

/* Conditions for compile_if() */

# define COND_NOT	0	/* ! cond */
# define COND_AND	1	/* cond && cond */
# define COND_OR	2	/* cond || cond */

# define COND_EXISTS	3	/* arg */
# define COND_EQUALS	4	/* arg = arg */
# define COND_NOTEQ	5	/* arg != arg */
# define COND_LESS	6	/* arg < arg  */
# define COND_LESSEQ	7	/* arg <= arg */
# define COND_MORE	8	/* arg > arg  */
# define COND_MOREEQ	9	/* arg >= arg */
# define COND_IN	10	/* arg in arg */
./src/execcmd.h100440    167    454         513  7102105137  12026 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

/*
 * execcmd.h - execute a shell script
 *
 * 05/04/94 (seiwald) - async multiprocess interface
 */

void execcmd();
int execwait();

# define EXEC_CMD_OK	0
# define EXEC_CMD_FAIL	1
# define EXEC_CMD_INTR	2
./src/execmac.c100440    167    454        2657  7102105137  12051 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

# include "jam.h"
# include "execcmd.h"
# include "lists.h"
# include <errno.h>

# ifdef macintosh

/*
 * execunix.c - execute a shell script on UNIX
 *
 * If $(JAMSHELL) is defined, uses that to formulate execvp().
 * The default is:
 *
 *	/bin/sh -c %
 *
 * Each word must be an individual element in a jam variable value.
 *
 * In $(JAMSHELL), % expands to the command string and ! expands to 
 * the slot number (starting at 1) for multiprocess (-j) invocations.
 * If $(JAMSHELL) doesn't include a %, it is tacked on as the last
 * argument.
 *
 * Don't just set JAMSHELL to /bin/sh - it won't work!
 *
 * External routines:
 *	execcmd() - launch an async command execution
 * 	execwait() - wait and drive at most one execution completion
 *
 * Internal routines:
 *	onintr() - bump intr to note command interruption
 *
 * 04/08/94 (seiwald) - Coherent/386 support added.
 * 05/04/94 (seiwald) - async multiprocess interface
 * 01/22/95 (seiwald) - $(JAMSHELL) support
 */

/*
 * execcmd() - launch an async command execution
 */

void
execcmd( string, func, closure, shell )
char *string;
void (*func)();
void *closure;
LIST *shell;
{
	
	printf( "%s", string );
	(*func)( closure, EXEC_CMD_OK );
}

/*
 * execwait() - wait and drive at most one execution completion
 */

int
execwait()
{
	return 0;
}

# endif /* macintosh */
./src/execunix.c100440    167    454       20325  7102105137  12304 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

# include "jam.h"
# include "execcmd.h"
# include "lists.h"
# include <errno.h>

# if defined( unix ) || defined( NT ) || defined( __OS2__ ) || defined(AMIGA)

# if defined( _AIX) || \
	(defined (COHERENT) && defined (_I386)) || \
	defined(__sgi) || \
	defined(__Lynx__) || \
	defined(M_XENIX) || \
	defined(__QNX__) || \
	defined(__BEOS__) || \
	defined(__ISC) || \
	defined(__OPENNT )
# define vfork() fork()
# endif

# if defined( NT ) || defined( __OS2__ )

# include <process.h>

# if !defined( __BORLANDC__ ) && !defined( __OS2__ )
# define wait my_wait
static int my_wait(int *status);
# endif

# endif

/*
 * execunix.c - execute a shell script on UNIX/WinNT/OS2/AmigaOS
 *
 * If $(JAMSHELL) is defined, uses that to formulate execvp()/spawnvp().
 * The default is:
 *
 *	/bin/sh -c %		[ on UNIX/AmigaOS ]
 *	cmd.exe /c %		[ on OS2/WinNT ]
 *
 * Each word must be an individual element in a jam variable value.
 *
 * In $(JAMSHELL), % expands to the command string and ! expands to 
 * the slot number (starting at 1) for multiprocess (-j) invocations.
 * If $(JAMSHELL) doesn't include a %, it is tacked on as the last
 * argument.
 *
 * Don't just set JAMSHELL to /bin/sh or cmd.exe - it won't work!
 *
 * External routines:
 *	execcmd() - launch an async command execution
 * 	execwait() - wait and drive at most one execution completion
 *
 * Internal routines:
 *	onintr() - bump intr to note command interruption
 *
 * 04/08/94 (seiwald) - Coherent/386 support added.
 * 05/04/94 (seiwald) - async multiprocess interface
 * 01/22/95 (seiwald) - $(JAMSHELL) support
 * 06/02/97 (gsar)    - full async multiprocess support for Win32
 */

static int intr = 0;

static int cmdsrunning = 0;

# ifdef NT
static void (*istat)( int );
void onintr( int );
# else
static void (*istat)();
#endif

static struct
{
	int	pid;		/* on win32, a real process handle */
	void	(*func)();
	void 	*closure;
# if defined( NT ) || defined( __OS2__ )
	char	*tempfile;
# endif
} cmdtab[ MAXJOBS ] = {{0}};

/*
 * onintr() - bump intr to note command interruption
 */

void
onintr( disp )
int disp;
{
	intr++;
	printf( "...interrupted\n" );
}

/*
 * execcmd() - launch an async command execution
 */

void
execcmd( string, func, closure, shell )
char *string;
void (*func)();
void *closure;
LIST *shell;
{
	int pid;
	int slot;
	char *argv[ MAXARGC + 1 ];	/* +1 for NULL */

# if defined( NT ) || defined( __OS2__ )
	static char *comspec;
	char *p;

	/* XXX this is questionable practice, since COMSPEC has
	 * a high degree of variability, resulting in Jamfiles
	 * that frequently won't work.  COMSPEC also denotes a shell
	 * fit for interative use, not necessarily/merely a shell
	 * capable of launching commands.  Besides, people can
	 * just set JAMSHELL instead.
	 */
	if( !comspec && !( comspec = getenv( "COMSPEC" ) ) )
	    comspec = "cmd.exe";
# endif

	/* Find a slot in the running commands table for this one. */

	for( slot = 0; slot < MAXJOBS; slot++ )
	    if( !cmdtab[ slot ].pid )
		break;

	if( slot == MAXJOBS )
	{
	    printf( "no slots for child!\n" );
	    exit( EXITBAD );
	}

# if defined( NT ) || defined( __OS2__ )
	if( !cmdtab[ slot ].tempfile )
	{
	    char *tempdir;

	    if( !( tempdir = getenv( "TEMP" ) ) &&
		!( tempdir = getenv( "TMP" ) ) )
		    tempdir = "\\temp";

	    cmdtab[ slot ].tempfile = malloc( strlen( tempdir ) + 14 );

	    sprintf( cmdtab[ slot ].tempfile, "%s\\jamtmp%02d.bat", 
				tempdir, slot );
	}

	/* Trim leading, ending white space */

	while( isspace( *string ) )
		++string;

	p = strchr( string, '\n' );

	while( p && isspace( *p ) )
		++p;

	/* If multi line, or too long, or JAMSHELL is set, write to bat file. */
	/* Otherwise, exec directly. */
	/* Frankly, if it is a single long line I don't think the */
	/* command interpreter will do any better -- it will fail. */

	if( p && *p || strlen( string ) > MAXLINE || shell )
	{
	    FILE *f;

	    /* Write command to bat file. */

	    f = fopen( cmdtab[ slot ].tempfile, "w" );
	    fputs( string, f );
	    fclose( f );

	    string = cmdtab[ slot ].tempfile;
	}
# endif

	/* Forumulate argv */
	/* If shell was defined, be prepared for % and ! subs. */
	/* Otherwise, use stock /bin/sh (on unix) or comspec (on NT). */

	if( shell )
	{
	    int i;
	    char jobno[4];
	    int gotpercent = 0;

	    sprintf( jobno, "%d", slot + 1 );

	    for( i = 0; shell && i < MAXARGC; i++, shell = list_next( shell ) )
	    {
		switch( shell->string[0] )
		{
		case '%':	argv[i] = string; gotpercent++; break;
		case '!':	argv[i] = jobno; break;
		default:	argv[i] = shell->string;
		}
		if( DEBUG_EXECCMD )
		    printf( "argv[%d] = '%s'\n", i, argv[i] );
	    }

	    if( !gotpercent )
		argv[i++] = string;

	    argv[i] = 0;
	}
	else
	{
# if defined( NT ) || defined( __OS2__ )
	    argv[0] = comspec;
	    argv[1] = "/Q/C";		/* anything more is non-portable */
# else
	    argv[0] = "/bin/sh";
	    argv[1] = "-c";
# endif
	    argv[2] = string;
	    argv[3] = 0;
	}

	/* Catch interrupts whenever commands are running. */

	if( !cmdsrunning++ )
	    istat = signal( SIGINT, onintr );

	/* Start the command */

# if defined( NT ) || defined( __OS2__ )
	if( ( pid = spawnvp( P_NOWAIT, argv[0], argv ) ) < 0 )
	{
	    perror( "spawn" );
	    exit( EXITBAD );
	}
# else
	if ((pid = vfork()) == 0) 
   	{
		execvp( argv[0], argv );
		_exit(127);
	}

	if( pid == -1 )
	{
	    perror( "vfork" );
	    exit( EXITBAD );
	}
# endif
	/* Save the operation for execwait() to find. */

	cmdtab[ slot ].pid = pid;
	cmdtab[ slot ].func = func;
	cmdtab[ slot ].closure = closure;

	/* Wait until we're under the limit of concurrent commands. */
	/* Don't trust globs.jobs alone. */

	while( cmdsrunning >= MAXJOBS || cmdsrunning >= globs.jobs )
	    if( !execwait() )
		break;
}

/*
 * execwait() - wait and drive at most one execution completion
 */

int
execwait()
{
	int i;
	int status, w;
	int rstat;

	/* Handle naive make1() which doesn't know if cmds are running. */

	if( !cmdsrunning )
	    return 0;

	/* Pick up process pid and status */
    
	while( ( w = wait( &status ) ) == -1 && errno == EINTR )
		;

	if( w == -1 )
	{
	    printf( "child process(es) lost!\n" );
	    perror("wait");
	    exit( EXITBAD );
	}

	/* Find the process in the cmdtab. */

	for( i = 0; i < MAXJOBS; i++ )
	    if( w == cmdtab[ i ].pid )
		break;

	if( i == MAXJOBS )
	{
	    printf( "waif child found!\n" );
	    exit( EXITBAD );
	}

	/* Drive the completion */

	if( !--cmdsrunning )
	    signal( SIGINT, istat );

	if( intr )
	    rstat = EXEC_CMD_INTR;
	else if( w == -1 || status != 0 )
	    rstat = EXEC_CMD_FAIL;
	else
	    rstat = EXEC_CMD_OK;

	cmdtab[ i ].pid = 0;

	(*cmdtab[ i ].func)( cmdtab[ i ].closure, rstat );

	return 1;
}

# if defined( NT ) && !defined( __BORLANDC__ )

# define WIN32_LEAN_AND_MEAN

# include <windows.h>		/* do the ugly deed */

static int
my_wait( status )
int *status;
{
	int i, num_active = 0;
	DWORD exitcode, waitcode;
	static HANDLE *active_handles = 0;

	if (!active_handles)
	    active_handles = (HANDLE *)malloc(globs.jobs * sizeof(HANDLE) );

	/* first see if any non-waited-for processes are dead,
	 * and return if so.
	 */
	for ( i = 0; i < globs.jobs; i++ ) {
	    if ( cmdtab[i].pid ) {
		if ( GetExitCodeProcess((HANDLE)cmdtab[i].pid, &exitcode) ) {
		    if ( exitcode == STILL_ACTIVE )
			active_handles[num_active++] = (HANDLE)cmdtab[i].pid;
		    else {
			CloseHandle((HANDLE)cmdtab[i].pid);
			*status = (int)((exitcode & 0xff) << 8);
			return cmdtab[i].pid;
		    }
		}
		else
		    goto FAILED;
	    }
	}

	/* if a child exists, wait for it to die */
	if ( !num_active ) {
	    errno = ECHILD;
	    return -1;
	}
	waitcode = WaitForMultipleObjects( num_active,
					   active_handles,
					   FALSE,
					   INFINITE );
	if ( waitcode != WAIT_FAILED ) {
	    if ( waitcode >= WAIT_ABANDONED_0
		&& waitcode < WAIT_ABANDONED_0 + num_active )
		i = waitcode - WAIT_ABANDONED_0;
	    else
		i = waitcode - WAIT_OBJECT_0;
	    if ( GetExitCodeProcess(active_handles[i], &exitcode) ) {
		CloseHandle(active_handles[i]);
		*status = (int)((exitcode & 0xff) << 8);
		return (int)active_handles[i];
	    }
	}

FAILED:
	errno = GetLastError();
	return -1;
    
}

# endif /* NT && !__BORLANDC__ */

# endif /* unix || NT || __OS2__ || AMIGA */
./src/execvms.c100440    167    454        6406  7102105137  12112 0ustar  laurateam/* 
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

# ifdef VMS

# include "jam.h"
# include "execcmd.h"
# include "lists.h"

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <iodef.h>
#include <ssdef.h>
#include <descrip.h>
#include <dvidef.h>
#include <clidef.h>

/*
 * execvms.c - execute a shell script, ala VMS
 *
 * The approach is this:
 *
 *	If the command is a single line, and shorter than WRTLEN (what we 
 *	believe to be the maximum line length), we just system() it.
 *
 *	If the command is multi-line, or longer than WRTLEN, we write the 
 *	command block to a temp file, splitting long lines (using "-" at 
 *	the end of the line to indicate contiuation), and then source that 
 *	temp file.  We use special logic to make sure we don't continue in
 *	the middle of a quoted string.
 *
 * 05/04/94 (seiwald) - async multiprocess interface; noop on VMS
 * 12/20/96 (seiwald) - rewritten to handle multi-line commands well
 * 01/14/96 (seiwald) - don't put -'s between "'s
 */

#define WRTLEN 240

#define MIN( a, b )	((a) < (b) ? (a) : (b))

/* 1 for the @ and 4 for the .com */

char tempnambuf[ L_tmpnam + 1 + 4 ] = {0};

void
execcmd( string, func, closure, shell )
char *string;
void (*func)();
void *closure;
LIST *shell;
{
	char *s, *e, *p;
	int rstat = EXEC_CMD_OK;
	int status;

	/* See if string is more than one line */
	/* discounting leading/trailing white space */

	for( s = string; *s && isspace( *s ); s++ )
		;

	e = p = strchr( s, '\n' );

	while( p && isspace( *p ) )
		++p;

	/* If multi line or long, write to com file. */
	/* Otherwise, exec directly. */

	if( p && *p || e - s > WRTLEN )
	{
	    FILE *f;

	    /* Create temp file invocation "@sys$scratch:tempfile.com" */

	    if( !*tempnambuf )
	    {
		tempnambuf[0] = '@';
		(void)tmpnam( tempnambuf + 1 );
		strcat( tempnambuf, ".com" );
	    }
	    
	    /* Open tempfile */

	    if( !( f = fopen( tempnambuf + 1, "w" ) ) )
	    {
		printf( "can't open command file\n" );
		(*func)( closure, EXEC_CMD_FAIL );
		return;
	    }

	    /* For each line of the string */

	    while( *string )
	    {
		char *s = strchr( string, '\n' );
		int len = s ? s + 1 - string : strlen( string );

		fputc( '$', f );

		/* For each chunk of a line that needs to be split */

		while( len > 0 )
		{
		    char *q = string;
		    char *qe = string + MIN( len, WRTLEN );
		    char *qq = q;
		    int quote = 0;

		    /* Look for matching "'s */

		    for( ; q < qe; q++ )
			if( *q == '"' && ( quote = !quote ) )
			    qq = q;

		    /* Back up to opening quote, if in one */

		    if( quote )
			q = qq;

		    fwrite( string, ( q - string ), 1, f );

		    len -= ( q - string );
		    string = q;

		    if( len )
		    {
			fputc( '-', f );
			fputc( '\n', f );
		    }
		}
	    }

	    fclose( f );

	    status = system( tempnambuf ) & 0x07;

	    unlink( tempnambuf + 1 );
	}
	else
	{
	    /* Execute single line command */
	    /* Strip trailing newline before execing */
	    if( e ) *e = 0;
	    status = system( s ) & 0x07;
	}

	/* Fail for error or fatal error */
	/* OK on OK, warning, or info exit */

	if( status == 2 || status == 4 )
	    rstat = EXEC_CMD_FAIL;

	(*func)( closure, rstat );
}

int 
execwait()
{
	return 0;
}

# endif /* VMS */
./src/expand.c100440    167    454       24070  7102105137  11734 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

# include "jam.h"
# include "lists.h"
# include "variable.h"
# include "expand.h"
# include "filesys.h"
# include "newstr.h"

/*
 * expand.c - expand a buffer, given variable values
 *
 * External routines:
 *
 *     var_expand() - variable-expand input string into list of strings
 *
 * Internal routines:
 *
 *     var_edit() - copy input target name to output, performing : modifiers
 *     var_mods() - parse : modifiers into FILENAME structure
 *
 * 01/25/94 (seiwald) - $(X)$(UNDEF) was expanding like plain $(X)
 * 04/13/94 (seiwald) - added shorthand L0 for null list pointer
 */

static void	var_edit();
static void	var_mods();

# define MAGIC_COLON	'\001'
# define MAGIC_LEFT	'\002'
# define MAGIC_RIGHT	'\003'

/*
 * var_expand() - variable-expand input string into list of strings
 *
 * Would just copy input to output, performing variable expansion, 
 * except that since variables can contain multiple values the result
 * of variable expansion may contain multiple values (a list).  Properly
 * performs "product" operations that occur in "$(var1)xxx$(var2)" or
 * even "$($(var2))".
 *
 * Returns a newly created list.
 */

LIST *
var_expand( l, in, end, lol, cancopyin )
LIST	*l;
char	*in;
char	*end;
LOL	*lol;
int	cancopyin;
{
	char out_buf[ MAXSYM ];
	char *out = out_buf;
	char *inp = in;
	char *ov;		/* for temp copy of variable in outbuf */
	int depth;

	if( DEBUG_VAREXP )
	    printf( "expand '%.*s'\n", end - in, in );

	/* This gets alot of cases: $(<) and $(>) */

	if( in[0] == '$' && in[1] == '(' && in[3] == ')' && !in[4] )
	{
	    switch( in[2] )
	    {
	    case '1':
	    case '<':
		return list_copy( l, lol_get( lol, 0 ) );

	    case '2':
	    case '>':
		return list_copy( l, lol_get( lol, 1 ) );
	    }
	}

	/* Just try simple copy of in to out. */

	while( in < end )
	    if( ( *out++ = *in++ ) == '$' && *in == '(' ) 
		goto expand;

	/* No variables expanded - just add copy of input string to list. */

	/* Cancopyin is an optimization: if the input was already a list */
	/* item, we can use the copystr() to put it on the new list. */
	/* Otherwise, we use the slower newstr(). */

	*out = '\0';

	if( cancopyin )
	    return list_new( l, copystr( inp ) );
	else
	    return list_new( l, newstr( out_buf ) );

    expand:
	/*
	 * Input so far (ignore blanks):
	 *
	 *	stuff-in-outbuf $(variable) remainder
	 *			 ^	             ^
	 *			 in		     end
	 * Output so far:
	 *
	 *	stuff-in-outbuf $
	 *	^	         ^
	 *	out_buf          out
	 *
	 *
	 * We just copied the $ of $(...), so back up one on the output.
	 * We now find the matching close paren, copying the variable and
	 * modifiers between the $( and ) temporarily into out_buf, so that
	 * we can replace :'s with MAGIC_COLON.  This is necessary to avoid
	 * being confused by modifier values that are variables containing
	 * :'s.  Ugly.
	 */

	depth = 1;
	out--, in++;
	ov = out;

	while( in < end && depth )
	{
	    switch( *ov++ = *in++ )
	    {
	    case '(': depth++; break;
	    case ')': depth--; break;
	    case ':': ov[-1] = MAGIC_COLON; break;
	    case '[': ov[-1] = MAGIC_LEFT; break;
	    case ']': ov[-1] = MAGIC_RIGHT; break;
	    }
	}

	/* Copied ) - back up. */

	ov--;

	/*
	 * Input so far (ignore blanks):
	 *
	 *	stuff-in-outbuf $(variable) remainder
	 *			            ^        ^
	 *			            in       end
	 * Output so far:
	 *
	 *	stuff-in-outbuf variable
	 *	^	        ^       ^
	 *	out_buf         out	ov
	 *
	 * Later we will overwrite 'variable' in out_buf, but we'll be
	 * done with it by then.  'variable' may be a multi-element list, 
	 * so may each value for '$(variable element)', and so may 'remainder'.
	 * Thus we produce a product of three lists.
	 */

	{
	    LIST *variables = 0;
	    LIST *remainder = 0;
	    LIST *vars;

	    /* Recursively expand variable name & rest of input */

	    if( out < ov )
		variables = var_expand( L0, out, ov, lol, 0 );
	    if( in < end )
		remainder = var_expand( L0, in, end, lol, 0 );

	    /* Now produce the result chain */

	    /* For each variable name */

	    for( vars = variables; vars; vars = list_next( vars ) )
	    {
		LIST *value;
		char *colon;
		char *bracket;
		char varname[ MAXSYM ];
		int i, sub1, sub2;

		/* Look for a : modifier in the variable name */
		/* Must copy into varname so we can modify it */

		strcpy( varname, vars->string );

		if( colon = strchr( varname, MAGIC_COLON ) )
		    *colon = '\0';

		if( bracket = strchr( varname, MAGIC_LEFT ) )
		{
		    char *dash;

		    if( dash = strchr( bracket + 1, '-' ) )
		    {
			*dash = '\0';
			sub1 = atoi( bracket + 1 );
			sub2 = atoi( dash + 1 );
		    }
		    else
		    {
			sub1 = sub2 = atoi( bracket + 1 );
		    }

		    *bracket = '\0';
		}
		else
		{
		    sub1 = sub2 = 0;	/* not needed */
		}

		/* Get variable value, specially handling $(<), $(>), $(n) */
		
		if( varname[0] == '<' && !varname[1] )
		{
		    value = lol_get( lol, 0 );
		}
		else if( varname[0] == '>' && !varname[1] )
		{
		    value = lol_get( lol, 1 );
		}
		else if( varname[0] >= '1' && varname[0] <= '9' && !varname[1] )
		{
		    value = lol_get( lol, varname[0] - '1' );
		}
		else 
		{
		    value = var_get( varname );
		}

		/* The fast path: $(x) - just copy the variable value. */

		if( out == out_buf && !bracket && !colon && in == end )
		{
		    l = list_copy( l, value );
		    continue;
		}

		/* For each variable value */

		for( i = 1; value; i++, value = list_next( value ) )
		{
		    LIST *rem;
		    char *out1;

		    /* Skip members not in subscript */

		    if( bracket && ( i < sub1 || sub2 && i > sub2 ) )
			continue;

		    /* Apply : mods, if present */

		    if( colon )
			var_edit( value->string, colon + 1, out );
		    else
			strcpy( out, value->string );

		    /* If no remainder, append result to output chain. */

		    if( in == end )
		    {
			l = list_new( l, newstr( out_buf ) );
			continue;
		    }

		    /* Remember the end of the variable expansion so */
		    /* we can just tack on each instance of 'remainder' */

		    out1 = out + strlen( out );

		    /* For each remainder, or just once if no remainder, */
		    /* append the complete string to the output chain */

		    for( rem = remainder; rem; rem = list_next( rem ) )
		    {
			strcpy( out1, rem->string );
			l = list_new( l, newstr( out_buf ) );
		    }
		}
	    }

	    /* variables & remainder were gifts from var_expand */
	    /* and must be freed */

	    if( variables )
		list_free( variables );
	    if( remainder)
		list_free( remainder );

	    if( DEBUG_VAREXP )
	    {
		printf( "expanded to " );
		list_print( l );
		printf( "\n" );
	    }

	    return l;
	}
}

/*
 * var_edit() - copy input target name to output, performing : modifiers
 */

typedef struct {
	char	downshift;	/* :L -- downshift result */
	char	upshift;	/* :U -- upshift result */
	char	parent;		/* :P -- go to parent directory */
} VAR_ACTS ;
	
static void
var_edit( in, mods, out )
char	*in;
char	*mods;
char	*out;
{
	FILENAME old, new;
	VAR_ACTS acts;

	/* Parse apart original filename, putting parts into "old" */

	file_parse( in, &old );

	/* Parse apart modifiers, putting them into "new" */

	var_mods( mods, &new, &acts );

	/* Replace any old with new */

	if( new.f_grist.ptr )
	    old.f_grist = new.f_grist;

	if( new.f_root.ptr )
	    old.f_root = new.f_root;

	if( new.f_dir.ptr )
	    old.f_dir = new.f_dir;

	if( new.f_base.ptr )
	    old.f_base = new.f_base;

	if( new.f_suffix.ptr )
	    old.f_suffix = new.f_suffix;

	if( new.f_member.ptr )
	    old.f_member = new.f_member;

	/* If requested, modify old to point to parent */

	if( acts.parent )
	    file_parent( &old );

	/* Put filename back together */

	file_build( &old, out, 0 );

	/* Handle upshifting, downshifting now */

	if( acts.upshift )
	{
	    for( ; *out; ++out )
		*out = toupper( *out );
	}
	else if( acts.downshift )
	{
	    for( ; *out; ++out )
		*out = tolower( *out );
	}
}


/*
 * var_mods() - parse : modifiers into FILENAME structure
 *
 * The : modifiers in a $(varname:modifier) currently support replacing
 * or omitting elements of a filename, and so they are parsed into a 
 * FILENAME structure (which contains pointers into the original string).
 *
 * Modifiers of the form "X=value" replace the component X with
 * the given value.  Modifiers without the "=value" cause everything 
 * but the component X to be omitted.  X is one of:
 *
 *	G <grist>
 *	D directory name
 *	B base name
 *	S .suffix
 *	M (member)
 *	R root directory - prepended to whole path
 *
 * This routine sets:
 *
 *	f->f_xxx.ptr = 0
 *	f->f_xxx.len = 0
 *		-> leave the original component xxx
 *
 *	f->f_xxx.ptr = string
 *	f->f_xxx.len = strlen( string )
 *		-> replace component xxx with string
 *
 *	f->f_xxx.ptr = ""
 *	f->f_xxx.len = 0
 *		-> omit component xxx
 *
 * var_edit() above and file_build() obligingly follow this convention.
 */

static void
var_mods( mods, f, acts )
char		*mods;
FILENAME	*f;
VAR_ACTS	*acts;
{
	char *flags = "GRDBSM";
	int havezeroed = 0;
	memset( (char *)f, 0, sizeof( *f ) );
	memset( (char *)acts, 0, sizeof( *acts ) );

	while( *mods )
	{
	    char *fl;
	    struct filepart *fp;

	    /* First take care of :U or :L (upshift, downshift) */

	    if( *mods == 'L' )
	    {
		acts->downshift = 1;
		++mods;
		continue;
	    }
	    else if( *mods == 'U' )
	    {
		acts->upshift = 1;
		++mods;
		continue;
	    }
	    else if( *mods == 'P' )
	    {
		acts->parent = 1;
		++mods;
		continue;
	    }

	    /* Now handle the file component flags */

	    if( !( fl = strchr( flags, *mods++ ) ) )
		break;	/* should complain, but so what... */

	    fp = &f->part[ fl - flags ];

	    if( *mods++ != '=' )
	    {
		/* :X - turn everything but X off */

		int i;

		mods--;

		if( !havezeroed++ )
		    for( i = 0; i < 6; i++ )
		{
		    f->part[ i ].len = 0;
		    f->part[ i ].ptr = "";
		}

		fp->ptr = 0;
	    }
	    else
	    {
		/* :X=value - set X to value */

		char *p;

		if( p = strchr( mods, MAGIC_COLON ) )
		{
		    fp->ptr = mods;
		    fp->len = p - mods;
		    mods = p + 1;
		}
		else
		{
		    fp->ptr = mods;
		    fp->len = strlen( mods );
		    mods += fp->len;
		}
	    }
	}
}
./src/expand.h100440    167    454         314  7102105137  11674 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

/*
 * expand.h - expand a buffer, given variable values
 */

LIST *var_expand();
./src/filemac.c100440    167    454        4706  7102105137  12041 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

# include "jam.h"
# include "filesys.h"

# ifdef macintosh

# include <sys/types.h>

# ifdef MPW
# include <sys/stat.h>
# else
# include <stat.h>
# endif

# include <dirent.h>

/*
 * filemac.c - manipulate file names and scan directories on macintosh
 *
 * External routines:
 *
 *	file_dirscan() - scan a directory for files
 *	file_time() - get timestamp of file, if not done by file_dirscan()
 *	file_archscan() - scan an archive for files
 *
 * File_dirscan() and file_archscan() call back a caller provided function
 * for each file found.  A flag to this callback function lets file_dirscan()
 * and file_archscan() indicate that a timestamp is being provided with the
 * file.   If file_dirscan() or file_archscan() do not provide the file's
 * timestamp, interested parties may later call file_time().
 *
 * 04/08/94 (seiwald) - Coherent/386 support added.
 * 12/19/94 (mikem) - solaris string table insanity support
 * 02/14/95 (seiwald) - parse and build /xxx properly
 * 05/03/96 (seiwald) - split into pathunix.c
 * 11/21/96 (peterk) - BEOS does not have Unix-style archives
 */

/*
 * file_dirscan() - scan a directory for files
 */

void
file_dirscan( dir, func )
char	*dir;
void	(*func)();
{
	FILENAME f;
	DIR *d;
	struct dirent *dirent;
	char filename[ MAXJPATH ];
	struct stat statbuf;

	/* First enter directory itself */

	memset( (char *)&f, '\0', sizeof( f ) );

	f.f_dir.ptr = dir;
	f.f_dir.len = strlen(dir);

	if( DEBUG_BINDSCAN )
	    printf( "scan directory %s\n", dir );
		
	/* Special case ":" - enter it */

	if( f.f_dir.len == 1 && f.f_dir.ptr[0] == ':' )
	    (*func)( dir, 0 /* not stat()'ed */, (time_t)0 );

	/* Now enter contents of directory */

	if( !( d = opendir( dir ) ) )
	    return;

	while( dirent = readdir( d ) )
	{
	    f.f_base.ptr = dirent->d_name;
	    f.f_base.len = strlen( f.f_base.ptr );

	    file_build( &f, filename, 0 );

	    (*func)( filename, 0 /* not stat()'ed */, (time_t)0 );
	}

	closedir( d );
}

/*
 * file_time() - get timestamp of file, if not done by file_dirscan()
 */

int
file_time( filename, time )
char	*filename;
time_t	*time;
{
	struct stat statbuf;

	if( stat( filename, &statbuf ) < 0 )
	    return -1;

	*time = statbuf.st_mtime;
	
	return 0;
}

/*
 * file_archscan() - scan an archive for files
 */

void
file_archscan( archive, func )
char *archive;
void (*func)();
{
}


# endif /* macintosh */

./src/filent.c100440    167    454       12711  7102105137  11735 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

# ifdef NT

# ifdef __BORLANDC__
# include <dir.h>
# include <dos.h>
# undef FILENAME	/* cpp namespace collision */
# define _finddata_t ffblk
# endif

# include "jam.h"
# include "filesys.h"

# include <io.h>
# include <sys/stat.h>

/*
 * filent.c - scan directories and archives on NT
 *
 * External routines:
 *
 *	file_dirscan() - scan a directory for files
 *	file_time() - get timestamp of file, if not done by file_dirscan()
 *	file_archscan() - scan an archive for files
 *
 * File_dirscan() and file_archscan() call back a caller provided function
 * for each file found.  A flag to this callback function lets file_dirscan()
 * and file_archscan() indicate that a timestamp is being provided with the
 * file.   If file_dirscan() or file_archscan() do not provide the file's
 * timestamp, interested parties may later call file_time().
 *
 * 07/10/95 (taylor)  Findfirst() returns the first file on NT.
 * 05/03/96 (seiwald) split apart into pathnt.c
 */

/*
 * file_dirscan() - scan a directory for files
 */

void
file_dirscan( dir, func )
char	*dir;
void	(*func)();
{
	FILENAME f;
	char filespec[ MAXJPATH ];
	char filename[ MAXJPATH ];
	long handle;
	int ret;
	struct _finddata_t finfo[1];

	/* First enter directory itself */

	memset( (char *)&f, '\0', sizeof( f ) );

	f.f_dir.ptr = dir;
	f.f_dir.len = strlen(dir);

	dir = *dir ? dir : ".";

 	/* Special case \ or d:\ : enter it */
 
 	if( f.f_dir.len == 1 && f.f_dir.ptr[0] == '\\' )
 	    (*func)( dir, 0 /* not stat()'ed */, (time_t)0 );
 	else if( f.f_dir.len == 3 && f.f_dir.ptr[1] == ':' )
 	    (*func)( dir, 0 /* not stat()'ed */, (time_t)0 );

	/* Now enter contents of directory */

	sprintf( filespec, "%s/*", dir );

	if( DEBUG_BINDSCAN )
	    printf( "scan directory %s\n", dir );

# ifdef __BORLANDC__
	if ( ret = findfirst( filespec, finfo, FA_NORMAL | FA_DIREC ) )
	    return;

	while( !ret )
	{
	    time_t time_write = finfo->ff_fdate;

	    time_write = (time_write << 16) | finfo->ff_ftime;
	    f.f_base.ptr = finfo->ff_name;
	    f.f_base.len = strlen( finfo->ff_name );

	    file_build( &f, filename );

	    (*func)( filename, 1 /* stat()'ed */, time_write );

	    ret = findnext( finfo );
	}
# else
	handle = _findfirst( filespec, finfo );

	if( ret = ( handle < 0L ) )
	    return;

	while( !ret )
	{
	    f.f_base.ptr = finfo->name;
	    f.f_base.len = strlen( finfo->name );

	    file_build( &f, filename, 0 );

	    (*func)( filename, 1 /* stat()'ed */, finfo->time_write );

	    ret = _findnext( handle, finfo );
	}

	_findclose( handle );
# endif

}

/*
 * file_time() - get timestamp of file, if not done by file_dirscan()
 */

int
file_time( filename, time )
char	*filename;
time_t	*time;
{
	/* On NT this is called only for C:/ */

	struct stat statbuf;

	if( stat( filename, &statbuf ) < 0 )
	    return -1;

	*time = statbuf.st_mtime;

	return 0;
}

/*
 * file_archscan() - scan an archive for files
 */

/* Straight from SunOS */

#define	ARMAG	"!<arch>\n"
#define	SARMAG	8

#define	ARFMAG	"`\n"

struct ar_hdr {
	char	ar_name[16];
	char	ar_date[12];
	char	ar_uid[6];
	char	ar_gid[6];
	char	ar_mode[8];
	char	ar_size[10];
	char	ar_fmag[2];
};

# define SARFMAG 2
# define SARHDR sizeof( struct ar_hdr )

void
file_archscan( archive, func )
char *archive;
void (*func)();
{
	struct ar_hdr ar_hdr;
	char *string_table = 0;
	char buf[ MAXJPATH ];
	long offset;
	int fd;

	if( ( fd = open( archive, O_RDONLY | O_BINARY, 0 ) ) < 0 )
	    return;

	if( read( fd, buf, SARMAG ) != SARMAG ||
	    strncmp( ARMAG, buf, SARMAG ) )
	{
	    close( fd );
	    return;
	}

	offset = SARMAG;

	if( DEBUG_BINDSCAN )
	    printf( "scan archive %s\n", archive );

	while( read( fd, &ar_hdr, SARHDR ) == SARHDR &&
	       !memcmp( ar_hdr.ar_fmag, ARFMAG, SARFMAG ) )
	{
	    long    lar_date;
	    long    lar_size;
	    char    *name = 0;
 	    char    *endname;
	    char    *c;

	    sscanf( ar_hdr.ar_date, "%ld", &lar_date );
	    sscanf( ar_hdr.ar_size, "%ld", &lar_size );

	    lar_size = ( lar_size + 1 ) & ~1;

	    if (ar_hdr.ar_name[0] == '/' && ar_hdr.ar_name[1] == '/' )
	    {
		/* this is the "string table" entry of the symbol table,
		** which holds strings of filenames that are longer than
		** 15 characters (ie. don't fit into a ar_name
		*/

		string_table = malloc(lar_size);
		if (read(fd, string_table, lar_size) != lar_size)
		    printf("error reading string table\n");
		offset += SARHDR + lar_size;
		continue;
	    }
	    else if (ar_hdr.ar_name[0] == '/' && ar_hdr.ar_name[1] != ' ')
	    {
		/* Long filenames are recognized by "/nnnn" where nnnn is
		** the offset of the string in the string table represented
		** in ASCII decimals.
		*/

		name = string_table + atoi( ar_hdr.ar_name + 1 );
		endname = name + strlen( name );
	    }
	    else
	    {
		/* normal name */
		name = ar_hdr.ar_name;
		endname = name + sizeof( ar_hdr.ar_name );
	    }

	    /* strip trailing space, slashes, and backslashes */

	    while( endname-- > name )
		if( *endname != ' ' && *endname != '\\' && *endname != '/' )
		    break;
	    *++endname = 0;

	    /* strip leading directory names, an NT specialty */

	    if( c = strrchr( name, '/' ) )
		name = c + 1;
	    if( c = strrchr( name, '\\' ) )
		name = c + 1;

	    sprintf( buf, "%s(%.*s)", archive, endname - name, name );
	    (*func)( buf, 1 /* time valid */, (time_t)lar_date );

	    offset += SARHDR + lar_size;
	    lseek( fd, offset, 0 );
	}

	close( fd );
}

# endif /* NT */
./src/fileos2.c100440    167    454        4776  7102105137  12013 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

# include "jam.h"
# include "filesys.h"

# ifdef __OS2__

# include <io.h>
# include <dos.h>

/*
 * fileos2.c - scan directories and archives on NT
 *
 * External routines:
 *
 *	file_dirscan() - scan a directory for files
 *	file_time() - get timestamp of file, if not done by file_dirscan()
 *	file_archscan() - scan an archive for files
 *
 * File_dirscan() and file_archscan() call back a caller provided function
 * for each file found.  A flag to this callback function lets file_dirscan()
 * and file_archscan() indicate that a timestamp is being provided with the
 * file.   If file_dirscan() or file_archscan() do not provide the file's
 * timestamp, interested parties may later call file_time().
 *
 * 07/10/95 (taylor)  Findfirst() returns the first file on NT.
 * 05/03/96 (seiwald) split apart into pathnt.c
 */

/*
 * file_dirscan() - scan a directory for files
 */

void
file_dirscan( dir, func )
char	*dir;
void	(*func)();
{
	FILENAME f;
	char filespec[ MAXJPATH ];
	char filename[ MAXJPATH ];
	long handle;
	int ret;
	struct _find_t finfo[1];

	/* First enter directory itself */

	memset( (char *)&f, '\0', sizeof( f ) );

	f.f_dir.ptr = dir;
	f.f_dir.len = strlen(dir);

	dir = *dir ? dir : ".";

 	/* Special case \ : enter it */
 
 	if( f.f_dir.len == 1 && f.f_dir.ptr[0] == '\\' )
 	    (*func)( dir, 0 /* not stat()'ed */, (time_t)0 );

	/* Now enter contents of directory */

	sprintf( filespec, "%s/*", dir );

	if( DEBUG_BINDSCAN )
	    printf( "scan directory %s\n", dir );

	/* Time info in dos find_t is not very useful.  It consists */
	/* of a separate date and time, and putting them together is */
	/* not easy.  So we leave that to a later stat() call. */

	if( !_dos_findfirst( filespec, _A_NORMAL|_A_RDONLY|_A_SUBDIR, finfo ) )
	{
	    do
	    {
		f.f_base.ptr = finfo->name;
		f.f_base.len = strlen( finfo->name );

		file_build( &f, filename, 0 );

		(*func)( filename, 0 /* not stat()'ed */, (time_t)0 );
	    }
	    while( !_dos_findnext( finfo ) );
	}

}

/*
 * file_time() - get timestamp of file, if not done by file_dirscan()
 */

int
file_time( filename, time )
char	*filename;
time_t	*time;
{
	/* This is called on OS2, not NT.  */
	/* NT fills in the time in the dirscan. */

	struct stat statbuf;

	if( stat( filename, &statbuf ) < 0 )
	    return -1;

	*time = statbuf.st_mtime;

	return 0;
}

void
file_archscan( archive, func )
char *archive;
void (*func)();
{
}

# endif /* OS2 */

./src/filesys.h100440    167    454        2126  7102105137  12116 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

/*
 * filesys.h - FILENAME struct and OS specific file routines 
 */

/*
 * FILENAME - a name of a file, broken into <grist>dir/base/suffix(member)
 *
 * <grist> is salt to distinguish between targets that otherwise would
 * have the same name:  it never appears in the bound name of a target.
 * (member) is an archive member name: the syntax is arbitrary, but must 
 * agree in file_parse(), file_build() and the Jambase.
 *
 * On VMS, we keep track of whether the original path was a directory
 * (without a file), so that $(VAR:D) can climb to the parent.
 */

typedef struct _filename FILENAME;

struct _filename {
	struct filepart {
		char	*ptr;
		int	len;
	} part[6];
# define f_grist	part[0]
# define f_root		part[1]
# define f_dir		part[2]
# define f_base		part[3]
# define f_suffix	part[4]
# define f_member	part[5]

# ifdef VMS
	int		parent;
# endif

} ;

void file_parse();
void file_build();
void file_parent();

void file_archscan();
void file_dirscan();

int file_time();
./src/fileunix.c100440    167    454       15516  7102105137  12305 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

# include "jam.h"
# include "filesys.h"

# if defined(unix) || defined(AMIGA)

# if defined(_SEQUENT_) || defined(__DGUX__) || \
     defined(M_XENIX) || defined(__ISC) 
# define PORTAR 1
# endif

#ifdef NeXT
/* need unistd for rhapsody's proper lseek */
# include <sys/dir.h>
# include <unistd.h>
#else
# include <dirent.h>
#endif

# if defined (COHERENT) && defined (_I386)
# include <arcoff.h>
# else
# if defined( __MVS__ ) || defined( __OPENNT )

#define	ARMAG	"!<arch>\n"
#define	SARMAG	8
#define	ARFMAG	"`\n"

struct ar_hdr		/* archive file member header - printable ascii */
{
	char	ar_name[16];	/* file member name - `/' terminated */
	char	ar_date[12];	/* file member date - decimal */
	char	ar_uid[6];	/* file member user id - decimal */
	char	ar_gid[6];	/* file member group id - decimal */
	char	ar_mode[8];	/* file member mode - octal */
	char	ar_size[10];	/* file member size - decimal */
	char	ar_fmag[2];	/* ARFMAG - string to end header */
};

# else
# if !defined( __QNX__ ) && !defined( __BEOS__ )
# include <ar.h>
# endif /* QNX */
# endif /* MVS */
# endif	/* COHERENT */
  

/*
 * fileunix.c - manipulate file names and scan directories on UNIX/AmigaOS
 *
 * External routines:
 *
 *	file_dirscan() - scan a directory for files
 *	file_time() - get timestamp of file, if not done by file_dirscan()
 *	file_archscan() - scan an archive for files
 *
 * File_dirscan() and file_archscan() call back a caller provided function
 * for each file found.  A flag to this callback function lets file_dirscan()
 * and file_archscan() indicate that a timestamp is being provided with the
 * file.   If file_dirscan() or file_archscan() do not provide the file's
 * timestamp, interested parties may later call file_time().
 *
 * 04/08/94 (seiwald) - Coherent/386 support added.
 * 12/19/94 (mikem) - solaris string table insanity support
 * 02/14/95 (seiwald) - parse and build /xxx properly
 * 05/03/96 (seiwald) - split into pathunix.c
 * 11/21/96 (peterk) - BEOS does not have Unix-style archives
 */

/*
 * file_dirscan() - scan a directory for files
 */

void
file_dirscan( dir, func )
char	*dir;
void	(*func)();
{
	FILENAME f;
	DIR *d;
#ifdef NeXT
	struct direct *dirent;
#else
	struct dirent *dirent;
#endif
	char filename[ MAXJPATH ];

	/* First enter directory itself */

	memset( (char *)&f, '\0', sizeof( f ) );

	f.f_dir.ptr = dir;
	f.f_dir.len = strlen(dir);

	dir = *dir ? dir : ".";

	/* Special case / : enter it */

	if( f.f_dir.len == 1 && f.f_dir.ptr[0] == '/' )
	    (*func)( dir, 0 /* not stat()'ed */, (time_t)0 );

	/* Now enter contents of directory */

	if( !( d = opendir( dir ) ) )
	    return;

	if( DEBUG_BINDSCAN )
	    printf( "scan directory %s\n", dir );

	while( dirent = readdir( d ) )
	{
# ifdef old_sinix
	    /* Broken structure definition on sinix. */
	    f.f_base.ptr = dirent->d_name - 2;
# else
	    f.f_base.ptr = dirent->d_name;
# endif
	    f.f_base.len = strlen( f.f_base.ptr );

	    file_build( &f, filename, 0 );

	    (*func)( filename, 0 /* not stat()'ed */, (time_t)0 );
	}

	closedir( d );
}

/*
 * file_time() - get timestamp of file, if not done by file_dirscan()
 */

int
file_time( filename, time )
char	*filename;
time_t	*time;
{
	struct stat statbuf;

	if( stat( filename, &statbuf ) < 0 )
	    return -1;

	*time = statbuf.st_mtime;
	return 0;
}

/*
 * file_archscan() - scan an archive for files
 */

# ifndef AIAMAG	/* God-fearing UNIX */

# define SARFMAG 2
# define SARHDR sizeof( struct ar_hdr )

void
file_archscan( archive, func )
char *archive;
void (*func)();
{
# if !defined( __QNX__ ) && !defined( __BEOS__ )
	struct ar_hdr ar_hdr;
	char buf[ MAXJPATH ];
	long offset;
	char    *string_table = 0;
	int fd;

	if( ( fd = open( archive, O_RDONLY, 0 ) ) < 0 )
	    return;

	if( read( fd, buf, SARMAG ) != SARMAG ||
	    strncmp( ARMAG, buf, SARMAG ) )
	{
	    close( fd );
	    return;
	}

	offset = SARMAG;

	if( DEBUG_BINDSCAN )
	    printf( "scan archive %s\n", archive );

	while( read( fd, &ar_hdr, SARHDR ) == SARHDR &&
	       !memcmp( ar_hdr.ar_fmag, ARFMAG, SARFMAG ) )
	{
	    char    lar_name[256];
	    long    lar_date;
	    long    lar_size;
	    long    lar_offset;
	    char *c;
	    char    *src, *dest;

	    strncpy( lar_name, ar_hdr.ar_name, sizeof(ar_hdr.ar_name) );

	    sscanf( ar_hdr.ar_date, "%ld", &lar_date );
	    sscanf( ar_hdr.ar_size, "%ld", &lar_size );

	    if (ar_hdr.ar_name[0] == '/')
	    {
		if (ar_hdr.ar_name[1] == '/')
		{
		    /* this is the "string table" entry of the symbol table,
		    ** which holds strings of filenames that are longer than
		    ** 15 characters (ie. don't fit into a ar_name
		    */

		    string_table = malloc(lar_size);
		    lseek(fd, offset + SARHDR, 0);
		    if (read(fd, string_table, lar_size) != lar_size)
			printf("error reading string table\n");
		}
		else if (string_table && ar_hdr.ar_name[1] != ' ')
		{
		    /* Long filenames are recognized by "/nnnn" where nnnn is
		    ** the offset of the string in the string table represented
		    ** in ASCII decimals.
		    */
		    dest = lar_name;
		    lar_offset = atoi(lar_name + 1);
		    src = &string_table[lar_offset];
		    while (*src != '/')
			*dest++ = *src++;
		    *dest = '/';
		}
	    }

	    c = lar_name - 1;
	    while( *++c != ' ' && *c != '/' )
		;
	    *c = '\0';

	    if ( DEBUG_BINDSCAN )
		printf( "archive name %s found\n", lar_name );

	    sprintf( buf, "%s(%s)", archive, lar_name );

	    (*func)( buf, 1 /* time valid */, (time_t)lar_date );

	    offset += SARHDR + ( ( lar_size + 1 ) & ~1 );
	    lseek( fd, offset, 0 );
	}

	if (string_table)
	    free(string_table);

	close( fd );

# endif /* QNX */

}

# else /* AIAMAG - RS6000 AIX */

void
file_archscan( archive, func )
char *archive;
void (*func)();
{
	struct fl_hdr fl_hdr;

	struct {
		struct ar_hdr hdr;
		char pad[ 256 ];
	} ar_hdr ;

	char buf[ MAXJPATH ];
	long offset;
	int fd;

	if( ( fd = open( archive, O_RDONLY, 0 ) ) < 0 )
	    return;

	if( read( fd, (char *)&fl_hdr, FL_HSZ ) != FL_HSZ ||
	    strncmp( AIAMAG, fl_hdr.fl_magic, SAIAMAG ) )
	{
	    close( fd );
	    return;
	}

	sscanf( fl_hdr.fl_fstmoff, "%ld", &offset );

	if( DEBUG_BINDSCAN )
	    printf( "scan archive %s\n", archive );

	while( offset > 0 &&
	       lseek( fd, offset, 0 ) >= 0 &&
	       read( fd, &ar_hdr, sizeof( ar_hdr ) ) >= sizeof( ar_hdr.hdr ) )
	{
	    long    lar_date;
	    int	    lar_namlen;

	    sscanf( ar_hdr.hdr.ar_namlen, "%d", &lar_namlen );
	    sscanf( ar_hdr.hdr.ar_date, "%ld", &lar_date );
	    sscanf( ar_hdr.hdr.ar_nxtmem, "%ld", &offset );

	    if( !lar_namlen )
		continue;

	    ar_hdr.hdr._ar_name.ar_name[ lar_namlen ] = '\0';

	    sprintf( buf, "%s(%s)", archive, ar_hdr.hdr._ar_name.ar_name );

	    (*func)( buf, 1 /* time valid */, (time_t)lar_date );
	}

	close( fd );
}

# endif /* AIAMAG - RS6000 AIX */

# endif /* unix || AMIGA */

./src/filevms.c100440    167    454       15267  7102105137  12132 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

# ifdef VMS

/*
 * filevms.c - scan directories and libaries on VMS
 *
 * External routines:
 *
 *	file_dirscan() - scan a directory for files
 *	file_time() - get timestamp of file, if not done by file_dirscan()
 *	file_archscan() - scan an archive for files
 *
 * File_dirscan() and file_archscan() call back a caller provided function
 * for each file found.  A flag to this callback function lets file_dirscan()
 * and file_archscan() indicate that a timestamp is being provided with the
 * file.   If file_dirscan() or file_archscan() do not provide the file's
 * timestamp, interested parties may later call file_time().
 *
 * 02/09/95 (seiwald) - bungled R=[xxx] - was using directory length!
 * 05/03/96 (seiwald) - split into pathvms.c
 */

# include <rms.h>
# include <iodef.h>
# include <ssdef.h>
# include <string.h>
# include <stdlib.h>
# include <stdio.h>
# include <descrip.h>

#include <lbrdef.h>
#include <credef.h>
#include <mhddef.h>
#include <lhidef.h>
#include <lib$routines.h>
#include <starlet.h>

# include "jam.h"
# include "filesys.h"

/* Supply missing prototypes for lbr$-routines*/
int lbr$close();
int lbr$get_index();
int lbr$ini_control();
int lbr$open();
int lbr$set_module();

/*
 * unlink() - remove a file
 */

unlink( f )
char *f;
{
	remove( f );
}

static void
file_cvttime( curtime, unixtime )
unsigned int *curtime;
time_t *unixtime;
{
    static const size_t divisor = 10000000;
    static unsigned int bastim[2] = { 0x4BEB4000, 0x007C9567 }; /* 1/1/1970 */
    int delta[2], remainder;

    lib$subx( curtime, bastim, delta );
    lib$ediv( &divisor, delta, unixtime, &remainder );
}

# define DEFAULT_FILE_SPECIFICATION "[]*.*;0"

# define min( a,b ) ((a)<(b)?(a):(b))

void
file_dirscan( char *dir, void (*func)() )
{

    struct FAB xfab;
    struct NAM xnam;
    struct XABDAT xab;
    char esa[256];
    char filename[256];
    char filename2[256];
    char dirname[256];
    register status;
    FILENAME f;

    memset( (char *)&f, '\0', sizeof( f ) );

    f.f_root.ptr = dir;
    f.f_root.len = strlen( dir );

	/* get the input file specification
	 */
    xnam = cc$rms_nam;
    xnam.nam$l_esa = esa;
    xnam.nam$b_ess = sizeof( esa ) - 1;
    xnam.nam$l_rsa = filename;
    xnam.nam$b_rss = min( sizeof( filename ) - 1, NAM$C_MAXRSS );

    xab = cc$rms_xabdat;                /* initialize extended attributes */
    xab.xab$b_cod = XAB$C_DAT;		/* ask for date */
    xab.xab$l_nxt = NULL;               /* terminate XAB chain      */

    xfab = cc$rms_fab;
    xfab.fab$l_dna = DEFAULT_FILE_SPECIFICATION;
    xfab.fab$b_dns = sizeof( DEFAULT_FILE_SPECIFICATION ) - 1;
    xfab.fab$l_fop = FAB$M_NAM;
    xfab.fab$l_fna = dir;			/* address of file name	    */
    xfab.fab$b_fns = strlen( dir );		/* length of file name	    */
    xfab.fab$l_nam = &xnam;			/* address of NAB block	    */
    xfab.fab$l_xab = (char *)&xab;       /* address of XAB block     */


    status = sys$parse( &xfab );

    if( DEBUG_BINDSCAN )
	printf( "scan directory %s\n", dir );

    if ( !( status & 1 ) )
	return;



    /* Add bogus directory for [000000] */

    if( !strcmp( dir, "[000000]" ) )
    {
	(*func)( "[000000]", 1 /* time valid */, 1 /* old but true */ );
    }

    /* Add bogus directory for [] */

    if( !strcmp( dir, "[]" ) )
    {
	(*func)( "[]", 1 /* time valid */, 1 /* old but true */ );
	(*func)( "[-]", 1 /* time valid */, 1 /* old but true */ );
    }

    while ( (status = sys$search( &xfab )) & 1 )
    {
	char *s;
	time_t time;

	/* "I think that might work" - eml */

	sys$open( &xfab );
	sys$close( &xfab );

	file_cvttime( &xab.xab$q_rdt, &time );

	filename[xnam.nam$b_rsl] = '\0';

	/* What we do with the name depends on the suffix: */
	/* .dir is a directory */
	/* .xxx is a file with a suffix */
	/* . is no suffix at all */

	if( xnam.nam$b_type == 4 && !strncmp( xnam.nam$l_type, ".DIR", 4 ) )
	{
	    /* directory */
	    sprintf( dirname, "[.%.*s]", xnam.nam$b_name, xnam.nam$l_name );
	    f.f_dir.ptr = dirname;
	    f.f_dir.len = strlen( dirname );
	    f.f_base.ptr = 0;
	    f.f_base.len = 0;
	    f.f_suffix.ptr = 0;
	    f.f_suffix.len = 0;
	}
	else
	{
	    /* normal file with a suffix */
	    f.f_dir.ptr = 0;
	    f.f_dir.len = 0;
	    f.f_base.ptr = xnam.nam$l_name;
	    f.f_base.len = xnam.nam$b_name;
	    f.f_suffix.ptr = xnam.nam$l_type;
	    f.f_suffix.len = xnam.nam$b_type;
	}

	file_build( &f, filename2, 0 );

	/*
	if( DEBUG_SEARCH )
	    printf("root '%s' base %.*s suf %.*s = %s\n",
		    dir,
		    xnam.nam$b_name, xnam.nam$l_name, 
		    xnam.nam$b_type, xnam.nam$l_type,
		    filename2);
	*/

	(*func)( filename2, 1 /* time valid */, time );
    }

    if ( status != RMS$_NMF && status != RMS$_FNF )
	lib$signal( xfab.fab$l_sts, xfab.fab$l_stv );
}    

int
file_time( filename, time )
char	*filename;
time_t	*time;
{
	/* This should never be called, as all files are */
	/* timestampped in file_dirscan() and file_archscan() */
	return -1;
}

static char *VMS_archive = 0;
static void (*VMS_func)() = 0;
static void *context;

static int
file_archmember( module, rfa )
struct dsc$descriptor_s *module;
unsigned long *rfa;
{
    static struct dsc$descriptor_s bufdsc =
		  {0, DSC$K_DTYPE_T, DSC$K_CLASS_S, NULL};

    struct mhddef *mhd;
    char filename[128];
    char buf[ MAXJPATH ];

    int library_date, status;

    register int i;
    register char *p;

    bufdsc.dsc$a_pointer = filename;
    bufdsc.dsc$w_length = sizeof( filename );
    status = lbr$set_module( &context, rfa, &bufdsc,
			     &bufdsc.dsc$w_length, NULL );
    if ( !(status & 1) )
	return ( 1 );

    mhd = (struct mhddef *)filename;

    file_cvttime( &mhd->mhd$l_datim, &library_date );

    for ( i = 0, p = module->dsc$a_pointer; i < module->dsc$w_length; i++, p++ )
	filename[i] = *p;

    filename[i] = '\0';

    sprintf( buf, "%s(%s.obj)", VMS_archive, filename );

    (*VMS_func)( buf, 1 /* time valid */, (time_t)library_date );

    return ( 1 );
}

void
file_archscan( archive, func )
char *archive;
void (*func)();
{
    static struct dsc$descriptor_s library =
		  {0, DSC$K_DTYPE_T, DSC$K_CLASS_S, NULL};

    unsigned long lfunc = LBR$C_READ;
    unsigned long typ = LBR$C_TYP_UNK;
    unsigned long index = 1;

    register status;

    VMS_archive = archive;
    VMS_func = func;

    status = lbr$ini_control( &context, &lfunc, &typ, NULL );
    if ( !( status & 1 ) )
	return;

    library.dsc$a_pointer = archive;
    library.dsc$w_length = strlen( archive );

    status = lbr$open( &context, &library, NULL, NULL, NULL, NULL, NULL );
    if ( !( status & 1 ) )
	return;

    (void) lbr$get_index( &context, &index, file_archmember, NULL );

    (void) lbr$close( &context );
}

# endif /* VMS */

./src/glob.c100440    167    454        4637  7102105137  11367 0ustar  laurateam/*
 * Copyright 1994 Christopher Seiwald.  All rights reserved. 
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

/*
 * glob.c - match a string against a simple pattern
 *
 * Understands the following patterns:
 *
 *	*	any number of characters
 *	?	any single character
 *	[a-z]	any single character in the range a-z
 *	[^a-z]	any single character not in the range a-z
 *	\x	match x
 *	
 * External functions:
 *
 *	glob() - match a string against a simple pattern
 *
 * Internal functions:
 *
 *	globchars() - build a bitlist to check for character group match
 */

# include "jam.h"

# define CHECK_BIT( tab, bit ) ( tab[ (bit)/8 ] & (1<<( (bit)%8 )) )
# define BITLISTSIZE 16	/* bytes used for [chars] in compiled expr */

static void globchars();

/*
 * glob() - match a string against a simple pattern
 */

int
glob( c, s )
register char *c;
register char *s;
{
	char bitlist[ BITLISTSIZE ];
	char *here;

	for( ;; )
	    switch( *c++ )
	{
	case '\0':
		return *s ? -1 : 0;

	case '?':
		if( !*s++ )
		    return 1;
		break;

	case '[':
		/* scan for matching ] */

		here = c;
		do if( !*c++ )
			return 1;
		while( here == c || *c != ']' );
		c++;

		/* build character class bitlist */

		globchars( here, c, bitlist );

		if( !CHECK_BIT( bitlist, *(unsigned char *)s ) )
			return 1;
		s++;
		break;

	case '*':
		here = s;

		while( *s ) 
			s++;

		/* Try to match the rest of the pattern in a recursive */
		/* call.  If the match fails we'll back up chars, retrying. */

		while( s != here )
		{
			int r;

			/* A fast path for the last token in a pattern */

			r = *c ? glob( c, s ) : *s ? -1 : 0;

			if( !r )
				return 0;
			else if( r < 0 )
				return 1;

			--s;
		}
		break;

	case '\\':
		/* Force literal match of next char. */

		if( !*c || *s++ != *c++ )
		    return 1;
		break;

	default:
		if( *s++ != c[-1] )
		    return 1;
		break;
	}
}

/*
 * globchars() - build a bitlist to check for character group match
 */

static void
globchars( s, e, b )
char *s, *e, *b;
{
	int neg = 0;

	memset( b, '\0', BITLISTSIZE  );

	if( *s == '^') 
		neg++, s++;

	while( s < e )
	{
		int c;

		if( s+2 < e && s[1] == '-' )
		{
			for( c = s[0]; c <= s[2]; c++ )
				b[ c/8 ] |= (1<<(c%8));
			s += 3;
		} else {
			c = *s++;
			b[ c/8 ] |= (1<<(c%8));
		}
	}
			
	if( neg )
	{
		int i;
		for( i = 0; i < BITLISTSIZE; i++ )
			b[ i ] ^= 0377;
	}

	/* Don't include \0 in either $[chars] or $[^chars] */

	b[0] &= 0376;
}
./src/hash.c100440    167    454       12102  7102105137  11371 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

# include "jam.h"
# include "hash.h"

/* 
 * hash.c - simple in-memory hashing routines 
 *
 * External routines:
 *
 *     hashinit() - initialize a hash table, returning a handle
 *     hashitem() - find a record in the table, and optionally enter a new one
 *     hashdone() - free a hash table, given its handle
 *
 * Internal routines:
 *
 *     hashrehash() - resize and rebuild hp->tab, the hash table
 *
 * 4/29/93 - ensure ITEM's are aligned
 */

char 	*hashsccssid="@(#)hash.c	1.14  ()  6/20/88";

/* Header attached to all data items entered into a hash table. */

struct hashhdr {
	struct item *next;
	int keyval;			/* for quick comparisons */
} ;

/* This structure overlays the one handed to hashenter(). */
/* It's actual size is given to hashinit(). */

struct hashdata {
	char	*key;
	/* rest of user data */
} ;

typedef struct item {
	struct hashhdr hdr;
	struct hashdata data;
} ITEM ;

# define MAX_LISTS 32

struct hash 
{
	/*
	 * the hash table, just an array of item pointers
	 */
	struct {
		int nel;
		ITEM **base;
	} tab;

	int bloat;	/* tab.nel / items.nel */
	int inel; 	/* initial number of elements */

	/*
	 * the array of records, maintained by these routines
	 * essentially a microallocator
	 */ 
	struct {
		int more;	/* how many more ITEMs fit in lists[ list ] */
		char *next;	/* where to put more ITEMs in lists[ list ] */
		int datalen;	/* length of records in this hash table */
		int size;	/* sizeof( ITEM ) + aligned datalen */
		int nel;	/* total ITEMs held by all lists[] */
		int list;	/* index into lists[] */

		struct {
			int nel;	/* total ITEMs held by this list */
			char *base;	/* base of ITEMs array */
		} lists[ MAX_LISTS ];
	} items;

	char *name;	/* just for hashstats() */
} ;

static void hashrehash();
static void hashstat();

/*
 * hashitem() - find a record in the table, and optionally enter a new one
 */

int
hashitem( hp, data, enter )
register struct hash *hp;
HASHDATA **data;
{
	ITEM **base;
	register ITEM *i;
	char *b = (*data)->key;
	int keyval;

	if( enter && !hp->items.more )
	    hashrehash( hp );

	if( !enter && !hp->items.nel )
	    return 0;

	keyval = *b;

	while( *b )
		keyval = keyval * 2147059363 + *b++;

	keyval &= 0x7FFFFFFF;

	base = hp->tab.base + ( keyval % hp->tab.nel );

	for( i = *base; i; i = i->hdr.next )
	    if( keyval == i->hdr.keyval && 
		!strcmp( i->data.key, (*data)->key ) )
	{
		*data = &i->data;
		return !0;
	}

	if( enter ) 
	{
		i = (ITEM *)hp->items.next;
		hp->items.next += hp->items.size;
		hp->items.more--;
		memcpy( (char *)&i->data, (char *)*data, hp->items.datalen );
		i->hdr.keyval = keyval;
		i->hdr.next = *base;
		*base = i;
		*data = &i->data;
	}

	return 0;
}

/*
 * hashrehash() - resize and rebuild hp->tab, the hash table
 */

static void hashrehash( hp )
register struct hash *hp;
{
	int i = ++hp->items.list;

	hp->items.more = i ? 2 * hp->items.nel : hp->inel;
	hp->items.next = (char *)malloc( hp->items.more * hp->items.size );

	hp->items.lists[i].nel = hp->items.more;
	hp->items.lists[i].base = hp->items.next;
	hp->items.nel += hp->items.more;

	if( hp->tab.base )
		free( (char *)hp->tab.base );

	hp->tab.nel = hp->items.nel * hp->bloat;
	hp->tab.base = (ITEM **)malloc( hp->tab.nel * sizeof(ITEM **) );

	memset( (char *)hp->tab.base, '\0', hp->tab.nel * sizeof( ITEM * ) );

	for( i = 0; i < hp->items.list; i++ )
	{
		int nel = hp->items.lists[i].nel;
		char *next = hp->items.lists[i].base;

		for( ; nel--; next += hp->items.size )
		{
			register ITEM *i = (ITEM *)next;
			ITEM **ip = hp->tab.base + i->hdr.keyval % hp->tab.nel;

			i->hdr.next = *ip;
			*ip = i;
		}
	}
}

/* --- */

# define ALIGNED(x) ( ( x + sizeof( ITEM ) - 1 ) & ~( sizeof( ITEM ) - 1 ) )

/*
 * hashinit() - initialize a hash table, returning a handle
 */

struct hash *
hashinit( datalen, name )
char *name;
{
	struct hash *hp = (struct hash *)malloc( sizeof( *hp ) );

	hp->bloat = 3;
	hp->tab.nel = 0;
	hp->tab.base = (ITEM **)0;
	hp->items.more = 0;
	hp->items.datalen = datalen;
	hp->items.size = sizeof( struct hashhdr ) + ALIGNED( datalen );
	hp->items.list = -1;
	hp->items.nel = 0;
	hp->inel = 11;
	hp->name = name;

	return hp;
}

/*
 * hashdone() - free a hash table, given its handle
 */

void
hashdone( hp )
struct hash *hp;
{
	int i;

	if( !hp )
	    return;

	if( DEBUG_MEM )
	    hashstat( hp );

	if( hp->tab.base )
		free( (char *)hp->tab.base );
	for( i = 0; i <= hp->items.list; i++ )
		free( hp->items.lists[i].base );
	free( (char *)hp );
}

/* ---- */

static void
hashstat( hp )
struct hash *hp;
{
	ITEM **tab = hp->tab.base;
	int nel = hp->tab.nel;
	int count = 0;
	int sets = 0;
	int run = ( tab[ nel - 1 ] != (ITEM *)0 );
	int i, here;

	for( i = nel; i > 0; i-- )
	{
		if( here = ( *tab++ != (ITEM *)0 ) )
			count++;
		if( here && !run )
			sets++;
		run = here;
	}

	printf( "%s table: %d+%d+%d (%dK+%dK) items+table+hash, %f density\n",
		hp->name, 
		count, 
		hp->items.nel,
		hp->tab.nel,
		hp->items.nel * hp->items.size / 1024,
		hp->tab.nel * sizeof( ITEM ** ) / 1024,
		(float)count / (float)sets );
}
./src/hash.h100440    167    454         603  7102105137  11341 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

/*
 * hash.h - simple in-memory hashing routines 
 */

typedef struct hashdata HASHDATA;

struct hash *	hashinit();
int		hashitem();
void		hashdone();

# define	hashenter( hp, data ) !hashitem( hp, data, !0 )
# define	hashcheck( hp, data ) hashitem( hp, data, 0 )
./src/headers.c100440    167    454        5021  7102105137  12043 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

# include "jam.h"
# include "lists.h"
# include "parse.h"
# include "compile.h"
# include "rules.h"
# include "variable.h"
# include "regexp.h"
# include "headers.h"
# include "newstr.h"

/*
 * headers.c - handle #includes in source files
 *
 * Using regular expressions provided as the variable $(HDRSCAN), 
 * headers() searches a file for #include files and phonies up a
 * rule invocation:
 * 
 *	$(HDRRULE) <target> : <include files> ;
 *
 * External routines:
 *    headers() - scan a target for include files and call HDRRULE
 *
 * Internal routines:
 *    headers1() - using regexp, scan a file and build include LIST
 *
 * 04/13/94 (seiwald) - added shorthand L0 for null list pointer
 */

static LIST *headers1();

/*
 * headers() - scan a target for include files and call HDRRULE
 */

# define MAXINC 10

void
headers( t )
TARGET *t;
{
	LIST	*hdrscan;
	LIST	*hdrrule;
	LIST	*headlist = 0;
	PARSE	p[3];
	regexp	*re[ MAXINC ];
	int	rec = 0;

	if( !( hdrscan = var_get( "HDRSCAN" ) ) || 
	    !( hdrrule = var_get( "HDRRULE" ) ) )
	        return;

	if( DEBUG_HEADER )
	    printf( "header scan %s\n", t->name );

	/* Compile all regular expressions in HDRSCAN */

	while( rec < MAXINC && hdrscan )
	{
	    re[rec++] = regcomp( hdrscan->string );
	    hdrscan = list_next( hdrscan );
	}

	/* Doctor up call to HDRRULE rule */
	/* Call headers1() to get LIST of included files. */

	p[0].string = hdrrule->string;
	p[0].left = &p[1];
	p[1].llist = list_new( L0, t->name );
	p[1].left = &p[2];
	p[2].llist = headers1( headlist, t->boundname, rec, re );
	p[2].left = 0;

	if( p[2].llist )
	{
	    LOL lol0;
	    lol_init( &lol0 );
	    compile_rule( p, &lol0 );
	}

	/* Clean up */

	list_free( p[1].llist );
	list_free( p[2].llist );

	while( rec )
	    free( (char *)re[--rec] );
}

/*
 * headers1() - using regexp, scan a file and build include LIST
 */

static LIST *
headers1( l, file, rec, re )
LIST	*l;
char	*file;
int	rec;
regexp	*re[];
{
    FILE	*f;
    char	buf[ 1024 ];
    int		i;

    if( !( f = fopen( file, "r" ) ) )
	return l;

    while( fgets( buf, sizeof( buf ), f ) )
    {
	for( i = 0; i < rec; i++ )
	    if( regexec( re[i], buf ) && re[i]->startp[1] )
	{
	    re[i]->endp[1][0] = '\0';

	    if( DEBUG_HEADER )
		printf( "header found: %s\n", re[i]->startp[1] );

	    l = list_new( l, newstr( re[i]->startp[1] ) );
	}
    }

    fclose( f );

    return l;
}

void
regerror( s )
char *s;
{
	printf( "re error %s\n", s );
}
./src/headers.h100440    167    454         303  7102105137  12026 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

/*
 * headers.h - handle #includes in source files
 */

void headers();
./src/jam.c100440    167    454       21575  7102105137  11233 0ustar  laurateam/*
 * /+\
 * +\	Copyright 1993, 1996 Christopher Seiwald.
 * \+/
 *
 * This file is part of jam.
 *
 * License is hereby granted to use this software and distribute it
 * freely, as long as this copyright notice is retained and modifications 
 * are clearly marked.
 *
 * ALL WARRANTIES ARE HEREBY DISCLAIMED.
 */

# include "jam.h"
# include "option.h"
# include "make.h"
# ifdef FATFS
# include "patchlev.h"
# else
# include "patchlevel.h"
# endif

/* These get various function declarations. */

# include "lists.h"
# include "parse.h"
# include "variable.h"
# include "compile.h"
# include "rules.h"
# include "newstr.h"
# include "scan.h"
# ifdef FATFS
# include "timestam.h"
# else
# include "timestamp.h"
# endif

/* Macintosh is "special" */

# ifdef macintosh
# include <QuickDraw.h>
# endif

/* And UNIX for this */

# ifdef unix
# include <sys/utsname.h>
# endif

/*
 * jam.c - make redux
 *
 * See jam(1) and Jamfile(5) for usage information.
 *
 * These comments document the code.
 *
 * The top half of the code is structured such:
 *
 *                       jam 
 *                      / | \ 
 *                 +---+  |  \
 *                /       |   \ 
 *         jamgram     option  \ 
 *        /  |   \              \
 *       /   |    \              \
 *      /    |     \             |
 *  scan     |     compile      make
 *   |       |    /    \       / |  \
 *   |       |   /      \     /  |   \
 *   |       |  /        \   /   |    \
 * jambase parse         rules  search make1
 *                               |	|   \
 *                               |	|    \
 *                               |	|     \
 *                           timestamp command execute
 *
 *
 * The support routines are called by all of the above, but themselves
 * are layered thus:
 *
 *                     variable|expand
 *                      /  |   |   |
 *                     /   |   |   |
 *                    /    |   |   |
 *                 lists   |   |   filesys
 *                    \    |   |
 *                     \   |   |
 *                      \  |   |
 *                     newstr  |
 *                        \    |
 *                         \   |
 *                          \  |
 *                          hash
 *
 * Roughly, the modules are:
 *
 *	command.c - maintain lists of commands
 *	compile.c - compile parsed jam statements
 *	execunix.c - execute a shell script on UNIX
 *	execvms.c - execute a shell script, ala VMS
 *	expand.c - expand a buffer, given variable values
 *	fileunix.c - manipulate file names and scan directories on UNIX
 *	filevms.c - manipulate file names and scan directories on VMS
 *	hash.c - simple in-memory hashing routines 
 *	headers.c - handle #includes in source files
 *	jambase.c - compilable copy of Jambase
 *	jamgram.y - jam grammar
 *	lists.c - maintain lists of strings
 *	make.c - bring a target up to date, once rules are in place
 *	make1.c - execute command to bring targets up to date
 *	newstr.c - string manipulation routines
 *	option.c - command line option processing
 *	parse.c - make and destroy parse trees as driven by the parser
 *	regexp.c - Henry Spencer's regexp
 *	rules.c - access to RULEs, TARGETs, and ACTIONs
 *	scan.c - the jam yacc scanner
 *	search.c - find a target along $(SEARCH) or $(LOCATE) 
 *	timestamp.c - get the timestamp of a file or archive member
 *	variable.c - handle jam multi-element variables
 *
 * 05/04/94 (seiwald) - async multiprocess (-j) support
 * 02/08/95 (seiwald) - -n implies -d2.
 * 02/22/95 (seiwald) - -v for version info.
 */

struct globs globs = {
	0,			/* noexec */
	1,			/* jobs */
# ifdef macintosh
	{ 0, 0 },		/* debug - suppress tracing output */
# else
	{ 0, 1 }, 		/* debug ... */
# endif
	0			/* output commands, not run them */
} ;

/* Symbols to be defined as true for use in Jambase */

static char *othersyms[] = { OSSYMS OSPLATSYM, JAMVERSYM, 0 } ;

# ifndef __WATCOM__
# ifndef __OS2__
# ifndef NT
extern char **environ;
# endif
# endif
# endif

# ifdef macintosh
# ifdef MPW
QDGlobals qd;
# endif
main( int argc, char **argv, char **environ )
# else
main( argc, argv )
char	**argv;
# endif
{
	int		n;
	char		*s;
	struct option	optv[N_OPTS];
	char		*all = "all";
	int		anyhow = 0;
	int		status;

# ifdef macintosh
	InitGraf(&qd.thePort);
# endif

	argc--, argv++;

	if( ( n = getoptions( argc, argv, "d:j:f:s:t:ano:v", optv ) ) < 0 )
	{
	    printf( "\nusage: jam [ options ] targets...\n\n" );

            printf( "-a      Build all targets, even if they are current.\n" );
            printf( "-dx     Set the debug level to x (0-9).\n" );
            printf( "-fx     Read x instead of Jambase.\n" );
            printf( "-jx     Run up to x shell commands concurrently.\n" );
            printf( "-n      Don't actually execute the updating actions.\n" );
            printf( "-ox     Write the updating actions to file x.\n" );
	    printf( "-sx=y   Set variable x=y, overriding environment.\n" );
            printf( "-tx     Rebuild x, even if it is up-to-date.\n" );
            printf( "-v      Print the version of jam and exit.\n\n" );

	    exit( EXITBAD );
	}

	argc -= n, argv += n;

	/* Version info. */

	if( ( s = getoptval( optv, 'v', 0 ) ) )
	{
	    printf( "Jam/MR  " );
	    printf( "Version %s.%s.  ", VERSION, PATCHLEVEL );
	    printf( "Copyright 1993, 1999 Christopher Seiwald.\n" );

	    return EXITOK;
	}

	/* Pick up interesting options */

	if( ( s = getoptval( optv, 'n', 0 ) ) )
	    globs.noexec++, globs.debug[2] = 1;

	if( ( s = getoptval( optv, 'a', 0 ) ) )
	    anyhow++;

	if( ( s = getoptval( optv, 'j', 0 ) ) )
	    globs.jobs = atoi( s );

	/* Turn on/off debugging */

	for( n = 0; s = getoptval( optv, 'd', n ); n++ )
	{
	    int i;

	    /* First -d, turn off defaults. */

	    if( !n )
		for( i = 0; i < DEBUG_MAX; i++ )
		    globs.debug[i] = 0;

	    i = atoi( s );

	    if( i < 0 || i >= DEBUG_MAX )
	    {
		printf( "Invalid debug level '%s'.\n", s );
		continue;
	    }

	    /* n turns on levels 1-n */
	    /* +n turns on level n */

	    if( *s == '+' )
		globs.debug[i] = 1;
	    else while( i )
		globs.debug[i--] = 1;
	}

	/* Set JAMDATE first */

	{
	    char *date;
	    time_t clock;
	    time( &clock );
	    date = newstr( ctime( &clock ) );

	    /* Trim newline from date */

	    if( strlen( date ) == 25 )
		date[ 24 ] = 0;

	    var_set( "JAMDATE", list_new( L0, newstr( date ) ), VAR_SET );
	}

	/* And JAMUNAME */
# ifdef unix
	{
	    struct utsname u;

	    if( uname( &u ) >= 0 )
	    {
		var_set( "JAMUNAME", 
			list_new( 
			list_new(
			list_new(
			list_new(
			list_new( L0, 
				newstr( u.sysname ) ),
				newstr( u.nodename ) ),
				newstr( u.release ) ),
				newstr( u.version ) ),
				newstr( u.machine ) ), VAR_SET );
	    }
	}
# endif /* unix */

	/* load up environment variables */

# ifdef MPW
	/*
	 * The third parameter of main() on the mac (at least when this
	 * is compiled with MPW tools) does not have entries of the form
	 * "name=value", but instead "name\0value".  Since var_defines()
	 * expects the former, we need to munge them before passing.
	 */
	{
	    char **munged, **src, **dest;
	    int envsize;

	    /* First determine the size of environ */
	    for( src = environ, envsize = 1; *src; src++, envsize++ );
	    munged = malloc( sizeof( char* ) * envsize );

	    for( src = environ, dest = munged; *src; src++, dest++ )
	    {
	    	/*
		 * Can't use strlen() to find the length of the environ
		 * entries without finding the first \0, and adding the
		 * lengths of the "name" and "value" parts (taking into
		 * account the terminating \0's.
		 */
		char *first0;
		int lenplusterminator;
		for( first0 = *src; *first0; first0++ );

		lenplusterminator = 2 + (first0-*src) + strlen(first0+1);
		*dest = malloc( lenplusterminator );
		memcpy( *dest, *src, lenplusterminator);
		*(*dest + (first0-*src)) = '=';
	    }
	    *dest = NULL;
	    var_defines( munged );
	}
# else
	var_defines( environ );
# endif
	var_defines( othersyms );

	/* Load up variables set on command line. */

	for( n = 0; s = getoptval( optv, 's', n ); n++ )
	{
	    char *symv[2];
	    symv[0] = s;
	    symv[1] = 0;
	    var_defines( symv );
	}

	/* Initialize builtins */

	compile_builtins();

	/* Parse ruleset */

	for( n = 0; s = getoptval( optv, 'f', n ); n++ )
	    parse_file( s );

	if( !n )
	    parse_file( "+" );

	status = yyanyerrors();

	/* Manually touch -t targets */

	for( n = 0; s = getoptval( optv, 't', n ); n++ )
	    touchtarget( s );

	/* If an output file is specified, set globs.cmdout to that */

	if( s = getoptval( optv, 'o', 0 ) )
	{
	    if( !( globs.cmdout = fopen( s, "w" ) ) )
	    {
		printf( "Failed to write to '%s'\n", s );
		exit( EXITBAD );
	    }
	    globs.noexec++;
	}

	/* Now make target */

	if( !argc )
	    status |= make( 1, &all, anyhow );
	else
	    status |= make( argc, argv, anyhow );

	/* Widely scattered cleanup */

	var_done();
	donerules();
	donestamps();
	donestr();

	/* close cmdout */

	if( globs.cmdout )
	    fclose( globs.cmdout );

	return status ? EXITBAD : EXITOK;
}
./src/jam.h100440    167    454       17353  7102105137  11237 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

/*
 * jam.h - includes and globals for jam
 *
 * 04/08/94 (seiwald) - Coherent/386 support added.
 * 04/21/94 (seiwald) - DGUX is __DGUX__, not just __DGUX.
 * 05/04/94 (seiwald) - new globs.jobs (-j jobs)
 * 11/01/94 (wingerd) - let us define path of Jambase at compile time.
 * 12/30/94 (wingerd) - changed command buffer size for NT (MS-DOS shell).
 * 02/22/95 (seiwald) - Jambase now in /usr/local/lib.
 * 04/30/95 (seiwald) - FreeBSD added.  Live Free or Die.
 * 05/10/95 (seiwald) - SPLITPATH character set up here.
 * 08/20/95 (seiwald) - added LINUX.
 * 08/21/95 (seiwald) - added NCR.
 * 10/23/95 (seiwald) - added SCO.
 * 01/03/96 (seiwald) - SINIX (nixdorf) added.
 * 03/13/96 (seiwald) - Jambase now compiled in; remove JAMBASE variable.
 * 04/29/96 (seiwald) - AIX now has 31 and 42 OSVERs.
 * 11/21/96 (peterk)  - added BeOS with MW CW mwcc
 * 12/21/96 (seiwald) - OSPLAT now defined for NT.
 * 07/19/99 (sickel)  - Mac OS X Server and Client support added
 */

# ifdef VMS

int unlink( char *f ); 	/* In filevms.c */

# include <types.h>
# include <file.h>
# include <stat.h>
# include <stdio.h>
# include <ctype.h>
# include <stdlib.h>
# include <signal.h>
# include <string.h>
# include <time.h>
# include <unixlib.h>

# ifdef __DECC
# define OSSYMS "VMS=true","OS=OPENVMS"
# else
# define OSSYMS "VMS=true","OS=VMS"
# endif 

# define MAXLINE 1024 /* longest 'together' actions */
# define SPLITPATH ','
# define EXITOK 1
# define EXITBAD 0

# else

# ifdef NT

# include <fcntl.h>
# include <stdlib.h>
# include <stdio.h>
# include <ctype.h>
# include <malloc.h>
# include <memory.h>
# include <signal.h>
# include <string.h>
# include <time.h>

# define OSSYMS "NT=true","OS=NT"
# define SPLITPATH ';'
# define MAXLINE 996	/* longest 'together' actions */
# define EXITOK 0
# define EXITBAD 1

# else

# ifdef __OS2__

# include <fcntl.h>
# include <stdlib.h>
# include <stdio.h>
# include <ctype.h>
# include <malloc.h>
# include <signal.h>
# include <string.h>
# include <time.h>

# define OSSYMS "OS2=true","OS=OS2"
# define SPLITPATH ';'
# define MAXLINE 996	/* longest 'together' actions */
# define EXITOK 0
# define EXITBAD 1

# else

# ifdef __QNX__

# define unix

# include <fcntl.h>
# include <stdlib.h>
# include <stdio.h>
# include <ctype.h>
# include <malloc.h>
# include <signal.h>
# include <string.h>
# include <time.h>

# define OSSYMS "UNIX=true","OS=QNX"
# define SPLITPATH ':'
# define MAXLINE 996	/* longest 'together' actions */
# define EXITOK 0
# define EXITBAD 1

# else /* QNX */

# ifdef macintosh
# include <time.h>
# include <stdlib.h>
# include <string.h>
# include <stdio.h>

# define OSSYMS "MAC=true","OS=MAC"
# define SPLITPATH ','
# define MAXLINE 10240	/* longest 'together' actions */
# define EXITOK 0
# define EXITBAD 1

# else /* not MAC */

# include <sys/types.h>
# include <sys/file.h>
# include <sys/stat.h>
# include <fcntl.h>
# ifndef ultrix
# include <stdlib.h>
# endif
# include <stdio.h>
# include <ctype.h>
# if !defined(__bsdi__)&&!defined(__FreeBSD__)
# if !defined(NeXT)&&!defined(__MACHTEN__)&&!defined(__APPLE__)
# if !defined(MVS)
# include <malloc.h>
# endif
# endif
# endif
# include <memory.h>
# include <signal.h>
# include <string.h>
# include <time.h>

# ifdef _AIX
# define unix
# ifdef _AIX41
# define OSSYMS "UNIX=true","OS=AIX","OSVER=41"
# else
# define OSSYMS "UNIX=true","OS=AIX","OSVER=32"
# endif
# endif

# ifdef __BEOS__
# define OSSYMS "UNIX=true","OS=BEOS"
# define unix
# endif

# ifdef __bsdi__
# define OSSYMS "UNIX=true","OS=BSDI"
# endif
# if defined (COHERENT) && defined (_I386)
# define OSSYMS "UNIX=true","OS=COHERENT"
# endif
# ifdef __FreeBSD__
# define OSSYMS "UNIX=true","OS=FREEBSD"
# endif
# ifdef __DGUX__
# define OSSYMS "UNIX=true","OS=DGUX"
# endif
# ifdef __hpux
# define OSSYMS "UNIX=true","OS=HPUX"
# endif
# ifdef __OPENNT
# define unix
# define OSSYMS "UNIX=true","OS=INTERIX"
# endif
# ifdef __sgi
# define OSSYMS "UNIX=true","OS=IRIX"
# endif
# ifdef __ISC
# define OSSYMS "UNIX=true","OS=ISC"
# endif
# ifdef linux
# define OSSYMS "UNIX=true","OS=LINUX"
# endif
# ifdef __Lynx__
# define OSSYMS "UNIX=true","OS=LYNX"
# define unix
# endif
# ifdef __MACHTEN__
# define OSSYMS "UNIX=true","OS=MACHTEN"
# endif
# ifdef __MVS__
# define unix
# define OSSYMS "UNIX=true","OS=MVS"
# endif
# ifdef _ATT4
# define OSSYMS "UNIX=true","OS=NCR"
# endif
# ifdef NeXT
# ifdef __APPLE__
# define OSSYMS "UNIX=true","OS=RHAPSODY"
# else
# define OSSYMS "UNIX=true","OS=NEXT"
# endif
# endif
# ifdef __APPLE__
# define unix
# define OSSYMS "UNIX=true","OS=MACOSX"
# endif
# ifdef __osf__
# define OSSYMS "UNIX=true","OS=OSF"
# endif
# ifdef _SEQUENT_
# define OSSYMS "UNIX=true","OS=PTX"
# endif
# ifdef M_XENIX
# define OSSYMS "UNIX=true","OS=SCO"
# endif
# ifdef sinix
# define unix
# define OSSYMS "UNIX=true","OS=SINIX"
# endif
# ifdef sun
# if defined(__svr4__) || defined(__SVR4)
# define OSSYMS "UNIX=true","OS=SOLARIS"
# else
# define OSSYMS "UNIX=true","OS=SUNOS"
# endif
# endif
# ifdef ultrix
# define OSSYMS "UNIX=true","OS=ULTRIX"
# endif
# if defined(__USLC__) && !defined(M_XENIX)
# define OSSYMS "UNIX=true","OS=UNIXWARE"
# endif
# ifdef AMIGA
# define OSSYMS "UNIX=true","OS=AMIGA"
# endif
# ifndef OSSYMS
# define OSSYMS "UNIX=true","OS=UNKNOWN"
# endif

# define MAXLINE 10240	/* longest 'together' actions' */
# define SPLITPATH ':'
# define EXITOK 0
# define EXITBAD 1

# endif /* mac */

# endif /* QNX */

# endif /* OS/2 */

# endif /* NT */

# endif /* UNIX */

/* OSPLAT definitions - note the leading , */

# define OSPLATSYM /**/

# if defined( _M_PPC ) || defined( PPC ) || defined( ppc )
# undef OSPLATSYM
# define OSPLATSYM ,"OSPLAT=PPC"
# endif

# if defined( _ALPHA_ ) || defined( __alpha__ )
# undef OSPLATSYM
# define OSPLATSYM ,"OSPLAT=AXP"
# endif

# if defined( _i386_ ) || defined( __i386__ ) || defined( _M_IX86 )
# if !defined( __FreeBSD__ ) && !defined( __OS2__)
# undef OSPLATSYM
# define OSPLATSYM ,"OSPLAT=X86"
# endif
# endif 

# ifdef __sparc__
# undef OSPLATSYM
# define OSPLATSYM ,"OSPLAT=SPARC"
# endif

/* You probably don't need to muck with these. */

# define MAXSYM	1024	/* longest symbol in the environment */
# define MAXJPATH 1024	/* longest filename */

# define MAXJOBS 64	/* silently enforce -j limit */
# define MAXARGC 32	/* words in $(JAMSHELL) */

# define CMDBUF 10240	/* size of command blocks */

/* Jam private definitions below. */

# define DEBUG_MAX	10

struct globs {
	int	noexec;
	int	jobs;
	char	debug[DEBUG_MAX];
	FILE	*cmdout;		/* print cmds, not run them */
} ;

extern struct globs globs;

# define DEBUG_MAKE	( globs.debug[ 1 ] )	/* show actions when executed */
# define DEBUG_MAKEQ	( globs.debug[ 2 ] )	/* show even quiet actions */
# define DEBUG_EXEC	( globs.debug[ 2 ] )	/* show text of actons */
# define DEBUG_MAKEPROG	( globs.debug[ 3 ] )	/* show progress of make0 */
# define DEBUG_BIND	( globs.debug[ 3 ] )	/* show when files bound */

# define DEBUG_EXECCMD	( globs.debug[ 4 ] )	/* show execcmds()'s work */

# define DEBUG_COMPILE	( globs.debug[ 5 ] )	/* show rule invocations */

# define DEBUG_HEADER	( globs.debug[ 6 ] )	/* show result of header scan */
# define DEBUG_BINDSCAN	( globs.debug[ 6 ] )	/* show result of dir scan */
# define DEBUG_SEARCH	( globs.debug[ 6 ] )	/* show attempts at binding */

# define DEBUG_VARSET	( globs.debug[ 7 ] )	/* show variable settings */
# define DEBUG_VARGET	( globs.debug[ 8 ] )	/* show variable fetches */
# define DEBUG_VAREXP	( globs.debug[ 8 ] )	/* show variable expansions */
# define DEBUG_IF	( globs.debug[ 8 ] )	/* show 'if' calculations */
# define DEBUG_LISTS	( globs.debug[ 9 ] )	/* show list manipulation */
# define DEBUG_SCAN	( globs.debug[ 9 ] )	/* show scanner tokens */
# define DEBUG_MEM	( globs.debug[ 9 ] )	/* show memory use */

./src/jambase.c100440    167    454       73106  7102105140  12055 0ustar  laurateam/* Generated by mkjambase from Jambase */
char *jambase[] = {
/* Jambase */
"OSFULL = $(OS)$(OSPLAT)$(OSVER) $(OS)$(OSPLAT) $(OS)$(OSVER) $(OS) ;\n",
"switch $(OS)\n",
"{\n",
"case AIX :	LINKLIBS default = -lbsd ;\n",
"case DGUX :	RANLIB default = \"\" ; RELOCATE = true ;\n",
"case HPUX :	RANLIB default = \"\" ;\n",
"INSTALL default = \"\" ;\n",
"case INTERIX :	RANLIB default = \"\" ;\n",
"JAMSHELL default = \"sh -c\" ;\n",
"CC default = gcc ;\n",
"case IRIX :	RANLIB default = \"\" ;\n",
"INSTALL default = \"\" ;\n",
"case MVS :	RANLIB default = \"\" ; \n",
"case NEXT :	AR default = libtool -o ;\n",
"RANLIB default = \"\" ;\n",
"case MACOSX : AR default = libtool -o ;\n",
"RANLIB default = \"\" ;\n",
"C++ default = c++ ;\n",
"MANDIR default = /usr/local/share/man ;\n",
"case NCR :	RANLIB default = \"\" ;\n",
"INSTALL default = \"\" ;\n",
"case PTX :	RANLIB default = \"\" ;\n",
"case QNX :	INSTALL default = \"\" ;\n",
"case SCO :	RANLIB default = \"\" ;\n",
"INSTALL default = \"\" ; RELOCATE = true ;\n",
"case SINIX :	RANLIB default = \"\" ;\n",
"case SOLARIS :	RANLIB default = \"\" ;\n",
"INSTALL default = \"install\" ;\n",
"AR default = \"/usr/ccs/bin/ar ru\" ;\n",
"case UNIXWARE :	RANLIB default = \"\" ; RELOCATE = true ;\n",
"}\n",
"if $(UNIX)\n",
"{\n",
"if $(OS) = QNX \n",
"{\n",
"AR		default = wlib ;\n",
"CC		default = cc ;\n",
"CCFLAGS		default = -Q ;	# quiet\n",
"C++		default = $(CC) ;\n",
"C++FLAGS	default = -Q ;	# quiet\n",
"LINK		default = $(CC) ;\n",
"LINKFLAGS	default = -Q ;	# quiet\n",
"NOARSCAN	default = true ;\n",
"RANLIB		default = \"\" ;\n",
"}\n",
"else if $(OS) = BEOS && $(METROWERKS)\n",
"{\n",
"AR		default = mwld -xml -o ;\n",
"BINDIR		default = /boot/bin ;\n",
"CC		default = mwcc ;\n",
"CCFLAGS		default = -nosyspath ;\n",
"C++		default = $(CC) ;\n",
"C++FLAGS	default = -nosyspath ;\n",
"FORTRAN		default = \"\" ;\n",
"LIBDIR		default = /boot/develop/libraries ;\n",
"LINK		default = mwld ;\n",
"LINKFLAGS	default = \"\" ;\n",
"LEX		default = \"\" ;\n",
"MANDIR		default = /boot/documentation/\"Shell Tools\"/HTML ;\n",
"NOARSCAN	default = true ;\n",
"RANLIB		default = \"\" ;	\n",
"STDHDRS		default = /boot/develop/headers/posix ;\n",
"YACC		default = \"\" ;\n",
"YACCFLAGS	default = \"\" ;\n",
"YACCFILES	default = \"\" ;\n",
"}\n",
"else if $(OS) = BEOS \n",
"{\n",
"BINDIR		default = /boot/bin ;\n",
"CC		default = gcc ;\n",
"C++		default = $(CC) ;\n",
"FORTRAN		default = \"\" ;\n",
"LIBDIR		default = /boot/develop/libraries ;\n",
"LINK		default = gcc ;\n",
"LINKLIBS	default = -lnet ;\n",
"LEX		default = \"\" ;\n",
"NOARSCAN	default = true ;\n",
"RANLIB		default = \"\" ;	\n",
"STDHDRS		default = /boot/develop/headers/posix ;\n",
"YACC		default = \"\" ;\n",
"YACCFLAGS	default = \"\" ;\n",
"YACCFILES	default = \"\" ;\n",
"}\n",
"else if $(OS) = AMIGA\n",
"{\n",
"CC				default = gcc ;\n",
"YACC			default = bison ;\n",
"YACCFLAGS	default = -d ;\n",
"YACCFILES	default = y.tab ;\n",
"}\n",
"AR		default = ar ru ;\n",
"AS		default = as ;\n",
"AWK		default = awk ;\n",
"ASFLAGS		default = ;\n",
"BINDIR		default = /usr/local/bin ;\n",
"C++		default = gcc ;\n",
"C++FLAGS	default = ;\n",
"CC		default = cc ;\n",
"CCFLAGS		default = ;\n",
"CP		default = cp ;\n",
"CHMOD		default = chmod ;\n",
"DOT		default	= . ;\n",
"DOTDOT		default	= .. ;\n",
"EXEMODE		default = 711 ;\n",
"FILEMODE	default = 644 ;\n",
"FORTRAN		default = f77 ;\n",
"FORTRANFLAGS	default = ;\n",
"HDRS		default = ;\n",
"INSTALL		default = install -c ;\n",
"LEX		default = lex ;\n",
"LIBDIR		default = /usr/local/lib ;\n",
"LINK		default = $(CC) ;\n",
"LINKFLAGS	default = $(CCFLAGS) ;\n",
"LINKLIBS	default = ;\n",
"LN		default = ln ;\n",
"MANDIR		default = /usr/local/man ;\n",
"MKDIR		default = mkdir ;\n",
"MV		default = mv -f ;\n",
"OPTIM		default = -O ;\n",
"RANLIB		default = ranlib ;\n",
"RCP		default = rcp ;\n",
"RSH		default = rsh ;\n",
"RM		default = rm -f ;\n",
"SED		default = sed ;\n",
"SHELLHEADER	default = \"#!/bin/sh\" ;\n",
"SHELLMODE	default = 755 ;\n",
"SLASH		default = / ;\n",
"STDHDRS		default = /usr/include ;\n",
"SUFLIB		default = .a ;\n",
"SUFOBJ		default = .o ;\n",
"SUFEXE		default = \"\" ;\n",
"UNDEFFLAG	default = \"-u _\" ;\n",
"YACC		default = yacc ;\n",
"YACCFLAGS	default = -d ;\n",
"YACCFILES	default = y.tab ;\n",
"}\n",
"else if $(NT)\n",
"{\n",
"AWK		default = awk ;\n",
"CHMOD		default = chmod ;\n",
"CP		default = copy ;\n",
"DOT		default	= . ;\n",
"DOTDOT		default	= .. ;\n",
"EXEMODE		default = 711 ;\n",
"FILEMODE	default = 644 ;\n",
"MKDIR		default = mkdir ;\n",
"MV		default = mv -f ;\n",
"OS			= NT ;		# replace Windows_NT\n",
"RCP		default = rcp ;\n",
"RSH		default = rsh ;\n",
"RM		default = del /f/q ;\n",
"SED		default = sed ;\n",
"SLASH		default = \\\\ ;\n",
"SUFLIB		default = .lib ;\n",
"SUFOBJ		default = .obj ;\n",
"SUFEXE		default = .exe ;\n",
"if $(BCCROOT)\n",
"{\n",
"ECHO \"Compiler is Borland C++\" ;\n",
"AR		default = tlib ;\n",
"ARFLAGS		default = /C /P64 ;\n",
"CC		default = bcc32 ;\n",
"CCFLAGS		default = -v -w- -DNT ;\n",
"C++		default = bcc32 ;\n",
"C++FLAGS	default = -v -w- ;\n",
"LINK		default = $(CC) ;\n",
"LINKFLAGS	default = $(CCFLAGS) ;\n",
"STDLIBPATH	default = $(BCCROOT)\\\\lib ;\n",
"STDHDRS		default = $(BCCROOT)\\\\include ;\n",
"NOARSCAN	default = true ;\n",
"}\n",
"else if $(MSVC)\n",
"{\n",
"ECHO \"Compiler is Microsoft Visual C++ 16 bit\" ;\n",
"AR		default = lib /nologo ;\n",
"CC		default = cl /nologo ;\n",
"CCFLAGS		default = /D \\\"WIN\\\" ;\n",
"C++		default = $(CC) ;\n",
"C++FLAGS	default = $(CCFLAGS) ;\n",
"LINK		default = $(CC) ;\n",
"LINKFLAGS	default = $(CCFLAGS) ;\n",
"LINKLIBS	default = \n",
"$(MSVC)\\\\lib\\\\mlibce.lib\n",
"$(MSVC)\\\\lib\\\\oldnames.lib\n",
";\n",
"LINKLIBS	default = ;\n",
"NOARSCAN	default = true ;\n",
"OPTIM		default =  ;\n",
"STDHDRS		default = $(MSVC)\\\\include ;\n",
"UNDEFFLAG	default = \"/u _\" ;\n",
"}\n",
"else if $(MSVCNT)\n",
"{\n",
"ECHO \"Compiler is Microsoft Visual C++\" ;\n",
"AR		default = lib ;\n",
"AS		default = masm386 ;\n",
"CC		default = cl /nologo ;\n",
"CCFLAGS		default = ;\n",
"C++		default = $(CC) ;\n",
"C++FLAGS	default = $(CCFLAGS) ;\n",
"LINK		default = link ;\n",
"LINKFLAGS	default = ;\n",
"LINKLIBS	default = $(MSVCNT)\\\\lib\\\\advapi32.lib\n",
"$(MSVCNT)\\\\lib\\\\libc.lib\n",
"$(MSVCNT)\\\\lib\\\\oldnames.lib\n",
"$(MSVCNT)\\\\lib\\\\kernel32.lib ;\n",
"OPTIM		default =  ;\n",
"STDHDRS		default = $(MSVCNT)\\\\include ;\n",
"UNDEFFLAG	default = \"/u _\" ;\n",
"}\n",
"else\n",
"{\n",
"EXIT On NT, set BCCROOT, MSVCNT, or MSVC to the root of the\n",
"Borland or Microsoft directories. ;\n",
"}\n",
"}\n",
"else if $(OS2)\n",
"{\n",
"WATCOM		default = $(watcom) ;\n",
"CP		default = copy ;\n",
"DOT		default	= . ;\n",
"DOTDOT		default	= .. ;\n",
"MKDIR		default = mkdir ;\n",
"MV		default = move ;\n",
"RM		default = del /f ;\n",
"SED		default = sed ;\n",
"SLASH		default = \\\\ ;\n",
"SUFLIB		default = .lib ;\n",
"SUFOBJ		default = .obj ;\n",
"SUFEXE		default = .exe ;\n",
"if ! $(WATCOM)\n",
"{\n",
"EXIT On OS2, set WATCOM to the root of the Watcom directory. ;\n",
"}\n",
"ECHO \"OS2 compiler is Watcom.\" ;\n",
"AR		default = wlib ;\n",
"CC		default = wcc386 ;\n",
"CCFLAGS		default = /zq /DOS2 /I$(WATCOM)\\\\h ; # zq=quiet\n",
"C++		default = wpp386 ;\n",
"C++FLAGS	default = $(CCFLAGS) ;\n",
"LINK		default = wcl386 ;\n",
"LINKFLAGS	default = /zq ; # zq=quiet\n",
"LINKLIBS	default = ;\n",
"NOARSCAN	default = true ;\n",
"OPTIM		default = ;\n",
"STDHDRS		default = $(WATCOM)\\\\h ;\n",
"UNDEFFLAG	default = \"/u _\" ;\n",
"}\n",
"else if $(VMS)\n",
"{\n",
"AS		default = as ;\n",
"CC		default = cc ;\n",
"CCFLAGS		default = ;\n",
"CP		default = copy/replace ;\n",
"CRELIB		default = true ;\n",
"DOT		default	= [] ;\n",
"DOTDOT		default	= [-] ;\n",
"EXEMODE		default = (w:e) ;\n",
"FILEMODE	default = (w:r) ;\n",
"HDRS		default = ;\n",
"LEX		default = lex ;\n",
"LINK		default = link ;\n",
"LINKFLAGS	default = ;\n",
"LINKLIBS	default = ;\n",
"MV		default = rename ;\n",
"OPTIM		default = ;\n",
"RM		default = delete ;\n",
"RUNVMS		default = mcr ;\n",
"SED		default = sed ;\n",
"SHELLMODE	default = (w:er) ;\n",
"SLASH		default = . ;\n",
"STDHDRS		default = decc$library_include ;\n",
"SUFLIB		default = .olb ;\n",
"SUFOBJ		default = .obj ;\n",
"SUFEXE		default = .exe ;\n",
"switch $(OS) \n",
"{\n",
"case OPENVMS : CCFLAGS default = /stand=vaxc ;\n",
"case VMS     : LINKLIBS default = sys$library:vaxcrtl.olb/lib ;\n",
"}\n",
"}\n",
"else if $(MAC)\n",
"{\n",
"CW		default = \"{CW}\" ;\n",
"CWMAC		default = \"$(CW):MacOS Support\" ;\n",
"CWMSL		default = \"$(CW):Metrowerks Standard Library\" ;\n",
"CWGUSI		default = \"{CWGUSI}\" ;\n",
"CC		default = mwcppc ;\n",
"CCFLAGS		default = -eol -w off ;\n",
"C++		default = mwcppc ;\n",
"C++FLAGS	default = -eol -w off ;\n",
"CP		default = copy ;\n",
"DOT		default = \":\" ;\n",
"DOTDOT		default = \"::\" ;\n",
"HDRS		default = \"$(CWGUSI):include\"\n",
"\"$(CWMAC):Headers:Universal Headers\"\n",
"\"$(CWMAC):Headers:System Extras Headers:MPW Extras\"\n",
"\"$(CWMSL):MSL C:MSL Common:Public Includes\"\n",
"\"$(CWMSL):MSL C:MSL Mac:Public Includes\" ;\n",
"LINK		default = mwlinkppc ;\n",
"LINKFLAGS	default = -mpwtool -warn ;\n",
"LINKLIBS	default = \"$(CWGUSI):Lib:GUSIMPW.Lib.PPC\"\n",
"\"$(CWGUSI):Lib:MSLGUSI.Lib.PPC\"\n",
"\"$(CWMAC):Libraries:MacOS Common:Interfacelib\"\n",
"\"$(CWMAC):Libraries:MacOS PPC:PPCToolLibs.o\"\n",
"\"$(CWMAC):Libraries:MacOS Common:PLStringFuncs Glue:PLStringFuncsPPC.lib\"\n",
"\"$(CWMAC):Libraries:Runtime:Runtime PPC:MSL MPWCRuntime.lib\"\n",
"\"$(CWMSL):MSL C:Bin:MSL C.PPC MPW(NL).Lib\"\n",
"\"$(CWMAC):Libraries:MacOS Common:Mathlib\" ;\n",
"MKDIR		default = newfolder ;\n",
"MV		default = rename ;\n",
"NOARSCAN	default = true ;\n",
"OPTIM		default = ;\n",
"RM		default = delete ;\n",
"SLASH		default = \":\" ;\n",
"STDHDRS		default = ; #$(MWCIncludes) ;\n",
"SUFLIB		default = .lib ;\n",
"SUFOBJ		default = .o ;\n",
"SUFEXE		default = \"\" ;\n",
"NOARSCAN	default = true ;\n",
"}\n",
"if $(NT) || $(OS2)\n",
"{\n",
"MSLIB 		default = lib ;\n",
"MSLINK		default = link ;\n",
"MSIMPLIB 	default = implib ;\n",
"MSRC		default = rc ;\n",
"}\n",
"JAMFILE		default = Jamfile ;\n",
"JAMRULES	default = Jamrules ;\n",
"HDRPATTERN = \"^[ 	]*#[ 	]*include[ 	]*[<\\\"](.*)[\\\">].*$\" ;\n",
"DEPENDS all : shell files lib exe obj ;\n",
"DEPENDS all shell files lib exe obj : first ;\n",
"NOTFILE all first shell files lib exe obj dirs clean uninstall ;\n",
"ALWAYS clean uninstall ;\n",
"rule As\n",
"{\n",
"DEPENDS $(<) : $(>) ;\n",
"ASFLAGS on $(<) += $(ASFLAGS) $(SUBDIRASFLAGS) ;\n",
"}\n",
"rule Bulk\n",
"{\n",
"local i ;\n",
"for i in $(>)\n",
"{\n",
"File $(i:D=$(<)) : $(i) ;\n",
"}\n",
"}\n",
"rule Cc\n",
"{\n",
"local _h ;\n",
"DEPENDS $(<) : $(>) ;\n",
"CCFLAGS on $(<) += $(CCFLAGS) $(SUBDIRCCFLAGS) ;\n",
"if $(RELOCATE)\n",
"{\n",
"CcMv $(<) : $(>) ;\n",
"}\n",
"_h = $(SEARCH_SOURCE) $(HDRS) $(SUBDIRHDRS) ;\n",
"if $(VMS) && $(_h)\n",
"{\n",
"SLASHINC on $(<) = \"/inc=(\" $(_h[1]) ,$(_h[2-]) \")\" ;\n",
"}\n",
"else if $(MAC) && $(_h)\n",
"{\n",
"local _i _j ;\n",
"_j = $(_h[1]) ;\n",
"for _i in $(_h[2-])\n",
"{\n",
"_j = $(_j),$(_i) ;\n",
"}\n",
"MACINC on $(<) = \\\"$(_j)\\\" ;\n",
"}\n",
"}\n",
"rule C++\n",
"{\n",
"local _h ;\n",
"DEPENDS $(<) : $(>) ;\n",
"C++FLAGS on $(<) += $(C++FLAGS) $(SUBDIRC++FLAGS) ;\n",
"if $(RELOCATE)\n",
"{\n",
"CcMv $(<) : $(>) ;\n",
"}\n",
"_h = $(SEARCH_SOURCE) $(HDRS) $(SUBDIRHDRS) ;\n",
"if $(VMS) && $(_h)\n",
"{\n",
"SLASHINC on $(<) = \"/inc=(\" $(_h[1]) ,$(_h[2-]) \")\" ;\n",
"}\n",
"else if $(MAC) && $(_h)\n",
"{\n",
"local _i _j ;\n",
"_j = $(_h[1]) ;\n",
"for _i in $(_h[2-])\n",
"{\n",
"_j = $(_j),$(_i) ;\n",
"}\n",
"MACINC on $(<) = \\\"$(_j)\\\" ;\n",
"}\n",
"}\n",
"rule File\n",
"{\n",
"DEPENDS files : $(<) ;\n",
"DEPENDS $(<) : $(>) ;\n",
"SEARCH on $(>) = $(SEARCH_SOURCE) ;\n",
"MODE on $(<) = $(FILEMODE) ;\n",
"Chmod $(<) ;\n",
"}\n",
"rule Fortran\n",
"{\n",
"DEPENDS $(<) : $(>) ;\n",
"}\n",
"rule GenFile \n",
"{\n",
"local s ;\n",
"makeGristedName s : $(<) ;\n",
"Depends $(s) : $(>[1]:S=$(SUFEXE)) $(>[2-]) ;\n",
"GenFile1 $(s) : $(>[1]:S=$(SUFEXE)) $(>[2-]) ;\n",
"Clean clean : $(s) ;\n",
"}\n",
"rule GenFile1\n",
"{\n",
"MakeLocate $(<) : $(LOCATE_SOURCE) ;\n",
"SEARCH on $(>) = $(SEARCH_SOURCE) ;\n",
"}\n",
"rule HardLink\n",
"{\n",
"DEPENDS files : $(<) ;\n",
"DEPENDS $(<) : $(>) ;\n",
"SEARCH on $(>) = $(SEARCH_SOURCE) ;\n",
"}\n",
"rule HdrRule\n",
"{\n",
"local s ;\n",
"if $(HDRGRIST) \n",
"{ \n",
"s = $(>:G=$(HDRGRIST)) ;\n",
"} else { \n",
"s = $(>) ; \n",
"}\n",
"INCLUDES $(<) : $(s) ;\n",
"SEARCH on $(s) = $(HDRSEARCH) ;\n",
"NOCARE $(s) ;\n",
"HDRSEARCH on $(s) = $(HDRSEARCH) ;\n",
"HDRSCAN on $(s) = $(HDRSCAN) ;\n",
"HDRRULE on $(s) = $(HDRRULE) ;\n",
"HDRGRIST on $(s) = $(HDRGRIST) ;\n",
"}\n",
"rule InstallInto\n",
"{\n",
"local i t ;\n",
"t = $(>:G=installed) ;\n",
"DEPENDS install : $(t) ;\n",
"DEPENDS $(t) : $(>) ;\n",
"SEARCH on $(>) = $(SEARCH_SOURCE) ;\n",
"MakeLocate $(t) : $(<) ;\n",
"Clean uninstall : $(t) ;\n",
"for i in $(>)\n",
"{\n",
"Install $(i:G=installed) : $(i) ;\n",
"}\n",
"if ! $(INSTALL)\n",
"{\n",
"Chmod $(t) ;\n",
"if $(OWNER) { Chown $(t) ; OWNER on $(t) = $(OWNER) ; }\n",
"if $(GROUP) { Chgrp $(t) ; GROUP on $(t) = $(GROUP) ; }\n",
"}\n",
"}\n",
"rule InstallBin\n",
"{\n",
"InstallInto $(<) : $(>) ;\n",
"MODE on $(>:G=installed) = $(EXEMODE) ;\n",
"}\n",
"rule InstallFile\n",
"{\n",
"InstallInto $(<) : $(>) ;\n",
"MODE on $(>:G=installed) = $(FILEMODE) ;\n",
"}\n",
"rule InstallLib\n",
"{\n",
"InstallInto $(<) : $(>) ;\n",
"MODE on $(>:G=installed) = $(FILEMODE) ;\n",
"}\n",
"rule InstallMan\n",
"{\n",
"local i s d ;\n",
"for i in $(>)\n",
"{\n",
"switch $(i:S)\n",
"{\n",
"case .1 : s = 1 ; case .2 : s = 2 ; case .3 : s = 3 ;\n",
"case .4 : s = 4 ; case .5 : s = 5 ; case .6 : s = 6 ;\n",
"case .7 : s = 7 ; case .8 : s = 8 ; case .l : s = l ;\n",
"case .n : s = n ; case .man : s = 1 ;\n",
"}\n",
"d = man$(s) ;\n",
"InstallInto $(d:R=$(<)) : $(i) ;\n",
"}\n",
"MODE on $(>:G=installed) = $(FILEMODE) ;\n",
"}\n",
"rule InstallShell\n",
"{\n",
"InstallInto $(<) : $(>) ;\n",
"MODE on $(>:G=installed) = $(SHELLMODE) ;\n",
"}\n",
"rule Lex\n",
"{\n",
"DEPENDS $(<) : $(>) ;\n",
"MakeLocate $(<) : $(LOCATE_SOURCE) ;\n",
"Clean clean : $(<) ;\n",
"}\n",
"rule Library\n",
"{\n",
"LibraryFromObjects $(<) : $(>:S=$(SUFOBJ)) ;\n",
"Objects $(>) ;\n",
"}\n",
"rule LibraryFromObjects\n",
"{\n",
"local i l s ;\n",
"makeGristedName s : $(>) ;\n",
"l = $(<:S=$(SUFLIB)) ;\n",
"if $(KEEPOBJS)\n",
"{\n",
"DEPENDS obj : $(s) ;\n",
"}\n",
"else\n",
"{\n",
"DEPENDS lib : $(l) ;\n",
"}\n",
"if ! $(l:D)\n",
"{\n",
"MakeLocate $(l) $(l)($(s:BS)) : $(LOCATE_TARGET) ;\n",
"}\n",
"if $(NOARSCAN) \n",
"{ \n",
"DEPENDS $(l) : $(s) ;\n",
"}\n",
"else\n",
"{\n",
"DEPENDS $(l) : $(l)($(s:BS)) ;\n",
"for i in $(s)\n",
"{\n",
"DEPENDS $(l)($(i:BS)) : $(i) ;\n",
"}\n",
"}\n",
"Clean clean : $(l) ;\n",
"if $(CRELIB) { CreLib $(l) : $(s[1]) ; }\n",
"Archive $(l) : $(s) ;\n",
"if $(RANLIB) { Ranlib $(l) ; }\n",
"if ! ( $(NOARSCAN) || $(KEEPOBJS) ) { RmTemps $(l) : $(s) ; }\n",
"}\n",
"rule Link\n",
"{\n",
"MODE on $(<) = $(EXEMODE) ;\n",
"Chmod $(<) ;\n",
"}\n",
"rule LinkLibraries\n",
"{\n",
"local t ;\n",
"if $(<:S)\n",
"{\n",
"t = $(<) ;\n",
"} else {\n",
"t = $(<:S=$(SUFEXE)) ;\n",
"}\n",
"DEPENDS $(t) : $(>:S=$(SUFLIB)) ;\n",
"NEEDLIBS on $(t) += $(>:S=$(SUFLIB)) ;\n",
"}\n",
"rule Main\n",
"{\n",
"MainFromObjects $(<) : $(>:S=$(SUFOBJ)) ;\n",
"Objects $(>) ;\n",
"}\n",
"rule MainFromObjects\n",
"{\n",
"local s t ;\n",
"makeGristedName s : $(>) ;\n",
"makeSuffixed t $(SUFEXE) : $(<) ;\n",
"if $(t) != $(<)\n",
"{\n",
"DEPENDS $(<) : $(t) ;\n",
"NOTFILE $(<) ;\n",
"}\n",
"DEPENDS exe : $(t) ;\n",
"DEPENDS $(t) : $(s) ;\n",
"MakeLocate $(t) : $(LOCATE_TARGET) ;\n",
"Clean clean : $(t) ;\n",
"Link $(t) : $(s) ;\n",
"}\n",
"rule MakeLocate\n",
"{\n",
"if $(>)\n",
"{\n",
"LOCATE on $(<) = $(>) ;\n",
"Depends $(<) : $(>[1]) ;\n",
"MkDir $(>[1]) ;\n",
"}\n",
"}\n",
"rule MkDir\n",
"{\n",
"if $(<) != $(DOT) && ! $($(<)-mkdir) \n",
"{\n",
"local s ;\n",
"$(<)-mkdir = true ;\n",
"MkDir1 $(<) ;\n",
"NOUPDATE $(<) ;\n",
"Depends dirs : $(<) ;\n",
"s = $(<:P) ;\n",
"if $(NT)\n",
"{\n",
"switch $(s)\n",
"{\n",
"case *:   : s = ;\n",
"case *:\\\\ : s = ;\n",
"}\n",
"}\n",
"if $(s) && $(s) != $(<)\n",
"{\n",
"Depends $(<) : $(s) ;\n",
"MkDir $(s) ;\n",
"}\n",
"else if $(s)\n",
"{\n",
"NOTFILE $(s) ;\n",
"}\n",
"}\n",
"}\n",
"rule Object\n",
"{\n",
"local h ;\n",
"Clean clean : $(<) ;\n",
"MakeLocate $(<) : $(LOCATE_TARGET) ;\n",
"SEARCH on $(>) = $(SEARCH_SOURCE) ;\n",
"HDRS on $(<) = $(SEARCH_SOURCE) $(HDRS) $(SUBDIRHDRS) ;\n",
"if $(SEARCH_SOURCE)\n",
"{\n",
"h = $(SEARCH_SOURCE) ;\n",
"}\n",
"else\n",
"{\n",
"h = \"\" ;\n",
"}\n",
"HDRRULE on $(>) = HdrRule ;\n",
"HDRSCAN on $(>) = $(HDRPATTERN) ;\n",
"HDRSEARCH on $(>) = $(HDRS) $(SUBDIRHDRS) $(h) $(STDHDRS) ;\n",
"HDRGRIST on $(>) = $(HDRGRIST) ;\n",
"switch $(>:S)\n",
"{\n",
"case .asm : As $(<) : $(>) ;\n",
"case .c :	Cc $(<) : $(>) ;\n",
"case .C :	C++ $(<) : $(>) ;\n",
"case .cc :	C++ $(<) : $(>) ;\n",
"case .cpp : C++ $(<) : $(>) ;\n",
"case .f :	Fortran $(<) : $(>) ;\n",
"case .l :	Cc $(<) : $(<:S=.c) ;\n",
"Lex $(<:S=.c) : $(>) ;\n",
"case .s :	As $(<) : $(>) ;\n",
"case .y :	Cc $(<) : $(<:S=.c) ;\n",
"Yacc $(<:S=.c) : $(>) ;\n",
"case * :	UserObject $(<) : $(>) ;\n",
"}\n",
"}\n",
"rule ObjectCcFlags\n",
"{\n",
"local s ;\n",
"makeGristedName s : $(<:S=$(SUFOBJ)) ;\n",
"CCFLAGS on $(s) += $(>) ;\n",
"}\n",
"rule ObjectC++Flags\n",
"{\n",
"local s ;\n",
"makeGristedName s : $(<:S=$(SUFOBJ)) ;\n",
"C++FLAGS on $(s) += $(>) ;\n",
"}\n",
"rule ObjectHdrs\n",
"{\n",
"local s ;\n",
"makeGristedName s : $(<:S=$(SUFOBJ)) ;\n",
"HDRS on $(s) += $(>) ;\n",
"}\n",
"rule Objects\n",
"{\n",
"local i s ;\n",
"makeGristedName s : $(<) ;\n",
"for i in $(s)\n",
"{\n",
"Object $(i:S=$(SUFOBJ)) : $(i) ;\n",
"DEPENDS obj : $(i:S=$(SUFOBJ)) ;\n",
"}\n",
"}\n",
"rule RmTemps\n",
"{\n",
"TEMPORARY $(>) ;\n",
"}\n",
"rule Setuid\n",
"{\n",
"local t ;\n",
"if $(<:S)\n",
"{\n",
"t = $(<) ;\n",
"} else {\n",
"t = $(<:S=$(SUFEXE)) ;\n",
"}\n",
"MODE on $(t) = 4711 ;\n",
"}\n",
"rule Shell\n",
"{\n",
"DEPENDS shell : $(<) ;\n",
"DEPENDS $(<) : $(>) ;\n",
"SEARCH on $(>) = $(SEARCH_SOURCE) ;\n",
"MODE on $(<) = $(SHELLMODE) ;\n",
"Clean clean : $(<) ;\n",
"Chmod $(<) ;\n",
"}\n",
"rule SubDir\n",
"{\n",
"local r s ;\n",
"if ! $($(<[1]))\n",
"{\n",
"if ! $(<[1])\n",
"{\n",
"EXIT SubDir syntax error ;\n",
"}\n",
"makeSubDir $(<[1]) : $(<[2-]) ;\n",
"}\n",
"if ! $($(<[1])-included)\n",
"{\n",
"$(<[1])-included = TRUE ;\n",
"r = $($(<[1])RULES) ;\n",
"if ! $(r)\n",
"{\n",
"r = $(JAMRULES:R=$($(<[1]))) ;\n",
"}\n",
"include $(r) ;\n",
"}\n",
"makeDirName s : $(<[2-]) ;\n",
"SUBDIR = $(s:R=$($(<[1]))) ;\n",
"SUBDIR_TOKENS = $(<[2-]) ;\n",
"SEARCH_SOURCE = $(SUBDIR) ;\n",
"LOCATE_SOURCE = $(ALL_LOCATE_TARGET) $(SUBDIR) ;\n",
"LOCATE_TARGET = $(ALL_LOCATE_TARGET) $(SUBDIR) ;\n",
"makeGrist SOURCE_GRIST : $(<[2-]) ;\n",
"SUBDIRCCFLAGS = ;\n",
"SUBDIRC++FLAGS = ;\n",
"SUBDIRHDRS = ;\n",
"}\n",
"rule SubDirCcFlags\n",
"{\n",
"SUBDIRCCFLAGS += $(<) ;\n",
"}\n",
"rule SubDirC++Flags\n",
"{\n",
"SUBDIRC++FLAGS += $(<) ;\n",
"}\n",
"rule SubDirHdrs\n",
"{\n",
"SUBDIRHDRS += $(<) ;\n",
"}\n",
"rule SubInclude\n",
"{\n",
"local s ;\n",
"if ! $($(<[1]))\n",
"{\n",
"EXIT Top level of source tree has not been set with $(<[1]) ;\n",
"}\n",
"makeDirName s : $(<[2-]) ;\n",
"include $(JAMFILE:D=$(s):R=$($(<[1]))) ;\n",
"}\n",
"rule Undefines\n",
"{\n",
"local t ;\n",
"if $(<:S)\n",
"{\n",
"t = $(<) ;\n",
"} else {\n",
"t = $(<:S=$(SUFEXE)) ;\n",
"}\n",
"UNDEFS on $(t) += $(UNDEFFLAG)$(>) ;\n",
"}\n",
"rule UserObject\n",
"{\n",
"EXIT \"Unknown suffix on\" $(>) \"- see UserObject rule in Jamfile(5).\" ;\n",
"}\n",
"rule Yacc\n",
"{\n",
"local h ;\n",
"h = $(<:BS=.h) ;\n",
"MakeLocate $(<) $(h) : $(LOCATE_SOURCE) ;\n",
"if $(YACC)\n",
"{\n",
"DEPENDS $(<) $(h) : $(>) ;\n",
"Yacc1 $(<) $(h) : $(>) ;\n",
"Clean clean : $(<) $(h) ;\n",
"}\n",
"INCLUDES $(<) : $(h) ;\n",
"}\n",
"rule makeString\n",
"{\n",
"local _t ;\n",
"$(<) = $(>[1]) ;\n",
"for _t in $(>[2-])\n",
"{\n",
"$(<) = $($(<))$(_t) ;\n",
"}\n",
"}\n",
"rule makeSubDir\n",
"{\n",
"local _i _d ;\n",
"if ! $(>[1]) \n",
"{\n",
"_d = $(DOT) ;\n",
"} \n",
"else\n",
"{\n",
"_d = $(DOTDOT) ;\n",
"for _i in $(>[2-])\n",
"{\n",
"_d = $(_d:R=$(DOTDOT)) ;\n",
"}\n",
"}\n",
"$(<) = $(_d) ;\n",
"}\n",
"rule addDirName\n",
"{\n",
"local _s _i ;\n",
"if ! $(>)\n",
"{\n",
"_s = $(DOT) ;\n",
"}\n",
"else if $(VMS)\n",
"{\n",
"switch $(>[1])\n",
"{\n",
"case *:* : _s = $(>[1]) ;\n",
"case \\\\[*\\\\] : _s = $(>[1]) ;\n",
"case * : _s = [.$(>[1])] ;\n",
"}\n",
"for _i in [.$(>[2-])]\n",
"{\n",
"_s = $(_i:R=$(_s)) ;\n",
"}\n",
"}\n",
"else if $(MAC)\n",
"{\n",
"_s = $(DOT) ;\n",
"for _i in $(>)\n",
"{\n",
"_s = $(_i:R=$(_s)) ;\n",
"}\n",
"}\n",
"else\n",
"{\n",
"_s = $(>[1]) ; \n",
"for _i in $(>[2-])\n",
"{\n",
"_s = $(_i:R=$(_s)) ;\n",
"}\n",
"}\n",
"$(<) += $(_s) ;\n",
"}\n",
"rule makeDirName\n",
"{\n",
"$(<) = ; addDirName $(<) : $(>) ;\n",
"}\n",
"rule makeGrist\n",
"{\n",
"local _g _i ;\n",
"_g = $(>[1]) ;\n",
"for _i in $(>[2-])\n",
"{\n",
"_g = $(_g)!$(_i) ;\n",
"}\n",
"$(<) = $(_g) ;\n",
"}\n",
"rule makeGristedName\n",
"{\n",
"local _i _o ;\n",
"if ! $(SOURCE_GRIST)\n",
"{\n",
"$(<) = $(>) ;\n",
"}\n",
"else \n",
"{\n",
"_o = ;\n",
"for _i in $(>)\n",
"{\n",
"switch $(_i)\n",
"{\n",
"case *.h :	_o += $(_i) ;\n",
"case * : 	_o += $(_i:G=$(SOURCE_GRIST)) ;\n",
"}\n",
"}\n",
"$(<) = $(_o) ;\n",
"}\n",
"}\n",
"rule makeCommon\n",
"{\n",
"if $($(<)[1]) && $($(<)[1]) = $($(>)[1])\n",
"{\n",
"$(<) = $($(<)[2-]) ;\n",
"$(>) = $($(>)[2-]) ;\n",
"makeCommon $(<) : $(>) ;\n",
"}\n",
"}\n",
"rule makeRelPath \n",
"{\n",
"local _l _r ;\n",
"_l = $(<[2-]) ;\n",
"_r = $(>) ;\n",
"makeCommon _l : _r ;\n",
"makeSubDir _l : $(_l) ;\n",
"makeDirName _r : $(_r) ;\n",
"if $(_r) = $(DOT) {\n",
"$(<[1]) = $(_l) ;\n",
"} else {\n",
"$(<[1]) = $(_r:R=$(_l)) ;\n",
"}\n",
"}\n",
"rule makeSuffixed\n",
"{\n",
"if $(<[2])\n",
"{\n",
"local _i ;\n",
"$(<[1]) = ;\n",
"for _i in $(>)\n",
"{\n",
"if $(_i:S)\n",
"{\n",
"$(<[1]) += $(_i) ;\n",
"}\n",
"else\n",
"{\n",
"$(<[1]) += $(_i:S=$(<[2])) ;\n",
"}\n",
"}\n",
"}\n",
"else\n",
"{\n",
"$(<[1]) = $(>) ;\n",
"}\n",
"}\n",
"rule unmakeDir\n",
"{\n",
"if $(>[1]:D) && $(>[1]:D) != $(>[1]) && $(>[1]:D) != \\\\\\\\ \n",
"{\n",
"unmakeDir $(<) : $(>[1]:D) $(>[1]:BS) $(>[2-]) ;\n",
"}\n",
"else\n",
"{\n",
"$(<) = $(>) ;\n",
"}\n",
"}\n",
"if $(UNIX)\n",
"{\n",
"if $(OS) = QNX \n",
"{\n",
"actions together piecemeal Archive\n",
"{\n",
"$(AR) $(<) +-$(>) \n",
"}\n",
"}\n",
"else if $(OS) = BEOS && $(METROWERKS)\n",
"{\n",
"actions together Archive\n",
"{\n",
"$(AR) $(<) $(>)\n",
"}\n",
"}\n",
"else\n",
"{\n",
"actions updated together piecemeal Archive\n",
"{\n",
"$(AR) $(<) $(>)\n",
"}\n",
"}\n",
"actions As\n",
"{\n",
"$(AS) $(ASFLAGS) -I$(HDRS) -o $(<) $(>)\n",
"}\n",
"if $(RELOCATE)\n",
"{\n",
"actions C++\n",
"{\n",
"$(C++) -c $(C++FLAGS) $(OPTIM) -I$(HDRS) $(>)\n",
"}\n",
"}\n",
"else\n",
"{\n",
"actions C++\n",
"{\n",
"$(C++) -c $(C++FLAGS) $(OPTIM) -I$(HDRS) -o $(<) $(>)\n",
"}\n",
"}\n",
"actions Cc\n",
"{\n",
"$(CC) -c $(CCFLAGS) $(OPTIM) -I$(HDRS) -o $(<) $(>)\n",
"}\n",
"if $(RELOCATE)\n",
"{\n",
"actions Cc\n",
"{\n",
"$(CC) -c $(CCFLAGS) $(OPTIM) -I$(HDRS) $(>)\n",
"}\n",
"}\n",
"actions ignore CcMv\n",
"{\n",
"[ $(<) != $(>:BS=$(SUFOBJ)) ] && $(MV) $(>:BS=$(SUFOBJ)) $(<)\n",
"}\n",
"actions Chgrp\n",
"{\n",
"chgrp $(GROUP) $(<)\n",
"}\n",
"actions Chmod\n",
"{\n",
"chmod $(MODE) $(<)\n",
"}\n",
"actions Chown\n",
"{\n",
"chown $(OWNER) $(<)\n",
"}\n",
"actions piecemeal together existing Clean\n",
"{\n",
"$(RM) $(>)\n",
"}\n",
"actions File\n",
"{\n",
"$(RM) $(<)\n",
"$(CP) $(>) $(<)\n",
"}\n",
"actions GenFile1\n",
"{\n",
"$(>[1]) $(<) $(>[2-])\n",
"}\n",
"actions Fortran\n",
"{\n",
"$(FORTRAN) $(FORTRANFLAGS) -o $(<) $(>)\n",
"}\n",
"actions HardLink\n",
"{\n",
"$(RM) $(<) && $(LN) $(>) $(<)\n",
"}\n",
"if $(INSTALL)\n",
"{\n",
"actions Install\n",
"{\n",
"$(INSTALL) -m$(MODE) -o$(OWNER) -g$(GROUP) $(>) $(<)\n",
"}\n",
"}\n",
"else\n",
"{\n",
"actions Install\n",
"{\n",
"$(CP) $(>) $(<) \n",
"}\n",
"}\n",
"actions Lex\n",
"{\n",
"$(LEX) $(>) && $(MV) lex.yy.c $(<)\n",
"}\n",
"actions Link bind NEEDLIBS\n",
"{\n",
"$(LINK) $(LINKFLAGS) -o $(<) $(UNDEFS) $(>) $(NEEDLIBS) $(LINKLIBS) \n",
"}\n",
"actions MkDir1\n",
"{\n",
"$(MKDIR) $(<)\n",
"}\n",
"actions together Ranlib\n",
"{\n",
"$(RANLIB) $(<)\n",
"}\n",
"actions quietly updated piecemeal together RmTemps\n",
"{\n",
"$(RM) $(>)\n",
"}\n",
"actions Shell\n",
"{\n",
"$(AWK) '\n",
"NR == 1 { print \"$(SHELLHEADER)\" }\n",
"NR == 1 && /^[#:]/ { next }\n",
"/^##/ { next }\n",
"{ print }\n",
"' < $(>) > $(<)\n",
"}\n",
"actions Yacc1\n",
"{\n",
"$(YACC) $(YACCFLAGS) $(>) &&\n",
"{\n",
"$(MV) $(YACCFILES).c $(<[1])\n",
"$(MV) $(YACCFILES).h $(<[2])\n",
"}\n",
"}\n",
"}\n",
"else if $(NT) || $(OS2)\n",
"{\n",
"if $(BCCROOT)\n",
"{\n",
"actions C++\n",
"{\n",
"$(C++) -c $(C++FLAGS) $(OPTIM) -I$(HDRS) -o$(<) $(>)\n",
"}\n",
"actions Link bind NEEDLIBS\n",
"{\n",
"$(LINK) -e$(<) $(LINKFLAGS) $(UNDEFS) -L$(LINKLIBS) $(NEEDLIBS) $(>)\n",
"}\n",
"actions updated together piecemeal Archive\n",
"{\n",
"$(AR) $(ARFLAGS) $(<) -+$(>)\n",
"}\n",
"actions Cc\n",
"{\n",
"$(CC) -c $(CCFLAGS) $(OPTIM) -I$(HDRS) -o$(<) $(>)\n",
"}\n",
"}\n",
"else if $(MSVC) \n",
"{\n",
"actions updated together piecemeal Archive\n",
"{\n",
"$(AR) $(<) -+$(>) ;\n",
"}\n",
"actions Cc\n",
"{\n",
"$(CC) /c $(CCFLAGS) $(OPTIM) /Fo$(<) /I$(HDRS) $(>)\n",
"}\n",
"actions C++\n",
"{\n",
"$(C++) /c $(C++FLAGS) $(OPTIM) /Fo$(<) /I$(HDRS) /Tp$(>)\n",
"}\n",
"actions Link bind NEEDLIBS\n",
"{\n",
"$(LINK) $(LINKFLAGS) /out:$(<) $(UNDEFS) $(>) $(NEEDLIBS) $(LINKLIBS)\n",
"}\n",
"}\n",
"else if $(MSVCNT)\n",
"{\n",
"actions updated together piecemeal Archive\n",
"{\n",
"if exist $(<) set _$(<:B)_=$(<)\n",
"$(AR) /out:$(<) %_$(<:B)_% $(>)\n",
"}\n",
"actions As\n",
"{\n",
"$(AS) /Ml /p /v /w2 $(>) $(<) ,nul,nul;\n",
"}\n",
"actions Cc\n",
"{\n",
"$(CC) /c $(CCFLAGS) $(OPTIM) /Fo$(<) /I$(HDRS) /I$(STDHDRS) $(>)\n",
"}\n",
"actions C++\n",
"{\n",
"$(C++) /c $(C++FLAGS) $(OPTIM) /Fo$(<) /I$(HDRS) /I$(STDHDRS) /Tp$(>)\n",
"}\n",
"actions Link bind NEEDLIBS\n",
"{\n",
"$(LINK) $(LINKFLAGS) /out:$(<) $(UNDEFS) $(>) $(NEEDLIBS) $(LINKLIBS)\n",
"}\n",
"}\n",
"else if $(WATCOM)\n",
"{\n",
"actions together piecemeal Archive\n",
"{\n",
"$(AR) $(<) +-$(>) \n",
"}\n",
"actions Cc\n",
"{\n",
"$(CC) $(CCFLAGS) $(OPTIM) /Fo=$(<) /I$(HDRS) $(>)\n",
"}\n",
"actions C++\n",
"{\n",
"$(C++) $(C++FLAGS) $(OPTIM) /Fo=$(<) /I$(HDRS) $(>)\n",
"}\n",
"actions Link bind NEEDLIBS\n",
"{\n",
"$(LINK) $(LINKFLAGS) /Fe=$(<) $(UNDEFS) $(>) $(NEEDLIBS) $(LINKLIBS)\n",
"}\n",
"}\n",
"actions Chmod\n",
"{\n",
"}\n",
"actions piecemeal together existing Clean\n",
"{\n",
"$(RM) $(>)\n",
"}\n",
"actions File\n",
"{\n",
"copy $(>) $(<)\n",
"}\n",
"actions GenFile1\n",
"{\n",
"$(>[1]) $(<) $(>[2-])\n",
"}\n",
"actions Install\n",
"{\n",
"copy $(>) $(<)\n",
"}\n",
"actions MkDir1\n",
"{\n",
"$(MKDIR) $(<)\n",
"}\n",
"actions quietly updated piecemeal together RmTemps\n",
"{\n",
"$(RM) $(>)\n",
"}\n",
"actions Shell\n",
"{\n",
"copy $(>) $(<)\n",
"}\n",
"}\n",
"else if $(VMS)\n",
"{\n",
"actions updated together piecemeal Archive \n",
"{\n",
"lib/replace $(<) $(>[1]) ,$(>[2-])\n",
"}\n",
"actions Cc\n",
"{ \n",
"cc/obj=$(<) $(CCFLAGS) $(OPTIM) $(SLASHINC) $(>) \n",
"}\n",
"actions C++\n",
"{ \n",
"cxx/obj=$(<) $(C++FLAGS) $(OPTIM) $(SLASHINC) $(>) \n",
"}\n",
"actions Chmod\n",
"{\n",
"set file/prot=$(MODE) $(<)\n",
"}\n",
"actions piecemeal together existing Clean\n",
"{\n",
"$(RM) $(>[1]);* ,$(>[2-]);*\n",
"}\n",
"actions together quietly CreLib\n",
"{\n",
"if f$search(\"$(<)\") .eqs. \"\" then lib/create $(<)\n",
"}\n",
"actions File\n",
"{\n",
"copy $(>) $(<)\n",
"}\n",
"actions GenFile1\n",
"{\n",
"mcr $(>[1]) $(<) $(>[2-])\n",
"}\n",
"actions Install\n",
"{\n",
"copy $(>) $(<)\n",
"}\n",
"actions Lex\n",
"{\n",
"$(LEX) $(>) \n",
"$(MV) lex.yy.c $(<)\n",
"}\n",
"actions Link bind NEEDLIBS\n",
"{\n",
"$(LINK)/exe=$(<) $(LINKFLAGS) $(>[1]) ,$(>[2-]) ,$(NEEDLIBS)/lib ,$(LINKLIBS)\n",
"}\n",
"actions MkDir1\n",
"{\n",
"create/dir $(<)\n",
"}\n",
"actions quietly updated piecemeal together RmTemps\n",
"{\n",
"$(RM) $(>[1]);* ,$(>[2-]);*\n",
"}\n",
"actions Shell\n",
"{\n",
"copy $(>) $(<)\n",
"}\n",
"actions Yacc1\n",
"{\n",
"$(YACC) $(YACCFLAGS) $(>)\n",
"$(MV) $(YACCFILES).c $(<[1])\n",
"$(MV) $(YACCFILES).h $(<[2])\n",
"}\n",
"}\n",
"else if $(MAC)\n",
"{\n",
"SP = \" \" ;\n",
"actions together Archive \n",
"{\n",
"$(LINK) -library -o $(<) $(>)\n",
"}\n",
"actions Cc\n",
"{\n",
"set MWCincludes $(MACINC)\n",
"$(CC) -o $(<) $(CCFLAGS) $(OPTIM) $(>) \n",
"}\n",
"actions C++\n",
"{ \n",
"set MWCincludes $(MACINC)\n",
"$(CC) -o $(<) $(C++FLAGS) $(OPTIM) $(>) \n",
"}\n",
"rule Chmod\n",
"{\n",
"}\n",
"actions piecemeal together existing Clean\n",
"{\n",
"$(RM) $(>)\n",
"}\n",
"actions File\n",
"{\n",
"copy $(>) $(<)\n",
"}\n",
"actions GenFile1\n",
"{\n",
"$(>[1]) $(<) $(>[2-])\n",
"}\n",
"actions Install\n",
"{\n",
"copy $(>) $(<)\n",
"}\n",
"actions Link bind NEEDLIBS\n",
"{\n",
"$(LINK) -o $(<) $(LINKFLAGS) $(>) $(NEEDLIBS) \"$(LINKLIBS)\"\n",
"}\n",
"actions MkDir1\n",
"{\n",
"$(MKDIR) $(<)\n",
"}\n",
"actions quietly updated piecemeal together RmTemps\n",
"{\n",
"$(RM) $(>)\n",
"}\n",
"actions Shell\n",
"{\n",
"copy $(>) $(<)\n",
"}\n",
"}\n",
"rule BULK { Bulk $(<) : $(>) ; }\n",
"rule FILE { File $(<) : $(>) ; }\n",
"rule HDRRULE { HdrRule $(<) : $(>) ; }\n",
"rule INSTALL { Install $(<) : $(>) ; }\n",
"rule LIBRARY { Library $(<) : $(>) ; }\n",
"rule LIBS { LinkLibraries $(<) : $(>) ; }\n",
"rule LINK { Link $(<) : $(>) ; }\n",
"rule MAIN { Main $(<) : $(>) ; }\n",
"rule SETUID { Setuid $(<) ; }\n",
"rule SHELL { Shell $(<) : $(>) ; }\n",
"rule UNDEFINES { Undefines $(<) : $(>) ; }\n",
"rule INSTALLBIN { InstallBin $(BINDIR) : $(<) ; }\n",
"rule INSTALLLIB { InstallLib $(LIBDIR) : $(<) ; }\n",
"rule INSTALLMAN { InstallMan $(MANDIR) : $(<) ; }\n",
"{\n",
"if $(JAMFILE) { include $(JAMFILE) ; }\n",
"}\n",
0 };
./src/jambase.h100440    167    454         565  7102105140  12021 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

/*
 * jambase.h - declaration for the internal jambase
 *
 * The file Jambase is turned into a C array of strings in jambase.c
 * so that it can be built in to the executable.  This is the 
 * declaration for that array.
 */

extern char *jambase[];
./src/jamgram.c100440    167    454       54570  7102105140  12075 0ustar  laurateam#ifndef lint
static char const yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93";
#endif
#define YYBYACC 1
#define YYMAJOR 1
#define YYMINOR 9
#define YYLEX yylex()
#define YYEMPTY -1
#define yyclearin (yychar=(YYEMPTY))
#define yyerrok (yyerrflag=0)
#define YYRECOVERING (yyerrflag!=0)
/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
#ifdef c_plusplus
#ifndef __cplusplus
#define __cplusplus
#endif
#endif
#ifdef __cplusplus
extern "C" { char *getenv(const char *); }
#else
extern char *getenv();
extern int yylex();
extern int yyparse();
#endif
#define YYPREFIX "yy"
#line 64 "jamgram.y"
#include "jam.h"

#include "lists.h"
#include "parse.h"
#include "scan.h"
#include "compile.h"
#include "newstr.h"

# define F0 (void (*)())0
# define P0 (PARSE *)0
# define S0 (char *)0

# define pset( l,r,a ) 	  parse_make( compile_set,P0,P0,S0,S0,l,r,a )
# define pset1( l,p,a )	  parse_make( compile_settings,p,P0,S0,S0,l,L0,a )
# define pstng( p,l,r,a ) pset1( p, parse_make( F0,P0,P0,S0,S0,l,r,0 ), a )
# define prule( s,p )     parse_make( compile_rule,p,P0,s,S0,L0,L0,0 )
# define prules( l,r )	  parse_make( compile_rules,l,r,S0,S0,L0,L0,0 )
# define pfor( s,p,l )    parse_make( compile_foreach,p,P0,s,S0,l,L0,0 )
# define psetc( s,p )     parse_make( compile_setcomp,p,P0,s,S0,L0,L0,0 )
# define psete( s,l,s1,f ) parse_make( compile_setexec,P0,P0,s,s1,l,L0,f )
# define pincl( l )       parse_make( compile_include,P0,P0,S0,S0,l,L0,0 )
# define pswitch( l,p )   parse_make( compile_switch,p,P0,S0,S0,l,L0,0 )
# define plocal( l,r,p )  parse_make( compile_local,p,P0,S0,S0,l,r,0 )
# define pnull()	  parse_make( compile_null,P0,P0,S0,S0,L0,L0,0 )
# define pcases( l,r )    parse_make( F0,l,r,S0,S0,L0,L0,0 )
# define pcase( s,p )     parse_make( F0,p,P0,s,S0,L0,L0,0 )
# define pif( l,r )	  parse_make( compile_if,l,r,S0,S0,L0,L0,0 )
# define pthen( l,r )	  parse_make( F0,l,r,S0,S0,L0,L0,0 )
# define pcond( c,l,r )	  parse_make( F0,l,r,S0,S0,L0,L0,c )
# define pcomp( c,l,r )	  parse_make( F0,P0,P0,S0,S0,l,r,c )
# define plol( p,l )	  parse_make( F0,p,P0,S0,S0,l,L0,0 )


#line 61 "y.tab.c"
#define _BANG 257
#define _BANG_EQUALS 258
#define _AMPERAMPER 259
#define _LPAREN 260
#define _RPAREN 261
#define _PLUS_EQUALS 262
#define _COLON 263
#define _SEMIC 264
#define _LANGLE 265
#define _LANGLE_EQUALS 266
#define _EQUALS 267
#define _RANGLE 268
#define _RANGLE_EQUALS 269
#define _QUESTION_EQUALS 270
#define ACTIONS 271
#define BIND 272
#define CASE 273
#define DEFAULT 274
#define ELSE 275
#define EXISTING 276
#define FOR 277
#define IF 278
#define IGNORE 279
#define IN 280
#define INCLUDE 281
#define LOCAL 282
#define ON 283
#define PIECEMEAL 284
#define QUIETLY 285
#define RULE 286
#define SWITCH 287
#define TOGETHER 288
#define UPDATED 289
#define _LBRACE 290
#define _BARBAR 291
#define _RBRACE 292
#define ARG 293
#define STRING 294
#define YYERRCODE 256
const short yylhs[] = {                                        -1,
    0,    1,    1,    1,    1,    2,    2,    2,    2,    2,
    2,    2,    2,    2,    2,    2,   11,   12,    2,    6,
    6,    6,    8,    8,    8,    8,    8,    8,    8,    8,
    8,    8,    8,    8,    7,    7,   13,    4,    4,    3,
   14,   14,    5,    9,    9,   15,   15,   15,   15,   15,
   15,   10,   10,
};
const short yylen[] = {                                         2,
    1,    0,    2,    4,    6,    3,    3,    3,    4,    6,
    5,    7,    5,    5,    7,    3,    0,    0,    9,    1,
    1,    1,    1,    3,    3,    3,    3,    3,    3,    3,
    2,    3,    3,    3,    0,    2,    4,    1,    3,    1,
    0,    2,    1,    0,    2,    1,    1,    1,    1,    1,
    1,    0,    2,
};
const short yydefred[] = {                                      0,
   44,    0,    0,   41,   41,    0,   41,    0,    0,    0,
    1,    0,    0,    0,    0,    0,    0,   43,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    3,   21,
   20,   22,    0,   41,   41,   51,   48,   50,   49,   47,
   46,    0,   45,   41,   31,    0,    0,    0,    0,    0,
    0,    0,   41,    0,    0,    0,    7,   42,    0,   41,
   16,    0,    6,   41,    8,   41,    0,    0,   41,    0,
    0,   34,   25,   26,   27,   24,   28,   29,   30,   32,
    0,    0,    4,    0,    0,    0,    0,   39,    0,   41,
    9,   53,   17,    0,    0,    0,    0,   13,   36,   11,
    0,    0,    0,    0,    5,    0,   10,   18,   12,   15,
   37,    0,   19,
};
const short yydgoto[] = {                                      10,
   11,   12,   27,   28,   13,   35,   86,   20,   14,   70,
  102,  112,   87,   22,   43,
};
const short yysindex[] = {                                   -182,
    0, -274, -252,    0,    0, -270,    0, -182,    0,    0,
    0, -182, -160, -152, -245, -252, -252,    0, -238, -237,
 -225, -250, -177, -165, -224, -240, -196, -189,    0,    0,
    0,    0, -191,    0,    0,    0,    0,    0,    0,    0,
    0, -187,    0,    0,    0, -227, -210, -210, -210, -210,
 -210, -210,    0, -252, -182, -252,    0,    0, -182,    0,
    0, -192,    0,    0,    0,    0, -136, -173,    0, -193,
 -181,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 -198, -158,    0, -149, -176, -174, -192,    0, -145,    0,
    0,    0,    0, -182, -155, -182, -134,    0,    0,    0,
 -129, -164, -154, -165,    0, -182,    0,    0,    0,    0,
    0, -153,    0,
};
const short yyrindex[] = {                                    140,
    0,    0,    0,    0,    0,    0,    0, -150, -190,    0,
    0,    3,    0,    0,    0,    0,    0,    0, -221,    0,
    0, -246,    0,    0,    0,    0, -121,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0, -146,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0, -150,    0,    0,    0,    3,    0,
    0, -147,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0, -212,    0,    0,    0,    0, -147,    0,    0,    0,
    0,    0,    0, -150,    1,    3,    0,    0,    0,    0,
    0,    0,    0,    0,    0, -259,    0,    0,    0,    0,
    0,    0,    0,
};
const short yygindex[] = {                                      0,
   -8,  -22,    2,   82,    9,   80,   61,   -6,    0,    0,
    0,    0,    0,    0,    0,
};
#define YYTABLESIZE 295
const short yytable[] = {                                      26,
   14,   61,    2,   29,   16,   21,   23,   17,   25,   45,
   46,   19,   40,    2,   40,   40,   40,   40,   15,   47,
   40,   54,   24,   40,   19,   19,   48,   49,   50,   51,
   52,   54,    2,   72,   44,   67,   68,   23,   57,   23,
   18,   53,   58,   40,   40,   71,   81,   80,   33,   82,
   83,   63,   55,   56,   79,   73,   74,   75,   76,   77,
   78,   84,   19,   56,   19,   62,   64,   89,   23,   23,
   92,   43,   41,   41,   65,   66,   43,   33,   33,   43,
   85,  110,   18,   43,   69,  103,   59,  105,    1,   60,
   91,  101,   43,   95,    2,    3,   93,  111,    4,    5,
   54,   30,   41,    6,    7,    1,   31,    8,   94,   32,
    9,    2,    3,   33,   96,    4,   97,   98,  100,  104,
    6,    7,   34,   36,    8,   30,   37,    9,  106,  108,
   31,   38,   39,   32,  107,   40,   41,  109,  113,    2,
   42,    2,   38,   52,   35,   88,   90,   99,    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,    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,
    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,    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,   14,    0,   14,    0,    2,    0,   14,   14,    0,
    0,   14,   14,    0,    0,    0,   14,   14,    0,    0,
   14,    0,   14,   14,    2,
};
const short yycheck[] = {                                       8,
    0,   24,    0,   12,  257,    4,    5,  260,    7,   16,
   17,    3,  259,  273,  261,  262,  263,  264,  293,  258,
  267,  259,  293,  270,   16,   17,  265,  266,  267,  268,
  269,  259,  292,  261,  280,   34,   35,  259,  264,  261,
  293,  280,  293,  290,  291,   44,   55,   54,  261,   56,
   59,  292,  290,  291,   53,   47,   48,   49,   50,   51,
   52,   60,   54,  291,   56,  290,  263,   66,  290,  291,
   69,  262,  263,  264,  264,  267,  267,  290,  291,  270,
  273,  104,  293,  274,  272,   94,  264,   96,  271,  267,
  264,   90,  283,  292,  277,  278,  290,  106,  281,  282,
  259,  262,  293,  286,  287,  271,  267,  290,  290,  270,
  293,  277,  278,  274,  264,  281,  293,  292,  264,  275,
  286,  287,  283,  276,  290,  262,  279,  293,  263,  294,
  267,  284,  285,  270,  264,  288,  289,  292,  292,    0,
  293,  292,  264,  290,  292,   64,   67,   87,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,  271,   -1,  273,   -1,  273,   -1,  277,  278,   -1,
   -1,  281,  282,   -1,   -1,   -1,  286,  287,   -1,   -1,
  290,   -1,  292,  293,  292,
};
#define YYFINAL 10
#ifndef YYDEBUG
#define YYDEBUG 0
#endif
#define YYMAXTOKEN 294
#if YYDEBUG
char *yyname[] = {
"end-of-file",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,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,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,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,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,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,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,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,0,0,0,0,0,0,0,0,"_BANG","_BANG_EQUALS",
"_AMPERAMPER","_LPAREN","_RPAREN","_PLUS_EQUALS","_COLON","_SEMIC","_LANGLE",
"_LANGLE_EQUALS","_EQUALS","_RANGLE","_RANGLE_EQUALS","_QUESTION_EQUALS",
"ACTIONS","BIND","CASE","DEFAULT","ELSE","EXISTING","FOR","IF","IGNORE","IN",
"INCLUDE","LOCAL","ON","PIECEMEAL","QUIETLY","RULE","SWITCH","TOGETHER",
"UPDATED","_LBRACE","_BARBAR","_RBRACE","ARG","STRING",
};
const char * const yyrule[] = {
"$accept : run",
"run : block",
"block :",
"block : rule block",
"block : LOCAL args _SEMIC block",
"block : LOCAL args _EQUALS args _SEMIC block",
"rule : _LBRACE block _RBRACE",
"rule : INCLUDE args _SEMIC",
"rule : ARG lol _SEMIC",
"rule : arg1 assign args _SEMIC",
"rule : arg1 ON args assign args _SEMIC",
"rule : arg1 DEFAULT _EQUALS args _SEMIC",
"rule : FOR ARG IN args _LBRACE block _RBRACE",
"rule : SWITCH args _LBRACE cases _RBRACE",
"rule : IF cond _LBRACE block _RBRACE",
"rule : IF cond _LBRACE block _RBRACE ELSE rule",
"rule : RULE ARG rule",
"$$1 :",
"$$2 :",
"rule : ACTIONS eflags ARG bindlist _LBRACE $$1 STRING $$2 _RBRACE",
"assign : _EQUALS",
"assign : _PLUS_EQUALS",
"assign : _QUESTION_EQUALS",
"cond : arg1",
"cond : arg1 _EQUALS arg1",
"cond : arg1 _BANG_EQUALS arg1",
"cond : arg1 _LANGLE arg1",
"cond : arg1 _LANGLE_EQUALS arg1",
"cond : arg1 _RANGLE arg1",
"cond : arg1 _RANGLE_EQUALS arg1",
"cond : arg1 IN args",
"cond : _BANG cond",
"cond : cond _AMPERAMPER cond",
"cond : cond _BARBAR cond",
"cond : _LPAREN cond _RPAREN",
"cases :",
"cases : case cases",
"case : CASE ARG _COLON block",
"lol : args",
"lol : args _COLON lol",
"args : argsany",
"argsany :",
"argsany : argsany ARG",
"arg1 : ARG",
"eflags :",
"eflags : eflags eflag",
"eflag : UPDATED",
"eflag : TOGETHER",
"eflag : IGNORE",
"eflag : QUIETLY",
"eflag : PIECEMEAL",
"eflag : EXISTING",
"bindlist :",
"bindlist : BIND args",
};
#endif
#ifndef YYSTYPE
typedef int YYSTYPE;
#endif
#ifdef YYSTACKSIZE
#undef YYMAXDEPTH
#define YYMAXDEPTH YYSTACKSIZE
#else
#ifdef YYMAXDEPTH
#define YYSTACKSIZE YYMAXDEPTH
#else
#define YYSTACKSIZE 500
#define YYMAXDEPTH 500
#endif
#endif
int yydebug;
int yynerrs;
int yyerrflag;
int yychar;
short *yyssp;
YYSTYPE *yyvsp;
YYSTYPE yyval;
YYSTYPE yylval;
short yyss[YYSTACKSIZE];
YYSTYPE yyvs[YYSTACKSIZE];
#define yystacksize YYSTACKSIZE
#define YYABORT goto yyabort
#define YYREJECT goto yyabort
#define YYACCEPT goto yyaccept
#define YYERROR goto yyerrlab

int
yyparse()
{
    register int yym, yyn, yystate;
#if YYDEBUG
    register char *yys;

    if ((yys = getenv("YYDEBUG")))
    {
        yyn = *yys;
        if (yyn >= '0' && yyn <= '9')
            yydebug = yyn - '0';
    }
#endif

    yynerrs = 0;
    yyerrflag = 0;
    yychar = (-1);

    yyssp = yyss;
    yyvsp = yyvs;
    *yyssp = yystate = 0;

yyloop:
    if ((yyn = yydefred[yystate])) goto yyreduce;
    if (yychar < 0)
    {
        if ((yychar = yylex()) < 0) yychar = 0;
#if YYDEBUG
        if (yydebug)
        {
            yys = 0;
            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
            if (!yys) yys = "illegal-symbol";
            printf("%sdebug: state %d, reading %d (%s)\n",
                    YYPREFIX, yystate, yychar, yys);
        }
#endif
    }
    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    {
#if YYDEBUG
        if (yydebug)
            printf("%sdebug: state %d, shifting to state %d\n",
                    YYPREFIX, yystate, yytable[yyn]);
#endif
        if (yyssp >= yyss + yystacksize - 1)
        {
            goto yyoverflow;
        }
        *++yyssp = yystate = yytable[yyn];
        *++yyvsp = yylval;
        yychar = (-1);
        if (yyerrflag > 0)  --yyerrflag;
        goto yyloop;
    }
    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    {
        yyn = yytable[yyn];
        goto yyreduce;
    }
    if (yyerrflag) goto yyinrecovery;
#if defined(lint) || defined(__GNUC__)
    goto yynewerror;
#endif
yynewerror:
    yyerror("syntax error");
#if defined(lint) || defined(__GNUC__)
    goto yyerrlab;
#endif
yyerrlab:
    ++yynerrs;
yyinrecovery:
    if (yyerrflag < 3)
    {
        yyerrflag = 3;
        for (;;)
        {
            if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
            {
#if YYDEBUG
                if (yydebug)
                    printf("%sdebug: state %d, error recovery shifting\
 to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
#endif
                if (yyssp >= yyss + yystacksize - 1)
                {
                    goto yyoverflow;
                }
                *++yyssp = yystate = yytable[yyn];
                *++yyvsp = yylval;
                goto yyloop;
            }
            else
            {
#if YYDEBUG
                if (yydebug)
                    printf("%sdebug: error recovery discarding state %d\n",
                            YYPREFIX, *yyssp);
#endif
                if (yyssp <= yyss) goto yyabort;
                --yyssp;
                --yyvsp;
            }
        }
    }
    else
    {
        if (yychar == 0) goto yyabort;
#if YYDEBUG
        if (yydebug)
        {
            yys = 0;
            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
            if (!yys) yys = "illegal-symbol";
            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
                    YYPREFIX, yystate, yychar, yys);
        }
#endif
        yychar = (-1);
        goto yyloop;
    }
yyreduce:
#if YYDEBUG
    if (yydebug)
        printf("%sdebug: state %d, reducing by rule %d (%s)\n",
                YYPREFIX, yystate, yyn, yyrule[yyn]);
#endif
    yym = yylen[yyn];
    yyval = yyvsp[1-yym];
    switch (yyn)
    {
case 1:
#line 102 "jamgram.y"
{ 
		    if( yyvsp[0].parse->func == compile_null )
		    {
			parse_free( yyvsp[0].parse );
		    }
		    else
		    {
			parse_save( yyvsp[0].parse ); 
		    }
		}
break;
case 2:
#line 120 "jamgram.y"
{ yyval.parse = pnull(); }
break;
case 3:
#line 122 "jamgram.y"
{ yyval.parse = prules( yyvsp[-1].parse, yyvsp[0].parse ); }
break;
case 4:
#line 124 "jamgram.y"
{ yyval.parse = plocal( yyvsp[-2].list, L0, yyvsp[0].parse ); }
break;
case 5:
#line 126 "jamgram.y"
{ yyval.parse = plocal( yyvsp[-4].list, yyvsp[-2].list, yyvsp[0].parse ); }
break;
case 6:
#line 130 "jamgram.y"
{ yyval.parse = yyvsp[-1].parse; }
break;
case 7:
#line 132 "jamgram.y"
{ yyval.parse = pincl( yyvsp[-1].list ); }
break;
case 8:
#line 134 "jamgram.y"
{ yyval.parse = prule( yyvsp[-2].string, yyvsp[-1].parse ); }
break;
case 9:
#line 136 "jamgram.y"
{ yyval.parse = pset( yyvsp[-3].list, yyvsp[-1].list, yyvsp[-2].number ); }
break;
case 10:
#line 138 "jamgram.y"
{ yyval.parse = pstng( yyvsp[-3].list, yyvsp[-5].list, yyvsp[-1].list, yyvsp[-2].number ); }
break;
case 11:
#line 140 "jamgram.y"
{ yyval.parse = pset( yyvsp[-4].list, yyvsp[-1].list, ASSIGN_DEFAULT ); }
break;
case 12:
#line 142 "jamgram.y"
{ yyval.parse = pfor( yyvsp[-5].string, yyvsp[-1].parse, yyvsp[-3].list ); }
break;
case 13:
#line 144 "jamgram.y"
{ yyval.parse = pswitch( yyvsp[-3].list, yyvsp[-1].parse ); }
break;
case 14:
#line 146 "jamgram.y"
{ yyval.parse = pif( yyvsp[-3].parse, pthen( yyvsp[-1].parse, pnull() ) ); }
break;
case 15:
#line 148 "jamgram.y"
{ yyval.parse = pif( yyvsp[-5].parse, pthen( yyvsp[-3].parse, yyvsp[0].parse ) ); }
break;
case 16:
#line 150 "jamgram.y"
{ yyval.parse = psetc( yyvsp[-1].string, yyvsp[0].parse ); }
break;
case 17:
#line 152 "jamgram.y"
{ yymode( SCAN_STRING ); }
break;
case 18:
#line 154 "jamgram.y"
{ yymode( SCAN_NORMAL ); }
break;
case 19:
#line 156 "jamgram.y"
{ yyval.parse = psete( yyvsp[-6].string,yyvsp[-5].list,yyvsp[-2].string,yyvsp[-7].number ); }
break;
case 20:
#line 164 "jamgram.y"
{ yyval.number = ASSIGN_SET; }
break;
case 21:
#line 166 "jamgram.y"
{ yyval.number = ASSIGN_APPEND; }
break;
case 22:
#line 168 "jamgram.y"
{ yyval.number = ASSIGN_DEFAULT; }
break;
case 23:
#line 176 "jamgram.y"
{ yyval.parse = pcomp( COND_EXISTS, yyvsp[0].list, L0 ); }
break;
case 24:
#line 178 "jamgram.y"
{ yyval.parse = pcomp( COND_EQUALS, yyvsp[-2].list, yyvsp[0].list ); }
break;
case 25:
#line 180 "jamgram.y"
{ yyval.parse = pcomp( COND_NOTEQ, yyvsp[-2].list, yyvsp[0].list ); }
break;
case 26:
#line 182 "jamgram.y"
{ yyval.parse = pcomp( COND_LESS, yyvsp[-2].list, yyvsp[0].list ); }
break;
case 27:
#line 184 "jamgram.y"
{ yyval.parse = pcomp( COND_LESSEQ, yyvsp[-2].list, yyvsp[0].list ); }
break;
case 28:
#line 186 "jamgram.y"
{ yyval.parse = pcomp( COND_MORE, yyvsp[-2].list, yyvsp[0].list ); }
break;
case 29:
#line 188 "jamgram.y"
{ yyval.parse = pcomp( COND_MOREEQ, yyvsp[-2].list, yyvsp[0].list ); }
break;
case 30:
#line 190 "jamgram.y"
{ yyval.parse = pcomp( COND_IN, yyvsp[-2].list, yyvsp[0].list ); }
break;
case 31:
#line 192 "jamgram.y"
{ yyval.parse = pcond( COND_NOT, yyvsp[0].parse, P0 ); }
break;
case 32:
#line 194 "jamgram.y"
{ yyval.parse = pcond( COND_AND, yyvsp[-2].parse, yyvsp[0].parse ); }
break;
case 33:
#line 196 "jamgram.y"
{ yyval.parse = pcond( COND_OR, yyvsp[-2].parse, yyvsp[0].parse ); }
break;
case 34:
#line 198 "jamgram.y"
{ yyval.parse = yyvsp[-1].parse; }
break;
case 35:
#line 209 "jamgram.y"
{ yyval.parse = P0; }
break;
case 36:
#line 211 "jamgram.y"
{ yyval.parse = pcases( yyvsp[-1].parse, yyvsp[0].parse ); }
break;
case 37:
#line 215 "jamgram.y"
{ yyval.parse = pcase( yyvsp[-2].string, yyvsp[0].parse ); }
break;
case 38:
#line 223 "jamgram.y"
{ yyval.parse = plol( P0, yyvsp[0].list ); }
break;
case 39:
#line 225 "jamgram.y"
{ yyval.parse = plol( yyvsp[0].parse, yyvsp[-2].list ); }
break;
case 40:
#line 234 "jamgram.y"
{ yymode( SCAN_NORMAL ); }
break;
case 41:
#line 238 "jamgram.y"
{ yyval.list = L0; yymode( SCAN_PUNCT ); }
break;
case 42:
#line 240 "jamgram.y"
{ yyval.list = list_new( yyvsp[-1].list, copystr( yyvsp[0].string ) ); }
break;
case 43:
#line 244 "jamgram.y"
{ yyval.list = list_new( L0, copystr( yyvsp[0].string ) ); }
break;
case 44:
#line 253 "jamgram.y"
{ yyval.number = 0; }
break;
case 45:
#line 255 "jamgram.y"
{ yyval.number = yyvsp[-1].number | yyvsp[0].number; }
break;
case 46:
#line 259 "jamgram.y"
{ yyval.number = EXEC_UPDATED; }
break;
case 47:
#line 261 "jamgram.y"
{ yyval.number = EXEC_TOGETHER; }
break;
case 48:
#line 263 "jamgram.y"
{ yyval.number = EXEC_IGNORE; }
break;
case 49:
#line 265 "jamgram.y"
{ yyval.number = EXEC_QUIETLY; }
break;
case 50:
#line 267 "jamgram.y"
{ yyval.number = EXEC_PIECEMEAL; }
break;
case 51:
#line 269 "jamgram.y"
{ yyval.number = EXEC_EXISTING; }
break;
case 52:
#line 278 "jamgram.y"
{ yyval.list = L0; }
break;
case 53:
#line 280 "jamgram.y"
{ yyval.list = yyvsp[0].list; }
break;
#line 695 "y.tab.c"
    }
    yyssp -= yym;
    yystate = *yyssp;
    yyvsp -= yym;
    yym = yylhs[yyn];
    if (yystate == 0 && yym == 0)
    {
#if YYDEBUG
        if (yydebug)
            printf("%sdebug: after reduction, shifting from state 0 to\
 state %d\n", YYPREFIX, YYFINAL);
#endif
        yystate = YYFINAL;
        *++yyssp = YYFINAL;
        *++yyvsp = yyval;
        if (yychar < 0)
        {
            if ((yychar = yylex()) < 0) yychar = 0;
#if YYDEBUG
            if (yydebug)
            {
                yys = 0;
                if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
                if (!yys) yys = "illegal-symbol";
                printf("%sdebug: state %d, reading %d (%s)\n",
                        YYPREFIX, YYFINAL, yychar, yys);
            }
#endif
        }
        if (yychar == 0) goto yyaccept;
        goto yyloop;
    }
    if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
        yystate = yytable[yyn];
    else
        yystate = yydgoto[yym];
#if YYDEBUG
    if (yydebug)
        printf("%sdebug: after reduction, shifting from state %d \
to state %d\n", YYPREFIX, *yyssp, yystate);
#endif
    if (yyssp >= yyss + yystacksize - 1)
    {
        goto yyoverflow;
    }
    *++yyssp = yystate;
    *++yyvsp = yyval;
    goto yyloop;
yyoverflow:
    yyerror("yacc stack overflow");
yyabort:
    return (1);
yyaccept:
    return (0);
}
./src/jamgram.h100440    167    454        1365  7102105141  12055 0ustar  laurateam#define _BANG 257
#define _BANG_EQUALS 258
#define _AMPERAMPER 259
#define _LPAREN 260
#define _RPAREN 261
#define _PLUS_EQUALS 262
#define _COLON 263
#define _SEMIC 264
#define _LANGLE 265
#define _LANGLE_EQUALS 266
#define _EQUALS 267
#define _RANGLE 268
#define _RANGLE_EQUALS 269
#define _QUESTION_EQUALS 270
#define ACTIONS 271
#define BIND 272
#define CASE 273
#define DEFAULT 274
#define ELSE 275
#define EXISTING 276
#define FOR 277
#define IF 278
#define IGNORE 279
#define IN 280
#define INCLUDE 281
#define LOCAL 282
#define ON 283
#define PIECEMEAL 284
#define QUIETLY 285
#define RULE 286
#define SWITCH 287
#define TOGETHER 288
#define UPDATED 289
#define _LBRACE 290
#define _BARBAR 291
#define _RBRACE 292
#define ARG 293
#define STRING 294
./src/jamgram.y100440    167    454       15520  7102105141  12114 0ustar  laurateam%token _BANG
%token _BANG_EQUALS
%token _AMPERAMPER
%token _LPAREN
%token _RPAREN
%token _PLUS_EQUALS
%token _COLON
%token _SEMIC
%token _LANGLE
%token _LANGLE_EQUALS
%token _EQUALS
%token _RANGLE
%token _RANGLE_EQUALS
%token _QUESTION_EQUALS
%token ACTIONS
%token BIND
%token CASE
%token DEFAULT
%token ELSE
%token EXISTING
%token FOR
%token IF
%token IGNORE
%token IN
%token INCLUDE
%token LOCAL
%token ON
%token PIECEMEAL
%token QUIETLY
%token RULE
%token SWITCH
%token TOGETHER
%token UPDATED
%token _LBRACE
%token _BARBAR
%token _RBRACE
/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

/*
 * jamgram.yy - jam grammar
 *
 * 04/13/94 (seiwald) - added shorthand L0 for null list pointer
 * 06/01/94 (seiwald) - new 'actions existing' does existing sources
 * 08/23/94 (seiwald) - Support for '+=' (append to variable)
 * 08/31/94 (seiwald) - Allow ?= as alias for "default =".
 * 09/15/94 (seiwald) - if conditionals take only single arguments, so
 *			that 'if foo == bar' gives syntax error (use =).
 * 02/11/95 (seiwald) - when scanning arguments to rules, only treat
 *			punctuation keywords as keywords.  All arg lists
 *			are terminated with punctuation keywords.
 */

%token ARG STRING

%left _BARBAR
%left _AMPERAMPER
%left _BANG

%{
#include "jam.h"

#include "lists.h"
#include "parse.h"
#include "scan.h"
#include "compile.h"
#include "newstr.h"

# define F0 (void (*)())0
# define P0 (PARSE *)0
# define S0 (char *)0

# define pset( l,r,a ) 	  parse_make( compile_set,P0,P0,S0,S0,l,r,a )
# define pset1( l,p,a )	  parse_make( compile_settings,p,P0,S0,S0,l,L0,a )
# define pstng( p,l,r,a ) pset1( p, parse_make( F0,P0,P0,S0,S0,l,r,0 ), a )
# define prule( s,p )     parse_make( compile_rule,p,P0,s,S0,L0,L0,0 )
# define prules( l,r )	  parse_make( compile_rules,l,r,S0,S0,L0,L0,0 )
# define pfor( s,p,l )    parse_make( compile_foreach,p,P0,s,S0,l,L0,0 )
# define psetc( s,p )     parse_make( compile_setcomp,p,P0,s,S0,L0,L0,0 )
# define psete( s,l,s1,f ) parse_make( compile_setexec,P0,P0,s,s1,l,L0,f )
# define pincl( l )       parse_make( compile_include,P0,P0,S0,S0,l,L0,0 )
# define pswitch( l,p )   parse_make( compile_switch,p,P0,S0,S0,l,L0,0 )
# define plocal( l,r,p )  parse_make( compile_local,p,P0,S0,S0,l,r,0 )
# define pnull()	  parse_make( compile_null,P0,P0,S0,S0,L0,L0,0 )
# define pcases( l,r )    parse_make( F0,l,r,S0,S0,L0,L0,0 )
# define pcase( s,p )     parse_make( F0,p,P0,s,S0,L0,L0,0 )
# define pif( l,r )	  parse_make( compile_if,l,r,S0,S0,L0,L0,0 )
# define pthen( l,r )	  parse_make( F0,l,r,S0,S0,L0,L0,0 )
# define pcond( c,l,r )	  parse_make( F0,l,r,S0,S0,L0,L0,c )
# define pcomp( c,l,r )	  parse_make( F0,P0,P0,S0,S0,l,r,c )
# define plol( p,l )	  parse_make( F0,p,P0,S0,S0,l,L0,0 )


%}

%%

run	: block
		{ 
		    if( $1.parse->func == compile_null )
		    {
			parse_free( $1.parse );
		    }
		    else
		    {
			parse_save( $1.parse ); 
		    }
		}
	;

/*
 * block - one or more rules
 * rule - any one of jam's rules
 */

block	: /* empty */
		{ $$.parse = pnull(); }
	| rule block
		{ $$.parse = prules( $1.parse, $2.parse ); }
	| LOCAL args _SEMIC block
		{ $$.parse = plocal( $2.list, L0, $4.parse ); }
	| LOCAL args _EQUALS args _SEMIC block
		{ $$.parse = plocal( $2.list, $4.list, $6.parse ); }
	;

rule	: _LBRACE block _RBRACE
		{ $$.parse = $2.parse; }
	| INCLUDE args _SEMIC
		{ $$.parse = pincl( $2.list ); }
	| ARG lol _SEMIC
		{ $$.parse = prule( $1.string, $2.parse ); }
	| arg1 assign args _SEMIC
		{ $$.parse = pset( $1.list, $3.list, $2.number ); }
	| arg1 ON args assign args _SEMIC
		{ $$.parse = pstng( $3.list, $1.list, $5.list, $4.number ); }
	| arg1 DEFAULT _EQUALS args _SEMIC
		{ $$.parse = pset( $1.list, $4.list, ASSIGN_DEFAULT ); }
	| FOR ARG IN args _LBRACE block _RBRACE
		{ $$.parse = pfor( $2.string, $6.parse, $4.list ); }
	| SWITCH args _LBRACE cases _RBRACE
		{ $$.parse = pswitch( $2.list, $4.parse ); }
	| IF cond _LBRACE block _RBRACE 
		{ $$.parse = pif( $2.parse, pthen( $4.parse, pnull() ) ); }
	| IF cond _LBRACE block _RBRACE ELSE rule
		{ $$.parse = pif( $2.parse, pthen( $4.parse, $7.parse ) ); }
	| RULE ARG rule
		{ $$.parse = psetc( $2.string, $3.parse ); }
	| ACTIONS eflags ARG bindlist _LBRACE
		{ yymode( SCAN_STRING ); }
	  STRING 
		{ yymode( SCAN_NORMAL ); }
	  _RBRACE
		{ $$.parse = psete( $3.string,$4.list,$7.string,$2.number ); }
	;

/*
 * assign - = or +=
 */

assign	: _EQUALS
		{ $$.number = ASSIGN_SET; }
	| _PLUS_EQUALS
		{ $$.number = ASSIGN_APPEND; }
	| _QUESTION_EQUALS
		{ $$.number = ASSIGN_DEFAULT; }
	;

/*
 * cond - a conditional for 'if'
 */

cond	: arg1 
		{ $$.parse = pcomp( COND_EXISTS, $1.list, L0 ); }
	| arg1 _EQUALS arg1 
		{ $$.parse = pcomp( COND_EQUALS, $1.list, $3.list ); }
	| arg1 _BANG_EQUALS arg1
		{ $$.parse = pcomp( COND_NOTEQ, $1.list, $3.list ); }
	| arg1 _LANGLE arg1
		{ $$.parse = pcomp( COND_LESS, $1.list, $3.list ); }
	| arg1 _LANGLE_EQUALS arg1 
		{ $$.parse = pcomp( COND_LESSEQ, $1.list, $3.list ); }
	| arg1 _RANGLE arg1 
		{ $$.parse = pcomp( COND_MORE, $1.list, $3.list ); }
	| arg1 _RANGLE_EQUALS arg1 
		{ $$.parse = pcomp( COND_MOREEQ, $1.list, $3.list ); }
	| arg1 IN args
		{ $$.parse = pcomp( COND_IN, $1.list, $3.list ); }
	| _BANG cond
		{ $$.parse = pcond( COND_NOT, $2.parse, P0 ); }
	| cond _AMPERAMPER cond 
		{ $$.parse = pcond( COND_AND, $1.parse, $3.parse ); }
	| cond _BARBAR cond
		{ $$.parse = pcond( COND_OR, $1.parse, $3.parse ); }
	| _LPAREN cond _RPAREN
		{ $$.parse = $2.parse; }
	;

/*
 * cases - action elements inside a 'switch'
 * case - a single action element inside a 'switch'
 *
 * Unfortunately, a right-recursive rule.
 */

cases	: /* empty */
		{ $$.parse = P0; }
	| case cases
		{ $$.parse = pcases( $1.parse, $2.parse ); }
	;

case	: CASE ARG _COLON block
		{ $$.parse = pcase( $2.string, $4.parse ); }
	;

/*
 * lol - list of lists
 */

lol	: args
		{ $$.parse = plol( P0, $1.list ); }
	| args _COLON lol
		{ $$.parse = plol( $3.parse, $1.list ); }
	;

/*
 * args - zero or more ARGs in a LIST
 * arg1 - exactly one ARG in a LIST 
 */

args	: argsany
		{ yymode( SCAN_NORMAL ); }
	;

argsany	: /* empty */
		{ $$.list = L0; yymode( SCAN_PUNCT ); }
	| argsany ARG
		{ $$.list = list_new( $1.list, copystr( $2.string ) ); }
	;

arg1	: ARG 
		{ $$.list = list_new( L0, copystr( $1.string ) ); }
	;

/*
 * eflags - zero or more modifiers to 'executes'
 * eflag - a single modifier to 'executes'
 */

eflags	: /* empty */
		{ $$.number = 0; }
	| eflags eflag
		{ $$.number = $1.number | $2.number; }
	;

eflag	: UPDATED
		{ $$.number = EXEC_UPDATED; }
	| TOGETHER
		{ $$.number = EXEC_TOGETHER; }
	| IGNORE
		{ $$.number = EXEC_IGNORE; }
	| QUIETLY
		{ $$.number = EXEC_QUIETLY; }
	| PIECEMEAL
		{ $$.number = EXEC_PIECEMEAL; }
	| EXISTING
		{ $$.number = EXEC_EXISTING; }
	;


/*
 * bindlist - list of variable to bind for an action
 */

bindlist : /* empty */
		{ $$.list = L0; }
	| BIND args
		{ $$.list = $2.list; }
	;


./src/jamgram.yy100440    167    454       14253  7102105141  12307 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

/*
 * jamgram.yy - jam grammar
 *
 * 04/13/94 (seiwald) - added shorthand L0 for null list pointer
 * 06/01/94 (seiwald) - new 'actions existing' does existing sources
 * 08/23/94 (seiwald) - Support for '+=' (append to variable)
 * 08/31/94 (seiwald) - Allow ?= as alias for "default =".
 * 09/15/94 (seiwald) - if conditionals take only single arguments, so
 *			that 'if foo == bar' gives syntax error (use =).
 * 02/11/95 (seiwald) - when scanning arguments to rules, only treat
 *			punctuation keywords as keywords.  All arg lists
 *			are terminated with punctuation keywords.
 */

%token ARG STRING

%left `||`
%left `&&`
%left `!`

%{
#include "jam.h"

#include "lists.h"
#include "parse.h"
#include "scan.h"
#include "compile.h"
#include "newstr.h"

# define F0 (void (*)())0
# define P0 (PARSE *)0
# define S0 (char *)0

# define pset( l,r,a ) 	  parse_make( compile_set,P0,P0,S0,S0,l,r,a )
# define pset1( l,p,a )	  parse_make( compile_settings,p,P0,S0,S0,l,L0,a )
# define pstng( p,l,r,a ) pset1( p, parse_make( F0,P0,P0,S0,S0,l,r,0 ), a )
# define prule( s,p )     parse_make( compile_rule,p,P0,s,S0,L0,L0,0 )
# define prules( l,r )	  parse_make( compile_rules,l,r,S0,S0,L0,L0,0 )
# define pfor( s,p,l )    parse_make( compile_foreach,p,P0,s,S0,l,L0,0 )
# define psetc( s,p )     parse_make( compile_setcomp,p,P0,s,S0,L0,L0,0 )
# define psete( s,l,s1,f ) parse_make( compile_setexec,P0,P0,s,s1,l,L0,f )
# define pincl( l )       parse_make( compile_include,P0,P0,S0,S0,l,L0,0 )
# define pswitch( l,p )   parse_make( compile_switch,p,P0,S0,S0,l,L0,0 )
# define plocal( l,r,p )  parse_make( compile_local,p,P0,S0,S0,l,r,0 )
# define pnull()	  parse_make( compile_null,P0,P0,S0,S0,L0,L0,0 )
# define pcases( l,r )    parse_make( F0,l,r,S0,S0,L0,L0,0 )
# define pcase( s,p )     parse_make( F0,p,P0,s,S0,L0,L0,0 )
# define pif( l,r )	  parse_make( compile_if,l,r,S0,S0,L0,L0,0 )
# define pthen( l,r )	  parse_make( F0,l,r,S0,S0,L0,L0,0 )
# define pcond( c,l,r )	  parse_make( F0,l,r,S0,S0,L0,L0,c )
# define pcomp( c,l,r )	  parse_make( F0,P0,P0,S0,S0,l,r,c )
# define plol( p,l )	  parse_make( F0,p,P0,S0,S0,l,L0,0 )


%}

%%

run	: block
		{ 
		    if( $1.parse->func == compile_null )
		    {
			parse_free( $1.parse );
		    }
		    else
		    {
			parse_save( $1.parse ); 
		    }
		}
	;

/*
 * block - one or more rules
 * rule - any one of jam's rules
 */

block	: /* empty */
		{ $$.parse = pnull(); }
	| rule block
		{ $$.parse = prules( $1.parse, $2.parse ); }
	| `local` args `;` block
		{ $$.parse = plocal( $2.list, L0, $4.parse ); }
	| `local` args `=` args `;` block
		{ $$.parse = plocal( $2.list, $4.list, $6.parse ); }
	;

rule	: `{` block `}`
		{ $$.parse = $2.parse; }
	| `include` args `;`
		{ $$.parse = pincl( $2.list ); }
	| ARG lol `;`
		{ $$.parse = prule( $1.string, $2.parse ); }
	| arg1 assign args `;`
		{ $$.parse = pset( $1.list, $3.list, $2.number ); }
	| arg1 `on` args assign args `;`
		{ $$.parse = pstng( $3.list, $1.list, $5.list, $4.number ); }
	| arg1 `default` `=` args `;`
		{ $$.parse = pset( $1.list, $4.list, ASSIGN_DEFAULT ); }
	| `for` ARG `in` args `{` block `}`
		{ $$.parse = pfor( $2.string, $6.parse, $4.list ); }
	| `switch` args `{` cases `}`
		{ $$.parse = pswitch( $2.list, $4.parse ); }
	| `if` cond `{` block `}` 
		{ $$.parse = pif( $2.parse, pthen( $4.parse, pnull() ) ); }
	| `if` cond `{` block `}` `else` rule
		{ $$.parse = pif( $2.parse, pthen( $4.parse, $7.parse ) ); }
	| `rule` ARG rule
		{ $$.parse = psetc( $2.string, $3.parse ); }
	| `actions` eflags ARG bindlist `{`
		{ yymode( SCAN_STRING ); }
	  STRING 
		{ yymode( SCAN_NORMAL ); }
	  `}`
		{ $$.parse = psete( $3.string,$4.list,$7.string,$2.number ); }
	;

/*
 * assign - = or +=
 */

assign	: `=`
		{ $$.number = ASSIGN_SET; }
	| `+=`
		{ $$.number = ASSIGN_APPEND; }
	| `?=`
		{ $$.number = ASSIGN_DEFAULT; }
	;

/*
 * cond - a conditional for 'if'
 */

cond	: arg1 
		{ $$.parse = pcomp( COND_EXISTS, $1.list, L0 ); }
	| arg1 `=` arg1 
		{ $$.parse = pcomp( COND_EQUALS, $1.list, $3.list ); }
	| arg1 `!=` arg1
		{ $$.parse = pcomp( COND_NOTEQ, $1.list, $3.list ); }
	| arg1 `<` arg1
		{ $$.parse = pcomp( COND_LESS, $1.list, $3.list ); }
	| arg1 `<=` arg1 
		{ $$.parse = pcomp( COND_LESSEQ, $1.list, $3.list ); }
	| arg1 `>` arg1 
		{ $$.parse = pcomp( COND_MORE, $1.list, $3.list ); }
	| arg1 `>=` arg1 
		{ $$.parse = pcomp( COND_MOREEQ, $1.list, $3.list ); }
	| arg1 `in` args
		{ $$.parse = pcomp( COND_IN, $1.list, $3.list ); }
	| `!` cond
		{ $$.parse = pcond( COND_NOT, $2.parse, P0 ); }
	| cond `&&` cond 
		{ $$.parse = pcond( COND_AND, $1.parse, $3.parse ); }
	| cond `||` cond
		{ $$.parse = pcond( COND_OR, $1.parse, $3.parse ); }
	| `(` cond `)`
		{ $$.parse = $2.parse; }
	;

/*
 * cases - action elements inside a 'switch'
 * case - a single action element inside a 'switch'
 *
 * Unfortunately, a right-recursive rule.
 */

cases	: /* empty */
		{ $$.parse = P0; }
	| case cases
		{ $$.parse = pcases( $1.parse, $2.parse ); }
	;

case	: `case` ARG `:` block
		{ $$.parse = pcase( $2.string, $4.parse ); }
	;

/*
 * lol - list of lists
 */

lol	: args
		{ $$.parse = plol( P0, $1.list ); }
	| args `:` lol
		{ $$.parse = plol( $3.parse, $1.list ); }
	;

/*
 * args - zero or more ARGs in a LIST
 * arg1 - exactly one ARG in a LIST 
 */

args	: argsany
		{ yymode( SCAN_NORMAL ); }
	;

argsany	: /* empty */
		{ $$.list = L0; yymode( SCAN_PUNCT ); }
	| argsany ARG
		{ $$.list = list_new( $1.list, copystr( $2.string ) ); }
	;

arg1	: ARG 
		{ $$.list = list_new( L0, copystr( $1.string ) ); }
	;

/*
 * eflags - zero or more modifiers to 'executes'
 * eflag - a single modifier to 'executes'
 */

eflags	: /* empty */
		{ $$.number = 0; }
	| eflags eflag
		{ $$.number = $1.number | $2.number; }
	;

eflag	: `updated`
		{ $$.number = EXEC_UPDATED; }
	| `together`
		{ $$.number = EXEC_TOGETHER; }
	| `ignore`
		{ $$.number = EXEC_IGNORE; }
	| `quietly`
		{ $$.number = EXEC_QUIETLY; }
	| `piecemeal`
		{ $$.number = EXEC_PIECEMEAL; }
	| `existing`
		{ $$.number = EXEC_EXISTING; }
	;


/*
 * bindlist - list of variable to bind for an action
 */

bindlist : /* empty */
		{ $$.list = L0; }
	| `bind` args
		{ $$.list = $2.list; }
	;


./src/jamgramtab.h100440    167    454        1410  7102105141  12533 0ustar  laurateam	{ "!", _BANG },
	{ "!=", _BANG_EQUALS },
	{ "&&", _AMPERAMPER },
	{ "(", _LPAREN },
	{ ")", _RPAREN },
	{ "+=", _PLUS_EQUALS },
	{ ":", _COLON },
	{ ";", _SEMIC },
	{ "<", _LANGLE },
	{ "<=", _LANGLE_EQUALS },
	{ "=", _EQUALS },
	{ ">", _RANGLE },
	{ ">=", _RANGLE_EQUALS },
	{ "?=", _QUESTION_EQUALS },
	{ "actions", ACTIONS },
	{ "bind", BIND },
	{ "case", CASE },
	{ "default", DEFAULT },
	{ "else", ELSE },
	{ "existing", EXISTING },
	{ "for", FOR },
	{ "if", IF },
	{ "ignore", IGNORE },
	{ "in", IN },
	{ "include", INCLUDE },
	{ "local", LOCAL },
	{ "on", ON },
	{ "piecemeal", PIECEMEAL },
	{ "quietly", QUIETLY },
	{ "rule", RULE },
	{ "switch", SWITCH },
	{ "together", TOGETHER },
	{ "updated", UPDATED },
	{ "{", _LBRACE },
	{ "||", _BARBAR },
	{ "}", _RBRACE },
./src/lists.c100440    167    454        7353  7102105141  11573 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

# include "jam.h"
# include "newstr.h"
# include "lists.h"

/*
 * lists.c - maintain lists of strings
 *
 * The whole of jam relies on lists of strings as a datatype.  This
 * module, in conjunction with newstr.c, handles these relatively
 * efficiently.
 *
 * External routines:
 *
 *	list_append() - append a list onto another one, returning total
 *	list_new() - tack a string onto the end of a list of strings
 * 	list_copy() - copy a whole list of strings
 *	list_sublist() - copy a subset of a list of strings
 *	list_free() - free a list of strings
 *	list_print() - print a list of strings to stdout
 *
 * This implementation essentially uses a singly linked list, but
 * guarantees that the head element of every list has a valid pointer
 * to the tail of the list, so the new elements can efficiently and 
 * properly be appended to the end of a list.
 *
 * To avoid massive allocation, list_free() just tacks the whole freed
 * chain onto freelist and list_new() looks on freelist first for an
 * available list struct.  list_free() does not free the strings in the 
 * chain: it lazily lets list_new() do so.
 *
 * 08/23/94 (seiwald) - new list_append()
 */

static LIST *freelist = 0;	/* junkpile for list_free() */

/*
 * list_append() - append a list onto another one, returning total
 */

LIST *
list_append( l, nl )
LIST	*l;
LIST	*nl;
{
	if( !nl )
	{
	    /* Just return l */
	}
	else if( !l )
	{
	    l = nl;
	}
	else
	{
	    /* Graft two non-empty lists. */
	    l->tail->next = nl;
	    l->tail = nl->tail;
	}

	return l;
}

/*
 * list_new() - tack a string onto the end of a list of strings
 */

LIST *
list_new( head, string )
LIST	*head;
char	*string;
{
	LIST *l;

	if( DEBUG_LISTS )
	    printf( "list > %s <\n", string );

	/* Get list struct from freelist, if one available.  */
	/* Otherwise allocate. */
	/* If from freelist, must free string first */

	if( freelist )
	{
	    l = freelist;
	    freestr( l->string );
	    freelist = freelist->next;
	}
	else
	{
	    l = (LIST *)malloc( sizeof( *l ) );
	}

	/* If first on chain, head points here. */
	/* If adding to chain, tack us on. */
	/* Tail must point to this new, last element. */

	if( !head ) head = l;
	else head->tail->next = l;
	head->tail = l;
	l->next = 0;

	l->string = string;

	return head;
}

/*
 * list_copy() - copy a whole list of strings (nl) onto end of another (l)
 */

LIST *
list_copy( l, nl )
LIST	*l;
LIST 	*nl;
{
	for( ; nl; nl = list_next( nl ) )
	    l = list_new( l, copystr( nl->string ) );

	return l;
}

/*
 * list_sublist() - copy a subset of a list of strings
 */

LIST *
list_sublist( l, start, count )
LIST	*l;
{
	LIST	*nl = 0;

	for( ; l && start--; l = list_next( l ) )
	    ;

	for( ; l && count--; l = list_next( l ) )
	    nl = list_new( nl, copystr( l->string ) );

	return nl;
}

/*
 * list_free() - free a list of strings
 */

void
list_free( head )
LIST	*head;
{
	/* Just tack onto freelist. */

	if( head )
	{
	    head->tail->next = freelist;
	    freelist = head;
	}
}

/*
 * list_print() - print a list of strings to stdout
 */

void
list_print( l )
LIST	*l;
{
	for( ; l; l = list_next( l ) )
	    printf( "%s ", l->string );
}

void
lol_init( lol )
LOL	*lol;
{
	lol->count = 0;
}

void
lol_add( lol, l )
LOL	*lol;
LIST	*l;
{
	if( lol->count < LOL_MAX )
	    lol->list[ lol->count++ ] = l;
}

void
lol_free( lol )
LOL	*lol;
{
	int i;

	for( i = 0; i < lol->count; i++ )
	    list_free( lol->list[i] );

	lol->count = 0;
}

LIST *
lol_get( lol, i )
LOL	*lol;
int	i;
{
	return i < lol->count ? lol->list[i] : 0;
}

void
lol_print( lol )
LOL	*lol;
{
	int i;

	for( i = 0; i < lol->count; i++ )
	{
	    if( i )
		printf( " : " );
	    list_print( lol->list[i] );
	}
}
./src/lists.h100440    167    454        1516  7102105141  11573 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

/*
 * lists.h - the LIST structure and routines to manipulate them
 *
 * 04/13/94 (seiwald) - added shorthand L0 for null list pointer
 * 08/23/94 (seiwald) - new list_append()
 */

/*
 * LIST - list of strings
 */

typedef struct _list LIST;

struct _list {
	LIST	*next;
	LIST	*tail;		/* only valid in head node */
	char	*string;	/* private copy */
} ;

typedef struct _lol LOL;

# define LOL_MAX 9

struct _lol {
	int	count;
	LIST	*list[ LOL_MAX ];
} ;

LIST	*list_append();
LIST 	*list_copy();
LIST 	*list_new();
void	list_free();
void	list_print();
LIST	*list_sublist();

# define list_next( l ) ((l)->next)

# define L0 ((LIST *)0)

void	lol_init();
void	lol_add();
void	lol_free();
LIST	*lol_get();
void	lol_print();
./src/make.c100440    167    454       24234  7102105141  11367 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

/*
 * make.c - bring a target up to date, once rules are in place
 *
 * This modules controls the execution of rules to bring a target and
 * its dependencies up to date.  It is invoked after the targets, rules,
 * et. al. described in rules.h are created by the interpreting of the
 * jam files.
 *
 * This file contains the main make() entry point and the first pass
 * make0().  The second pass, make1(), which actually does the command
 * execution, is in make1.c.
 *
 * External routines:
 *	make() - make a target, given its name
 *
 * Internal routines:
 * 	make0() - bind and scan everything to make a TARGET
 *
 * 12/26/93 (seiwald) - allow NOTIME targets to be expanded via $(<), $(>)
 * 01/04/94 (seiwald) - print all targets, bounded, when tracing commands
 * 04/08/94 (seiwald) - progress report now reflects only targets with actions
 * 04/11/94 (seiwald) - Combined deps & headers into deps[2] in TARGET.
 * 12/20/94 (seiwald) - NOTIME renamed NOTFILE.
 * 12/20/94 (seiwald) - make0() headers after determining fate of target, so 
 *			that headers aren't seen as dependents on themselves.
 * 01/19/95 (seiwald) - distinguish between CANTFIND/CANTMAKE targets.
 * 02/02/95 (seiwald) - propagate leaf source time for new LEAVES rule.
 * 02/14/95 (seiwald) - NOUPDATE rule means don't update existing target.
 * 08/22/95 (seiwald) - NOUPDATE targets immune to anyhow (-a) flag.
 */

# include "jam.h"

# include "lists.h"
# include "parse.h"
# include "variable.h"
# include "rules.h"

# include "search.h"
# include "newstr.h"
# include "make.h"
# include "headers.h"
# include "command.h"

static void make0();

# ifndef max
# define max( a,b ) ((a)>(b)?(a):(b))
# endif

typedef struct {
	int	temp;
	int	updating;
	int	cantfind;
	int	cantmake;
	int	targets;
	int	made;
} COUNTS ;

static char *target_fate[] = 
{
	"init",		/* T_FATE_INIT */
	"making", 	/* T_FATE_MAKING */
	"stable", 	/* T_FATE_STABLE */
	"newer",	/* T_FATE_NEWER */
	"temp", 	/* T_FATE_ISTMP */
	"touched", 	/* T_FATE_TOUCHED */
	"missing", 	/* T_FATE_MISSING */
	"old", 		/* T_FATE_OUTDATED */
	"update", 	/* T_FATE_UPDATE */
	"nofind", 	/* T_FATE_CANTFIND */
	"nomake" 	/* T_FATE_CANTMAKE */
} ;

static char *target_bind[] = 
{
	"unbound",
	"missing",
	"parents",
	"exists",
} ;

# define spaces(x) ( "                " + 16 - ( x > 16 ? 16 : x ) )

/*
 * make() - make a target, given its name
 */

int
make( n_targets, targets, anyhow )
int	n_targets;
char	**targets;
int	anyhow;
{
	int i;
	COUNTS counts[1];
	int status = 0;		/* 1 if anything fails */

	memset( (char *)counts, 0, sizeof( *counts ) );

	for( i = 0; i < n_targets; i++ )
	{
	    TARGET *t = bindtarget( targets[i] );

	    make0( t, T_BIND_UNBOUND, (time_t)0, 0, counts, anyhow );
	}

	if( DEBUG_MAKE )
	{
	    if( counts->targets )
		printf( "...found %d target(s)...\n", counts->targets );
	    if( counts->temp )
		printf( "...using %d temp target(s)...\n", counts->temp );
	    if( counts->updating )
		printf( "...updating %d target(s)...\n", counts->updating );
	    if( counts->cantfind )
		printf( "...can't find %d target(s)...\n", counts->cantfind );
	    if( counts->cantmake )
		printf( "...can't make %d target(s)...\n", counts->cantmake );
	}

	status = counts->cantfind || counts->cantmake;

	for( i = 0; i < n_targets; i++ )
	    status |= make1( bindtarget( targets[i] ) );

	return status;
}

/*
 * make0() - bind and scan everything to make a TARGET
 *
 * Make0() recursively binds a target, searches for #included headers,
 * calls itself on those headers, and calls itself on any dependents.
 */

static void
make0( t, pbinding, ptime, depth, counts, anyhow )
TARGET	*t;
int	pbinding;	/* parent target's binding */
time_t	ptime;		/* parent target's timestamp */
int	depth;		/* for display purposes */
COUNTS	*counts;	/* for reporting */
int	anyhow;		/* forcibly touch all (real) targets */
{
	TARGETS	*c;
	int	fate, hfate;
	time_t	last, leaf, hlast, hleaf;
	char	*flag = "";

	if( DEBUG_MAKEPROG )
	    printf( "make\t--\t%s%s\n", spaces( depth ), t->name );

	/* 
	 * Step 1: don't remake if already trying or tried 
	 */

	switch( t->fate )
	{
	case T_FATE_MAKING:
	    printf( "warning: %s depends on itself\n", t->name );
	    return;

	default:
	    return;

	case T_FATE_INIT:
	    break;
	}

	t->fate = T_FATE_MAKING;

	/*
	 * Step 2: under the influence of "on target" variables,
	 * bind the target and search for headers.
	 */

	/* Step 2a: set "on target" variables. */

	pushsettings( t->settings );

	/* Step 2b: find and timestamp the target file (if it's a file). */

	if( t->binding == T_BIND_UNBOUND && !( t->flags & T_FLAG_NOTFILE ) )
	{
	    t->boundname = search( t->name, &t->time );
	    t->binding = t->time ? T_BIND_EXISTS : T_BIND_MISSING;
	}

	/* If temp file doesn't exist, use parent */

	if( t->binding == T_BIND_MISSING && t->flags & T_FLAG_TEMP && ptime )
	{
	    t->time = ptime;
	    t->binding = t->time ? T_BIND_PARENTS : T_BIND_MISSING;
	}

	/* Step 2c: If its a file, search for headers. */

	if( t->binding == T_BIND_EXISTS )
	    headers( t );

	/* Step 2d: reset "on target" variables */

	popsettings( t->settings );

	/* 
	 * Pause for a little progress reporting 
	 */

	if( DEBUG_BIND )
	{
	    if( strcmp( t->name, t->boundname ) )
	    {
		printf( "bind\t--\t%s%s: %s\n",
			spaces( depth ), t->name, t->boundname );
	    }

	    switch( t->binding )
	    {
	    case T_BIND_UNBOUND:
	    case T_BIND_MISSING:
	    case T_BIND_PARENTS:
		printf( "time\t--\t%s%s: %s\n",
			spaces( depth ), t->name, target_bind[ t->binding ] );
		break;

	    case T_BIND_EXISTS:
		printf( "time\t--\t%s%s: %s",
			spaces( depth ), t->name, ctime( &t->time ) );
		break;
	    }
	}

	/* 
	 * Step 3: recursively make0() dependents 
	 */

	last = 0;
	leaf = 0;
	fate = T_FATE_STABLE;

	for( c = t->deps[ T_DEPS_DEPENDS ]; c; c = c->next )
	{
	    make0( c->target, t->binding, t->time, depth + 1, counts, anyhow );
	    leaf = max( leaf, c->target->leaf );
	    leaf = max( leaf, c->target->hleaf );

	    /* If LEAVES has been applied, we only heed the timestamps of */
	    /* the leaf source nodes. */

	    if( t->flags & T_FLAG_LEAVES )
	    {
		last = leaf;
		continue;
	    }

	    last = max( last, c->target->time );
	    last = max( last, c->target->htime );
	    fate = max( fate, c->target->fate );
	    fate = max( fate, c->target->hfate );
	}

	/* If a NOUPDATE file exists, make dependents eternally old. */

	if( t->flags & T_FLAG_NOUPDATE )
	{
	    last = 0;
	    t->time = 0;

	    /*
	     * Don't inherit our fate from our dependents.  Decide fate
	     * based only upon other flags and our binding (done later).
	     */

	    fate = T_FATE_STABLE;
	}

	/* Step 3b: determine fate: rebuild target or what? */

	/* 
	    In English:
		If can't find or make child, can't make target.
		If children changed, make target.
		If target missing, make it.
		If children newer, make target.
		If temp's children newer, make temp.
		If deliberately touched, make it.
		If up-to-date temp file present, use it.
		If target exists but parent not, mark target newer.
		If target newer than parent, mark target newer.
		Don't propagate child's "newer" status.
	*/

	if( fate >= T_FATE_BROKEN )
	{
	    fate = T_FATE_CANTMAKE;
	}
	else if( fate >= T_FATE_SPOIL )
	{
	    fate = T_FATE_UPDATE;
	}
	else if( t->binding == T_BIND_MISSING )
	{
	    fate = T_FATE_MISSING;
	}
	else if( t->binding == T_BIND_EXISTS && last > t->time )
	{
	    fate = T_FATE_OUTDATED;
	}
	else if( t->binding == T_BIND_PARENTS && last > t->time )
	{
	    fate = T_FATE_OUTDATED;
	}
	else if( t->flags & T_FLAG_TOUCHED )
	{
	    fate = T_FATE_TOUCHED;
	}
	else if( anyhow && !( t->flags & T_FLAG_NOUPDATE ) )
	{
	    fate = T_FATE_TOUCHED;
	}
	else if( t->binding == T_BIND_EXISTS && t->flags & T_FLAG_TEMP )
	{
	    fate = T_FATE_ISTMP;
	}
	else if( t->binding == T_BIND_EXISTS && pbinding == T_BIND_MISSING )
	{
	    fate = T_FATE_NEWER;
	}
	else if( t->binding == T_BIND_EXISTS && ptime && t->time > ptime )
	{
	    fate = T_FATE_NEWER;
	}
	else if( fate == T_FATE_NEWER )
	{
	    fate = T_FATE_STABLE;
	}

	/* Step 3c: handle missing files */
	/* If it's missing and there are no actions to create it, boom. */
	/* If we can't make a target we don't care about, 'sokay */
	/* We could insist that there are updating actions for all missing */
	/* files, but if they have dependents we just pretend it's NOTFILE. */

	if( fate == T_FATE_MISSING && 
		!t->actions && 
		!t->deps[ T_DEPS_DEPENDS ] )
	{
	    if( t->flags & T_FLAG_NOCARE )
	    {
		fate = T_FATE_STABLE;
	    }
	    else
	    {
		printf( "don't know how to make %s\n", t->name );

		fate = T_FATE_CANTFIND;
	    }
	}

	/* Step 3d: propagate dependents' time & fate. */
	/* Set leaf time to be our time only if this is a leaf. */

	t->time = max( t->time, last );
	t->leaf = leaf ? leaf : t->time ;
	t->fate = fate;

	/*
	 * Step 4: Recursively make0() headers.
	 */

	/* Step 4a: recursively make0() headers */

	hlast = 0;
	hleaf = 0;
	hfate = T_FATE_STABLE;

	for( c = t->deps[ T_DEPS_INCLUDES ]; c; c = c->next )
	{
	    make0( c->target, pbinding, ptime, depth + 1, counts, anyhow );
	    hlast = max( hlast, c->target->time );
	    hlast = max( hlast, c->target->htime );
	    hleaf = max( hleaf, c->target->leaf );
	    hleaf = max( hleaf, c->target->hleaf );
	    hfate = max( hfate, c->target->fate );
	    hfate = max( hfate, c->target->hfate );
	}

	/* Step 4b: propagate dependents' time & fate. */

	t->htime = hlast;
	t->hleaf = hleaf ? hleaf : t->htime;
	t->hfate = hfate;

	/* 
	 * Step 5: a little harmless tabulating for tracing purposes 
	 */

	if( !( ++counts->targets % 1000 ) && DEBUG_MAKE )
	    printf( "...patience...\n" );

	if( fate == T_FATE_ISTMP )
	    counts->temp++;
	else if( fate == T_FATE_CANTFIND )
	    counts->cantfind++;
	else if( fate == T_FATE_CANTMAKE && t->actions )
	    counts->cantmake++;
	else if( fate >= T_FATE_BUILD && fate < T_FATE_BROKEN && t->actions )
	    counts->updating++;

	if( !( t->flags & T_FLAG_NOTFILE ) && fate >= T_FATE_SPOIL )
	    flag = "+";
	else if( t->binding == T_BIND_EXISTS && ptime && t->time > ptime )
	    flag = "*";

	if( DEBUG_MAKEPROG )
	    printf( "made%s\t%s\t%s%s\n", 
		flag, target_fate[ t->fate ], 
		spaces( depth ), t->name );
}

./src/make.h100440    167    454         333  7102105141  11326 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

/*
 * make.h - bring a target up to date, once rules are in place
 */

int make();
int make1();
./src/make1.c100440    167    454       40017  7102105141  11445 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

/*
 * make1.c - execute command to bring targets up to date
 *
 * This module contains make1(), the entry point called by make() to 
 * recursively decend the dependency graph executing update actions as
 * marked by make0().
 *
 * External routines:
 *
 *	make1() - execute commands to update a TARGET and all its dependents
 *
 * Internal routines, the recursive/asynchronous command executors:
 *
 *	make1a() - recursively traverse target tree, calling make1b()
 *	make1b() - dependents of target built, now build target with make1c()
 *	make1c() - launch target's next command, call make1b() when done
 *	make1d() - handle command execution completion and call back make1c()
 *
 * Internal support routines:
 *
 *	make1cmds() - turn ACTIONS into CMDs, grouping, splitting, etc
 *	make1chunk() - compute number of source that can fit on cmd line
 *	make1list() - turn a list of targets into a LIST, for $(<) and $(>)
 * 	make1settings() - for vars that get bound values, build up replacement lists
 * 	make1bind() - bind targets that weren't bound in dependency analysis
 *
 * 04/16/94 (seiwald) - Split from make.c.
 * 04/21/94 (seiwald) - Handle empty "updated" actions.
 * 05/04/94 (seiwald) - async multiprocess (-j) support
 * 06/01/94 (seiwald) - new 'actions existing' does existing sources
 * 12/20/94 (seiwald) - NOTIME renamed NOTFILE.
 * 01/19/95 (seiwald) - distinguish between CANTFIND/CANTMAKE targets.
 * 01/22/94 (seiwald) - pass per-target JAMSHELL down to execcmd().
 * 02/28/95 (seiwald) - Handle empty "existing" actions.
 * 03/10/95 (seiwald) - Fancy counts.
 */

# include "jam.h"

# include "lists.h"
# include "parse.h"
# include "variable.h"
# include "rules.h"

# include "search.h"
# include "newstr.h"
# include "make.h"
# include "command.h"
# include "execcmd.h"

static void make1a();
static void make1b();
static void make1c();
static void make1d();

static CMD *make1cmds();
static int make1chunk();
static LIST *make1list();
static SETTINGS *make1settings();
static void make1bind();

/* Ugly static - it's too hard to carry it through the callbacks. */

static struct {
	int	failed;
	int	skipped;
	int	total;
	int	made;
} counts[1] ;

/*
 * make1() - execute commands to update a TARGET and all its dependents
 */

static int intr = 0;

int
make1( t )
TARGET *t;
{
	memset( (char *)counts, 0, sizeof( *counts ) );

	/* Recursively make the target and its dependents */

	make1a( t, (TARGET *)0 );

	/* Wait for any outstanding commands to finish running. */

	while( execwait() )
	    ;

	/* Talk about it */

	if( DEBUG_MAKE && counts->failed )
	    printf( "...failed updating %d target(s)...\n", counts->failed );

	if( DEBUG_MAKE && counts->skipped )
	    printf( "...skipped %d target(s)...\n", counts->skipped );

	if( DEBUG_MAKE && counts->made )
	    printf( "...updated %d target(s)...\n", counts->made );

	return counts->total != counts->made;
}

/*
 * make1a() - recursively traverse target tree, calling make1b()
 */

static void
make1a( t, parent )
TARGET	*t;
TARGET	*parent;
{
	TARGETS	*c;
	int i;

	/* If the parent is the first to try to build this target */
	/* or this target is in the make1c() quagmire, arrange for the */
	/* parent to be notified when this target is built. */

	if( parent )
	    switch( t->progress )
	{
	case T_MAKE_INIT:
	case T_MAKE_ACTIVE:
	case T_MAKE_RUNNING:
	    t->parents = targetentry( t->parents, parent );
	    parent->asynccnt++;
	}

	if( t->progress != T_MAKE_INIT )
	    return;

	/* Asynccnt counts the dependents preventing this target from */
	/* proceeding to make1b() for actual building.  We start off with */
	/* a count of 1 to prevent anything from happening until we can */
	/* call all dependents.  This 1 is accounted for when we call */
	/* make1b() ourselves, below. */

	t->asynccnt = 1;

	/* Recurse on our dependents, manipulating progress to guard */
	/* against circular dependency. */

	t->progress = T_MAKE_ONSTACK;

	for( i = T_DEPS_DEPENDS; i <= T_DEPS_INCLUDES; i++ )
	    for( c = t->deps[i]; c && !intr; c = c->next )
		make1a( c->target, t );

	t->progress = T_MAKE_ACTIVE;

	/* Now that all dependents have bumped asynccnt, we now allow */
	/* decrement our reference to asynccnt. */ 

	make1b( t );
}

/*
 * make1b() - dependents of target built, now build target with make1c()
 */

static void
make1b( t )
TARGET	*t;
{
	TARGETS	*c;
	int 	i;
	char 	*failed = "dependents";

	/* If any dependents are still outstanding, wait until they */
	/* call make1b() to signal their completion. */

	if( --t->asynccnt )
	    return;

	/* Now ready to build target 't'... if dependents built ok. */

	/* Collect status from dependents */

	for( i = T_DEPS_DEPENDS; i <= T_DEPS_INCLUDES; i++ )
	    for( c = t->deps[i]; c; c = c->next )
		if( c->target->status > t->status )
	{
	    failed = c->target->name;
	    t->status = c->target->status;
	}

	/* If actions on deps have failed, bail. */
	/* Otherwise, execute all actions to make target */

	if( t->status == EXEC_CMD_FAIL && t->actions )
	{
	    ++counts->skipped;
	    printf( "...skipped %s for lack of %s...\n", t->name, failed );
	}

	if( t->status == EXEC_CMD_OK )
	    switch( t->fate )
	{
	case T_FATE_INIT:
	case T_FATE_MAKING:
	    /* shouldn't happen */

	case T_FATE_STABLE:
	case T_FATE_NEWER:
	    break;

	case T_FATE_CANTFIND:
	case T_FATE_CANTMAKE:
	    t->status = EXEC_CMD_FAIL;
	    break;

	case T_FATE_ISTMP:
	    if( DEBUG_MAKE )
		printf( "...using %s...\n", t->name );
	    break;

	case T_FATE_TOUCHED:
	case T_FATE_MISSING:
	case T_FATE_OUTDATED:
	case T_FATE_UPDATE:
	    /* Set "on target" vars, build actions, unset vars */
	    /* Set "progress" so that make1c() counts this target among */
	    /* the successes/failures. */

	    if( t->actions )
	    {
		if( DEBUG_MAKE && !( ++counts->total % 100 ) )
		    printf( "...on %dth target...\n", counts->total );

		pushsettings( t->settings );
		t->cmds = (char *)make1cmds( t->actions );
		popsettings( t->settings );

		t->progress = T_MAKE_RUNNING;
	    }

	    break;
	}

	/* Call make1c() to begin the execution of the chain of commands */
	/* needed to build target.  If we're not going to build target */
	/* (because of dependency failures or because no commands need to */
	/* be run) the chain will be empty and make1c() will directly */
	/* signal the completion of target. */

	make1c( t );
}

/*
 * make1c() - launch target's next command, call make1b() when done
 */

static void
make1c( t )
TARGET	*t;
{
	CMD	*cmd = (CMD *)t->cmds;

	/* If there are (more) commands to run to build this target */
	/* (and we haven't hit an error running earlier comands) we */
	/* launch the command with execcmd(). */
	
	/* If there are no more commands to run, we collect the status */
	/* from all the actions then report our completion to all the */
	/* parents. */

	if( cmd && t->status == EXEC_CMD_OK )
	{
	    if( DEBUG_MAKE )
		if( DEBUG_MAKEQ || ! ( cmd->rule->flags & RULE_QUIETLY ) )
	    {
		printf( "%s ", cmd->rule->name );
		list_print( lol_get( &cmd->args, 0 ) );
		printf( "\n" );
	    }

	    if( DEBUG_EXEC )
		printf( "%s\n", cmd->buf );

	    if( globs.cmdout )
		fprintf( globs.cmdout, "%s", cmd->buf );

	    if( globs.noexec )
	    {
		make1d( t, EXEC_CMD_OK );
	    } 
	    else
	    {
		fflush( stdout );
		execcmd( cmd->buf, make1d, t, cmd->shell );
	    }
	}
	else
	{
	    TARGETS	*c;
	    ACTIONS	*actions;

	    /* Collect status from actions, and distribute it as well */

	    for( actions = t->actions; actions; actions = actions->next )
		if( actions->action->status > t->status )
		    t->status = actions->action->status;

	    for( actions = t->actions; actions; actions = actions->next )
		if( t->status > actions->action->status )
		    actions->action->status = t->status;

	    /* Tally success/failure for those we tried to update. */

	    if( t->progress == T_MAKE_RUNNING )
		switch( t->status )
	    {
	    case EXEC_CMD_OK:
		++counts->made;
		break;
	    case EXEC_CMD_FAIL:
		++counts->failed;
		break;
	    }

	    /* Tell parents dependent has been built */

	    t->progress = T_MAKE_DONE;

	    for( c = t->parents; c; c = c->next )
		make1b( c->target );
	}
}

/*
 * make1d() - handle command execution completion and call back make1c()
 */

static void
make1d( t, status )
TARGET	*t;
int	status;
{
	CMD	*cmd = (CMD *)t->cmds;

	/* Execcmd() has completed.  All we need to do is fiddle with the */
	/* status and signal our completion so make1c() can run the next */
	/* command.  On interrupts, we bail heavily. */

	if( status == EXEC_CMD_FAIL && ( cmd->rule->flags & RULE_IGNORE ) )
	    status = EXEC_CMD_OK;

	/* On interrupt, set intr so _everything_ fails */

	if( status == EXEC_CMD_INTR )
	    ++intr;

	if( status == EXEC_CMD_FAIL && DEBUG_MAKE )
	{
	    /* Print command text on failure */

	    if( !DEBUG_EXEC )
		printf( "%s\n", cmd->buf );

	    printf( "...failed %s ", cmd->rule->name );
	    list_print( lol_get( &cmd->args, 0 ) );
	    printf( "...\n" );
	}

	/* If the command was interrupted or failed and the target */
	/* is not "precious", remove the targets */

	if( status != EXEC_CMD_OK && !( cmd->rule->flags & RULE_TOGETHER ) )
	{
	    LIST *targets = lol_get( &cmd->args, 0 );

	    for( ; targets; targets = list_next( targets ) )
		if( !unlink( targets->string ) )
		    printf( "...removing %s\n", targets->string );
	}

	/* Free this command and call make1c() to move onto next command. */

	t->status = status;
	t->cmds = (char *)cmd_next( cmd );

	cmd_free( cmd );

	make1c( t );
}

/*
 * make1cmds() - turn ACTIONS into CMDs, grouping, splitting, etc
 *
 * Essentially copies a chain of ACTIONs to a chain of CMDs, 
 * grouping RULE_TOGETHER actions, splitting RULE_PIECEMEAL actions,
 * and handling RULE_NEWSRCS actions.  The result is a chain of
 * CMDs which can be expanded by var_string() and executed with
 * execcmd().
 */

static CMD *
make1cmds( a0 )
ACTIONS	*a0;
{
	CMD *cmds = 0;
	CMD *cmdlast = 0;
	LIST *shell = var_get( "JAMSHELL" );	/* shell is per-target */

	/* Step through actions */
	/* Actions may be shared with other targets or grouped with */
	/* RULE_TOGETHER, so actions already seen are skipped. */

	for( ; a0; a0 = a0->next )
	{
	    RULE    *rule = a0->action->rule;
	    SETTINGS *boundvars;
	    int	    chunk = 0;
	    LIST    *nt, *ns;
	    ACTIONS *a1;

	    /* Only do rules with commands to execute. */
	    /* If this action has already been executed, use saved status */

	    if( !rule->actions || a0->action->running )
		continue;

	    a0->action->running = 1;
	    
	    /* Make LISTS of targets and sources */
	    /* If `execute together` has been specified for this rule, tack */
	    /* on sources from each instance of this rule for this target. */

	    nt = make1list( L0, a0->action->targets, 0 );
	    ns = make1list( L0, a0->action->sources, rule->flags );

	    if( rule->flags & RULE_TOGETHER )
		for( a1 = a0->next; a1; a1 = a1->next )
		    if( a1->action->rule == rule && !a1->action->running )
	    {
		ns = make1list( ns, a1->action->sources, rule->flags );
		a1->action->running = 1;
	    }

	    /* If doing only updated (or existing) sources, but none have */
	    /* been updated (or exist), skip this action. */

	    if( !ns && ( rule->flags & ( RULE_NEWSRCS | RULE_EXISTING ) ) )
	    {
		list_free( nt );
		continue;
	    }

	    /* If we had 'actions xxx bind vars' we bind the vars now */

	    boundvars = make1settings( rule->bindlist );
	    pushsettings( boundvars );

	    /* If rule is to be cut into (at most) MAXLINE pieces, estimate */
	    /* bytes per $(>) element and aim for using MAXLINE minus a */
	    /* fudgefactor. */

	    if( rule->flags & RULE_PIECEMEAL )
		chunk = make1chunk( rule->actions, nt, ns );

	    /* Either cut the actions into pieces, or do it whole. */

	    if( chunk < 0 )
	    {
		printf( "fatal error: %s command line too long (max %d)\n", 
			rule->name, MAXLINE );
		exit( EXITBAD );
	    }

	    if( chunk )
	    {
		int  start;
		LIST *somes;

		if( DEBUG_EXECCMD )
		    printf( "%s: %d args per exec\n", rule->name, chunk );

		for( start = 0;
		     somes = list_sublist( ns, start, chunk );
		     start += chunk )
		{
		    cmdlast = cmds;
		    cmds = cmd_new( cmds, rule, 
				list_copy( L0, nt ), somes, 
				list_copy( L0, shell ), chunk );
		    if ( cmds == NULL ) {
			cmds = cmdlast; /* remember where we were */
			chunk = chunk >> 1; /* adjust chunk size */
			if ( DEBUG_EXECCMD )
			    printf( "warning: adjusted chunk size to %d\n",
				    chunk );
			if ( chunk == 0 )
			    chunk = 1;
			start -= chunk; /* back up */
                    }
		}

		list_free( nt );
		list_free( ns );
	    }
	    else
	    {
		cmds = cmd_new( cmds, rule, nt, ns, list_copy( L0, shell ), 1 );
	    }

	    /* Free the variables whose values were bound by */
	    /* 'actions xxx bind vars' */

	    popsettings( boundvars );
	    freesettings( boundvars );
	}

	return cmds;
}

/*
 * make1chunk() - compute number of source that can fit on cmd line
 */

static int
make1chunk( cmd, targets, sources )
char	*cmd;
LIST	*targets;
LIST	*sources;
{
	int onesize;
	int twosize;
	int chunk = 0;
	char buf[ MAXLINE ];
	LOL lol;

	/* XXX -- egregious manipulation of lol */
	/* a) we set items directly, b) we don't free it */

	lol_init( &lol );
	lol.count = 2;
	lol.list[0] = targets;

	lol.list[1] = list_sublist( sources, 0, 1 );
	onesize = var_string( cmd, buf, MAXLINE, &lol );
	list_free( lol.list[1] );

	if( onesize < 0 )
	    return -1;

	lol.list[1] = list_sublist( sources, 0, 2 );
	twosize = var_string( cmd, buf, MAXLINE, &lol );
	list_free( lol.list[1] );

	if( twosize < 0 )
	    return -1;

	if( twosize > onesize )
	    chunk = 3 * ( MAXLINE - onesize ) / 5 / ( twosize - onesize ) + 1;

	return chunk;
}


/*
 * make1list() - turn a list of targets into a LIST, for $(<) and $(>)
 */

static LIST *
make1list( l, targets, flags )
LIST	*l;
TARGETS	*targets;
int	flags;
{
    for( ; targets; targets = targets->next )
    {
	TARGET *t = targets->target;

	/* Sources to 'actions existing' are never in the dependency */
	/* graph (if they were, they'd get built and 'existing' would */
	/* be superfluous, so throttle warning message about independent */
	/* targets. */

	if( t->binding == T_BIND_UNBOUND )
	    make1bind( t, !( flags & RULE_EXISTING ) );

	if( ( flags & RULE_EXISTING ) && t->binding != T_BIND_EXISTS )
	    continue;

	if( ( flags & RULE_NEWSRCS ) && t->fate <= T_FATE_STABLE )
	    continue;

	/* Prohibit duplicates for RULE_TOGETHER */

	if( flags & RULE_TOGETHER )
	{
	    LIST *m;

	    for( m = l; m; m = m->next )
		if( !strcmp( m->string, t->boundname ) )
		    break;

	    if( m )
		continue;
	}

	/* Build new list */

	l = list_new( l, copystr( t->boundname ) );
    }

    return l;
}

/*
 * make1settings() - for vars that get bound values, build up replacement lists
 */

static SETTINGS *
make1settings( vars )
LIST	*vars;
{
	SETTINGS *settings = 0;

	for( ; vars; vars = list_next( vars ) )
	{
	    LIST *l = var_get( vars->string );
	    LIST *nl = 0;

	    for( ; l; l = list_next( l ) ) 
	    {
		TARGET *t = bindtarget( l->string );

		/* Make sure the target is bound, warning if it is not in the */
		/* dependency graph. */

		if( t->binding == T_BIND_UNBOUND )
		    make1bind( t, 1 );

		/* Build new list */

		nl = list_new( nl, copystr( t->boundname ) );
	    }

	    /* Add to settings chain */

	    settings = addsettings( settings, 0, vars->string, nl );
	}

	return settings;
}

/*
 * make1bind() - bind targets that weren't bound in dependency analysis
 *
 * Spot the kludge!  If a target is not in the dependency tree, it didn't 
 * get bound by make0(), so we have to do it here.  Ugly.
 */

static void
make1bind( t, warn )
TARGET	*t;
int	warn;
{
	if( t->flags & T_FLAG_NOTFILE )
	    return;

	/* Sources to 'actions existing' are never in the dependency */
	/* graph (if they were, they'd get built and 'existing' would */
	/* be superfluous, so throttle warning message about independent */
	/* targets. */

	if( warn )
	    printf( "warning: using independent target %s\n", t->name );

	pushsettings( t->settings );
	t->boundname = search( t->name, &t->time );
	t->binding = t->time ? T_BIND_EXISTS : T_BIND_MISSING;
	popsettings( t->settings );
}
./src/mkjambase.c100440    167    454        4063  7102105141  12362 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

/*
 * mkjambase.c - turn Jambase into a big C structure
 *
 * Usage: mkjambase jambase.c Jambase ...
 *
 * Results look like this:
 *
 *	 char *jambase[] = {
 *	 "...\n",
 *	 ...
 *	 0 };
 *
 * Handles \'s and "'s specially; knows to delete blank and comment lines.
 *
 */

# include <stdio.h>
# include <string.h>

main( int argc, char **argv, char **envp)
{
	char buf[ 1024 ];
	FILE *fin;
	FILE *fout;
	char *p;
	int doDotC = 0;

	if( argc < 3 )
	{
	    fprintf( stderr, "usage: %s jambase.c Jambase ...\n", argv[0] );
	    return -1;
	}

	if( !( fout = fopen( argv[1], "w" ) ) )
	{
	    perror( argv[1] );
	    return -1;
	}

	/* If the file ends in .c generate a C source file */

	if( ( p = strrchr( argv[1], '.' ) ) && !strcmp( p, ".c" ) )
	    doDotC++;

	/* Now process the files */

	argc -= 2, argv += 2;

	if( doDotC )
	{
	    fprintf( fout, "/* Generated by mkjambase from Jambase */\n" );
	    fprintf( fout, "char *jambase[] = {\n" );
	}

	for( ; argc--; argv++ )
	{
	    if( !( fin = fopen( *argv, "r" ) ) )
	    {
		perror( *argv );
		return -1;
	    }

	    if( doDotC )
	    {
		fprintf( fout, "/* %s */\n", *argv );
	    }
	    else
	    {
		fprintf( fout, "### %s ###\n", *argv );
	    }

	    while( fgets( buf, sizeof( buf ), fin ) )
	    {
		if( doDotC )
		{
		    char *p = buf;

		    /* Strip leading whitespace. */

		    while( *p == ' ' || *p == '\t' || *p == '\n' )
			p++;

		    /* Drop comments and empty lines. */

		    if( *p == '#' || !*p )
			continue;

		    /* Copy */

		    putc( '"', fout );

		    for( ; *p && *p != '\n'; p++ )
			switch( *p )
		    {
		    case '\\': putc( '\\', fout ); putc( '\\', fout ); break;
		    case '"': putc( '\\', fout ); putc( '"', fout ); break;
		    default: putc( *p, fout ); break;
		    }

		    fprintf( fout, "\\n\",\n" );
		}
		else
		{
		    fprintf( fout, "%s", buf );
		}

	    }

	    fclose( fin );
	}
	    
	if( doDotC )
	    fprintf( fout, "0 };\n" );

	fclose( fout );

	return 0;
}
./src/newstr.c100440    167    454        3323  7102105141  11750 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

# include "jam.h"
# include "newstr.h"
# include "hash.h"

/*
 * newstr.c - string manipulation routines
 *
 * To minimize string copying, string creation, copying, and freeing
 * is done through newstr.
 *
 * External functions:
 *
 *    newstr() - return a malloc'ed copy of a string
 *    copystr() - return a copy of a string previously returned by newstr()
 *    freestr() - free a string returned by newstr() or copystr()
 *    donestr() - free string tables
 *
 * Once a string is passed to newstr(), the returned string is readonly.
 *
 * This implementation builds a hash table of all strings, so that multiple 
 * calls of newstr() on the same string allocate memory for the string once.
 * Strings are never actually freed.
 */

typedef char *STRING;

static struct hash *strhash = 0;
static int strtotal = 0;

/*
 * newstr() - return a malloc'ed copy of a string
 */

char *
newstr( string )
char *string;
{
	STRING str, *s = &str;

	if( !strhash )
	    strhash = hashinit( sizeof( STRING ), "strings" );

	*s = string;

	if( hashenter( strhash, (HASHDATA **)&s ) )
	{
	    int l = strlen( string );
	    char *m = (char *)malloc( l + 1 );

	    strtotal += l + 1;
	    memcpy( m, string, l + 1 );
	    *s = m;
	}

	return *s;
}

/*
 * copystr() - return a copy of a string previously returned by newstr()
 */

char *
copystr( s )
char	*s;
{
	return s;
}

/*
 * freestr() - free a string returned by newstr() or copystr()
 */

void
freestr( s )
char *s;
{
}

/*
 * donestr() - free string tables
 */

void
donestr()
{
	hashdone( strhash );

	if( DEBUG_MEM )
	    printf( "%dK in strings\n", strtotal / 1024 );
}
./src/newstr.h100440    167    454         360  7102105141  11733 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

/*
 * newstr.h - string manipulation routines
 */

char *newstr();
char *copystr();
void freestr();
void donestr();

./src/option.c100440    167    454        3215  7102105141  11736 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

# include "jam.h"
# include "option.h"

/*
 * option.c - command line option processing
 *
 * {o >o
 *  \<>) "Process command line options as defined in <option.h>.
 *		  Return the number of argv[] elements used up by options,
 *		  or -1 if an invalid option flag was given or an argument
 *		  was supplied for an option that does not require one."
 */

int
getoptions(argc, argv, opts, optv)
char **argv;
char *opts;
option *optv;
{
    int i;
    int optc = N_OPTS;

    memset( (char *)optv, '\0', sizeof( *optv ) * N_OPTS );

    for( i = 0; i < argc; i++ )
    {
	char *arg;

	if( argv[i][0] != '-' || !isalpha( argv[i][1] ) )
	    break;

	if( !optc-- )
	{
	    printf( "too many options (%d max)\n", N_OPTS );
	    return -1;
	}

	for( arg = &argv[i][1]; *arg; arg++ )
	{
	    char *f;

	    for( f = opts; *f; f++ )
		if( *f == *arg )
		    break;

	    if( !*f )
	    {
		printf( "Invalid option: -%c\n", *arg );
		return -1;
	    }

	    optv->flag = *f;

	    if( f[1] != ':' )
	    {
		optv++->val = "true";
	    }
	    else if( arg[1] )
	    {
		optv++->val = &arg[1];
		break;
	    }
	    else if( ++i < argc )
	    {
		optv++->val = argv[i];
		break;
	    }
	    else
	    {
		printf( "option: -%c needs argument\n", *f );
		return -1;
	    }
	}
    }

    return i;
}

/*
 * Name: getoptval() - find an option given its character
 */

char *
getoptval( optv, opt, subopt )
option *optv;
char opt;
int subopt;
{
	int i;

	for( i = 0; i < N_OPTS; i++, optv++ )
	    if( optv->flag == opt && !subopt-- )
		return optv->val;

	return 0;
}
./src/option.h100440    167    454         771  7102105141  11727 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

/*
 * option.h - command line option processing
 *
 * {o >o
 *  \ -) "Command line option."
 */

typedef struct option
{
	char	flag;		/* filled in by getoption() */
	char	*val;		/* set to random address if true */
} option;

# define N_OPTS 256

int 	getoptions( /* int argc, char **argv, char *opts, option *optv */ );
char 	*getoptval( /* option *optv, char opt, int subopt */ );
./src/parse.c100440    167    454        3050  7102105141  11535 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

# include "jam.h"
# include "lists.h"
# include "parse.h"
# include "scan.h"
# include "newstr.h"

/*
 * parse.c - make and destroy parse trees as driven by the parser
 */

static PARSE *yypsave;

void
parse_file( f )
char *f;
{
	/* Suspend scan of current file */
	/* and push this new file in the stream */

	yyfparse(f);

	/* Now parse each block of rules and execute it. */
	/* Execute it outside of the parser so that recursive */
	/* calls to yyrun() work (no recursive yyparse's). */

	for(;;)
	{
	    LOL l;
	    PARSE *p;

	    lol_init( &l );

	    yypsave = 0;

	    if( yyparse() || !( p = yypsave ) )
		break;

	    (*(p->func))( p, &l );

	    parse_free( p );
	}
}

void
parse_save( p )
PARSE *p;
{
	yypsave = p;
}

PARSE *
parse_make( func, left, right, string, string1, llist, rlist, num )
void	(*func)();
PARSE	*left;
PARSE	*right;
char	*string;
char	*string1;
LIST	*llist;
LIST	*rlist;
int	num;
{
	PARSE	*p = (PARSE *)malloc( sizeof( PARSE ) );

	p->func = func;
	p->left = left;
	p->right = right;
	p->string = string;
	p->string1 = string1;
	p->llist = llist;
	p->rlist = rlist;
	p->num = num;

	return p;
}

void
parse_free( p )
PARSE	*p;
{
	if( p->string )
	    freestr( p->string );
	if( p->string1 )
	    freestr( p->string1 );
	if( p->llist )
	    list_free( p->llist );
	if( p->rlist )
	    list_free( p->rlist );
	if( p->left )
	    parse_free( p->left );
	if( p->right )
	    parse_free( p->right );
	
	free( (char *)p );
}
./src/parse.h100440    167    454         726  7102105141  11531 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

/*
 * parse.h - make and destroy parse trees as driven by the parser
 */

/*
 * parse tree node
 */

typedef struct _PARSE PARSE;

struct _PARSE {
	void	(*func)();
	PARSE	*left;
	PARSE	*right;
	char	*string;
	char	*string1;
	LIST	*llist;
	LIST	*rlist;
	int	num;
} ;

void 	parse_file();
void 	parse_save();
PARSE	*parse_make();
void	parse_free();
./src/patchlevel.h100440    167    454         331  7102105141  12536 0ustar  laurateam/* Keep JAMVERSYM in sync with VERSION and PATCHLEVEL. */
/* It can be accessed as $(JAM) in the Jamfile. */

#define VERSION "2"
#ifndef PATCHLEVEL 
#define PATCHLEVEL "2.5"
#endif
#define JAMVERSYM "JAMVERSION=2.2"
./src/pathmac.c100440    167    454       13731  7102105142  12070 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

# include "jam.h"
# include "filesys.h"

# ifdef macintosh

# define DELIM ':'

/*
 * pathunix.c - manipulate file names on UNIX, NT, OS2
 *
 * External routines:
 *
 *	file_parse() - split a file name into dir/base/suffix/member
 *	file_build() - build a filename given dir/base/suffix/member
 *	file_parent() - make a FILENAME point to its parent dir
 *
 * File_parse() and file_build() just manipuate a string and a structure;
 * they do not make system calls.
 *
 * 04/08/94 (seiwald) - Coherent/386 support added.
 * 12/26/93 (seiwald) - handle dir/.suffix properly in file_build()
 * 12/19/94 (mikem) - solaris string table insanity support
 * 12/21/94 (wingerd) Use backslashes for pathnames - the NT way.
 * 02/14/95 (seiwald) - parse and build /xxx properly
 * 02/23/95 (wingerd) Compilers on NT can handle "/" in pathnames, so we
 *                    should expect hdr searches to come up with strings
 *                    like "thing/thing.h". So we need to test for "/" as
 *                    well as "\" when parsing pathnames.
 * 03/16/95 (seiwald) - fixed accursed typo on line 69.
 * 05/03/96 (seiwald) - split from filent.c, fileunix.c
 * 12/20/96 (seiwald) - when looking for the rightmost . in a file name,
 *		      don't include the archive member name.
 */

/*
 * file_parse() - split a file name into dir/base/suffix/member
 */

void
file_parse( file, f )
char		*file;
FILENAME	*f;
{
	char *p, *q;
	char *end;
	
	memset( (char *)f, 0, sizeof( *f ) );

	/* Look for <grist> */

	if( file[0] == '<' && ( p = strchr( file, '>' ) ) )
	{
	    f->f_grist.ptr = file;
	    f->f_grist.len = p - file;
	    file = p + 1;
	}

	/* Look for dir: */

	p = strrchr( file, DELIM );

	if( p )
	{
	    f->f_dir.ptr = file;
	    f->f_dir.len = p - file;
	    
	    /* Dir of : is : */
#if 0
	    if( !f->f_dir.len )
	    	++f->f_dir.len;
# else
	    f->f_dir.len++;
# endif
	    file = p + 1;
	}

	end = file + strlen( file );

	/* Look for (member) */

	if( ( p = strchr( file, '(' ) ) && end[-1] == ')' )
	{
	    f->f_member.ptr = p + 1;
	    f->f_member.len = end - p - 2;
	    end = p;
	} 

	/* Look for .suffix */
	/* This would be memrchr() */

	p = 0;
	q = file;

	while( q = memchr( q, '.', end - q ) )
	    p = q++;

	if( p )
	{
	    f->f_suffix.ptr = p;
	    f->f_suffix.len = end - p;
	    end = p;
	}

	/* Leaves base */

	f->f_base.ptr = file;
	f->f_base.len = end - file;
}

/*
 * file_build() - build a filename given dir/base/suffix/member
 */
 
# define DIR_EMPTY	0	/* "" */
# define DIR_DOT	1	/* : */
# define DIR_DOTDOT	2	/* :: */
# define DIR_ABS	3	/* dira:dirb: */
# define DIR_REL	4	/* :dira:dirb: */

# define G_DIR		0	/* take dir */
# define G_ROOT		1	/* take root */
# define G_CAT		2	/* prepend root to dir */
# define G_DTDR		3	/* :: of rel dir */
# define G_DDDD		4	/* make it ::: (../..) */
# define G_MT		5	/* leave it empty */

char grid[5][5] = {
/* 		EMPTY	DOT	DOTDOT	ABS	REL */
/* EMPTY */   {	G_MT,	G_DIR,	G_DIR,	G_DIR,	G_DIR },
/* DOT */     {	G_ROOT,	G_DIR,	G_DIR,	G_DIR,	G_DIR },
/* DOTDOT */  {	G_ROOT,	G_ROOT,	G_DDDD,	G_DIR,	G_DTDR },
/* ABS */     {	G_ROOT,	G_ROOT, G_ROOT,	G_DIR,	G_CAT },
/* REL */     {	G_ROOT,	G_ROOT,	G_ROOT,	G_DIR,	G_CAT }
} ;

static int
file_flags( ptr, len )
char	*ptr;
int	len;
{
	if( !len )
	    return DIR_EMPTY;
	if( len == 1 && ptr[0] == DELIM )
	    return DIR_DOT;
	if( len == 2 && ptr[0] == DELIM && ptr[1] == DELIM )
	    return DIR_DOTDOT;
	if( ptr[0] == DELIM )
	    return DIR_REL;
	return DIR_ABS;
}

void
file_build( f, file, binding )
FILENAME	*f;
char		*file;
int		binding;
{
	char *ofile = file;
	int dflag, rflag, act;
	
	if( DEBUG_SEARCH )
	{
	printf("build file: ");
	if( f->f_root.len )
		printf( "root = '%.*s' ", f->f_root.len, f->f_root.ptr );
	if( f->f_dir.len )
		printf( "dir = '%.*s' ", f->f_dir.len, f->f_dir.ptr );
	if( f->f_base.len )
		printf( "base = '%.*s' ", f->f_base.len, f->f_base.ptr );
	}
	
	/* Start with the grist.  If the current grist isn't */
	/* surrounded by <>'s, add them. */

	if( f->f_grist.len )
	{
	    if( f->f_grist.ptr[0] != '<' ) *file++ = '<';
	    memcpy( file, f->f_grist.ptr, f->f_grist.len );
	    file += f->f_grist.len;
	    if( file[-1] != '>' ) *file++ = '>';
	}
	
	/* Combine root & directory, according to the grid. */
	
	dflag = file_flags( f->f_dir.ptr, f->f_dir.len );
	rflag = file_flags( f->f_root.ptr, f->f_root.len );
	
	switch( act = grid[ rflag ][ dflag ] )
	{
	case G_DTDR:
		/* :: of rel dir */
		*file++ = DELIM;
		/* fall through */
		
	case G_DIR: 	
		/* take dir */
		memcpy( file, f->f_dir.ptr, f->f_dir.len );
	    	file += f->f_dir.len;
		break;
		
	case G_ROOT:	
		/* take root */
		memcpy( file, f->f_root.ptr, f->f_root.len );
	    	file += f->f_root.len;
		break;
	    
	case G_CAT:	
		/* prepend root to dir */
		memcpy( file, f->f_root.ptr, f->f_root.len );
	    	file += f->f_root.len;
		if( file[-1] == DELIM ) --file;
		memcpy( file, f->f_dir.ptr, f->f_dir.len );
	    	file += f->f_dir.len;
		break;
	
	case G_DDDD:	
		/* make it ::: (../..) */
		strcpy( file, ":::" );
		file += 3;
		break;
	}

	/* Put : between dir and file (if none already) */
	
	if( act != G_MT && 
	    file[-1] != DELIM && 
	    ( f->f_base.len || f->f_suffix.len ) )
	{
	    *file++ = DELIM;
	}

	if( f->f_base.len )
	{
	    memcpy( file, f->f_base.ptr, f->f_base.len );
	    file += f->f_base.len;
	}

	if( f->f_suffix.len )
	{
	    memcpy( file, f->f_suffix.ptr, f->f_suffix.len );
	    file += f->f_suffix.len;
	}

	if( f->f_member.len )
	{
	    *file++ = '(';
	    memcpy( file, f->f_member.ptr, f->f_member.len );
	    file += f->f_member.len;
	    *file++ = ')';
	}
	*file = 0;	
	
	if( DEBUG_SEARCH )
		printf(" -> '%s'\n", ofile);
}

/*
 *	file_parent() - make a FILENAME point to its parent dir
 */

void
file_parent( f )
FILENAME *f;
{
	/* just set everything else to nothing */

	f->f_base.ptr =
	f->f_suffix.ptr =
	f->f_member.ptr = "";

	f->f_base.len = 
	f->f_suffix.len = 
	f->f_member.len = 0;
}

# endif /* macintosh */
./src/pathunix.c100440    167    454       12262  7102105142  12311 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

# include "jam.h"
# include "filesys.h"

# if defined( unix ) || defined( NT ) || defined( __OS2__ ) || defined(AMIGA)

# if defined(unix) || defined(AMIGA)
# define DELIM '/'
# else
# define DELIM '\\'
# endif

/*
 * pathunix.c - manipulate file names on UNIX, NT, OS2, AmigaOS
 *
 * External routines:
 *
 *	file_parse() - split a file name into dir/base/suffix/member
 *	file_build() - build a filename given dir/base/suffix/member
 *	file_parent() - make a FILENAME point to its parent dir
 *
 * File_parse() and file_build() just manipuate a string and a structure;
 * they do not make system calls.
 *
 * 04/08/94 (seiwald) - Coherent/386 support added.
 * 12/26/93 (seiwald) - handle dir/.suffix properly in file_build()
 * 12/19/94 (mikem) - solaris string table insanity support
 * 12/21/94 (wingerd) Use backslashes for pathnames - the NT way.
 * 02/14/95 (seiwald) - parse and build /xxx properly
 * 02/23/95 (wingerd) Compilers on NT can handle "/" in pathnames, so we
 *                    should expect hdr searches to come up with strings
 *                    like "thing/thing.h". So we need to test for "/" as
 *                    well as "\" when parsing pathnames.
 * 03/16/95 (seiwald) - fixed accursed typo on line 69.
 * 05/03/96 (seiwald) - split from filent.c, fileunix.c
 * 12/20/96 (seiwald) - when looking for the rightmost . in a file name,
 *		      don't include the archive member name.
 */

/*
 * file_parse() - split a file name into dir/base/suffix/member
 */

void
file_parse( file, f )
char		*file;
FILENAME	*f;
{
	char *p, *q;
	char *end;
	
	memset( (char *)f, 0, sizeof( *f ) );

	/* Look for <grist> */

	if( file[0] == '<' && ( p = strchr( file, '>' ) ) )
	{
	    f->f_grist.ptr = file;
	    f->f_grist.len = p - file;
	    file = p + 1;
	}

	/* Look for dir/ */

	p = strrchr( file, '/' );

# ifndef UNIX
# ifndef AMIGA
	/* On NT, look for dir\ as well */
	{
	    char *p1 = strrchr( file, '\\' );
	    p = p1 > p ? p1 : p;
	}
# endif
# endif

	if( p )
	{
	    f->f_dir.ptr = file;
	    f->f_dir.len = p - file;
	
	    /* Special case for / - dirname is /, not "" */

	    if( !f->f_dir.len )
		f->f_dir.len = 1;

# ifndef UNIX
# ifndef AMIGA
	    /* Special case for D:/ - dirname is D:/, not "D:" */

	    if( f->f_dir.len == 2 && file[1] == ':' )
		f->f_dir.len = 3;
# endif
# endif

	    file = p + 1;
	}

	end = file + strlen( file );

	/* Look for (member) */

	if( ( p = strchr( file, '(' ) ) && end[-1] == ')' )
	{
	    f->f_member.ptr = p + 1;
	    f->f_member.len = end - p - 2;
	    end = p;
	} 

	/* Look for .suffix */
	/* This would be memrchr() */

	p = 0;
	q = file;

	while( q = memchr( q, '.', end - q ) )
	    p = q++;

	if( p )
	{
	    f->f_suffix.ptr = p;
	    f->f_suffix.len = end - p;
	    end = p;
	}

	/* Leaves base */

	f->f_base.ptr = file;
	f->f_base.len = end - file;
}

/*
 * file_build() - build a filename given dir/base/suffix/member
 */

void
file_build( f, file, binding )
FILENAME	*f;
char		*file;
int		binding;
{
	/* Start with the grist.  If the current grist isn't */
	/* surrounded by <>'s, add them. */

	if( f->f_grist.len )
	{
	    if( f->f_grist.ptr[0] != '<' ) *file++ = '<';
	    memcpy( file, f->f_grist.ptr, f->f_grist.len );
	    file += f->f_grist.len;
	    if( file[-1] != '>' ) *file++ = '>';
	}

	/* Don't prepend root if it's . or directory is rooted */

# if defined(unix) || defined(AMIGA)

	if( f->f_root.len 
	    && !( f->f_root.len == 1 && f->f_root.ptr[0] == '.' )
	    && !( f->f_dir.len && f->f_dir.ptr[0] == '/' ) )

# else /* unix */

	if( f->f_root.len 
	    && !( f->f_root.len == 1 && f->f_root.ptr[0] == '.' )
	    && !( f->f_dir.len && f->f_dir.ptr[0] == '/' )
	    && !( f->f_dir.len && f->f_dir.ptr[0] == '\\' )
	    && !( f->f_dir.len && f->f_dir.ptr[1] == ':' ) )

# endif /* unix */

	{
	    memcpy( file, f->f_root.ptr, f->f_root.len );
	    file += f->f_root.len;
	    *file++ = DELIM;
	}

	if( f->f_dir.len )
	{
	    memcpy( file, f->f_dir.ptr, f->f_dir.len );
	    file += f->f_dir.len;
	}

	/* UNIX: Put / between dir and file */
	/* NT:   Put \ between dir and file */

	if( f->f_dir.len && ( f->f_base.len || f->f_suffix.len ) )
	{
	    /* UNIX: Special case for dir \ : don't add another \ */
	    /* NT:   Special case for dir / : don't add another / */

# ifndef UNIX
# ifndef AMIGA
	    if( !( f->f_dir.len == 3 && f->f_dir.ptr[1] == ':' ) )
# endif
# endif
		if( !( f->f_dir.len == 1 && f->f_dir.ptr[0] == DELIM ) )
		    *file++ = DELIM;
	}

	if( f->f_base.len )
	{
	    memcpy( file, f->f_base.ptr, f->f_base.len );
	    file += f->f_base.len;
	}

	if( f->f_suffix.len )
	{
	    memcpy( file, f->f_suffix.ptr, f->f_suffix.len );
	    file += f->f_suffix.len;
	}

	if( f->f_member.len )
	{
	    *file++ = '(';
	    memcpy( file, f->f_member.ptr, f->f_member.len );
	    file += f->f_member.len;
	    *file++ = ')';
	}
	*file = 0;
}

/*
 *	file_parent() - make a FILENAME point to its parent dir
 */

void
file_parent( f )
FILENAME *f;
{
	/* just set everything else to nothing */

	f->f_base.ptr =
	f->f_suffix.ptr =
	f->f_member.ptr = "";

	f->f_base.len = 
	f->f_suffix.len = 
	f->f_member.len = 0;
}

# endif /* unix, NT, OS/2, AmigaOS */
./src/pathvms.c100440    167    454       21072  7102105142  12132 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

# ifdef VMS

# define DEBUG

/*
 * pathvms.c - manipulate file names on VMS
 *
 * External routines:
 *
 *	file_parse() - split a file name into dir/base/suffix/member
 *	file_build() - build a filename given dir/base/suffix/member
 *	file_parent() - make a FILENAME point to its parent dir
 *
 * File_parse() and file_build() just manipuate a string and a structure;
 * they do not make system calls.
 *
 * WARNING!  This file contains voodoo logic, as black magic is 
 * necessary for wrangling with VMS file name.  Woe be to people
 * who mess with this code.
 *
 * 02/09/95 (seiwald) - bungled R=[xxx] - was using directory length!
 * 05/03/96 (seiwald) - split from filevms.c
 */

# include "jam.h"
# include "filesys.h"

/*
 * file_parse() - split a file name into dir/base/suffix/member
 */

void
file_parse( file, f )
char		*file;
FILENAME	*f;
{
	char *p, *q;
	char *end;
	
	memset( (char *)f, 0, sizeof( *f ) );

	/* Look for <grist> */

	if( file[0] == '<' && ( p = strchr( file, '>' ) ) )
	{
	    f->f_grist.ptr = file;
	    f->f_grist.len = p - file;
	    file = p + 1;
	}

	/* Look for dev:[dir] or dev: */

	if( ( p = strchr( file, ']' ) ) || ( p = strchr( file, ':' ) ) )
	{
	    f->f_dir.ptr = file;
	    f->f_dir.len = p + 1 - file;
	    file = p + 1;
	}

	end = file + strlen( file );

	/* Look for (member) */

	if( ( p = strchr( file, '(' ) ) && end[-1] == ')' )
	{
	    f->f_member.ptr = p + 1;
	    f->f_member.len = end - p - 2;
	    end = p;
	} 

	/* Look for .suffix */
	/* This would be memrchr() */

	p = 0;
	q = file;

	while( q = memchr( q, '.', end - q ) )
	    p = q++;

	if( p )
	{
	    f->f_suffix.ptr = p;
	    f->f_suffix.len = end - p;
	    end = p;
	}

	/* Leaves base */

	f->f_base.ptr = file;
	f->f_base.len = end - file;

	/* Is this a directory without a file spec? */

	f->parent = 0;
}

/*
 *	dir		mods		result
 *	---		---		------
 * Rerooting:
 *
 *	(none)		:R=dev:		dev:		
 *	devd:		:R=dev:		devd:
 *	devd:[dir]	:R=dev:		devd:[dir]
 *	[.dir]		:R=dev:		dev:[dir]	questionable
 *	[dir]		:R=dev:		dev:[dir]
 *
 *	(none)		:R=[rdir]	[rdir]		questionable
 *	devd:		:R=[rdir]	devd:
 *	devd:[dir]	:R=[rdir]	devd:[dir]
 *	[.dir]		:R=[rdir]	[rdir.dir]	questionable
 *	[dir]		:R=[rdir]	[rdir]
 *
 *	(none)		:R=dev:[root]	dev:[root]
 *	devd:		:R=dev:[root]	devd:
 *	devd:[dir]	:R=dev:[root]	devd:[dir]
 *	[.dir]		:R=dev:[root]	dev:[root.dir]
 *	[dir]		:R=dev:[root]	[dir]
 *
 * Climbing to parent:
 *
 */

# define DIR_EMPTY	0	/* empty string */
# define DIR_DEV	1	/* dev: */
# define DIR_DEVDIR	2	/* dev:[dir] */
# define DIR_DOTDIR	3	/* [.dir] */
# define DIR_DASHDIR	4	/* [-] or [-.dir] */
# define DIR_ABSDIR	5	/* [dir] */
# define DIR_ROOT	6	/* [000000] or dev:[000000] */

# define G_DIR		0	/* take just dir */
# define G_ROOT		1	/* take just root */
# define G_VAD		2	/* root's dev: + [abs] */
# define G_DRD		3	/* root's dev:[dir] + [.rel] */
# define G_VRD		4	/* root's dev: + [.rel] made [abs] */
# define G_DDD		5	/* root's dev:[dir] + . + [dir] */

static int grid[7][7] = {

/* root/dir	EMPTY	DEV	DEVDIR	DOTDIR	DASH,	ABSDIR	ROOT */
/* EMPTY */	G_DIR,	G_DIR,	G_DIR,	G_DIR,	G_DIR,	G_DIR,	G_DIR,
/* DEV */	G_ROOT,	G_DIR,	G_DIR,	G_VRD,	G_VAD,	G_VAD,	G_VAD,
/* DEVDIR */	G_ROOT,	G_DIR,	G_DIR,	G_DRD,	G_VAD,	G_VAD,	G_VAD,
/* DOTDIR */	G_ROOT,	G_DIR,	G_DIR,	G_DRD,	G_DIR,	G_DIR,	G_DIR,
/* DASHDIR */	G_ROOT,	G_DIR,	G_DIR,	G_DRD,	G_DDD,	G_DIR,	G_DIR,
/* ABSDIR */	G_ROOT,	G_DIR,	G_DIR,	G_DRD,	G_DIR,	G_DIR,	G_DIR,
/* ROOT */	G_ROOT,	G_DIR,	G_DIR,	G_VRD,	G_DIR,	G_DIR,	G_DIR,

} ;

struct dirinf {
	int	flags;

	struct {
		char	*ptr;
		int	len;
	} dev, dir;
} ;

static char *
strnchr( buf, c, len )
char	*buf;
int	c;
int	len;
{
	while( len-- )
	    if( *buf && *buf++ == c )
		return buf - 1;

	return 0;
}

static void
dir_flags( buf, len, i )
char	*buf;
int	len;
struct dirinf *i;
{
	char *p;

	if( !buf || !len )
	{
	    i->flags = DIR_EMPTY;
	    i->dev.ptr =
	    i->dir.ptr = 0;
	    i->dev.len =
	    i->dir.len = 0;
	}
	else if( p = strnchr( buf, ':', len ) )
	{
	    i->dev.ptr = buf;
	    i->dev.len = p + 1 - buf;
	    i->dir.ptr = buf + i->dev.len;
	    i->dir.len = len - i->dev.len;
	    i->flags = i->dir.len && *i->dir.ptr == '[' ? DIR_DEVDIR : DIR_DEV;
	}
	else
	{
	    i->dev.ptr = buf;
	    i->dev.len = 0;
	    i->dir.ptr = buf;
	    i->dir.len = len;

	    if( *buf == '[' && buf[1] == ']' )
		i->flags = DIR_EMPTY;
	    else if( *buf == '[' && buf[1] == '.' )
		i->flags = DIR_DOTDIR;
	    else if( *buf == '[' && buf[1] == '-' )
		i->flags = DIR_DASHDIR;
	    else
		i->flags = DIR_ABSDIR;
	}

	/* But if its rooted in any way */

	if( i->dir.len == 8 && !strncmp( i->dir.ptr, "[000000]", 8 ) )
	    i->flags = DIR_ROOT;
}

/*
 * file_build() - build a filename given dir/base/suffix/member
 */

void
file_build( f, file, binding )
FILENAME	*f;
char		*file;
int		binding;
{
	char *ofile = file;
	struct dirinf root, dir;
	int g;

	/* Start with the grist.  If the current grist isn't */
	/* surrounded by <>'s, add them. */

	if( f->f_grist.len )
	{
	    if( f->f_grist.ptr[0] != '<' ) *file++ = '<';
	    memcpy( file, f->f_grist.ptr, f->f_grist.len );
	    file += f->f_grist.len;
	    if( file[-1] != '>' ) *file++ = '>';
	}

	/* Get info on root and dir for combining. */

	dir_flags( f->f_root.ptr, f->f_root.len, &root );
	dir_flags( f->f_dir.ptr, f->f_dir.len, &dir );

	/* Combine */

	switch( g = grid[ root.flags ][ dir.flags ] )
	{
	case G_DIR:	
		/* take dir */
		memcpy( file, f->f_dir.ptr, f->f_dir.len );
		file += f->f_dir.len;
		break;

	case G_ROOT:	
		/* take root */
		memcpy( file, f->f_root.ptr, f->f_root.len );
		file += f->f_root.len;
		break;

	case G_VAD:	
		/* root's dev + abs directory */
		memcpy( file, root.dev.ptr, root.dev.len );
		file += root.dev.len;
		memcpy( file, dir.dir.ptr, dir.dir.len );
		file += dir.dir.len;
		break;
		
	case G_DRD:	
	case G_DDD:
		/* root's dev:[dir] + rel directory */
		memcpy( file, f->f_root.ptr, f->f_root.len );
		file += f->f_root.len;

		/* sanity checks: root ends with ] */

		if( file[-1] == ']' )
		     --file;	

		/* Add . if separating two -'s */

		if( g == G_DDD )
		    *file++ = '.';

		/* skip [ of dir */
		memcpy( file, dir.dir.ptr + 1, dir.dir.len - 1 );
		file += dir.dir.len - 1;
		break;

	case G_VRD:	
		/* root's dev + rel directory made abs */
		memcpy( file, root.dev.ptr, root.dev.len );
		file += root.dev.len;
		*file++ = '[';
		/* skip [. of rel dir */
		memcpy( file, dir.dir.ptr + 2, dir.dir.len - 2 );
		file += dir.dir.len - 2;
		break;
	}

# ifdef DEBUG
	if( DEBUG_SEARCH && ( root.flags || dir.flags ) )
	{
		*file = 0;
		printf( "%d x %d = %d (%s)\n", root.flags, dir.flags,
			grid[ root.flags ][ dir.flags ], ofile );
	}
# endif 

	/* 
	 * Now do the special :P modifier when no file was present.
	 *	(none)		(none)
	 *	[dir1.dir2]	[dir1]
	 *	[dir]		[000000]
	 *	[.dir]		[]
	 *	[]		[]
	 */

	if( file[-1] == ']' && f->parent )
	{
	    while( file-- > ofile )
	    {
		if( *file == '.' )
		{
		    *file++ = ']';
		    break;
		}
		else if( *file == '-' )
		{
		    /* handle .- or - */
		    if( file > ofile && file[-1] == '.' )
		    	--file;
		    *file++ = ']';
		    break;
		}
		else if( *file == '[' )
		{
		    if( file[1] == ']' )
		    {
		    	file += 2;
		    }
		    else
		    {
			strcpy( file, "[000000]" );
			file += 8;
		    }
		    break;
		}
	    }
	}

	/* Now copy the file pieces. */

	if( f->f_base.len )
	{
	    memcpy( file, f->f_base.ptr, f->f_base.len );
	    file += f->f_base.len;
	}

	/* If there is no suffix, we append a "." onto all generated */
	/* names.  This keeps VMS from appending its own (wrong) idea */
	/* of what the suffix should be. */

	if( f->f_suffix.len )
	{
	    memcpy( file, f->f_suffix.ptr, f->f_suffix.len );
	    file += f->f_suffix.len;
	}
	else if( binding && f->f_base.len )
	{
	    *file++ = '.';
	}

	if( f->f_member.len )
	{
	    *file++ = '(';
	    memcpy( file, f->f_member.ptr, f->f_member.len );
	    file += f->f_member.len;
	    *file++ = ')';
	}
	*file = 0;

# ifdef DEBUG
	if( DEBUG_SEARCH )
	    printf("built %.*s + %.*s / %.*s suf %.*s mem %.*s -> %s\n", 
		    f->f_root.len, f->f_root.ptr,
		    f->f_dir.len, f->f_dir.ptr,
		    f->f_base.len, f->f_base.ptr,
		    f->f_suffix.len, f->f_suffix.ptr,
		    f->f_member.len, f->f_member.ptr,
		    ofile );
# endif
}

/*
 *	file_parent() - make a FILENAME point to its parent dir
 */

void
file_parent( f )
FILENAME *f;
{
	if( f->f_base.len )
	{
	    f->f_base.ptr =
	    f->f_suffix.ptr =
	    f->f_member.ptr = "";

	    f->f_base.len =
	    f->f_suffix.len =
	    f->f_member.len = 0;
	}
	else
	{
	    f->parent = 1;
	}
}

# endif /* VMS */
./src/regexp.c100440    167    454       75577  7102105142  11765 0ustar  laurateam/*
 * regcomp and regexec -- regsub and regerror are elsewhere
 *
 *	Copyright (c) 1986 by University of Toronto.
 *	Written by Henry Spencer.  Not derived from licensed software.
 *
 *	Permission is granted to anyone to use this software for any
 *	purpose on any computer system, and to redistribute it freely,
 *	subject to the following restrictions:
 *
 *	1. The author is not responsible for the consequences of use of
 *		this software, no matter how awful, even if they arise
 *		from defects in it.
 *
 *	2. The origin of this software must not be misrepresented, either
 *		by explicit claim or by omission.
 *
 *	3. Altered versions must be plainly marked as such, and must not
 *		be misrepresented as being the original software.
 *** THIS IS AN ALTERED VERSION.  It was altered by John Gilmore,
 *** hoptoad!gnu, on 27 Dec 1986, to add \n as an alternative to |
 *** to assist in implementing egrep.
 *** THIS IS AN ALTERED VERSION.  It was altered by John Gilmore,
 *** hoptoad!gnu, on 27 Dec 1986, to add \< and \> for word-matching
 *** as in BSD grep and ex.
 *** THIS IS AN ALTERED VERSION.  It was altered by John Gilmore,
 *** hoptoad!gnu, on 28 Dec 1986, to optimize characters quoted with \.
 *** THIS IS AN ALTERED VERSION.  It was altered by James A. Woods,
 *** ames!jaw, on 19 June 1987, to quash a regcomp() redundancy.
 *** THIS IS AN ALTERED VERSION.  It was altered by Christopher Seiwald
 *** seiwald@vix.com, on 28 August 1993, for use in jam.  Regmagic.h
 *** was moved into regexp.h, and the include of regexp.h now uses "'s
 *** to avoid conflicting with the system regexp.h.  Const, bless its
 *** soul, was removed so it can compile everywhere.  The declaration
 *** of strchr() was in conflict on AIX, so it was removed (as it is
 *** happily defined in string.h).
 *
 * Beware that some of this code is subtly aware of the way operator
 * precedence is structured in regular expressions.  Serious changes in
 * regular-expression syntax might require a total rethink.
 */
#include "regexp.h"
#include <stdio.h>
#include <ctype.h>
#ifndef ultrix
#include <stdlib.h>
#endif
#include <string.h>

/*
 * The "internal use only" fields in regexp.h are present to pass info from
 * compile to execute that permits the execute phase to run lots faster on
 * simple cases.  They are:
 *
 * regstart	char that must begin a match; '\0' if none obvious
 * reganch	is the match anchored (at beginning-of-line only)?
 * regmust	string (pointer into program) that match must include, or NULL
 * regmlen	length of regmust string
 *
 * Regstart and reganch permit very fast decisions on suitable starting points
 * for a match, cutting down the work a lot.  Regmust permits fast rejection
 * of lines that cannot possibly match.  The regmust tests are costly enough
 * that regcomp() supplies a regmust only if the r.e. contains something
 * potentially expensive (at present, the only such thing detected is * or +
 * at the start of the r.e., which can involve a lot of backup).  Regmlen is
 * supplied because the test in regexec() needs it and regcomp() is computing
 * it anyway.
 */

/*
 * Structure for regexp "program".  This is essentially a linear encoding
 * of a nondeterministic finite-state machine (aka syntax charts or
 * "railroad normal form" in parsing technology).  Each node is an opcode
 * plus a "next" pointer, possibly plus an operand.  "Next" pointers of
 * all nodes except BRANCH implement concatenation; a "next" pointer with
 * a BRANCH on both ends of it is connecting two alternatives.  (Here we
 * have one of the subtle syntax dependencies:  an individual BRANCH (as
 * opposed to a collection of them) is never concatenated with anything
 * because of operator precedence.)  The operand of some types of node is
 * a literal string; for others, it is a node leading into a sub-FSM.  In
 * particular, the operand of a BRANCH node is the first node of the branch.
 * (NB this is *not* a tree structure:  the tail of the branch connects
 * to the thing following the set of BRANCHes.)  The opcodes are:
 */

/* definition	number	opnd?	meaning */
#define	END	0	/* no	End of program. */
#define	BOL	1	/* no	Match "" at beginning of line. */
#define	EOL	2	/* no	Match "" at end of line. */
#define	ANY	3	/* no	Match any one character. */
#define	ANYOF	4	/* str	Match any character in this string. */
#define	ANYBUT	5	/* str	Match any character not in this string. */
#define	BRANCH	6	/* node	Match this alternative, or the next... */
#define	BACK	7	/* no	Match "", "next" ptr points backward. */
#define	EXACTLY	8	/* str	Match this string. */
#define	NOTHING	9	/* no	Match empty string. */
#define	STAR	10	/* node	Match this (simple) thing 0 or more times. */
#define	PLUS	11	/* node	Match this (simple) thing 1 or more times. */
#define	WORDA	12	/* no	Match "" at wordchar, where prev is nonword */
#define	WORDZ	13	/* no	Match "" at nonwordchar, where prev is word */
#define	OPEN	20	/* no	Mark this point in input as start of #n. */
			/*	OPEN+1 is number 1, etc. */
#define	CLOSE	30	/* no	Analogous to OPEN. */

/*
 * Opcode notes:
 *
 * BRANCH	The set of branches constituting a single choice are hooked
 *		together with their "next" pointers, since precedence prevents
 *		anything being concatenated to any individual branch.  The
 *		"next" pointer of the last BRANCH in a choice points to the
 *		thing following the whole choice.  This is also where the
 *		final "next" pointer of each individual branch points; each
 *		branch starts with the operand node of a BRANCH node.
 *
 * BACK		Normal "next" pointers all implicitly point forward; BACK
 *		exists to make loop structures possible.
 *
 * STAR,PLUS	'?', and complex '*' and '+', are implemented as circular
 *		BRANCH structures using BACK.  Simple cases (one character
 *		per match) are implemented with STAR and PLUS for speed
 *		and to minimize recursive plunges.
 *
 * OPEN,CLOSE	...are numbered at compile time.
 */

/*
 * A node is one char of opcode followed by two chars of "next" pointer.
 * "Next" pointers are stored as two 8-bit pieces, high order first.  The
 * value is a positive offset from the opcode of the node containing it.
 * An operand, if any, simply follows the node.  (Note that much of the
 * code generation knows about this implicit relationship.)
 *
 * Using two bytes for the "next" pointer is vast overkill for most things,
 * but allows patterns to get big without disasters.
 */
#define	OP(p)	(*(p))
#define	NEXT(p)	(((*((p)+1)&0377)<<8) + (*((p)+2)&0377))
#define	OPERAND(p)	((p) + 3)

/*
 * See regmagic.h for one further detail of program structure.
 */


/*
 * Utility definitions.
 */
#ifndef CHARBITS
#define	UCHARAT(p)	((int)*(unsigned char *)(p))
#else
#define	UCHARAT(p)	((int)*(p)&CHARBITS)
#endif

#define	FAIL(m)	{ regerror(m); return(NULL); }
#define	ISMULT(c)	((c) == '*' || (c) == '+' || (c) == '?')

/*
 * Flags to be passed up and down.
 */
#define	HASWIDTH	01	/* Known never to match null string. */
#define	SIMPLE		02	/* Simple enough to be STAR/PLUS operand. */
#define	SPSTART		04	/* Starts with * or +. */
#define	WORST		0	/* Worst case. */

/*
 * Global work variables for regcomp().
 */
static char *regparse;		/* Input-scan pointer. */
static int regnpar;		/* () count. */
static char regdummy;
static char *regcode;		/* Code-emit pointer; &regdummy = don't. */
static long regsize;		/* Code size. */

/*
 * Forward declarations for regcomp()'s friends.
 */
#ifndef STATIC
#define	STATIC	static
#endif
STATIC char *reg();
STATIC char *regbranch();
STATIC char *regpiece();
STATIC char *regatom();
STATIC char *regnode();
STATIC char *regnext();
STATIC void regc();
STATIC void reginsert();
STATIC void regtail();
STATIC void regoptail();
#ifdef STRCSPN
STATIC int strcspn();
#endif

/*
 - regcomp - compile a regular expression into internal code
 *
 * We can't allocate space until we know how big the compiled form will be,
 * but we can't compile it (and thus know how big it is) until we've got a
 * place to put the code.  So we cheat:  we compile it twice, once with code
 * generation turned off and size counting turned on, and once "for real".
 * This also means that we don't allocate space until we are sure that the
 * thing really will compile successfully, and we never have to move the
 * code and thus invalidate pointers into it.  (Note that it has to be in
 * one piece because free() must be able to free it all.)
 *
 * Beware that the optimization-preparation code in here knows about some
 * of the structure of the compiled regexp.
 */
regexp *
regcomp(exp)
char *exp;
{
	register regexp *r;
	register char *scan;
	register char *longest;
	register unsigned len;
	int flags;

	if (exp == NULL)
		FAIL("NULL argument");

	/* First pass: determine size, legality. */
#ifdef notdef
	if (exp[0] == '.' && exp[1] == '*') exp += 2;  /* aid grep */
#endif
	regparse = (char *)exp;
	regnpar = 1;
	regsize = 0L;
	regcode = &regdummy;
	regc(MAGIC);
	if (reg(0, &flags) == NULL)
		return(NULL);

	/* Small enough for pointer-storage convention? */
	if (regsize >= 32767L)		/* Probably could be 65535L. */
		FAIL("regexp too big");

	/* Allocate space. */
	r = (regexp *)malloc(sizeof(regexp) + (unsigned)regsize);
	if (r == NULL)
		FAIL("out of space");

	/* Second pass: emit code. */
	regparse = (char *)exp;
	regnpar = 1;
	regcode = r->program;
	regc(MAGIC);
	if (reg(0, &flags) == NULL)
		return(NULL);

	/* Dig out information for optimizations. */
	r->regstart = '\0';	/* Worst-case defaults. */
	r->reganch = 0;
	r->regmust = NULL;
	r->regmlen = 0;
	scan = r->program+1;			/* First BRANCH. */
	if (OP(regnext(scan)) == END) {		/* Only one top-level choice. */
		scan = OPERAND(scan);

		/* Starting-point info. */
		if (OP(scan) == EXACTLY)
			r->regstart = *OPERAND(scan);
		else if (OP(scan) == BOL)
			r->reganch++;

		/*
		 * If there's something expensive in the r.e., find the
		 * longest literal string that must appear and make it the
		 * regmust.  Resolve ties in favor of later strings, since
		 * the regstart check works with the beginning of the r.e.
		 * and avoiding duplication strengthens checking.  Not a
		 * strong reason, but sufficient in the absence of others.
		 */
		if (flags&SPSTART) {
			longest = NULL;
			len = 0;
			for (; scan != NULL; scan = regnext(scan))
				if (OP(scan) == EXACTLY && strlen(OPERAND(scan)) >= len) {
					longest = OPERAND(scan);
					len = strlen(OPERAND(scan));
				}
			r->regmust = longest;
			r->regmlen = len;
		}
	}

	return(r);
}

/*
 - reg - regular expression, i.e. main body or parenthesized thing
 *
 * Caller must absorb opening parenthesis.
 *
 * Combining parenthesis handling with the base level of regular expression
 * is a trifle forced, but the need to tie the tails of the branches to what
 * follows makes it hard to avoid.
 */
static char *
reg(paren, flagp)
int paren;			/* Parenthesized? */
int *flagp;
{
	register char *ret;
	register char *br;
	register char *ender;
	register int parno;
	int flags;

	*flagp = HASWIDTH;	/* Tentatively. */

	/* Make an OPEN node, if parenthesized. */
	if (paren) {
		if (regnpar >= NSUBEXP)
			FAIL("too many ()");
		parno = regnpar;
		regnpar++;
		ret = regnode(OPEN+parno);
	} else
		ret = NULL;

	/* Pick up the branches, linking them together. */
	br = regbranch(&flags);
	if (br == NULL)
		return(NULL);
	if (ret != NULL)
		regtail(ret, br);	/* OPEN -> first. */
	else
		ret = br;
	if (!(flags&HASWIDTH))
		*flagp &= ~HASWIDTH;
	*flagp |= flags&SPSTART;
	while (*regparse == '|' || *regparse == '\n') {
		regparse++;
		br = regbranch(&flags);
		if (br == NULL)
			return(NULL);
		regtail(ret, br);	/* BRANCH -> BRANCH. */
		if (!(flags&HASWIDTH))
			*flagp &= ~HASWIDTH;
		*flagp |= flags&SPSTART;
	}

	/* Make a closing node, and hook it on the end. */
	ender = regnode((paren) ? CLOSE+parno : END);	
	regtail(ret, ender);

	/* Hook the tails of the branches to the closing node. */
	for (br = ret; br != NULL; br = regnext(br))
		regoptail(br, ender);

	/* Check for proper termination. */
	if (paren && *regparse++ != ')') {
		FAIL("unmatched ()");
	} else if (!paren && *regparse != '\0') {
		if (*regparse == ')') {
			FAIL("unmatched ()");
		} else
			FAIL("junk on end");	/* "Can't happen". */
		/* NOTREACHED */
	}

	return(ret);
}

/*
 - regbranch - one alternative of an | operator
 *
 * Implements the concatenation operator.
 */
static char *
regbranch(flagp)
int *flagp;
{
	register char *ret;
	register char *chain;
	register char *latest;
	int flags;

	*flagp = WORST;		/* Tentatively. */

	ret = regnode(BRANCH);
	chain = NULL;
	while (*regparse != '\0' && *regparse != ')' &&
	       *regparse != '\n' && *regparse != '|') {
		latest = regpiece(&flags);
		if (latest == NULL)
			return(NULL);
		*flagp |= flags&HASWIDTH;
		if (chain == NULL)	/* First piece. */
			*flagp |= flags&SPSTART;
		else
			regtail(chain, latest);
		chain = latest;
	}
	if (chain == NULL)	/* Loop ran zero times. */
		(void) regnode(NOTHING);

	return(ret);
}

/*
 - regpiece - something followed by possible [*+?]
 *
 * Note that the branching code sequences used for ? and the general cases
 * of * and + are somewhat optimized:  they use the same NOTHING node as
 * both the endmarker for their branch list and the body of the last branch.
 * It might seem that this node could be dispensed with entirely, but the
 * endmarker role is not redundant.
 */
static char *
regpiece(flagp)
int *flagp;
{
	register char *ret;
	register char op;
	register char *next;
	int flags;

	ret = regatom(&flags);
	if (ret == NULL)
		return(NULL);

	op = *regparse;
	if (!ISMULT(op)) {
		*flagp = flags;
		return(ret);
	}

	if (!(flags&HASWIDTH) && op != '?')
		FAIL("*+ operand could be empty");
	*flagp = (op != '+') ? (WORST|SPSTART) : (WORST|HASWIDTH);

	if (op == '*' && (flags&SIMPLE))
		reginsert(STAR, ret);
	else if (op == '*') {
		/* Emit x* as (x&|), where & means "self". */
		reginsert(BRANCH, ret);			/* Either x */
		regoptail(ret, regnode(BACK));		/* and loop */
		regoptail(ret, ret);			/* back */
		regtail(ret, regnode(BRANCH));		/* or */
		regtail(ret, regnode(NOTHING));		/* null. */
	} else if (op == '+' && (flags&SIMPLE))
		reginsert(PLUS, ret);
	else if (op == '+') {
		/* Emit x+ as x(&|), where & means "self". */
		next = regnode(BRANCH);			/* Either */
		regtail(ret, next);
		regtail(regnode(BACK), ret);		/* loop back */
		regtail(next, regnode(BRANCH));		/* or */
		regtail(ret, regnode(NOTHING));		/* null. */
	} else if (op == '?') {
		/* Emit x? as (x|) */
		reginsert(BRANCH, ret);			/* Either x */
		regtail(ret, regnode(BRANCH));		/* or */
		next = regnode(NOTHING);		/* null. */
		regtail(ret, next);
		regoptail(ret, next);
	}
	regparse++;
	if (ISMULT(*regparse))
		FAIL("nested *?+");

	return(ret);
}

/*
 - regatom - the lowest level
 *
 * Optimization:  gobbles an entire sequence of ordinary characters so that
 * it can turn them into a single node, which is smaller to store and
 * faster to run.  Backslashed characters are exceptions, each becoming a
 * separate node; the code is simpler that way and it's not worth fixing.
 */
static char *
regatom(flagp)
int *flagp;
{
	register char *ret;
	int flags;

	*flagp = WORST;		/* Tentatively. */

	switch (*regparse++) {
	/* FIXME: these chars only have meaning at beg/end of pat? */
	case '^':
		ret = regnode(BOL);
		break;
	case '$':
		ret = regnode(EOL);
		break;
	case '.':
		ret = regnode(ANY);
		*flagp |= HASWIDTH|SIMPLE;
		break;
	case '[': {
			register int class;
			register int classend;

			if (*regparse == '^') {	/* Complement of range. */
				ret = regnode(ANYBUT);
				regparse++;
			} else
				ret = regnode(ANYOF);
			if (*regparse == ']' || *regparse == '-')
				regc(*regparse++);
			while (*regparse != '\0' && *regparse != ']') {
				if (*regparse == '-') {
					regparse++;
					if (*regparse == ']' || *regparse == '\0')
						regc('-');
					else {
						class = UCHARAT(regparse-2)+1;
						classend = UCHARAT(regparse);
						if (class > classend+1)
							FAIL("invalid [] range");
						for (; class <= classend; class++)
							regc(class);
						regparse++;
					}
				} else
					regc(*regparse++);
			}
			regc('\0');
			if (*regparse != ']')
				FAIL("unmatched []");
			regparse++;
			*flagp |= HASWIDTH|SIMPLE;
		}
		break;
	case '(':
		ret = reg(1, &flags);
		if (ret == NULL)
			return(NULL);
		*flagp |= flags&(HASWIDTH|SPSTART);
		break;
	case '\0':
	case '|':
	case '\n':
	case ')':
		FAIL("internal urp");	/* Supposed to be caught earlier. */
		break;
	case '?':
	case '+':
	case '*':
		FAIL("?+* follows nothing");
		break;
	case '\\':
		switch (*regparse++) {
		case '\0':
			FAIL("trailing \\");
			break;
		case '<':
			ret = regnode(WORDA);
			break;
		case '>':
			ret = regnode(WORDZ);
			break;
		/* FIXME: Someday handle \1, \2, ... */
		default:
			/* Handle general quoted chars in exact-match routine */
			goto de_fault;
		}
		break;
	de_fault:
	default:
		/*
		 * Encode a string of characters to be matched exactly.
		 *
		 * This is a bit tricky due to quoted chars and due to
		 * '*', '+', and '?' taking the SINGLE char previous
		 * as their operand.
		 *
		 * On entry, the char at regparse[-1] is going to go
		 * into the string, no matter what it is.  (It could be
		 * following a \ if we are entered from the '\' case.)
		 * 
		 * Basic idea is to pick up a good char in  ch  and
		 * examine the next char.  If it's *+? then we twiddle.
		 * If it's \ then we frozzle.  If it's other magic char
		 * we push  ch  and terminate the string.  If none of the
		 * above, we push  ch  on the string and go around again.
		 *
		 *  regprev  is used to remember where "the current char"
		 * starts in the string, if due to a *+? we need to back
		 * up and put the current char in a separate, 1-char, string.
		 * When  regprev  is NULL,  ch  is the only char in the
		 * string; this is used in *+? handling, and in setting
		 * flags |= SIMPLE at the end.
		 */
		{
			char *regprev;
			register char ch;

			regparse--;			/* Look at cur char */
			ret = regnode(EXACTLY);
			for ( regprev = 0 ; ; ) {
				ch = *regparse++;	/* Get current char */
				switch (*regparse) {	/* look at next one */

				default:
					regc(ch);	/* Add cur to string */
					break;

				case '.': case '[': case '(':
				case ')': case '|': case '\n':
				case '$': case '^':
				case '\0':
				/* FIXME, $ and ^ should not always be magic */
				magic:
					regc(ch);	/* dump cur char */
					goto done;	/* and we are done */

				case '?': case '+': case '*':
					if (!regprev) 	/* If just ch in str, */
						goto magic;	/* use it */
					/* End mult-char string one early */
					regparse = regprev; /* Back up parse */
					goto done;

				case '\\':
					regc(ch);	/* Cur char OK */
					switch (regparse[1]){ /* Look after \ */
					case '\0':
					case '<':
					case '>':
					/* FIXME: Someday handle \1, \2, ... */
						goto done; /* Not quoted */
					default:
						/* Backup point is \, scan							 * point is after it. */
						regprev = regparse;
						regparse++; 
						continue;	/* NOT break; */
					}
				}
				regprev = regparse;	/* Set backup point */
			}
		done:
			regc('\0');
			*flagp |= HASWIDTH;
			if (!regprev)		/* One char? */
				*flagp |= SIMPLE;
		}
		break;
	}

	return(ret);
}

/*
 - regnode - emit a node
 */
static char *			/* Location. */
regnode(op)
char op;
{
	register char *ret;
	register char *ptr;

	ret = regcode;
	if (ret == &regdummy) {
		regsize += 3;
		return(ret);
	}

	ptr = ret;
	*ptr++ = op;
	*ptr++ = '\0';		/* Null "next" pointer. */
	*ptr++ = '\0';
	regcode = ptr;

	return(ret);
}

/*
 - regc - emit (if appropriate) a byte of code
 */
static void
regc(b)
char b;
{
	if (regcode != &regdummy)
		*regcode++ = b;
	else
		regsize++;
}

/*
 - reginsert - insert an operator in front of already-emitted operand
 *
 * Means relocating the operand.
 */
static void
reginsert(op, opnd)
char op;
char *opnd;
{
	register char *src;
	register char *dst;
	register char *place;

	if (regcode == &regdummy) {
		regsize += 3;
		return;
	}

	src = regcode;
	regcode += 3;
	dst = regcode;
	while (src > opnd)
		*--dst = *--src;

	place = opnd;		/* Op node, where operand used to be. */
	*place++ = op;
	*place++ = '\0';
	*place++ = '\0';
}

/*
 - regtail - set the next-pointer at the end of a node chain
 */
static void
regtail(p, val)
char *p;
char *val;
{
	register char *scan;
	register char *temp;
	register int offset;

	if (p == &regdummy)
		return;

	/* Find last node. */
	scan = p;
	for (;;) {
		temp = regnext(scan);
		if (temp == NULL)
			break;
		scan = temp;
	}

	if (OP(scan) == BACK)
		offset = scan - val;
	else
		offset = val - scan;
	*(scan+1) = (offset>>8)&0377;
	*(scan+2) = offset&0377;
}

/*
 - regoptail - regtail on operand of first argument; nop if operandless
 */
static void
regoptail(p, val)
char *p;
char *val;
{
	/* "Operandless" and "op != BRANCH" are synonymous in practice. */
	if (p == NULL || p == &regdummy || OP(p) != BRANCH)
		return;
	regtail(OPERAND(p), val);
}

/*
 * regexec and friends
 */

/*
 * Global work variables for regexec().
 */
static char *reginput;		/* String-input pointer. */
static char *regbol;		/* Beginning of input, for ^ check. */
static char **regstartp;	/* Pointer to startp array. */
static char **regendp;		/* Ditto for endp. */

/*
 * Forwards.
 */
STATIC int regtry();
STATIC int regmatch();
STATIC int regrepeat();

#ifdef DEBUG
int regnarrate = 0;
void regdump();
STATIC char *regprop();
#endif

/*
 - regexec - match a regexp against a string
 */
int
regexec(prog, string)
register regexp *prog;
register char *string;
{
	register char *s;

	/* Be paranoid... */
	if (prog == NULL || string == NULL) {
		regerror("NULL parameter");
		return(0);
	}

	/* Check validity of program. */
	if (UCHARAT(prog->program) != MAGIC) {
		regerror("corrupted program");
		return(0);
	}

	/* If there is a "must appear" string, look for it. */
	if (prog->regmust != NULL) {
		s = (char *)string;
		while ((s = strchr(s, prog->regmust[0])) != NULL) {
			if (strncmp(s, prog->regmust, prog->regmlen) == 0)
				break;	/* Found it. */
			s++;
		}
		if (s == NULL)	/* Not present. */
			return(0);
	}

	/* Mark beginning of line for ^ . */
	regbol = (char *)string;

	/* Simplest case:  anchored match need be tried only once. */
	if (prog->reganch)
		return(regtry(prog, string));

	/* Messy cases:  unanchored match. */
	s = (char *)string;
	if (prog->regstart != '\0')
		/* We know what char it must start with. */
		while ((s = strchr(s, prog->regstart)) != NULL) {
			if (regtry(prog, s))
				return(1);
			s++;
		}
	else
		/* We don't -- general case. */
		do {
			if (regtry(prog, s))
				return(1);
		} while (*s++ != '\0');

	/* Failure. */
	return(0);
}

/*
 - regtry - try match at specific point
 */
static int			/* 0 failure, 1 success */
regtry(prog, string)
regexp *prog;
char *string;
{
	register int i;
	register char **sp;
	register char **ep;

	reginput = string;
	regstartp = prog->startp;
	regendp = prog->endp;

	sp = prog->startp;
	ep = prog->endp;
	for (i = NSUBEXP; i > 0; i--) {
		*sp++ = NULL;
		*ep++ = NULL;
	}
	if (regmatch(prog->program + 1)) {
		prog->startp[0] = string;
		prog->endp[0] = reginput;
		return(1);
	} else
		return(0);
}

/*
 - regmatch - main matching routine
 *
 * Conceptually the strategy is simple:  check to see whether the current
 * node matches, call self recursively to see whether the rest matches,
 * and then act accordingly.  In practice we make some effort to avoid
 * recursion, in particular by going through "ordinary" nodes (that don't
 * need to know whether the rest of the match failed) by a loop instead of
 * by recursion.
 */
static int			/* 0 failure, 1 success */
regmatch(prog)
char *prog;
{
	register char *scan;	/* Current node. */
	char *next;		/* Next node. */

	scan = prog;
#ifdef DEBUG
	if (scan != NULL && regnarrate)
		fprintf(stderr, "%s(\n", regprop(scan));
#endif
	while (scan != NULL) {
#ifdef DEBUG
		if (regnarrate)
			fprintf(stderr, "%s...\n", regprop(scan));
#endif
		next = regnext(scan);

		switch (OP(scan)) {
		case BOL:
			if (reginput != regbol)
				return(0);
			break;
		case EOL:
			if (*reginput != '\0')
				return(0);
			break;
		case WORDA:
			/* Must be looking at a letter, digit, or _ */
			if ((!isalnum(*reginput)) && *reginput != '_')
				return(0);
			/* Prev must be BOL or nonword */
			if (reginput > regbol &&
			    (isalnum(reginput[-1]) || reginput[-1] == '_'))
				return(0);
			break;
		case WORDZ:
			/* Must be looking at non letter, digit, or _ */
			if (isalnum(*reginput) || *reginput == '_')
				return(0);
			/* We don't care what the previous char was */
			break;
		case ANY:
			if (*reginput == '\0')
				return(0);
			reginput++;
			break;
		case EXACTLY: {
				register int len;
				register char *opnd;

				opnd = OPERAND(scan);
				/* Inline the first character, for speed. */
				if (*opnd != *reginput)
					return(0);
				len = strlen(opnd);
				if (len > 1 && strncmp(opnd, reginput, len) != 0)
					return(0);
				reginput += len;
			}
			break;
		case ANYOF:
 			if (*reginput == '\0' || strchr(OPERAND(scan), *reginput) == NULL)
				return(0);
			reginput++;
			break;
		case ANYBUT:
 			if (*reginput == '\0' || strchr(OPERAND(scan), *reginput) != NULL)
				return(0);
			reginput++;
			break;
		case NOTHING:
			break;
		case BACK:
			break;
		case OPEN+1:
		case OPEN+2:
		case OPEN+3:
		case OPEN+4:
		case OPEN+5:
		case OPEN+6:
		case OPEN+7:
		case OPEN+8:
		case OPEN+9: {
				register int no;
				register char *save;

				no = OP(scan) - OPEN;
				save = reginput;

				if (regmatch(next)) {
					/*
					 * Don't set startp if some later
					 * invocation of the same parentheses
					 * already has.
					 */
					if (regstartp[no] == NULL)
						regstartp[no] = save;
					return(1);
				} else
					return(0);
			}
			break;
		case CLOSE+1:
		case CLOSE+2:
		case CLOSE+3:
		case CLOSE+4:
		case CLOSE+5:
		case CLOSE+6:
		case CLOSE+7:
		case CLOSE+8:
		case CLOSE+9: {
				register int no;
				register char *save;

				no = OP(scan) - CLOSE;
				save = reginput;

				if (regmatch(next)) {
					/*
					 * Don't set endp if some later
					 * invocation of the same parentheses
					 * already has.
					 */
					if (regendp[no] == NULL)
						regendp[no] = save;
					return(1);
				} else
					return(0);
			}
			break;
		case BRANCH: {
				register char *save;

				if (OP(next) != BRANCH)		/* No choice. */
					next = OPERAND(scan);	/* Avoid recursion. */
				else {
					do {
						save = reginput;
						if (regmatch(OPERAND(scan)))
							return(1);
						reginput = save;
						scan = regnext(scan);
					} while (scan != NULL && OP(scan) == BRANCH);
					return(0);
					/* NOTREACHED */
				}
			}
			break;
		case STAR:
		case PLUS: {
				register char nextch;
				register int no;
				register char *save;
				register int min;

				/*
				 * Lookahead to avoid useless match attempts
				 * when we know what character comes next.
				 */
				nextch = '\0';
				if (OP(next) == EXACTLY)
					nextch = *OPERAND(next);
				min = (OP(scan) == STAR) ? 0 : 1;
				save = reginput;
				no = regrepeat(OPERAND(scan));
				while (no >= min) {
					/* If it could work, try it. */
					if (nextch == '\0' || *reginput == nextch)
						if (regmatch(next))
							return(1);
					/* Couldn't or didn't -- back up. */
					no--;
					reginput = save + no;
				}
				return(0);
			}
			break;
		case END:
			return(1);	/* Success! */
			break;
		default:
			regerror("memory corruption");
			return(0);
			break;
		}

		scan = next;
	}

	/*
	 * We get here only if there's trouble -- normally "case END" is
	 * the terminating point.
	 */
	regerror("corrupted pointers");
	return(0);
}

/*
 - regrepeat - repeatedly match something simple, report how many
 */
static int
regrepeat(p)
char *p;
{
	register int count = 0;
	register char *scan;
	register char *opnd;

	scan = reginput;
	opnd = OPERAND(p);
	switch (OP(p)) {
	case ANY:
		count = strlen(scan);
		scan += count;
		break;
	case EXACTLY:
		while (*opnd == *scan) {
			count++;
			scan++;
		}
		break;
	case ANYOF:
		while (*scan != '\0' && strchr(opnd, *scan) != NULL) {
			count++;
			scan++;
		}
		break;
	case ANYBUT:
		while (*scan != '\0' && strchr(opnd, *scan) == NULL) {
			count++;
			scan++;
		}
		break;
	default:		/* Oh dear.  Called inappropriately. */
		regerror("internal foulup");
		count = 0;	/* Best compromise. */
		break;
	}
	reginput = scan;

	return(count);
}

/*
 - regnext - dig the "next" pointer out of a node
 */
static char *
regnext(p)
register char *p;
{
	register int offset;

	if (p == &regdummy)
		return(NULL);

	offset = NEXT(p);
	if (offset == 0)
		return(NULL);

	if (OP(p) == BACK)
		return(p-offset);
	else
		return(p+offset);
}

#ifdef DEBUG

STATIC char *regprop();

/*
 - regdump - dump a regexp onto stdout in vaguely comprehensible form
 */
void
regdump(r)
regexp *r;
{
	register char *s;
	register char op = EXACTLY;	/* Arbitrary non-END op. */
	register char *next;


	s = r->program + 1;
	while (op != END) {	/* While that wasn't END last time... */
		op = OP(s);
		printf("%2d%s", s-r->program, regprop(s));	/* Where, what. */
		next = regnext(s);
		if (next == NULL)		/* Next ptr. */
			printf("(0)");
		else 
			printf("(%d)", (s-r->program)+(next-s));
		s += 3;
		if (op == ANYOF || op == ANYBUT || op == EXACTLY) {
			/* Literal string, where present. */
			while (*s != '\0') {
				putchar(*s);
				s++;
			}
			s++;
		}
		putchar('\n');
	}

	/* Header fields of interest. */
	if (r->regstart != '\0')
		printf("start `%c' ", r->regstart);
	if (r->reganch)
		printf("anchored ");
	if (r->regmust != NULL)
		printf("must have \"%s\"", r->regmust);
	printf("\n");
}

/*
 - regprop - printable representation of opcode
 */
static char *
regprop(op)
char *op;
{
	register char *p;
	static char buf[50];

	(void) strcpy(buf, ":");

	switch (OP(op)) {
	case BOL:
		p = "BOL";
		break;
	case EOL:
		p = "EOL";
		break;
	case ANY:
		p = "ANY";
		break;
	case ANYOF:
		p = "ANYOF";
		break;
	case ANYBUT:
		p = "ANYBUT";
		break;
	case BRANCH:
		p = "BRANCH";
		break;
	case EXACTLY:
		p = "EXACTLY";
		break;
	case NOTHING:
		p = "NOTHING";
		break;
	case BACK:
		p = "BACK";
		break;
	case END:
		p = "END";
		break;
	case OPEN+1:
	case OPEN+2:
	case OPEN+3:
	case OPEN+4:
	case OPEN+5:
	case OPEN+6:
	case OPEN+7:
	case OPEN+8:
	case OPEN+9:
		sprintf(buf+strlen(buf), "OPEN%d", OP(op)-OPEN);
		p = NULL;
		break;
	case CLOSE+1:
	case CLOSE+2:
	case CLOSE+3:
	case CLOSE+4:
	case CLOSE+5:
	case CLOSE+6:
	case CLOSE+7:
	case CLOSE+8:
	case CLOSE+9:
		sprintf(buf+strlen(buf), "CLOSE%d", OP(op)-CLOSE);
		p = NULL;
		break;
	case STAR:
		p = "STAR";
		break;
	case PLUS:
		p = "PLUS";
		break;
	case WORDA:
		p = "WORDA";
		break;
	case WORDZ:
		p = "WORDZ";
		break;
	default:
		regerror("corrupted opcode");
		break;
	}
	if (p != NULL)
		(void) strcat(buf, p);
	return(buf);
}
#endif

/*
 * The following is provided for those people who do not have strcspn() in
 * their C libraries.  They should get off their butts and do something
 * about it; at least one public-domain implementation of those (highly
 * useful) string routines has been published on Usenet.
 */
#ifdef STRCSPN
/*
 * strcspn - find length of initial segment of s1 consisting entirely
 * of characters not from s2
 */

static int
strcspn(s1, s2)
char *s1;
char *s2;
{
	register char *scan1;
	register char *scan2;
	register int count;

	count = 0;
	for (scan1 = s1; *scan1 != '\0'; scan1++) {
		for (scan2 = s2; *scan2 != '\0';)	/* ++ moved down. */
			if (*scan1 == *scan2++)
				return(count);
		count++;
	}
	return(count);
}
#endif
./src/regexp.h100440    167    454        1330  7102105142  11722 0ustar  laurateam/*
 * Definitions etc. for regexp(3) routines.
 *
 * Caveat:  this is V8 regexp(3) [actually, a reimplementation thereof],
 * not the System V one.
 */
#define NSUBEXP  10
typedef struct regexp {
	char *startp[NSUBEXP];
	char *endp[NSUBEXP];
	char regstart;		/* Internal use only. */
	char reganch;		/* Internal use only. */
	char *regmust;		/* Internal use only. */
	int regmlen;		/* Internal use only. */
	char program[1];	/* Unwarranted chumminess with compiler. */
} regexp;

extern regexp *regcomp();
extern int regexec();
extern void regsub();
extern void regerror();

/*
 * The first byte of the regexp internal "program" is actually this magic
 * number; the start node begins in the second byte.
 */
#define	MAGIC	0234
./src/rules.c100440    167    454       12127  7102105142  11603 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

# include "jam.h"
# include "lists.h"
# include "parse.h"
# include "variable.h"
# include "rules.h"
# include "newstr.h"
# include "hash.h"

/*
 * rules.c - access to RULEs, TARGETs, and ACTIONs
 *
 * External routines:
 *
 *    bindrule() - return pointer to RULE, creating it if necessary
 *    bindtarget() - return pointer to TARGET, creating it if necessary
 *    touchtarget() - mark a target to simulate being new
 *    targetlist() - turn list of target names into a TARGET chain
 *    targetentry() - add a TARGET to a chain of TARGETS
 *    actionlist() - append to an ACTION chain
 *    addsettings() - add a deferred "set" command to a target
 *    usesettings() - set all target specific variables
 *    pushsettings() - set all target specific variables
 *    popsettings() - reset target specific variables to their pre-push values
 *    freesettings() - delete a settings list
 *    donerules() - free RULE and TARGET tables
 *
 * 04/12/94 (seiwald) - actionlist() now just appends a single action.
 * 08/23/94 (seiwald) - Support for '+=' (append to variable)
 */

static struct hash *rulehash = 0;
static struct hash *targethash = 0;


/*
 * bindrule() - return pointer to RULE, creating it if necessary
 */

RULE *
bindrule( rulename ) 
char 	*rulename;
{
	RULE rule, *r = &rule;

	if( !rulehash )
	    rulehash = hashinit( sizeof( RULE ), "rules" );

	r->name = rulename;

	if( hashenter( rulehash, (HASHDATA **)&r ) )
	{
	    r->name = newstr( rulename );	/* never freed */
	    r->procedure = (PARSE *)0;
	    r->actions = (char *)0;
	    r->bindlist = L0;
	    r->flags = 0;
	}

	return r;
}

/*
 * bindtarget() - return pointer to TARGET, creating it if necessary
 */

TARGET *
bindtarget( targetname )
char	*targetname;
{
	TARGET target, *t = &target;

	if( !targethash )
	    targethash = hashinit( sizeof( TARGET ), "targets" );

	t->name = targetname;

	if( hashenter( targethash, (HASHDATA **)&t ) )
	{
	    memset( (char *)t, '\0', sizeof( *t ) );
	    t->name = newstr( targetname );	/* never freed */
	    t->boundname = t->name;		/* default for T_FLAG_NOTFILE */
	}

	return t;
}

/*
 * touchtarget() - mark a target to simulate being new
 */

void
touchtarget( t )
char *t;
{
	bindtarget( t )->flags |= T_FLAG_TOUCHED;
}

/*
 * targetlist() - turn list of target names into a TARGET chain
 *
 * Inputs:
 *	chain	existing TARGETS to append to
 *	targets	list of target names
 */

TARGETS *
targetlist( chain, targets )
TARGETS	*chain;
LIST 	*targets;
{
	for( ; targets; targets = list_next( targets ) )
	    chain = targetentry( chain, bindtarget( targets->string ) );

	return chain;
}

/*
 * targetentry() - add a TARGET to a chain of TARGETS
 *
 * Inputs:
 *	chain	exisitng TARGETS to append to
 *	target	new target to append
 */

TARGETS *
targetentry( chain, target )
TARGETS	*chain;
TARGET	*target;
{
	TARGETS *c;

	c = (TARGETS *)malloc( sizeof( TARGETS ) );
	c->target = target;

	if( !chain ) chain = c;
	else chain->tail->next = c;
	chain->tail = c;
	c->next = 0;

	return chain;
}

/*
 * actionlist() - append to an ACTION chain
 */

ACTIONS *
actionlist( chain, action )
ACTIONS	*chain;
ACTION	*action;
{
	ACTIONS *actions = (ACTIONS *)malloc( sizeof( ACTIONS ) );

	actions->action = action;

	if( !chain ) chain = actions;
	else chain->tail->next = actions;
	chain->tail = actions;
	actions->next = 0;

	return chain;
}

/*
 * addsettings() - add a deferred "set" command to a target
 *
 * Adds a variable setting (varname=list) onto a chain of settings
 * for a particular target.  Replaces the previous previous value,
 * if any, unless 'append' says to append the new list onto the old.
 * Returns the head of the chain of settings.
 */

SETTINGS *
addsettings( head, append, symbol, value )
SETTINGS *head;
int	append;
char	*symbol;
LIST	*value;
{
	SETTINGS *v;
	
	/* Look for previous setting */

	for( v = head; v; v = v->next )
	    if( !strcmp( v->symbol, symbol ) )
		break;

	/* If not previously set, alloc a new. */
	/* If appending, do so. */
	/* Else free old and set new. */

	if( !v )
	{
	    v = (SETTINGS *)malloc( sizeof( *v ) );
	    v->symbol = newstr( symbol );
	    v->value = value;
	    v->next = head;
	    head = v;
	}
	else if( append )
	{
	    v->value = list_append( v->value, value );
	}
	else
	{
	    list_free( v->value );
	    v->value = value;
	} 

	/* Return (new) head of list. */

	return head;
}

/*
 * pushsettings() - set all target specific variables
 */

void
pushsettings( v )
SETTINGS *v;
{
	for( ; v; v = v->next )
	    v->value = var_swap( v->symbol, v->value );
}

/*
 * popsettings() - reset target specific variables to their pre-push values
 */

void
popsettings( v )
SETTINGS *v;
{
	pushsettings( v );	/* just swap again */
}

/*
 *    freesettings() - delete a settings list
 */

void
freesettings( v )
SETTINGS *v;
{
	while( v )
	{
	    SETTINGS *n = v->next;

	    freestr( v->symbol );
	    list_free( v->value );
	    free( (char *)v );

	    v = n;
	}
}

/*
 * donerules() - free RULE and TARGET tables
 */

void
donerules()
{
	hashdone( rulehash );
	hashdone( targethash );
}
./src/rules.h100440    167    454       12672  7102105142  11615 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

/*
 * rules.h -  targets, rules, and related information
 *
 * This file describes the structures holding the targets, rules, and
 * related information accumulated by interpreting the statements
 * of the jam files.
 *
 * The following are defined:
 *
 *	RULE - a generic jam rule, the product of RULE and ACTIONS 
 *	ACTIONS - a chain of ACTIONs 
 *	ACTION - a RULE instance with targets and sources 
 *	SETTINGS - variables to set when executing a TARGET's ACTIONS 
 *	TARGETS - a chain of TARGETs 
 *	TARGET - a file or "thing" that can be built 
 *
 * 04/11/94 (seiwald) - Combined deps & headers into deps[2] in TARGET.
 * 04/12/94 (seiwald) - actionlist() now just appends a single action.
 * 06/01/94 (seiwald) - new 'actions existing' does existing sources
 * 12/20/94 (seiwald) - NOTIME renamed NOTFILE.
 * 01/19/95 (seiwald) - split DONTKNOW into CANTFIND/CANTMAKE.
 * 02/02/95 (seiwald) - new LEAVES modifier on targets.
 * 02/14/95 (seiwald) - new NOUPDATE modifier on targets.
 */

typedef struct _rule RULE;
typedef struct _target TARGET;
typedef struct _targets TARGETS;
typedef struct _action ACTION;
typedef struct _actions ACTIONS;
typedef struct _settings SETTINGS ;

/* RULE - a generic jam rule, the product of RULE and ACTIONS */

struct _rule {
	char	*name;
	PARSE	*procedure;		/* parse tree from RULE */
	char	*actions;		/* command string from ACTIONS */
	LIST	*bindlist;		/* variable to bind for actions */
	int	flags;			/* modifiers on ACTIONS */

# define	RULE_NEWSRCS	0x01	/* $(>) is updated sources only */
# define	RULE_TOGETHER	0x02	/* combine actions on single target */
# define	RULE_IGNORE	0x04	/* ignore return status of executes */
# define	RULE_QUIETLY	0x08	/* don't mention it unless verbose */
# define	RULE_PIECEMEAL	0x10	/* split exec so each $(>) is small */
# define	RULE_EXISTING	0x20	/* $(>) is pre-exisitng sources only */

} ;

/* ACTIONS - a chain of ACTIONs */

struct _actions {
	ACTIONS	*next;
	ACTIONS	*tail;			/* valid only for head */
	ACTION	*action;
} ;

/* ACTION - a RULE instance with targets and sources */

struct _action {
	RULE	*rule;
	TARGETS	*targets;
	TARGETS	*sources;		/* aka $(>) */
	char	running;		/* has been started */
	char	status;			/* see TARGET status */
} ;

/* SETTINGS - variables to set when executing a TARGET's ACTIONS */

struct _settings {
	SETTINGS *next;
	char	*symbol;		/* symbol name for var_set() */
	LIST	*value;			/* symbol value for var_set() */
} ;

/* TARGETS - a chain of TARGETs */

struct _targets {
	TARGETS	*next;
	TARGETS	*tail;			/* valid only for head */
	TARGET	*target;
} ;

/* TARGET - a file or "thing" that can be built */

struct _target {
	char	*name;
	char	*boundname;		/* if search() relocates target */
	ACTIONS	*actions;		/* rules to execute, if any */
	SETTINGS *settings;		/* variables to define */

	char	flags;			/* status info */

# define 	T_FLAG_TEMP 	0x01	/* TEMPORARY applied */
# define 	T_FLAG_NOCARE 	0x02	/* NOCARE applied */
# define 	T_FLAG_NOTFILE 	0x04	/* NOTFILE applied */
# define	T_FLAG_TOUCHED	0x08	/* ALWAYS applied or -t target */
# define	T_FLAG_LEAVES	0x10	/* LEAVES applied */
# define	T_FLAG_NOUPDATE	0x20	/* NOUPDATE applied */

	char	binding;		/* how target relates to real file */

# define 	T_BIND_UNBOUND	0	/* a disembodied name */
# define 	T_BIND_MISSING	1	/* couldn't find real file */
# define 	T_BIND_PARENTS	2	/* using parent's timestamp */
# define 	T_BIND_EXISTS	3	/* real file, timestamp valid */

	TARGETS	*deps[2];		/* dependencies */

# define	T_DEPS_DEPENDS	0	/* due to DEPENDS */
# define	T_DEPS_INCLUDES	1	/* due to INCLUDES */

	time_t	time;			/* update time */
	time_t	leaf;			/* update time of leaf sources */
	time_t	htime;			/* header's time */
	time_t	hleaf;			/* update time of leaf headers */

	char	fate;			/* make0()'s diagnosis */
	char	hfate;			/* collected fate for headers */

# define 	T_FATE_INIT	0	/* nothing done to target */
# define 	T_FATE_MAKING	1	/* make0(target) on stack */

# define 	T_FATE_STABLE	2	/* target didn't need updating */
# define	T_FATE_NEWER	3	/* target newer than parent */

# define	T_FATE_SPOIL	4	/* >= SPOIL rebuilds parents */
# define 	T_FATE_ISTMP	4	/* unneeded temp target oddly present */

# define	T_FATE_BUILD	5	/* >= BUILD rebuilds target */
# define	T_FATE_TOUCHED	5	/* manually touched with -t */
# define	T_FATE_MISSING	6	/* is missing, needs updating */
# define 	T_FATE_OUTDATED	7	/* is out of date, needs updating */
# define 	T_FATE_UPDATE	8	/* deps updated, needs updating */

# define 	T_FATE_BROKEN	9	/* >= BROKEN ruins parents */
# define 	T_FATE_CANTFIND	9	/* no rules to make missing target */
# define 	T_FATE_CANTMAKE	10	/* can't find dependents */

	char	progress;		/* tracks make1() progress */

# define	T_MAKE_INIT	0	/* make1(target) not yet called */
# define	T_MAKE_ONSTACK	1	/* make1(target) on stack */
# define	T_MAKE_ACTIVE	2	/* make1(target) in make1b() */
# define	T_MAKE_RUNNING	3	/* make1(target) running commands */
# define	T_MAKE_DONE	4	/* make1(target) done */

	char	status;			/* execcmd() result */

	int	asynccnt;		/* child deps outstanding */
	TARGETS	*parents;		/* used by make1() for completion */
	char	*cmds;			/* type-punned command list */
} ;

RULE	*bindrule();
TARGET	*bindtarget();
void	touchtarget();
TARGETS	*targetlist();
TARGETS	*targetentry();
ACTIONS	*actionlist();
SETTINGS *addsettings();
void 	pushsettings();
void 	popsettings();
void	freesettings();
void	donerules();
./src/scan.c100440    167    454       16140  7102105142  11374 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

# include "jam.h"
# include "lists.h"
# include "parse.h"
# include "scan.h"
# include "jamgram.h"
# include "jambase.h"
# include "newstr.h"

/*
 * scan.c - the jam yacc scanner
 *
 * 12/26/93 (seiwald) - bump buf in yylex to 10240 - yuk.
 * 09/16/94 (seiwald) - check for overflows, unmatched {}'s, etc.
 *			Also handle tokens abutting EOF by remembering
 *			to return EOF now matter how many times yylex()
 *			reinvokes yyline().
 * 02/11/95 (seiwald) - honor only punctuation keywords if SCAN_PUNCT.
 * 07/27/95 (seiwald) - Include jamgram.h after scan.h, so that YYSTYPE is
 *			defined before Linux's yacc tries to redefine it.
 */

struct keyword {
	char *word;
	int type;
} keywords[] = {
#ifdef FATFS
# include "jamgramt.h"
#else
# include "jamgramtab.h"
#endif
	{ 0, 0 }
} ;

struct include {
	struct include *next;	/* next serial include file */
	char 	*string;	/* pointer into current line */
	char	**strings;	/* for yyfparse() -- text to parse */
	FILE 	*file;		/* for yyfparse() -- file being read */
	char 	*fname;		/* for yyfparse() -- file name */
	int 	line;		/* line counter for error messages */
	char 	buf[ 512 ];	/* for yyfparse() -- line buffer */
} ;

static struct include *incp = 0; /* current file; head of chain */

static int scanmode = SCAN_NORMAL;
static int anyerrors = 0;
static char *symdump();

# define BIGGEST_TOKEN 10240	/* no single token can be larger */

/* 
 * Set parser mode: normal, string, or keyword
 */

void
yymode( n )
int n;
{
	scanmode = n;
}

void
yyerror( s )
char *s;
{
	if( incp )
	    printf( "%s: line %d: ", incp->fname, incp->line );

	printf( "%s at %s\n", s, symdump( &yylval ) );

	++anyerrors;
}

int
yyanyerrors()
{
	return anyerrors != 0;
}

void
yyfparse( s )
char *s;
{
	struct include *i = (struct include *)malloc( sizeof( *i ) );

	/* Push this onto the incp chain. */

	i->string = "";
	i->strings = 0;
	i->file = 0;
	i->fname = copystr( s );
	i->line = 0;
	i->next = incp;
	incp = i;

	/* If the filename is "+", it means use the internal jambase. */

	if( !strcmp( s, "+" ) )
	    i->strings = jambase;
}

/*
 * yyline() - read new line and return first character
 *
 * Fabricates a continuous stream of characters across include files,
 * returning EOF at the bitter end.
 */

int
yyline()
{
	struct include *i = incp;

	if( !incp )
	    return EOF;

	/* Once we start reading from the input stream, we reset the */
	/* include insertion point so that the next include file becomes */
	/* the head of the list. */

	/* If there is more data in this line, return it. */

	if( *i->string )
	    return *i->string++;

	/* If we're reading from an internal string list, go to the */
	/* next string. */

	if( i->strings )
	{
	    if( !*i->strings )
		goto next;

	    i->line++;
	    i->string = *(i->strings++);
	    return *i->string++;
	}

	/* If necessary, open the file */

	if( !i->file )
	{
	    FILE *f = stdin;

	    if( strcmp( i->fname, "-" ) && !( f = fopen( i->fname, "r" ) ) )
		perror( i->fname );

	    i->file = f;
	}

	/* If there's another line in this file, start it. */

	if( i->file && fgets( i->buf, sizeof( i->buf ), i->file ) )
	{
	    i->line++;
	    i->string = i->buf;
	    return *i->string++;
	}

    next:
	/* This include is done.  */
	/* Free it up and return EOF so yyparse() returns to parse_file(). */

	incp = i->next;

	/* Close file, free name */

	if( i->file && i->file != stdin )
	    fclose( i->file );
	freestr( i->fname );
	free( (char *)i );

	return EOF;
}

/*
 * yylex() - set yylval to current token; return its type
 *
 * Macros to move things along:
 *
 *	yychar() - return and advance character; invalid after EOF
 *	yyprev() - back up one character; invalid before yychar()
 *
 * yychar() returns a continuous stream of characters, until it hits
 * the EOF of the current include file.
 */

# define yychar() ( *incp->string ? *incp->string++ : yyline() )
# define yyprev() ( incp->string-- )

int
yylex()
{
	int c;
	char buf[BIGGEST_TOKEN];
	char *b = buf;

	if( !incp )
	    goto eof;

	/* Get first character (whitespace or of token) */

	c = yychar();

	if( scanmode == SCAN_STRING )
	{
	    /* If scanning for a string (action's {}'s), look for the */
	    /* closing brace.  We handle matching braces, if they match! */

	    int nest = 1;

	    while( c != EOF && b < buf + sizeof( buf ) )
	    {
		    if( c == '{' )
			nest++;

		    if( c == '}' && !--nest )
			break;

		    *b++ = c;

		    c = yychar();
	    }

	    /* We ate the ending brace -- regurgitate it. */

	    if( c != EOF )
		yyprev();

	    /* Check obvious errors. */

	    if( b == buf + sizeof( buf ) )
	    {
		yyerror( "action block too big" );
		goto eof;
	    }

	    if( nest )
	    {
		yyerror( "unmatched {} in action block" );
		goto eof;
	    }

	    *b = 0;
	    yylval.type = STRING;
	    yylval.string = newstr( buf );

	}
	else
	{
	    char *b = buf;
	    int inquote = 0;
	    int literal = 0;
	    int hasquote = 0;
	    struct keyword *k;
		
	    /* Eat white space */

	    for( ;; )
	    {
		/* Skip past white space */

		while( c != EOF && isspace( c ) )
			c = yychar();

		/* Not a comment?  Swallow up comment line. */

		if( c != '#' )
			break;
		while( ( c = yychar() ) != EOF && c != '\n' )
			;
	    }

	    /* c now points to the first character of a token. */

	    if( c == EOF )
		goto eof;

	    /* look for white space to delimit word */
	    /* "'s get stripped but preserve white space */

	    while( b < buf + sizeof( buf ) )
	    {
		if( literal )
		    *b++ = c, literal = 0;
		else if( c == '\\' )
		    literal++;
		else if( c == '"' )
		    inquote = !inquote, hasquote++;
		else
		    *b++ = c;

		if( ( c = yychar() ) == EOF || !inquote && isspace( c ) )
		    break;
	    }

	    /* Check obvious errors. */

	    if( b == buf + sizeof( buf ) )
	    {
		yyerror( "string too big" );
		goto eof;
	    }

	    if( inquote )
	    {
		yyerror( "unmatched \" in string" );
		goto eof;
	    }

	    /* We looked ahead a character - back up. */

	    if( c != EOF )
		yyprev();

	    /* scan token table */
	    /* don't scan if it's "anything", $anything, */
	    /* or an alphabetic when were looking for punctuation */

	    *b = 0;
	    yylval.type = ARG;

	    if( !hasquote && 
		*buf != '$' && 
		!( isalpha( *buf ) && scanmode == SCAN_PUNCT ) )
	    {
		for( k = keywords; k->word; k++ )
		    if( *buf == *k->word && !strcmp( k->word, buf ) )
		{
		    yylval.type = k->type;
		    yylval.string = k->word;	/* used by symdump */
		    break;
		}
	    }

	    if( yylval.type == ARG )
		yylval.string = newstr( buf );
	}

	if( DEBUG_SCAN )
		printf( "scan %s\n", symdump( &yylval ) );

	return yylval.type;

eof:
	yylval.type = EOF;
	return yylval.type;
}

static char *
symdump( s )
YYSTYPE *s;
{
	static char buf[ BIGGEST_TOKEN + 20 ];

	switch( s->type )
	{
	case EOF:
		sprintf( buf, "EOF" );
		break;
	case 0:
		sprintf( buf, "unknown symbol %s", s->string );
		break;
	case ARG:
		sprintf( buf, "argument %s", s->string );
		break;
	case STRING:
		sprintf( buf, "string \"%s\"", s->string );
		break;
	default:
		sprintf( buf, "keyword %s", s->string );
		break;
	}
	return buf;
}
./src/scan.h100440    167    454        2422  7102105142  11357 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

/*
 * scan.h - the jam yacc scanner
 *
 * External functions:
 *
 *	yyerror( char *s ) - print a parsing error message
 *	yyfparse( char *s ) - scan include file s
 *	yylex() - parse the next token, returning its type
 *	yymode() - adjust lexicon of scanner
 *	yyparse() - declaration for yacc parser
 *	yyanyerrors() - indicate if any parsing errors occured
 *
 * The yymode() function is for the parser to adjust the lexicon of the
 * scanner.  Aside from normal keyword scanning, there is a mode to
 * handle action strings (look only for the closing }) and a mode to 
 * ignore most keywords when looking for a punctuation keyword.  This 
 * allows non-punctuation keywords to be used in lists without quoting.
 */

/*
 * YYSTYPE - value of a lexical token
 */

# define YYSTYPE YYSYMBOL

typedef struct _YYSTYPE {
	int		type;
	char		*string;
	PARSE		*parse;
	LIST		*list;
	int		number;
} YYSTYPE;

extern YYSTYPE yylval;

void yyerror();
void yyfparse();
int yylex();
void yymode();
int yyparse();
int yyanyerrors();

# define SCAN_NORMAL	0	/* normal parsing */
# define SCAN_STRING	1	/* look only for matching } */
# define SCAN_PUNCT	2	/* only punctuation keywords */
./src/search.c100440    167    454        3042  7102105142  11672 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

# include "jam.h"
# include "lists.h"
# include "search.h"
#ifdef FATFS
# include "timestam.h"
#else
# include "timestamp.h"
#endif
# include "filesys.h"
# include "variable.h"
# include "newstr.h"

/*
 * search.c - find a target along $(SEARCH) or $(LOCATE) 
 */

char *
search( target, time )
char	*target;
time_t	*time;
{
	FILENAME f[1];
	LIST	*varlist;
	char	buf[ MAXJPATH ];

	/* Parse the filename */

	file_parse( target, f );

	f->f_grist.ptr = 0;
	f->f_grist.len = 0;

	if( varlist = var_get( "LOCATE" ) )
	{
	    f->f_root.ptr = varlist->string;
	    f->f_root.len = strlen( varlist->string );

	    file_build( f, buf, 1 );

	    if( DEBUG_SEARCH )
		printf( "locate %s: %s\n", target, buf );

	    timestamp( buf, time );

	    return newstr( buf );
	}
	else if( varlist = var_get( "SEARCH" ) )
	{
	    while( varlist )
	    {
		f->f_root.ptr = varlist->string;
		f->f_root.len = strlen( varlist->string );

		file_build( f, buf, 1 );

		if( DEBUG_SEARCH )
		    printf( "search %s: %s\n", target, buf );

		timestamp( buf, time );

		if( *time )
		    return newstr( buf );

		varlist = list_next( varlist );
	    }
	}

	/* Look for the obvious */
	/* This is a questionable move.  Should we look in the */
	/* obvious place if SEARCH is set? */

	f->f_root.ptr = 0;
	f->f_root.len = 0;

	file_build( f, buf, 1 );

	if( DEBUG_SEARCH )
	    printf( "search %s: %s\n", target, buf );

	timestamp( buf, time );

	return newstr( buf );
}
./src/search.h100440    167    454         315  7102105142  11657 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

/*
 * search.h - find a target along $(SEARCH) or $(LOCATE) 
 */

char *search();
./src/timestamp.c100440    167    454        7263  7102105142  12441 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

# include "jam.h"
# include "hash.h"
# include "filesys.h"
#ifdef FATFS
# include "timestam.h"
#else
# include "timestamp.h"
#endif
# include "newstr.h"

/*
 * timestamp.c - get the timestamp of a file or archive member
 */

/*
 * BINDING - all known files
 */

typedef struct _binding BINDING;

struct _binding {
	char	*name;
	short	flags;

# define BIND_SCANNED	0x01	/* if directory or arch, has been scanned */

	short	progress;

# define BIND_INIT	0	/* never seen */
# define BIND_NOENTRY	1	/* timestamp requested but file never found */
# define BIND_SPOTTED	2	/* file found but not timed yet */
# define BIND_MISSING	3	/* file found but can't get timestamp */
# define BIND_FOUND	4	/* file found and time stamped */

	time_t	time;		/* update time - 0 if not exist */
} ;

static struct hash *bindhash = 0;
static void time_enter();

static char *time_progress[] =
{
	"INIT",
	"NOENTRY",
	"SPOTTED",
	"MISSING",
	"FOUND"
} ;


/*
 * timestamp() - return timestamp on a file, if present
 */

void
timestamp( target, time )
char	*target;
time_t	*time;
{
	FILENAME f1, f2;
	BINDING	binding, *b = &binding;
	char buf[ MAXJPATH ];

#if defined( NT ) || defined( VMS )
	char path[ MAXJPATH ];
	char *p = path;

	do *p++ = tolower( *target );
	while( *target++ );

	target = path;
#endif /* NT or VMS */

	if( !bindhash )
	    bindhash = hashinit( sizeof( BINDING ), "bindings" );

	/* Quick path - is it there? */

	b->name = target;
	b->time = b->flags = 0;
	b->progress = BIND_INIT;

	if( hashenter( bindhash, (HASHDATA **)&b ) )
	    b->name = newstr( target );		/* never freed */

	if( b->progress != BIND_INIT )
	    goto afterscanning;

	b->progress = BIND_NOENTRY;

	/* Not found - have to scan for it */

	file_parse( target, &f1 );

	/* Scan directory if not already done so */

	{
	    BINDING binding, *b = &binding;

	    f2 = f1;
	    f2.f_grist.len = 0;
	    file_parent( &f2 );
	    file_build( &f2, buf, 0 );

	    b->name = buf;
	    b->time = b->flags = 0;
	    b->progress = BIND_INIT;

	    if( hashenter( bindhash, (HASHDATA **)&b ) )
		b->name = newstr( buf );	/* never freed */

	    if( !( b->flags & BIND_SCANNED ) )
	    {
		file_dirscan( buf, time_enter );
		b->flags |= BIND_SCANNED;
	    }
	}

	/* Scan archive if not already done so */

	if( f1.f_member.len )
	{
	    BINDING binding, *b = &binding;

	    f2 = f1;
	    f2.f_grist.len = 0;
	    f2.f_member.len = 0;
	    file_build( &f2, buf, 0 );

	    b->name = buf;
	    b->time = b->flags = 0;
	    b->progress = BIND_INIT;

	    if( hashenter( bindhash, (HASHDATA **)&b ) )
		b->name = newstr( buf );	/* never freed */

	    if( !( b->flags & BIND_SCANNED ) )
	    {
		file_archscan( buf, time_enter );
		b->flags |= BIND_SCANNED;
	    }
	}

    afterscanning:

	if( b->progress == BIND_SPOTTED )
	{
	    if( file_time( b->name, &b->time ) < 0 )
		b->progress = BIND_MISSING;
	    else
		b->progress = BIND_FOUND;
	}

	*time = b->progress == BIND_FOUND ? b->time : 0;
}

static void
time_enter( target, found, time )
char	*target;
int	found;
time_t	time;
{
	BINDING	binding, *b = &binding;

#if defined( NT ) || defined( VMS )
	char path[ MAXJPATH ];
	char *p = path;

	do *p++ = tolower( *target );
	while( *target++ );

	target = path;
#endif /* NT or VMS */

	b->name = target;
	b->flags = 0;

	if( hashenter( bindhash, (HASHDATA **)&b ) )
	    b->name = newstr( target );		/* never freed */

	b->time = time;
	b->progress = found ? BIND_FOUND : BIND_SPOTTED;

	if( DEBUG_BINDSCAN )
	    printf( "time ( %s ) : %s\n", target, time_progress[b->progress] );
}

/*
 * donestamps() - free timestamp tables
 */

void
donestamps()
{
	hashdone( bindhash );
}
./src/timestamp.h100440    167    454         350  7102105142  12414 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

/*
 * timestamp.h - get the timestamp of a file or archive member
 */

void timestamp();
void donestamps();

./src/variable.c100440    167    454       13771  7102105142  12244 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

# include "jam.h"
# include "lists.h"
# include "parse.h"
# include "variable.h"
# include "expand.h"
# include "hash.h"
# include "filesys.h"
# include "newstr.h"

/*
 * variable.c - handle jam multi-element variables
 *
 * External routines:
 *
 *	var_defines() - load a bunch of variable=value settings
 *	var_list() - variable expand an input list, generating a new list
 *	var_string() - expand a string with variables in it
 *	var_get() - get value of a user defined symbol
 *	var_set() - set a variable in jam's user defined symbol table
 *	var_swap() - swap a variable's value with the given one
 *	var_done() - free variable tables
 *
 * Internal routines:
 *
 *	var_enter() - make new var symbol table entry, returning var ptr
 *	var_dump() - dump a variable to stdout
 *
 * 04/13/94 (seiwald) - added shorthand L0 for null list pointer
 * 08/23/94 (seiwald) - Support for '+=' (append to variable)
 * 01/22/95 (seiwald) - split environment variables at blanks or :'s
 * 05/10/95 (seiwald) - split path variables at SPLITPATH (not :)
 */

static struct hash *varhash = 0;

/*
 * VARIABLE - a user defined multi-value variable
 */

typedef struct _variable VARIABLE ;

struct _variable {
	char	*symbol;
	LIST	*value;
} ;

static VARIABLE	*var_enter();
static void	var_dump();



/*
 * var_defines() - load a bunch of variable=value settings
 *
 * If variable name ends in PATH, split value at :'s.  
 * Otherwise, split at blanks.
 */

void
var_defines( e )
char **e;
{
	for( ; *e; e++ )
	{
	    char *val;

	    if( val = strchr( *e, '=' ) )
	    {
		LIST *l = L0;
		char *pp, *p;
		char split = ' ';
		char buf[ MAXSYM ];

		/* Split *PATH at :'s, not spaces */

		if( val - 4 >= *e )
		{
		    if( !strncmp( val - 4, "PATH", 4 ) ||
		        !strncmp( val - 4, "Path", 4 ) ||
		        !strncmp( val - 4, "path", 4 ) )
			    split = SPLITPATH;
		}

		/* Do the split */

		for( pp = val + 1; p = strchr( pp, split ); pp = p + 1 )
		{
		    strncpy( buf, pp, p - pp );
		    buf[ p - pp ] = '\0';
		    l = list_new( l, newstr( buf ) );
		}

		l = list_new( l, newstr( pp ) );

		/* Get name */

		strncpy( buf, *e, val - *e );
		buf[ val - *e ] = '\0';

		var_set( buf, l, VAR_SET );
	    }
	}
}

/*
 * var_list() - variable expand an input list, generating a new list
 *
 * Returns a newly created list.
 */

LIST *
var_list( ilist, lol )
LIST	*ilist;
LOL	*lol;
{
	LIST *olist = 0;

	while( ilist )
	{
	    char *s = ilist->string;
	    olist = var_expand( olist, s, s + strlen(s), lol, 1 );
	    ilist = list_next( ilist );
	}

	return olist;
}


/*
 * var_string() - expand a string with variables in it
 *
 * Copies in to out; doesn't modify targets & sources.
 */

int
var_string( in, out, outsize, lol )
char	*in;
char	*out;
int	outsize;
LOL	*lol;
{
	char 	*out0 = out;
	char	*oute = out + outsize - 1;

	while( *in )
	{
	    char	*lastword;
	    int		dollar = 0;

	    /* Copy white space */

	    while( isspace( *in ) )
	    {
		if( out >= oute )
		    return -1;

		*out++ = *in++;
	    }

	    lastword = out;

	    /* Copy non-white space, watching for variables */

	    while( *in && !isspace( *in ) )
	    {
	        if( out >= oute )
		    return -1;

		if( in[0] == '$' && in[1] == '(' )
		    dollar++;

		*out++ = *in++;
	    }

	    /* If a variable encountered, expand it and and embed the */
	    /* space-separated members of the list in the output. */

	    if( dollar )
	    {
		LIST	*l;

		l = var_expand( L0, lastword, out, lol, 0 );

		out = lastword;

		for( ; l; l = list_next( l ) )
		{
		    int so = strlen( l->string );

		    if( out + so >= oute )
			return -1;

		    strcpy( out, l->string );
		    out += so;
		    *out++ = ' ';
		}

		list_free( l );
	    }
	}

	if( out >= oute )
	    return -1;

	*out++ = '\0';

	return out - out0;
}

/*
 * var_get() - get value of a user defined symbol
 *
 * Returns NULL if symbol unset.
 */

LIST *
var_get( symbol )
char	*symbol;
{
	VARIABLE var, *v = &var;

	v->symbol = symbol;

	if( varhash && hashcheck( varhash, (HASHDATA **)&v ) )
	{
	    if( DEBUG_VARGET )
		var_dump( v->symbol, v->value, "get" );
	    return v->value;
	}
    
	return 0;
}

/*
 * var_set() - set a variable in jam's user defined symbol table
 *
 * 'flag' controls the relationship between new and old values of
 * the variable: SET replaces the old with the new; APPEND appends
 * the new to the old; DEFAULT only uses the new if the variable
 * was previously unset.
 *
 * Copies symbol.  Takes ownership of value.
 */

void
var_set( symbol, value, flag )
char	*symbol;
LIST	*value;
int	flag;
{
	VARIABLE *v = var_enter( symbol );

	if( DEBUG_VARSET )
	    var_dump( symbol, value, "set" );

	switch( flag )
	{
	case VAR_SET:
	    /* Replace value */
	    list_free( v->value );
	    v->value = value;
	    break;

	case VAR_APPEND:
	    /* Append value */
	    v->value = list_append( v->value, value );
	    break;

	case VAR_DEFAULT:
	    /* Set only if unset */
	    if( !v->value )
		v->value = value;
	    else
		list_free( value );
	    break;
	}
}

/*
 * var_swap() - swap a variable's value with the given one
 */

LIST *
var_swap( symbol, value )
char	*symbol;
LIST	*value;
{
	VARIABLE *v = var_enter( symbol );
	LIST 	 *oldvalue = v->value;

	if( DEBUG_VARSET )
	    var_dump( symbol, value, "set" );

	v->value = value;

	return oldvalue;
}



/*
 * var_enter() - make new var symbol table entry, returning var ptr
 */

static VARIABLE *
var_enter( symbol )
char	*symbol;
{
	VARIABLE var, *v = &var;

	if( !varhash )
	    varhash = hashinit( sizeof( VARIABLE ), "variables" );

	v->symbol = symbol;
	v->value = 0;

	if( hashenter( varhash, (HASHDATA **)&v ) )
	    v->symbol = newstr( symbol );	/* never freed */

	return v;
}

/*
 * var_dump() - dump a variable to stdout
 */

static void
var_dump( symbol, value, what )
char	*symbol;
LIST	*value;
char	*what;
{
	printf( "%s %s = ", what, symbol );
	list_print( value );
	printf( "\n" );
}

/*
 * var_done() - free variable tables
 */

void
var_done()
{
	hashdone( varhash );
}
./src/variable.h100440    167    454        1070  7102105142  12216 0ustar  laurateam/*
 * Copyright 1993, 1995 Christopher Seiwald.
 *
 * This file is part of Jam - see jam.c for Copyright information.
 */

/*
 * variable.h - handle jam multi-element variables
 *
 * 08/23/94 (seiwald) - Support for '+=' (append to variable)
 */

LIST *var_get();
void var_defines();
void var_set();
LIST *var_swap();
LIST *var_list();
int var_string();
void var_done();

/*
 * Defines for var_set().
 */

# define VAR_SET	0	/* override previous value */
# define VAR_APPEND	1	/* append to previous value */
# define VAR_DEFAULT	2	/* set only if no previous value */

./src/yyacc100550    167    454        2511  7102105143  11317 0ustar  laurateam#!/bin/sh

# yyacc - yacc wrapper
#
# Allows tokens to be written as `literal` and then automatically 
# substituted with #defined tokens.
#
# Usage:
#	yyacc file.y filetab.h file.yy 
#
# inputs:
#	file.yy		yacc grammar with ` literals
#
# outputs:
#	file.y		yacc grammar
#	filetab.h	array of string <-> token mappings
#
# 3-13-93
#	Documented and p moved in sed command (for some reason,
#	s/x/y/p doesn't work).
# 10-12-93
#	Take basename as second argument.
# 12-31-96
#	reversed order of args to be compatible with GenFile rule

outy=${1?}
outh=${2?}
in=${3?}
out=`basename $in .yy`

T=/tmp/yy$$
trap 'rm -f $T.*' 0

sed '
	: 1
	/`/{
		h
		s/[^`]*`\([^`]*\)`.*/\1/
		p
		g
		s/[^`]*`[^`]*`//
		b 1
	}
	d
' $in | sort -u | sed '
	h
	y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/
	s/:/_COLON/
	s/!/_BANG/
	s/&&/_AMPERAMPER/
	s/&/_AMPER/
	s/+/_PLUS/
	s/||/_BARBAR/
	s/|/_BAR/
	s/;/_SEMIC/
	s/-/_MINUS/
	s/</_LANGLE/
	s/>/_RANGLE/
	s/\./_PERIOD/
	s/?/_QUESTION/
	s/=/_EQUALS/
	s/,/_COMMA/
	s/\[/_LBRACKET/
	s/]/_RBRACKET/
	s/{/_LBRACE/
	s/}/_RBRACE/
	s/(/_LPAREN/
	s/)/_RPAREN/
	s/FILE/_FILE_/
	G
	s/\n/ /
' > $T.1

sed '
	s:^\(.*\) \(.*\)$:s/`\2`/\1/g:
	s:\.:\\.:g
	s:\[:\\[:g
' $T.1 > $T.s

rm -f $outy $outh

(
	sed 's:^\(.*\) \(.*\)$:%token \1:' $T.1
	sed -f $T.s $in
) > $outy

(
	sed 's:^\(.*\) \(.*\)$:	{ "\2", \1 },:' $T.1 
) > $outh