2004-09-08 10:05:19 -05:00
|
|
|
/* $RCSfile: dmake.c,v $
|
2007-10-15 09:38:21 -05:00
|
|
|
-- $Revision: 1.12 $
|
|
|
|
-- last change: $Author: ihi $ $Date: 2007-10-15 15:38:21 $
|
2000-09-22 09:33:37 -05:00
|
|
|
--
|
|
|
|
-- SYNOPSIS
|
|
|
|
-- The main program.
|
|
|
|
--
|
|
|
|
-- DESCRIPTION
|
|
|
|
--
|
|
|
|
-- dmake [-#dbug_string] [ options ]
|
|
|
|
-- [ macro definitions ] [ target ... ]
|
|
|
|
--
|
|
|
|
-- This file contains the main command line parser for the
|
|
|
|
-- make utility. The valid flags recognized are as follows:
|
|
|
|
--
|
|
|
|
-- -f file - use file as the makefile
|
|
|
|
-- -C file - duplicate console output to file (MSDOS only)
|
|
|
|
-- -K file - .KEEP_STATE file
|
|
|
|
-- -#dbug_string - dump out debugging info, see below
|
2006-04-20 05:59:05 -05:00
|
|
|
-- -v[cdfimrtw] - verbose, print what we are doing, as we do it
|
|
|
|
-- -m[trae] - measure timing information
|
2000-09-22 09:33:37 -05:00
|
|
|
--
|
|
|
|
-- options: (can be catenated, ie -irn == -i -r -n)
|
|
|
|
--
|
|
|
|
-- -A - enable AUGMAKE special target mapping
|
|
|
|
-- -B - enable non-use of TABS to start recipe lines
|
|
|
|
-- -c - use non-standard comment scanning
|
|
|
|
-- -d - do not use directory cache
|
|
|
|
-- -i - ignore errors
|
|
|
|
-- -n - trace and print, do not execute commands
|
|
|
|
-- -t - touch, update dates without executing commands
|
|
|
|
-- -T - do not apply transitive closure on inference rules
|
|
|
|
-- -r - don't use internal rules
|
|
|
|
-- -s - do your work silently
|
|
|
|
-- -S - force Sequential make, overrides -P
|
|
|
|
-- -q - check if target is up to date. Does not
|
|
|
|
-- do anything. Returns 0 if up to date, -1
|
|
|
|
-- otherwise.
|
|
|
|
-- -p - print out a version of the makefile
|
|
|
|
-- -P# - set value of MAXPROCESS
|
|
|
|
-- -E - define environment strings as macros
|
|
|
|
-- -e - as -E but done after parsing makefile
|
|
|
|
-- -u - force unconditional update of target
|
|
|
|
-- -k - make all independent targets even if errors
|
|
|
|
-- -V - print out this make version number
|
|
|
|
-- -M - Microsoft make compatibility, (* disabled *)
|
|
|
|
-- -h - print out usage info
|
|
|
|
-- -x - export macro defs to environment
|
|
|
|
-- -X - ignore #! lines found in makefile
|
|
|
|
--
|
|
|
|
-- NOTE: - #ddbug_string is only availabe for versions of dmake that
|
|
|
|
-- have been compiled with -DDBUG switch on. Not the case for
|
|
|
|
-- distributed versions. Any such versions must be linked
|
|
|
|
-- together with a version of Fred Fish's debug code.
|
|
|
|
--
|
|
|
|
-- NOTE: - in order to compile the code the include file stddef.h
|
|
|
|
-- must be shipped with the bundled code.
|
|
|
|
--
|
|
|
|
-- AUTHOR
|
|
|
|
-- Dennis Vadura, dvadura@dmake.wticorp.com
|
|
|
|
--
|
|
|
|
-- WWW
|
|
|
|
-- http://dmake.wticorp.com/
|
|
|
|
--
|
|
|
|
-- COPYRIGHT
|
|
|
|
-- Copyright (c) 1996,1997 by WTI Corp. All rights reserved.
|
|
|
|
--
|
|
|
|
-- This program is NOT free software; you can redistribute it and/or
|
|
|
|
-- modify it under the terms of the Software License Agreement Provided
|
|
|
|
-- in the file <distribution-root>/readme/license.txt.
|
|
|
|
--
|
|
|
|
-- LOG
|
|
|
|
-- Use cvs log to obtain detailed change logs.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Set this flag to one, and the global variables in vextern.h will not
|
|
|
|
* be defined as 'extern', instead they will be defined as global vars
|
|
|
|
* when this module is compiled. */
|
|
|
|
#define _DEFINE_GLOBALS_ 1
|
|
|
|
|
2004-10-22 02:04:42 -05:00
|
|
|
#include "extern.h" /* this includes config.h */
|
2000-09-22 09:33:37 -05:00
|
|
|
#include "sysintf.h"
|
|
|
|
|
|
|
|
#ifndef MSDOS
|
|
|
|
#define USAGE \
|
|
|
|
"Usage:\n%s [-P#] [-{f|K} file] [-{w|W} target ...] [macro[!][[*][+][:]]=value ...]\n"
|
|
|
|
#define USAGE2 \
|
2006-04-20 05:59:05 -05:00
|
|
|
"%s [-v[cdfimrtw]] [-m[trae]] [-ABcdeEghiknpqrsStTuVxX] [target ...]\n"
|
2000-09-22 09:33:37 -05:00
|
|
|
#else
|
|
|
|
#define USAGE \
|
|
|
|
"Usage:\n%s [-P#] [-{f|C|K} file] [-{w|W} target ...] [macro[!][[*][+][:]]=value ...]\n"
|
|
|
|
#define USAGE2 \
|
2006-04-20 05:59:05 -05:00
|
|
|
"%s [-v[cdfimrtw]] [-m[trae]] [-ABcdeEghiknpqrsStTuVxX] [target ...]\n"
|
2000-09-22 09:33:37 -05:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/* We don't use va_end at all, so define it out so that it doesn't produce
|
|
|
|
* lots of "Value not used" warnings. */
|
|
|
|
#ifdef va_end
|
|
|
|
#undef va_end
|
|
|
|
#endif
|
|
|
|
#define va_end(expand_to_null)
|
|
|
|
|
|
|
|
/* Make certain that ARG macro is correctly defined. */
|
|
|
|
#ifdef ARG
|
|
|
|
#undef ARG
|
|
|
|
#endif
|
|
|
|
#define ARG(a,b) a b
|
|
|
|
|
|
|
|
static char *sccid = "Copyright (c) 1990,...,1997 by WTI Corp.";
|
|
|
|
static char _warn = TRUE; /* warnings on by default */
|
|
|
|
|
|
|
|
static void _do_VPATH();
|
|
|
|
static void _do_ReadEnvironment();
|
|
|
|
#if !defined(__GNUC__) && !defined(__IBMC__)
|
|
|
|
static void _do_f_flag ANSI((char, char *, char **));
|
|
|
|
#else
|
|
|
|
static void _do_f_flag ANSI((int, char *, char **));
|
|
|
|
#endif
|
|
|
|
|
2002-10-11 07:42:49 -05:00
|
|
|
PUBLIC int
|
2000-09-22 09:33:37 -05:00
|
|
|
main(argc, argv)
|
|
|
|
int argc;
|
|
|
|
char **argv;
|
|
|
|
{
|
|
|
|
#ifdef MSDOS
|
|
|
|
char* std_fil_name = NIL(char);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
char* fil_name = NIL(char);
|
|
|
|
char* state_name = NIL(char);
|
|
|
|
char* whatif = NIL(char);
|
|
|
|
char* cmdmacs;
|
|
|
|
char* targets;
|
2007-10-15 09:38:21 -05:00
|
|
|
STRINGPTR cltarget = NIL(STRING); /* list of targets from command line. */
|
|
|
|
STRINGPTR cltarget_first = NIL(STRING); /* Pointer to first element. */
|
2000-09-22 09:33:37 -05:00
|
|
|
FILE* mkfil;
|
|
|
|
int ex_val;
|
|
|
|
int m_export;
|
|
|
|
|
2007-01-18 02:29:05 -06:00
|
|
|
/* Uncomment the following line to pass commands to the DBUG engine
|
|
|
|
* before the command line switches (-#..) are evaluated. */
|
|
|
|
/*
|
|
|
|
DB_PUSH("d,path");
|
|
|
|
*/
|
2000-09-22 09:33:37 -05:00
|
|
|
DB_ENTER("main");
|
|
|
|
|
|
|
|
/* Initialize Global variables to their default values */
|
|
|
|
Prolog(argc, argv);
|
|
|
|
Create_macro_vars();
|
|
|
|
Catch_signals(Quit);
|
|
|
|
|
2006-04-20 05:59:05 -05:00
|
|
|
/* This macro is only defined for some OSs, see sysintf.c for details *
|
|
|
|
* and NULL if undefined. */
|
|
|
|
Def_macro("ABSMAKECMD", AbsPname, M_PRECIOUS|M_NOEXPORT );
|
|
|
|
|
2000-09-22 09:33:37 -05:00
|
|
|
Def_macro( "MAKECMD", Pname, M_PRECIOUS|M_NOEXPORT );
|
|
|
|
Pname = Basename(Pname);
|
|
|
|
|
|
|
|
DB_PROCESS(Pname);
|
|
|
|
(void) setvbuf(stdout, NULL, _IOLBF, BUFSIZ); /* stdout line buffered */
|
|
|
|
|
|
|
|
Continue = FALSE;
|
|
|
|
Comment = FALSE;
|
|
|
|
Get_env = FALSE;
|
|
|
|
Force = FALSE;
|
|
|
|
Target = FALSE;
|
|
|
|
If_expand = FALSE;
|
|
|
|
Listing = FALSE;
|
|
|
|
Readenv = FALSE;
|
|
|
|
Rules = TRUE;
|
|
|
|
Trace = FALSE;
|
|
|
|
Touch = FALSE;
|
|
|
|
Check = FALSE;
|
|
|
|
Microsoft = FALSE;
|
|
|
|
Makemkf = FALSE;
|
2007-06-12 00:04:45 -05:00
|
|
|
UseWinpath= FALSE;
|
2000-09-22 09:33:37 -05:00
|
|
|
No_exec = FALSE;
|
|
|
|
m_export = FALSE;
|
|
|
|
cmdmacs = NIL(char);
|
|
|
|
targets = NIL(char);
|
2006-04-20 05:59:05 -05:00
|
|
|
Is_exec_shell = FALSE;
|
|
|
|
Shell_exec_target = NIL(CELL);
|
|
|
|
stdout_redir = NIL(FILE);
|
2000-09-22 09:33:37 -05:00
|
|
|
|
2007-01-18 02:29:05 -06:00
|
|
|
/* Get fd for for @@-recipe silencing. */
|
|
|
|
if( (zerofd = open(NULLDEV, O_WRONLY)) == -1 )
|
|
|
|
Fatal( "Error opening %s !", NULLDEV );
|
|
|
|
|
2006-04-20 05:59:05 -05:00
|
|
|
Verbose = V_NOFLAG;
|
|
|
|
Measure = M_NOFLAG;
|
2000-09-22 09:33:37 -05:00
|
|
|
Transitive = TRUE;
|
|
|
|
Nest_level = 0;
|
|
|
|
Line_number = 0;
|
|
|
|
Suppress_temp_file = FALSE;
|
|
|
|
Skip_to_eof = FALSE;
|
|
|
|
|
|
|
|
while( --argc > 0 ) {
|
|
|
|
register char *p;
|
|
|
|
char *q;
|
|
|
|
|
|
|
|
if( *(p = *++argv) == '-' ) {
|
|
|
|
if( p[1] == '\0' ) Fatal("Missing option letter");
|
|
|
|
|
|
|
|
/* copy options to Buffer for $(MFLAGS), strip 'f' and 'C'*/
|
|
|
|
q = strchr(Buffer, '\0');
|
|
|
|
while (*p != '\0') {
|
|
|
|
char c = (*q++ = *p++);
|
|
|
|
if( c == 'f' || c == 'C' ) q--;
|
|
|
|
}
|
|
|
|
|
|
|
|
if( *(q-1) == '-' )
|
|
|
|
q--;
|
|
|
|
else
|
|
|
|
*q++ = ' ';
|
|
|
|
|
|
|
|
*q = '\0';
|
|
|
|
|
|
|
|
for( p = *argv+1; *p; p++) switch (*p) {
|
|
|
|
case 'f':
|
|
|
|
_do_f_flag( 'f', *++argv, &fil_name ); argc--;
|
|
|
|
break;
|
|
|
|
|
|
|
|
#if defined(MSDOS) && !defined(OS2)
|
|
|
|
case 'C':
|
|
|
|
_do_f_flag( 'C', *++argv, &std_fil_name ); argc--;
|
|
|
|
Hook_std_writes( std_fil_name );
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
case 'K':
|
|
|
|
_do_f_flag( 'K', *++argv, &state_name ); argc--;
|
|
|
|
Def_macro(".KEEP_STATE", state_name, M_EXPANDED|M_PRECIOUS);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'W':
|
|
|
|
case 'w': {
|
|
|
|
CELLPTR wif;
|
|
|
|
_do_f_flag( 'w', *++argv, &whatif ); argc--;
|
|
|
|
wif = Def_cell(whatif);
|
|
|
|
wif->ce_attr |= A_WHATIF;
|
|
|
|
whatif = NIL(char);
|
|
|
|
|
|
|
|
if ( *p == 'W')
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/*FALLTHRU*/
|
|
|
|
|
|
|
|
case 'n':
|
|
|
|
Trace = TRUE;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'k': Continue = TRUE; break;
|
|
|
|
case 'c': Comment = TRUE; break;
|
|
|
|
case 'p': Listing = TRUE; break;
|
|
|
|
case 'r': Rules = FALSE; break;
|
|
|
|
case 't': Touch = TRUE; break;
|
|
|
|
case 'q': Check = TRUE; break;
|
|
|
|
case 'u': Force = TRUE; break;
|
|
|
|
case 'x': m_export = TRUE; break;
|
|
|
|
case 'X': No_exec = TRUE; break;
|
|
|
|
case 'T': Transitive = FALSE; break;
|
|
|
|
case 'e': Get_env = 'e'; break;
|
|
|
|
case 'E': Get_env = 'E'; break;
|
|
|
|
|
2006-04-20 05:59:05 -05:00
|
|
|
case 'V': Version(); Quit(0); break;
|
2000-09-22 09:33:37 -05:00
|
|
|
case 'A': Def_macro("AUGMAKE", "y", M_EXPANDED); break;
|
|
|
|
case 'B': Def_macro(".NOTABS", "y", M_EXPANDED); break;
|
|
|
|
case 'i': Def_macro(".IGNORE", "y", M_EXPANDED); break;
|
|
|
|
case 's': Def_macro(".SILENT", "y", M_EXPANDED); break;
|
|
|
|
case 'S': Def_macro(".SEQUENTIAL", "y", M_EXPANDED); break;
|
|
|
|
case 'g': Def_macro(".IGNOREGROUP","y", M_EXPANDED); break;
|
|
|
|
case 'd': Def_macro(".DIRCACHE",NIL(char),M_EXPANDED); break;
|
|
|
|
|
|
|
|
case 'v':
|
|
|
|
if( p[-1] != '-' ) Usage(TRUE);
|
|
|
|
while( p[1] ) switch( *++p ) {
|
|
|
|
case 'c': Verbose |= V_DIR_CACHE; break;
|
|
|
|
case 'd': Verbose |= V_DIR_SET; break;
|
|
|
|
case 'f': Verbose |= V_FILE_IO; break;
|
|
|
|
case 'i': Verbose |= V_INFER; break;
|
|
|
|
case 'm': Verbose |= V_MAKE; break;
|
2004-09-08 10:05:19 -05:00
|
|
|
case 'r': Verbose |= V_FORCEECHO; break;
|
2000-09-22 09:33:37 -05:00
|
|
|
case 't': Verbose |= V_LEAVE_TMP; break;
|
|
|
|
case 'w': Verbose |= V_WARNALL; break;
|
|
|
|
|
|
|
|
default: Usage(TRUE); break;
|
|
|
|
}
|
|
|
|
if( !Verbose ) Verbose = V_ALL;
|
2004-09-08 10:05:19 -05:00
|
|
|
if( Verbose & V_FORCEECHO ) {
|
|
|
|
HASHPTR hp;
|
|
|
|
/* This cleans the .SILENT setting */
|
|
|
|
hp = Def_macro(".SILENT", "", M_EXPANDED);
|
2006-09-25 03:39:05 -05:00
|
|
|
/* This overrides the bitmask for further occurences of
|
|
|
|
* .SILENT to "no bits allowed", see bit variables in the
|
|
|
|
* set_macro_value() definition in dag.c.
|
|
|
|
* The bitmask is already set by Create_macro_vars() in
|
|
|
|
* imacs.c and is overridden for the V_FORCEECHO case. */
|
2004-09-08 10:05:19 -05:00
|
|
|
hp->MV_MASK = A_DEFAULT;
|
|
|
|
}
|
2000-09-22 09:33:37 -05:00
|
|
|
break;
|
|
|
|
|
2006-04-20 05:59:05 -05:00
|
|
|
case 'm':
|
|
|
|
if( p[-1] != '-' ) Usage(TRUE);
|
|
|
|
while( p[1] ) switch( *++p ) {
|
|
|
|
case 't': Measure |= M_TARGET; break;
|
|
|
|
case 'r': Measure |= M_RECIPE; break;
|
|
|
|
case 'a': Measure |= M_ABSPATH; break;
|
|
|
|
case 'e': Measure |= M_SHELLESC; break;
|
|
|
|
|
|
|
|
default: Usage(TRUE); break;
|
|
|
|
}
|
|
|
|
if( !Measure ) Measure = M_TARGET;
|
|
|
|
break;
|
|
|
|
|
2000-09-22 09:33:37 -05:00
|
|
|
case 'P':
|
|
|
|
if( p[1] ) {
|
2007-01-18 02:29:05 -06:00
|
|
|
/* Only set MAXPROCESS if -S flag is *not* used. */
|
|
|
|
if( !(Glob_attr & A_SEQ) )
|
|
|
|
Def_macro( "MAXPROCESS", p+1, M_MULTI|M_EXPANDED );
|
2000-09-22 09:33:37 -05:00
|
|
|
p += strlen(p)-1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
Fatal( "Missing number for -P flag" );
|
|
|
|
break;
|
|
|
|
|
|
|
|
#ifdef DBUG
|
|
|
|
case '#':
|
|
|
|
DB_PUSH(p+1);
|
|
|
|
p += strlen(p)-1;
|
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
case 'h': Usage(FALSE); break;
|
|
|
|
case 0: break; /* lone - */
|
|
|
|
default: Usage(TRUE); break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if( (q = strchr(p, '=')) != NIL(char) ) {
|
|
|
|
cmdmacs = DmStrAdd( cmdmacs, DmStrDup2(p), TRUE );
|
|
|
|
Parse_macro( p, (q[-1]!='+')?M_PRECIOUS:M_DEFAULT );
|
|
|
|
}
|
|
|
|
else {
|
2007-10-15 09:38:21 -05:00
|
|
|
/* Remember the targets from the command line. */
|
|
|
|
register STRINGPTR nsp;
|
|
|
|
|
2000-09-22 09:33:37 -05:00
|
|
|
targets = DmStrAdd( targets, DmStrDup(p), TRUE );
|
2007-10-15 09:38:21 -05:00
|
|
|
|
|
|
|
TALLOC(nsp, 1, STRING);
|
|
|
|
nsp->st_string = DmStrDup( p );
|
|
|
|
nsp->st_next = NIL(STRING);
|
|
|
|
|
|
|
|
if(cltarget != NIL(STRING) )
|
|
|
|
cltarget->st_next = nsp;
|
|
|
|
else
|
|
|
|
cltarget_first = nsp;
|
|
|
|
|
|
|
|
cltarget = nsp;
|
2000-09-22 09:33:37 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Def_macro( "MAKEMACROS", cmdmacs, M_PRECIOUS|M_NOEXPORT );
|
|
|
|
Def_macro( "MAKETARGETS", targets, M_PRECIOUS|M_NOEXPORT );
|
|
|
|
if( cmdmacs != NIL(char) ) FREE(cmdmacs);
|
|
|
|
if( targets != NIL(char) ) FREE(targets);
|
|
|
|
|
|
|
|
Def_macro( "MFLAGS", Buffer, M_PRECIOUS|M_NOEXPORT );
|
|
|
|
Def_macro( "%", "$@", M_PRECIOUS|M_NOEXPORT );
|
|
|
|
|
|
|
|
if( *Buffer ) Def_macro( "MAKEFLAGS", Buffer+1, M_PRECIOUS|M_NOEXPORT );
|
|
|
|
|
2007-10-15 09:38:21 -05:00
|
|
|
_warn = FALSE; /* disable warnings for builtin rules */
|
|
|
|
Target = TRUE; /* make sure we don't mark any of the default rules as
|
|
|
|
* potential targets. */
|
|
|
|
Make_rules(); /* Parse the strings stored in Rule_tab. */
|
2000-09-22 09:33:37 -05:00
|
|
|
_warn = TRUE;
|
|
|
|
|
2007-01-18 02:29:05 -06:00
|
|
|
/* If -r was not given find and parse startup-makefile. */
|
2000-09-22 09:33:37 -05:00
|
|
|
if( Rules ) {
|
|
|
|
char *fname;
|
|
|
|
|
2006-04-20 05:59:05 -05:00
|
|
|
/* Search_file() also checks the environment variable. */
|
2000-09-22 09:33:37 -05:00
|
|
|
if( (mkfil=Search_file("MAKESTARTUP", &fname)) != NIL(FILE) ) {
|
|
|
|
Parse(mkfil);
|
|
|
|
Def_macro( "MAKESTARTUP", fname, M_EXPANDED|M_MULTI|M_FORCE );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
Fatal( "Configuration file `%s' not found", fname );
|
|
|
|
}
|
|
|
|
|
2007-10-15 09:38:21 -05:00
|
|
|
/* Define the targets set on the command line now. */
|
|
|
|
Target = FALSE; /* Will be set to TRUE when the default targets are set. */
|
|
|
|
for( cltarget = cltarget_first; cltarget != NIL(STRING); ) {
|
|
|
|
CELLPTR cp;
|
|
|
|
STRINGPTR nta = cltarget->st_next;
|
|
|
|
|
|
|
|
Add_prerequisite(Targets, cp = Def_cell(cltarget->st_string),
|
|
|
|
FALSE, FALSE);
|
|
|
|
cp->ce_flag |= F_TARGET;
|
|
|
|
cp->ce_attr |= A_FRINGE;
|
|
|
|
Target = TRUE;
|
|
|
|
|
|
|
|
FREE(cltarget->st_string);
|
|
|
|
FREE(cltarget);
|
|
|
|
cltarget = nta;
|
|
|
|
}
|
2000-09-22 09:33:37 -05:00
|
|
|
|
|
|
|
if( Get_env == 'E' ) _do_ReadEnvironment();
|
|
|
|
|
2007-01-18 02:29:05 -06:00
|
|
|
/* Search for and parse user makefile. */
|
2000-09-22 09:33:37 -05:00
|
|
|
if( fil_name != NIL(char) )
|
|
|
|
mkfil = Openfile( fil_name, FALSE, TRUE );
|
|
|
|
else {
|
|
|
|
/* Search .MAKEFILES dependent list looking for a makefile.
|
|
|
|
*/
|
|
|
|
register CELLPTR cp;
|
|
|
|
|
|
|
|
cp = Def_cell( ".MAKEFILES" );
|
|
|
|
mkfil = TryFiles(cp->CE_PRQ);
|
|
|
|
}
|
|
|
|
|
|
|
|
if( mkfil != NIL(FILE) ) {
|
|
|
|
char *f = Filename();
|
|
|
|
char *p;
|
|
|
|
|
|
|
|
if( strcmp(f, "stdin") == 0 ) f = "-";
|
|
|
|
p = DmStrAdd( "-f", f, FALSE );
|
|
|
|
Def_macro( "MAKEFILE", p, M_PRECIOUS|M_NOEXPORT );
|
|
|
|
Parse( mkfil );
|
|
|
|
}
|
|
|
|
else if( !Rules )
|
|
|
|
Fatal( "No `makefile' present" );
|
|
|
|
|
|
|
|
if( Nest_level ) Fatal( "Missing .END for .IF" );
|
|
|
|
if( Get_env == 'e' ) _do_ReadEnvironment();
|
|
|
|
|
|
|
|
_do_VPATH(); /* kludge it up with .SOURCE */
|
|
|
|
|
|
|
|
if( Listing ) Dump(); /* print out the structures */
|
|
|
|
if( Trace ) Glob_attr &= ~A_SILENT; /* make sure we see the trace */
|
|
|
|
|
|
|
|
if( !Target )
|
|
|
|
Fatal( "No target" );
|
|
|
|
else {
|
|
|
|
Test_circle( Root, TRUE );
|
|
|
|
Check_circle_dfa();
|
|
|
|
}
|
|
|
|
|
|
|
|
if( m_export ) {
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for( i=0; i<HASH_TABLE_SIZE; ++i ) {
|
|
|
|
HASHPTR hp = Macs[i];
|
|
|
|
|
|
|
|
while( hp ) {
|
|
|
|
if( !(hp->ht_flag & M_NOEXPORT) && hp->ht_value != NIL(char) )
|
|
|
|
if( Write_env_string(hp->ht_name, hp->ht_value) != 0 )
|
|
|
|
Warning( "Could not export %s", hp->ht_name );
|
|
|
|
hp = hp->ht_next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if( Buffer != NIL(char) ) {FREE( Buffer ); Buffer = NIL(char);}
|
|
|
|
if( Trace ) Def_macro(".SEQUENTIAL", "y", M_EXPANDED);
|
|
|
|
|
|
|
|
ex_val = Make_targets();
|
|
|
|
|
|
|
|
Clear_signals();
|
2007-01-18 02:29:05 -06:00
|
|
|
|
|
|
|
/* Close fd for for @@-recipe silencing. */
|
|
|
|
if( close(zerofd) )
|
|
|
|
Fatal( "Error closing %s !", NULLDEV );
|
2000-09-22 09:33:37 -05:00
|
|
|
Epilog(ex_val); /* Does not return -- EVER */
|
2002-10-11 07:42:49 -05:00
|
|
|
return 0;
|
2000-09-22 09:33:37 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
_do_f_flag( flag, name, fname )
|
|
|
|
char flag;
|
|
|
|
char *name;
|
|
|
|
char **fname;
|
|
|
|
{
|
|
|
|
if( *fname == NIL(char) ) {
|
|
|
|
if( name != NIL(char) ) {
|
|
|
|
*fname = name;
|
|
|
|
} else
|
|
|
|
Fatal("No file name for -%c", flag);
|
|
|
|
} else
|
|
|
|
Fatal("Only one `-%c file' allowed", flag);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
_do_ReadEnvironment()
|
|
|
|
{
|
|
|
|
t_attr saveattr = Glob_attr;
|
|
|
|
|
|
|
|
Glob_attr |= A_SILENT;
|
|
|
|
ReadEnvironment();
|
|
|
|
Glob_attr = saveattr;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
_do_VPATH()
|
|
|
|
{
|
|
|
|
HASHPTR hp;
|
|
|
|
char *_rl[2];
|
|
|
|
extern char **Rule_tab;
|
|
|
|
|
|
|
|
hp = GET_MACRO("VPATH");
|
|
|
|
if( hp == NIL(HASH) ) return;
|
|
|
|
|
|
|
|
_rl[0] = ".SOURCE :^ $(VPATH:s/:/ /)";
|
|
|
|
_rl[1] = NIL(char);
|
|
|
|
|
|
|
|
Rule_tab = _rl;
|
|
|
|
Parse( NIL(FILE) );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* The file table and pointer to the next FREE slot for use by both
|
|
|
|
Openfile and Closefile. Each open stacks the new file onto the open
|
|
|
|
file stack, and a corresponding close will close the passed file, and
|
|
|
|
return the next file on the stack. The maximum number of nested
|
|
|
|
include files is limited by the value of MAX_INC_DEPTH */
|
|
|
|
|
|
|
|
static struct {
|
|
|
|
FILE *file; /* file pointer */
|
|
|
|
char *name; /* name of file */
|
|
|
|
int numb; /* line number */
|
|
|
|
} ftab[ MAX_INC_DEPTH ];
|
|
|
|
|
|
|
|
static int next_file_slot = 0;
|
|
|
|
|
|
|
|
/* Set the proper macro value to reflect the depth of the .INCLUDE directives
|
|
|
|
* and the name of the file we are reading.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
_set_inc_depth()
|
|
|
|
{
|
|
|
|
char buf[10];
|
|
|
|
sprintf( buf, "%d", next_file_slot );
|
|
|
|
Def_macro( "INCDEPTH", buf, M_MULTI|M_NOEXPORT );
|
|
|
|
Def_macro( "INCFILENAME",
|
|
|
|
next_file_slot ? ftab[next_file_slot-1].name : "",
|
|
|
|
M_MULTI|M_NOEXPORT );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PUBLIC FILE *
|
|
|
|
Openfile(name, mode, err)/*
|
|
|
|
===========================
|
|
|
|
This routine opens a file for input or output depending on mode.
|
|
|
|
If the file name is `-' then it returns standard input.
|
|
|
|
The file is pushed onto the open file stack. */
|
|
|
|
char *name;
|
|
|
|
int mode;
|
|
|
|
int err;
|
|
|
|
{
|
|
|
|
FILE *fil;
|
|
|
|
|
|
|
|
DB_ENTER("Openfile");
|
|
|
|
|
2002-10-11 07:42:49 -05:00
|
|
|
if( name == NIL(char) || !*name ) {
|
2000-09-22 09:33:37 -05:00
|
|
|
if( !err )
|
|
|
|
DB_RETURN(NIL(FILE));
|
|
|
|
else
|
|
|
|
Fatal( "Openfile: NIL filename" );
|
2002-10-11 07:42:49 -05:00
|
|
|
}
|
2000-09-22 09:33:37 -05:00
|
|
|
|
|
|
|
if( next_file_slot == MAX_INC_DEPTH )
|
|
|
|
Fatal( "Too many open files. Max nesting level is %d.", MAX_INC_DEPTH);
|
|
|
|
|
|
|
|
DB_PRINT( "io", ("Opening file [%s], in slot %d", name, next_file_slot) );
|
|
|
|
|
|
|
|
if( strcmp("-", name) == 0 ) {
|
|
|
|
name = "stdin";
|
|
|
|
fil = stdin;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
fil = fopen( name, mode ? "w":"r" );
|
|
|
|
|
|
|
|
if( Verbose & V_FILE_IO )
|
|
|
|
printf( "%s: Openning [%s] for %s", Pname, name, mode?"write":"read" );
|
|
|
|
|
|
|
|
if( fil == NIL(FILE) ) {
|
|
|
|
if( Verbose & V_FILE_IO ) printf( " (fail)\n" );
|
|
|
|
if( err )
|
|
|
|
Fatal( mode ? "Cannot open file %s for write" : "File %s not found",
|
|
|
|
name );
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if( Verbose & V_FILE_IO ) printf( " (success)\n" );
|
|
|
|
ftab[next_file_slot].file = fil;
|
|
|
|
ftab[next_file_slot].numb = Line_number;
|
|
|
|
ftab[next_file_slot++].name = DmStrDup(name);
|
|
|
|
Line_number = 0;
|
|
|
|
_set_inc_depth();
|
|
|
|
}
|
|
|
|
|
|
|
|
DB_RETURN(fil);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PUBLIC FILE *
|
|
|
|
Closefile()/*
|
|
|
|
=============
|
|
|
|
This routine is used to close the last file opened. This forces make
|
|
|
|
to open files in a last open first close fashion. It returns the
|
|
|
|
file pointer to the next file on the stack, and NULL if the stack is empty.*/
|
|
|
|
{
|
|
|
|
DB_ENTER("Closefile");
|
|
|
|
|
|
|
|
if( !next_file_slot )
|
|
|
|
DB_RETURN( NIL(FILE) );
|
|
|
|
|
|
|
|
if( ftab[--next_file_slot].file != stdin ) {
|
|
|
|
DB_PRINT( "io", ("Closing file in slot %d", next_file_slot) );
|
|
|
|
|
|
|
|
if( Verbose & V_FILE_IO )
|
|
|
|
printf( "%s: Closing [%s]\n", Pname, ftab[next_file_slot].name );
|
|
|
|
|
|
|
|
fclose( ftab[next_file_slot].file );
|
|
|
|
FREE( ftab[next_file_slot].name );
|
|
|
|
}
|
|
|
|
|
|
|
|
_set_inc_depth();
|
|
|
|
|
|
|
|
if( next_file_slot > 0 ) {
|
|
|
|
Line_number = ftab[next_file_slot].numb;
|
|
|
|
DB_RETURN( ftab[next_file_slot-1].file );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
Line_number = 0;
|
|
|
|
|
|
|
|
DB_RETURN( NIL(FILE) );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PUBLIC FILE *
|
|
|
|
Search_file( macname, rname )
|
|
|
|
char *macname;
|
|
|
|
char **rname;
|
|
|
|
{
|
|
|
|
HASHPTR hp;
|
|
|
|
FILE *fil = NIL(FILE);
|
2002-10-11 07:42:49 -05:00
|
|
|
char *fname = NIL(char);
|
2000-09-22 09:33:37 -05:00
|
|
|
char *ename = NIL(char);
|
|
|
|
|
|
|
|
/* order of precedence is:
|
|
|
|
*
|
|
|
|
* MACNAME from command line (precious is marked)
|
|
|
|
* ... via MACNAME:=filename definition.
|
|
|
|
* MACNAME from environment
|
|
|
|
* MACNAME from builtin rules (not precious)
|
|
|
|
*/
|
|
|
|
|
|
|
|
if( (hp = GET_MACRO(macname)) != NIL(HASH) )
|
|
|
|
ename = fname = Expand(hp->ht_value);
|
|
|
|
|
|
|
|
if( hp->ht_flag & M_PRECIOUS ) fil = Openfile(fname, FALSE, FALSE);
|
|
|
|
|
|
|
|
if( fil == NIL(FILE) ) {
|
|
|
|
fname=Expand(Read_env_string(macname));
|
|
|
|
if( (fil = Openfile(fname, FALSE, FALSE)) != NIL(FILE) ) FREE(ename);
|
|
|
|
}
|
|
|
|
|
|
|
|
if( fil == NIL(FILE) && hp != NIL(HASH) )
|
|
|
|
fil = Openfile(fname=ename, FALSE, FALSE);
|
|
|
|
|
|
|
|
if( rname ) *rname = fname;
|
|
|
|
|
|
|
|
return(fil);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PUBLIC char *
|
|
|
|
Filename()/*
|
|
|
|
============
|
|
|
|
Return name of file on top of stack */
|
|
|
|
{
|
|
|
|
return( next_file_slot==0 ? NIL(char) : ftab[next_file_slot-1].name );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PUBLIC int
|
|
|
|
Nestlevel()/*
|
|
|
|
=============
|
|
|
|
Return the file nesting level */
|
|
|
|
{
|
|
|
|
return( next_file_slot );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PUBLIC FILE *
|
2006-04-20 05:59:05 -05:00
|
|
|
TryFiles(lp)/*
|
|
|
|
==============
|
|
|
|
Try to open a makefile, try to make it if needed and return a
|
|
|
|
filepointer to the first successful found or generated file.
|
|
|
|
The function returns NIL(FILE) if nothing was found. */
|
2000-09-22 09:33:37 -05:00
|
|
|
LINKPTR lp;
|
|
|
|
{
|
|
|
|
FILE *mkfil = NIL(FILE);
|
|
|
|
|
|
|
|
if( lp != NIL(LINK) ) {
|
|
|
|
int s_n, s_t, s_q;
|
|
|
|
|
|
|
|
s_n = Trace;
|
|
|
|
s_t = Touch;
|
|
|
|
s_q = Check;
|
|
|
|
|
|
|
|
Trace = Touch = Check = FALSE;
|
2007-10-15 09:38:21 -05:00
|
|
|
/* We are making a makefile. Wait for it. */
|
2000-09-22 09:33:37 -05:00
|
|
|
Makemkf = Wait_for_completion = TRUE;
|
|
|
|
mkfil = NIL(FILE);
|
|
|
|
|
|
|
|
for(; lp != NIL(LINK) && mkfil == NIL(FILE); lp=lp->cl_next) {
|
|
|
|
if( lp->cl_prq->ce_attr & A_FRINGE ) continue;
|
|
|
|
|
|
|
|
mkfil = Openfile( lp->cl_prq->CE_NAME, FALSE, FALSE );
|
|
|
|
|
2006-04-20 05:59:05 -05:00
|
|
|
/* Note that no error handling for failed Make() calls is possible
|
|
|
|
* as expected errors (no rule to make the makefile) or unexpected
|
|
|
|
* errors both return -1. */
|
|
|
|
if( mkfil == NIL(FILE) && Make(lp->cl_prq, NIL(CELL)) != -1 ) {
|
2000-09-22 09:33:37 -05:00
|
|
|
mkfil = Openfile( lp->cl_prq->CE_NAME, FALSE, FALSE );
|
2007-10-15 09:38:21 -05:00
|
|
|
/* Remove flags that indicate that the target was already made.
|
|
|
|
* This is also needed to avoid conflicts with the circular
|
|
|
|
* dependency check in rulparse(), see issues 62118 and 81296
|
|
|
|
* for details. */
|
|
|
|
Unmake(lp->cl_prq);
|
2006-04-20 05:59:05 -05:00
|
|
|
}
|
2000-09-22 09:33:37 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
Trace = s_n;
|
|
|
|
Touch = s_t;
|
|
|
|
Check = s_q;
|
|
|
|
Makemkf = Wait_for_completion = FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return(mkfil);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
** print error message from variable arg list
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int errflg = TRUE;
|
|
|
|
static int warnflg = FALSE;
|
|
|
|
|
|
|
|
static void
|
|
|
|
errargs(fmt, args)
|
|
|
|
char *fmt;
|
|
|
|
va_list args;
|
|
|
|
{
|
|
|
|
int warn = _warn && warnflg && !(Glob_attr & A_SILENT);
|
|
|
|
|
|
|
|
if( errflg || warn ) {
|
|
|
|
char *f = Filename();
|
|
|
|
|
|
|
|
fprintf( stderr, "%s: ", Pname );
|
|
|
|
if( f != NIL(char) ) fprintf(stderr, "%s: line %d: ", f, Line_number);
|
|
|
|
|
|
|
|
if( errflg )
|
2006-04-20 05:59:05 -05:00
|
|
|
fprintf(stderr, "Error: -- ");
|
2000-09-22 09:33:37 -05:00
|
|
|
else if( warn )
|
2006-04-20 05:59:05 -05:00
|
|
|
fprintf(stderr, "Warning: -- ");
|
2000-09-22 09:33:37 -05:00
|
|
|
|
|
|
|
vfprintf( stderr, fmt, args );
|
|
|
|
putc( '\n', stderr );
|
2006-04-20 05:59:05 -05:00
|
|
|
if( errflg && !Continue ) Quit(0);
|
2000-09-22 09:33:37 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Print error message and abort
|
|
|
|
*/
|
|
|
|
PUBLIC void
|
|
|
|
#ifndef __MWERKS__
|
|
|
|
Fatal(ARG(char *,fmt), ARG(va_alist_type,va_alist))
|
|
|
|
#else
|
|
|
|
Fatal(char * fmt, ...)
|
|
|
|
#endif
|
|
|
|
DARG(char *,fmt)
|
|
|
|
DARG(va_alist_type,va_alist)
|
|
|
|
{
|
|
|
|
va_list args;
|
|
|
|
|
|
|
|
va_start(args, fmt);
|
|
|
|
Continue = FALSE;
|
|
|
|
errargs(fmt, args);
|
|
|
|
va_end(args);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** error message and exit (unless -k)
|
|
|
|
*/
|
|
|
|
PUBLIC void
|
|
|
|
#ifndef __MWERKS__
|
|
|
|
Error(ARG(char *,fmt), ARG(va_alist_type,va_alist))
|
|
|
|
#else
|
|
|
|
Error(char * fmt, ...)
|
|
|
|
#endif
|
|
|
|
DARG(char *,fmt)
|
|
|
|
DARG(va_alist_type,va_alist)
|
|
|
|
{
|
|
|
|
va_list args;
|
|
|
|
|
|
|
|
va_start(args, fmt);
|
|
|
|
errargs(fmt, args);
|
|
|
|
va_end(args);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
** non-fatal message
|
|
|
|
*/
|
|
|
|
PUBLIC void
|
|
|
|
#ifndef __MWERKS__
|
|
|
|
Warning(ARG(char *,fmt), ARG(va_alist_type,va_alist))
|
|
|
|
#else
|
|
|
|
Warning(char * fmt , ...)
|
|
|
|
#endif
|
|
|
|
DARG(char *,fmt)
|
|
|
|
DARG(va_alist_type,va_alist)
|
|
|
|
{
|
|
|
|
va_list args;
|
|
|
|
|
|
|
|
va_start(args, fmt);
|
|
|
|
warnflg = TRUE;
|
|
|
|
errflg = FALSE;
|
|
|
|
errargs(fmt, args);
|
|
|
|
errflg = TRUE;
|
|
|
|
warnflg = FALSE;
|
|
|
|
va_end(args);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PUBLIC void
|
|
|
|
No_ram()
|
|
|
|
{
|
|
|
|
Fatal( "No more memory" );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PUBLIC void
|
|
|
|
Usage( eflag )
|
|
|
|
int eflag;
|
|
|
|
{
|
|
|
|
register char *p;
|
|
|
|
char *fill;
|
|
|
|
|
|
|
|
fill = DmStrDup(Pname);
|
|
|
|
for(p=fill; *p; p++) *p=' ';
|
|
|
|
|
|
|
|
if( eflag ) {
|
|
|
|
fprintf(stderr, USAGE, Pname);
|
|
|
|
fprintf(stderr, USAGE2, fill);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
printf(USAGE, Pname);
|
|
|
|
printf(USAGE2, fill);
|
|
|
|
puts(" -P# - set max number of child processes for parallel make");
|
|
|
|
puts(" -f file - use file as the makefile");
|
|
|
|
#ifdef MSDOS
|
|
|
|
puts(" -C [+]file - duplicate console output to file, ('+' => append)");
|
|
|
|
#endif
|
|
|
|
puts(" -K file - use file as the .KEEP_STATE file");
|
|
|
|
puts(" -w target - show what you would do if 'target' were out of date");
|
|
|
|
puts(" -W target - rebuild pretending that 'target' is out of date");
|
2006-04-20 05:59:05 -05:00
|
|
|
puts(" -v[cdfimrtw] - verbose, indicate what we are doing, (-v => -vcdfimrtw)");
|
2000-09-22 09:33:37 -05:00
|
|
|
puts(" c => dump directory cache info only" );
|
|
|
|
puts(" d => dump change of directory info only" );
|
|
|
|
puts(" f => dump file open/close info only" );
|
|
|
|
puts(" i => dump inference information only" );
|
|
|
|
puts(" m => dump make of target information only" );
|
2004-09-08 10:05:19 -05:00
|
|
|
puts(" r => Force output of recipe lines and warnings," );
|
|
|
|
puts(" overrides -s" );
|
2000-09-22 09:33:37 -05:00
|
|
|
puts(" t => keep temporary files when done" );
|
|
|
|
puts(" w => issue non-essential warnings\n" );
|
|
|
|
|
2006-04-20 05:59:05 -05:00
|
|
|
puts(" -m[trae] - Measure timing information, (-m => -mt)");
|
|
|
|
puts(" t => display the start and end time of each target" );
|
|
|
|
puts(" r => display the start and end time of each recipe" );
|
|
|
|
puts(" a => display the target as an absolute path" );
|
|
|
|
puts(" e => display the timing of shell escape macros\n" );
|
|
|
|
|
2000-09-22 09:33:37 -05:00
|
|
|
puts("Options: (can be catenated, ie -irn == -i -r -n)");
|
|
|
|
puts(" -A - enable AUGMAKE special target mapping");
|
|
|
|
puts(" -B - enable the use of spaces instead of tabs to start recipes");
|
|
|
|
puts(" -c - use non standard comment scanning");
|
|
|
|
puts(" -d - do not use directory cache");
|
|
|
|
puts(" -E - define environment strings as macros");
|
|
|
|
puts(" -e - same as -E but done after parsing makefile");
|
|
|
|
puts(" -g - disable the special meaning of [ ... ] for group recipes");
|
|
|
|
puts(" -h - print out usage info");
|
|
|
|
puts(" -i - ignore errors");
|
|
|
|
puts(" -k - make independent targets, even if errors");
|
|
|
|
puts(" -n - trace and print, do not execute commands");
|
|
|
|
puts(" -p - print out a version of the makefile");
|
|
|
|
puts(" -q - check if target is up to date. Does not do");
|
|
|
|
puts(" anything. Returns 0 if up to date, 1 otherwise");
|
|
|
|
puts(" -r - don't use internal rules");
|
|
|
|
puts(" -s - do your work silently");
|
|
|
|
puts(" -S - disable parallel (force sequential) make, overrides -P");
|
|
|
|
puts(" -t - touch, update time stamps without executing commands");
|
|
|
|
puts(" -T - do not apply transitive closure on inference rules");
|
|
|
|
puts(" -u - force unconditional update of target");
|
|
|
|
puts(" -V - print out version number");
|
|
|
|
puts(" -x - export macro values to environment");
|
|
|
|
puts(" -X - ignore #! lines at start of makefile");
|
|
|
|
}
|
|
|
|
|
2006-04-20 05:59:05 -05:00
|
|
|
Quit(0);
|
2000-09-22 09:33:37 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
PUBLIC void
|
|
|
|
Version()
|
|
|
|
{
|
|
|
|
extern char **Rule_tab;
|
|
|
|
char **p;
|
|
|
|
|
2006-04-20 05:59:05 -05:00
|
|
|
printf("%s - Version %s (%s)\n", Pname, VERSION, BUILDINFO);
|
|
|
|
printf("%s\n\n", sccid);
|
2000-09-22 09:33:37 -05:00
|
|
|
|
|
|
|
puts("Default Configuration:");
|
|
|
|
for (p=Rule_tab; *p != NIL(char); p++)
|
|
|
|
printf("\t%s\n", *p);
|
|
|
|
|
|
|
|
printf("\n");
|
2007-01-18 02:29:05 -06:00
|
|
|
|
|
|
|
#if defined(HAVE_SPAWN_H) || defined(__CYGWIN__)
|
|
|
|
/* Only systems that have spawn ar concerned whether spawn or fork/exec
|
|
|
|
* are used. */
|
|
|
|
#if ENABLE_SPAWN
|
|
|
|
printf("Subprocesses are executed using: spawn.\n\n");
|
|
|
|
#else
|
|
|
|
printf("Subprocesses are executed using: fork/exec.\n\n");
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
printf("Please read the NEWS file for the latest release notes.\n");
|
2000-09-22 09:33:37 -05:00
|
|
|
}
|