/*** NMAKE.C - main module *****************************************************
*
* Copyright (c) 1988-1990, Microsoft Corporation. All rights reserved.
*
* Purpose:
* This is the main module of nmake
*
* Revision History:
* 01-Feb-1994 HV Move messages to external file.
* 15-Nov-1993 JdR Major speed improvements
* 15-Oct-1993 HV Use tchar.h instead of mbstring.h directly, change STR*() to _ftcs*()
* 10-May-1993 HV Add include file mbstring.h
* Change the str* functions to STR*
* 26-Mar-1992 HV Rewrite filename() to use _splitpath()
* 06-Oct-1992 GBS Removed extern for _pgmptr
* 08-Jun-1992 SS add IDE feedback support
* 08-Jun-1992 SS Port to DOSX32
* 29-May-1990 SB Fix precedence of predefined inference rules ...
* 25-May-1990 SB Various fixes: 1> New inference rules for fortran and pascal;
* 2> Resolving ties in timestamps in favour of building;
* 3> error U1058 does not echo the filename anymore (ctrl-c
* caused filename and lineno to be dispalyed and this was
* trouble for PWB
* 01-May-1990 SB Add predefined rules and inference rules for FORTRAN
* 23-Apr-1990 SB Add predefined rules and inference rules for COBOL
* 20-Apr-1990 SB Don't show lineno for CTRL+C handler error
* 17-Apr-1990 SB Pass copy of makeflags to putenv() else freeing screws the
* DGROUP.
* 23-Feb-1990 SB chdir(MAKEDIR) to avoid returning to bad directory in DOS
* 02-Feb-1990 SB change fopen() to FILEOPEN()
* 31-Jan-1990 SB Postpone defineMAcro("MAKE") to doMAke(); Put freshly
* allocated strings in the macro table as freeStructures()
* free's the macroTable[]
* 24-Jan-1990 SB Add byte to call for sprintf() for "@del ..." case for /z
* 29-Dec-1989 SB ignore /Z when /T also specified
* 29-Dec-1989 SB nmake -? was giving error with TMP directory nonexistent
* 19-Dec-1989 SB nmake /z requests
* 14-Dec-1989 SB Trunc MAKEFLAGS averts GPF;Silently ignore /z in protect mode
* 12-Dec-1989 SB =c, =d for NMAKE /Z
* 08-Dec-1989 SB /NZ causes /N to override /Z; add #define TEST_RUNTIME stuff
* 01-Dec-1989 SB Contains an hack #ifdef'ed for Overlayed version
* 22-Nov-1989 SB Changed free() to FREE()
* 17-Nov-1989 SB defined INCL_NOPM; generate del commands to del temps
* 19-Oct-1989 SB ifdef SLASHK'ed stuff for -k
* 04-Sep-1989 SB echoing and redirection problem for -z fixed
* 17-Aug-1989 SB added #ifdef DEBUG's and error -nz incompatible
* 31-Jul-1989 SB Added check of return value -1 (error in spawning) for -help
* remove -z option help message
* 12-Jul-1989 SB readEnvironmentVars() was not using environ variable but an
* old pointer (envPtr) to it. In the meantime environ was
* getting updated. Safer to use environ directly.
* 29-Jun-1989 SB freeStructures() now deletes inlineFileList also
* 28-Jun-1989 SB changed deletion of inline files to end of mainmain() instead of
* doMake() to avoid deletion when a child make quits.
* 19-Jun-1989 SB modified .bas.obj to have ';' at end of cmd line
* 21-May-1989 SB freeRules() gets another parameter to avoid bogus messages
* 18-May-1989 SB change delScriptFiles() to do unlink instead of calling
* execLine. Thus, ^C handling is better now. No more hangs
* 15-May-1989 SB Added /make support; inherit /nologo
* 13-May-1989 SB Changed delScriptFiles(); added MAKEDIR; Added BASIC rules
* Changed chkPrecious()
* 01-May-1989 SB Changed FILEINFO to void *; OS/2 Version 1.2 support
* 17-Apr-1989 SB on -help spawn 'qh /u nmake' instead. rc = 3 signals error
* 14-Apr-1989 SB no 'del inlinefile' cmd for -n. -z now gives 'goto NmakeExit'
* CC and AS allocated of the heap and not from Data Segment
* 05-Apr-1989 SB made all funcs NEAR; Reqd to make all function calls NEAR
* 27-Mar-1989 SB Changed unlinkTmpFiles() to delScriptFiles()
* 10-Mar-1989 SB Removed blank link from PWB.SHL output
* 09-Mar-1989 SB changed param in call to findRule. fBuf is allocated on the
* heap in useDefaultMakefile()
* 24-Feb-1989 SB Inherit MAKEFLAGS to Env for XMake Compatibility
* 22-Feb-1989 SB Ignore '-' or '/' in parseCommandLine()
* 16-Feb-1989 SB add delScriptFiles() to delete temp script files at the
* end of the make. Also called on ^c and ^break
* 15-Feb-1989 SB Rewrote useDefaultMakefile(); MAKEFLAGS can contain all flags
* now
* 13-Feb-1989 SB Rewrote filename() for OS/2 1.2 support, now returns BOOL.
* 3-Feb-1989 SB Renamed freeUnusedRules() to freeRules(); moved prototype to
* proto.h
* 9-Jan-1989 SB Improved /help;added -?
* 3-Jan-1989 SB Changes for /help and /nologo
* 5-Dec-1988 SB Made chkPrecious() CDECL as signal() expects it
* main has CDECL too; cleaned prototypes (added void)
* 30-Nov-1988 SB Added for 'z' option in setFlags() and chkPrecious()
* 10-Nov-1988 SB Removed '#ifndef IBM' as IBM ver has a separate tree
* 21-Oct-1988 SB Added fInheritUserEnv to inherit macro definitions
* 22-Sep-1988 RB Changed a lingering reference of /B to /A.
* 15-Sep-1988 RB Move some def's out to GLOBALS.
* 17-Aug-1988 RB Clean up.
* 15-Aug-1988 RB /B ==> /A for XMAKE compatibility.
* 11-Jul-1988 rj Removed OSMODE definition.
* Removed NMAKE & NMAKEFLAGS (sob!).
* 8-Jul-1988 rj Added OSMODE definition.
* 7-Jul-1988 rj #ifndef IBM'ed NMAKE & NMAKEFLAGS
* 6-Jul-1988 rj Ditched shell, argVector, moved getComSpec to build.c.
* 5-Jul-1988 rj Fixed (*pfSPAWN) declarations.
* 28-Jun-1988 rj Added NMAKEFLAGS predefined macro.
* 24-Jun-1988 rj Added NMAKE predefined macro.
* Added doError flag to unlinkTmpFiles call.
* 23-Jun-1988 rj Fixed okToDelete to delete less often.
* 22-Jun-1988 rj Make chkPrecious use error messages
* 25-May-1988 rb Make InitLeadByte() smarter.
* 20-May-1988 rb Change built-in macro names.
* 18-May-1988 rb Remove comment about built-in rules and macros.
* 17-May-1988 rb Load built-in rules in right place.
* 16-May-1988 rb Conditionalize recursive make feature.
* 8-May-1988 rb Better initialization of system shell.
*
*******************************************************************************/
#include "nmake.h"
#include "nmmsg.h"
#include "proto.h"
#include "globals.h"
#include "grammar.h"
#define INCL_NOPM
#define INCL_DOSSIGNALS
#if !defined(DOS) && !defined(FLAT)
#include <os2.h>
#endif
#define MAX(A,B) (A) > (B) ? (A) : (B)
/* ----------------------------------------------------------------------------
* prototypes for main and all functions static to this module
*/
void __cdecl main(unsigned, char**, char**);
LOCAL void NEAR readEnvironmentVars(void);
LOCAL void NEAR readMakeFiles(void);
LOCAL void NEAR useDefaultMakefile(void);
LOCAL BOOL NEAR filename(const char*, char**);
LOCAL void NEAR freeStructures(void);
LOCAL void NEAR loadBuiltInRules(void);
//void pascal chkPrecious(USHORT, USHORT);
LOCAL void __cdecl chkPrecious(int sig);
LOCAL void NEAR InitializeEnv(void);
LOCAL UCHAR NEAR isPrecious(char*);
void NEAR removeTrailChars(char *);
extern void CDECL NEAR makeIdeMessage (unsigned, unsigned,...);
void CDECL NEAR usage (void);
/* ----------------------------------------------------------------------------
* global variables that live in this module but that are also used in
* other modules:
*/
#ifdef DEBUG
char *dummy="dummy";
#endif
char * makeStr = NULL; /* this make invocation name */
#ifdef DOS
char * startupDir;
#endif
char NEAR fileStr[MAXNAME];
char * initSavPtr = NULL; /* save area for initialized vars */
unsigned saveBytes = 0;
char ** envPtr = NULL;
UCHAR okToDelete = FALSE; /* do not del unless exec'ing cmd */
#if defined(FLAT)
UCHAR fRunningUnderTNT = FALSE;
extern UCHAR FIsTNT(void);
#endif
char * builtInTarg[] = {".SUFFIXES",
".c.obj",
".c.exe",
".cpp.obj",
".cpp.exe",
".cxx.obj",
".cxx.exe",
".asm.obj",
".asm.exe",
".bas.obj",
".cbl.obj",
".cbl.exe",
".for.obj",
".for.exe",
".pas.obj",
".pas.exe",
".rc.res",
NULL};
char * bltInCmd0[] = {".exe", ".obj", ".asm", ".c", ".cpp", ".cxx",
".bas", ".cbl", ".for", ".pas", ".res", ".rc",
NULL};
char * bltInCmd1[] = {"$(CC) $(CFLAGS) /c $*.c", NULL};
char * bltInCmd2[] = {"$(CC) $(CFLAGS) $*.c", NULL};
char * bltInCmd3[] = {"$(CPP) $(CPPFLAGS) /c $*.cpp", NULL};
char * bltInCmd4[] = {"$(CPP) $(CPPFLAGS) $*.cpp", NULL};
char * bltInCmd5[] = {"$(CXX) $(CXXFLAGS) /c $*.cxx", NULL};
char * bltInCmd6[] = {"$(CXX) $(CXXFLAGS) $*.cxx", NULL};
char * bltInCmd7[] = {"$(AS) $(AFLAGS) /c $*.asm", NULL};
char * bltInCmd8[] = {"$(AS) $(AFLAGS) $*.asm", NULL};
char * bltInCmd9[] = {"$(BC) $(BFLAGS) $*.bas;", NULL};
char * bltInCmd10[] = {"$(COBOL) $(COBFLAGS) $*.cbl;", NULL};
char * bltInCmd11[] = {"$(COBOL) $(COBFLAGS) $*.cbl, $*.exe;", NULL};
char * bltInCmd12[] = {"$(FOR) /c $(FFLAGS) $*.for", NULL};
char * bltInCmd13[] = {"$(FOR) $(FFLAGS) $*.for", NULL};
char * bltInCmd14[] = {"$(PASCAL) /c $(PFLAGS) $*.pas", NULL};
char * bltInCmd15[] = {"$(PASCAL) $(PFLAGS) $*.pas", NULL};
char * bltInCmd16[] = {"$(RC) $(RFLAGS) /r $*", NULL};
char ** builtInCom[] = {bltInCmd0, bltInCmd1, bltInCmd2, bltInCmd3,
bltInCmd4, bltInCmd5, bltInCmd6, bltInCmd7,
bltInCmd8, bltInCmd9, bltInCmd10, bltInCmd11,
bltInCmd12, bltInCmd13, bltInCmd14, bltInCmd15,
bltInCmd16, NULL};
/* ----------------------------------------------------------------------------
* Local to this module
*/
#ifndef NO_OPTION_Z
LOCAL char nmakeExitLabelCmd[] = ":NMAKEEXIT";
#endif
/* --------------------------------------------------------------------
* main
*
* actions: saves the initial global variables in a
* block. calls doMake() and then delTempScriptFiles()
*/
void __cdecl
main(
unsigned argc,
char *argv[],
char *envp[]) /* environment variables */
{
extern unsigned saveBytes;
extern char **envPtr;
int status; /* returned by doMake */
extern char *makeStr;
#ifdef OS2_SIGNALS
PUSHORT prev;
unsigned long _FAR *pfnsig;
#endif
InitializeEnv();
#if defined(FLAT)
fRunningUnderTNT = FIsTNT();
#endif
initCharmap();
initMacroTable(macroTable);
#ifdef DEBUG_MEMORY
//This puts 0xff in all free entries in the heap
_heapset(0xff);
#endif
envPtr = envp;
#ifdef DEBUG_COMMANDLINE
{
int iArg = argc;
char **chchArg = argv;
for (; iArg--; chchArg++)
printf("'%s' ", *chchArg);
printf("\n");
}
#endif
#ifdef TEST_RUNTIME
//Tests RunTime error R6001
{char near *foo = NULL; *foo = '1';}
#endif
#ifdef DOS
startupDir = getCurDir();
#endif
#ifdef FLAT
resultbuf_size = sizeof(struct _finddata_t);
#ifdef NT
ext_size = CCHMAXPATHCOMP;
filename_size = CCHMAXPATHCOMP;
filenameext_size = CCHMAXPATH;
#endif
#else
/* If OS/2 1.2 and beyond then allowed max sizes vary
*/
if (_osmajor < 10 || _osmode == DOS_MODE)
resultbuf_size = sizeof(struct find_t);
else if (_osminor < 20)
resultbuf_size = sizeof(struct FileFindBuf);
else {
ext_size = CCHMAXPATHCOMP;
filename_size = CCHMAXPATHCOMP;
filenameext_size = CCHMAXPATH;
resultbuf_size = sizeof(struct _FILEFINDBUF);
}
#endif
if (!makeStr) /* extract file name */
if (!filename(_ftcscpy(fileStr, _pgmptr), &makeStr))
makeStr = "NMAKE";
// Initialize the message file
SetErrorFile("nmake.err", _pgmptr, 1); // 1=Search Exe Path
#if defined(SELF_RECURSE)
initSavPtr = (char *)allocate(saveBytes = (&endOfSave - &startOfSave));
memmove(initSavPtr, &startOfSave, saveBytes);
#endif
/* set up handler for .PRECIOUS the handler tries to remove the
* current target when control-C'd, unless it is "precious"
*/
#ifdef OS2_SIGNALS
This commented out part was trial for using OS/2 function calls
It still has some problems
DOSSETSIGHANDLER(chkPrecious, pfnsig, prev, SIGA_ACCEPT, SIG_CTRLC);
if (_osmode == OS2_MODE) {
DOSSETSIGHANDLER(chkPrecious, NULL, NULL, SIGA_ACCEPT, SIG_CTRLBREAK);
DOSSETSIGHANDLER(chkPrecious, NULL, NULL, SIGA_ACCEPT, SIG_KILLPROCESS);
}
#endif
signal(SIGINT, chkPrecious);
signal(SIGTERM, chkPrecious);
makeIdeMessage(0, 0);
status = doMake(argc, argv, NULL);
#ifndef NO_OPTION_Z
/* If -Z is specified then NMAKE needs to have errorLevel check in the
* batch file. So add the goto label for exit and print the Reverse batch
* file
*/
if (ON(gFlags, F1_REVERSE_BATCH_FILE)) {
STRINGLIST *revCmd;
//Adds ':NMAKEEXIT' to jump to end when error occurs
revCmd = makeNewStrListElement();
revCmd->text = nmakeExitLabelCmd;
prependItem(&revList, revCmd);
//'=c' means echo at current line
revCmd = makeNewStrListElement();
revCmd->text = makeString("=c");
appendItem(&revList, revCmd);
//'=d' turns echoing on (unless preceeded by @)
revCmd = makeNewStrListElement();
revCmd->text = makeString("=d");
appendItem(&revList, revCmd);
}
#endif
delScriptFiles();
#ifndef NO_OPTION_Z
if (ON(gFlags, F1_REVERSE_BATCH_FILE))
printReverseFile();
#endif
#ifdef MEMORY_DEBUG
mem_status();
#endif
#ifdef HEAP_DIAGNOSTICS
printHeapDiagnostics();
#endif
#ifdef NMK_DEBUG
fprintf(stderr, "Exiting...\n");
#endif
if (!fSlashKStatus)
//error when slashK specified
status = 1;
#if !defined(NDEBUG) && !defined(NT_BUILD)
printStats();
#endif
exit(status);
}
//
// On some systems, the environment strings may be allocated as one large block,
// making it expensive to manipulate them. In that case, we copy each environment
// strings to its own allocation and release the large block
//
LOCAL void NEAR
InitializeEnv(
void
) {
#if !defined(FLAT)
char **ppch = copyEnviron(environ);
free(*environ);
free(environ);
environ = ppch;
#endif
}
extern void NEAR endNameList(void);
extern void NEAR addItemToList(void);
extern void NEAR assignDependents(void);
extern void NEAR assignBuildCommands(void);
/* loadBuiltInRules() -- Loads built in Rules to the NMAKE Tables
*
* Modifies:
* fInheritUserEnv -- is set to TRUE to inherit CC, AS
*
* Notes:
* Does this by calls to defineMacro(), which calls putMacro(). Since,
* fInheritUserEnv is set to TRUE, putMacro() will add to the Environment.
*/
LOCAL void NEAR
loadBuiltInRules(void)
{
char *tempTarg;
char **tempCom;
unsigned index;
char *macroName, *macroValue;
extern char *makestr;
/* We dynamically allocate CC and AS because they need to be freed in a
* recursive MAKE
*/
macroName = makeString("CC");
macroValue = makeString("cl");
defineMacro(macroName, macroValue, 0);
macroName = makeString("CXX");
macroValue = makeString("cl");
defineMacro(macroName, macroValue, 0);
macroName = makeString("CPP");
macroValue = makeString("cl");
defineMacro(macroName, macroValue, 0);
macroName = makeString("AS");
macroValue = makeString("ml");
defineMacro(macroName, macroValue, 0);
macroName = makeString("BC");
macroValue = makeString("bc");
defineMacro(macroName, macroValue, 0);
macroName = makeString("COBOL");
macroValue = makeString("cobol");
defineMacro(macroName, macroValue, 0);
macroName = makeString("FOR");
macroValue = makeString("fl");
defineMacro(macroName, macroValue, 0);
macroName = makeString("PASCAL");
macroValue = makeString("pl");
defineMacro(macroName, macroValue, 0);
macroName = makeString("RC");
macroValue = makeString("rc");
defineMacro(macroName, macroValue, 0);
macroName = makeString("MAKE");
macroValue = makeString(makeStr);
/* From environment so it won't get exported ; user can reset MAKE
*/
defineMacro(macroName, macroValue, M_ENVIRONMENT_DEF|M_WARN_IF_RESET);
for (index = 0; tempTarg = builtInTarg[index]; index++) {
name = makeString(tempTarg);
_ftcscpy(buf, ":");
endNameList();
for (tempCom=builtInCom[index];*tempCom;tempCom++) {
_ftcscpy(buf, *tempCom);
addItemToList();
}
if (index == 0)
assignDependents();
assignBuildCommands();
}
}
/* ----------------------------------------------------------------------------
* doMake()
*
* actions: prints a version message
* reads the environment variable MAKEFLAGS
* if MAKEFLAGS defined
* defines MAKEFLAGS to have that value w/in nmake
* sets a flag for each option if MAKEFLAGS defined
* else defines the macro MAKEFLAGS to be NULL
* parses commandline (adding option letters to MAKEFLAGS)
* reads all environment variables
* reads tools.ini
* reads makefile(s) (if -e flag set, new definitions in
* makefile won't override environment variable defs)
* prints information if -p flag
* processes makefile(s)
* prints information if -d flag and not -p flag (using both
* is overkill)
*
* In effect, the order for making assignments is (1 = least binding,
* 4 = most binding):
*
* 1) TOOLS.INI
* 2) environment (if -e flag, makefile)
* 3) makefile (if -e flag, environment)
* 4) command line
*
* The user can put anything he wants in the MAKEFLAGS environment variable.
* I don't check it for illegal flag values, because there are many xmake
* flags that we don't support. He shouldn't have to change his MAKEFLAGS
* to use nmake. Xmake always puts 'b' in MAKEFLAGS for "backward com-
* patibility" (or "botch") for the original Murray Hill version of make.
* It doesn't make sense to use -f in MAKEFLAGS, thus it is disallowed.
* It also makes little sense to let the default flags be -r, -p, or -d,
* so they aren't allowed in MAKEFLAGS, either.
*
* Even though DOS only uses uppercase in environment variables, this
* program may be ported to xenix in the future, thus we allow for the
* possibility that MAKEFLAGS and commandline options will be in upper
* and/or lower case.
*
* modifies: init global flag set if tools.ini is being parsed...
*/
int NEAR
doMake(argc, argv, parentBlkPtr)
unsigned argc;
char *argv[];
char *parentBlkPtr; /* state of parent, restored prior to return */
{
int status = 0;
char *p;
extern char *makeStr; /* the initial make invok name */
extern unsigned saveBytes;
char *makeDir, *curDir;
#ifdef DEBUG_ALL
printf ("DEBUG: In doMake\n");
#endif
#if !defined(SELF_RECURSE)
assert(parentBlkPtr == NULL);
#endif
/*
* Load built-ins here rather than in main(). Otherwise in a recursive
* make, doMake() will initialize rules to some value which has been
* freed by sortRules(). [RB]
* UNDONE: why is sortRules() not setting rules to NULL? [RB]
*/
#ifdef DEBUG
heapdump(__FILE__, __LINE__);
#endif
inlineFileList = (STRINGLIST *)NULL;
makeDir = makeString("MAKEDIR");
curDir = getCurDir();
defineMacro(makeDir, curDir, 0);
//TEMPFIX: We are truncating MAKEFLAGS environment variable to its limit
//to avoid GP Faults
if (p = getenv("MAKEFLAGS")) /* but not MAKEFLAGS */
_ftcsncpy(makeflags+10, p, _ftcslen(makeflags + 10));
/*
* fInheritUserEnv is set to TRUE so that the changes made get inherited
*/
fInheritUserEnv = (BOOL)TRUE;
//
// 07-05-92 BryanT Simply adding global strings to the macro array
// causes problems later when you go to free them
// from a recursive $(MAKE). Both the macro name
// and the macro's value must be created with
// makeString.
defineMacro(makeString("MAKEFLAGS"), makeString(makeflags+10), M_NON_RESETTABLE|M_ENVIRONMENT_DEF);
for (;p && *p; p++) /* set flags in MAKEFLAGS */
setFlags(*p, TRUE); /* TRUE says turn bits ON */
#ifdef DEBUG_ALL
heapdump(__FILE__, __LINE__);
#endif
parseCommandLine(--argc, ++argv); /* skip over program name */
#ifdef DEBUG_ALL
printf ("DEBUG: Command Line parsed\n");
#endif
#ifndef NO_OPTION_Z
if (ON(gFlags, F1_REVERSE_BATCH_FILE) &&
(ON(flags, F2_NO_EXECUTE) || ON(gFlags, F1_TOUCH_TARGETS)))
// We ignore /Z option when /N or /T is also specified
setFlags('Z', FALSE);
#endif
#ifdef DEAD_CODE
makeError(0, CMDLINE_N_Z_INCOMPATIBLE, makeStr);
#endif
if (!bannerDisplayed) displayBanner(); /* version number, etc. */
if (OFF(gFlags, F1_IGNORE_EXTERN_RULES)) { /* read tools.ini */
#ifdef DEBUG_ALL
printf ("DEBUG: Read Tools.ini\n");
#endif
loadBuiltInRules();
#ifdef DEBUG_ALL
printf ("DEBUG: loadBuiltInRules\n");
#endif
fName = "tools.ini";
#ifdef DEBUG_ALL
heapdump(__FILE__, __LINE__);
#endif
if (tagOpen("INIT", fName, makeStr)) {
++line;
init = TRUE; /* tools.ini being parsed */
#ifdef DEBUG_ALL
heapdump(__FILE__, __LINE__);
#endif
#ifdef DEBUG_ALL
printf ("DEBUG: Start Parse\n");
#endif
parse();
#ifdef DEBUG_ALL
printf ("DEBUG: Parsed\n");
#endif
if (fclose(file) == EOF)
makeError(0, ERROR_CLOSING_FILE, fName);
}
}
#ifdef DEBUG_ALL
heapdump(__FILE__, __LINE__);
#endif
#ifdef DEBUG_ALL
printf ("after tagopen\n");
#endif
// For XMake Compatibility MAKEFLAGS should always be inherited to the Env
// Put copy of makeflags so that the environment can be freed on return
// from a recursive make
if (PutEnv(makeString(makeflags)) == -1)
makeError(0, OUT_OF_ENV_SPACE);
#ifdef DEBUG_ALL
printf ("after putenv\n");
#endif
if (!makeFiles) useDefaultMakefile(); /* if no -f makefile given*/
#ifdef DEBUG_ALL
printf ("DEBUG: Used default\n");
#endif
readEnvironmentVars();
readMakeFiles(); /* read description files */
#ifdef DEBUG_ALL
printf ("DEBUG: Read makefile\n");
#endif
currentLine = 0; /* reset line after done */
sortRules(); /* reading files (for */
if (ON(gFlags, F1_PRINT_INFORMATION)) { /* error messages) */
showMacros();
showRules();
showTargets();
}
/* free buffer used for conditional processing - not required now */
if (lbufPtr)
FREE(lbufPtr);
#ifdef DEBUG_ALL
heapdump(__FILE__, __LINE__);
#endif
status = processTree();
#if defined(SELF_RECURSE)
/* restore state of the parent into the global area */
if (parentBlkPtr) {
/* free the space used up for this make invocation */
/* free the rule list, the macroTable, the targetTable */
freeStructures();
memmove(&startOfSave, parentBlkPtr, saveBytes);
FREE(parentBlkPtr);
}
#endif
#ifdef DEBUG_ALL
heapdump(__FILE__, __LINE__);
#endif
//We ignore retval from chdir because we cannot do anything if it fails
//This accomplishes a 'cd $(MAKEDIR)'.
_chdir(curDir);
return(status);
}
/*** filename -- filename part of a name ***************************************
*
* Scope:
* Local
*
* Purpose:
* A complete file name is of the form <drive:><path><filename><.ext>. This
* function returns the filename part of the name.
*
* Input:
* src -- The complete file name
* dst -- filename part of the complete file name
*
* Output:
* Returns TRUE if src has a filename part & FALSE otherwise
*
* Assumes:
* That the file name could have either '/' or '\' as path separator.
*
* Modifies Globals:
* None.
*
* Uses Globals:
* None.
*
* Notes:
* Allocates memory for filename part. Function was rewritten to support OS/2
* Ver 1.2 filenames.
*
* HV: One concern when I rewrite filename() to use _splitpath(): I declared
* szFilename with size _MAX_FNAME, which could blow up the stack if _MAX_FNAME
* is too large.
*
*******************************************************************************/
LOCAL BOOL NEAR
filename(const char *src, char **dst)
{
char szFilename[_MAX_FNAME]; // The filename part
// Split the full pathname to components
_splitpath(src, NULL, NULL, szFilename, NULL);
// Allocate & copy the filename part to the return string
*dst = makeString(szFilename);
// Finished
return (BOOL) _ftcslen(*dst);
}
/* ----------------------------------------------------------------------------
* readMakeFiles()
*
* actions: walks through the list calling parse on each makefile
* resets the line number before parsing each file
* removes name of parsed file from list
* frees removed element's storage space
*
* modifies: file global file pointer (FILE*)
* fName global pointer to file name (char*)
* line global line number used and updated by the
* lexer
* init global flag reset for parsing makefiles
* ( files other than tools.ini )
* makeFiles in main() by modifying contents of local
* pointer (list)
*
* We keep from fragmenting memory by not allocating and then freeing space
* for the (probably few) names in the files and targets lists. Instead
* we use the space already allocated for the argv[] vars, and use the space
* we alloc for the commandfile vars. The commandfile vars that could be
* freed here, but they aren't because we can't tell them from the argv[]
* vars. They will be freed at the end of the program.
*/
LOCAL void NEAR
readMakeFiles(void)
{
STRINGLIST *q;
for (q = makeFiles; q ; q = q->next) { /* for each name in list */
if ((q->text)[0] == '-' && !(q->text)[1]) {
fName = makeString("STDIN");
file = stdin;
}
else {
fName = makeString(q->text);
if (!(file = FILEOPEN(fName, "rt"))) /* open to read, text mode*/
makeError(0, CANT_OPEN_FILE, fName);
}
line = 0;
init = FALSE; /* not parsing tools.ini */
parse();
if (file != stdin && fclose(file) == EOF)
makeError(0, ERROR_CLOSING_FILE, fName);
}
//free the list of makefiles
freeStringList(makeFiles);
}
/*** readEnvironmentVars - Read in environment variables into Macro table ******
*
* Scope:
* Local.
*
* Purpose:
* Reads environment variables into the NMAKE macro Table. It walks through envp
* using environ making entries in NMAKE's hash table of macros for each string
* in the table.
*
* Input:
*
* Output:
*
* Errors/Warnings:
*
* Assumes:
* That the env contains strings of the form "VAR=value" i.e. '=' present.
*
* Modifies Globals:
* fInheritUserEnv - set to false.
*
* Uses Globals:
* environ - Null terminated table of pointers to environment variable
* definitions of the form "name=value" (Std C Runtime variable)
*
* Notes:
* If the user specifies "set name=value" as a build command for a target being
* built, the change in the environment will not be reflected in nmake's set of
* defined variables in the macro table.
*
* Undone/Incomplete:
* 1> Probably do not need envPtr global in NMAKE. (to be removed)
* 2> Probably don't need fInheritUserEnv (see PutMacro)
*
*******************************************************************************/
LOCAL void NEAR
readEnvironmentVars(void)
{
char *macro, *value;
char *t;
char **envPtr;
envPtr = environ;
for (;*envPtr; ++envPtr) {
if (t = _ftcschr(*envPtr, '=')) { /* should always be TRUE */
if (!_ftcsnicmp(*envPtr, "MAKEFLAGS", 8))
continue;
*t = '\0';
// Don't add empty names.
if (**envPtr == '\0')
continue;
// ALLOC: here we make copies of the macro name and value to define
macro = _ftcsupr(makeString(*envPtr));
value = makeString(t+1);
*t = '=';
fInheritUserEnv = (BOOL)FALSE;
if (!defineMacro(macro, value, M_ENVIRONMENT_DEF)) {
// ALLOC: here we free the copies if they were not added.
FREE(macro);
FREE(value);
}
}
}
}
/* ----------------------------------------------------------------------------
* parseCommandLine()
*
* arguments: argc count of arguments in argv vector
* argv table of pointers to commandline arguments
*
* actions: reads a command file if necessary
* sets switches
* defines macros
* makes a list of makefiles to read
* makes a list of targets to build
*
* modifies: makeFiles in main() by modifying contents of parameter
* pointer (list) to STRINGLIST pointer
* (makeFiles)
* makeTargets in main() by modifying contents of param
* pointer (targets) to STRINGLIST pointer
* fInheritUserEnv set to TRUE so that user defined changes in the
* environment variables get inherited by the Env
*
* nmake doesn't make new copies of command line macro values or environment
* variables, but instead uses pointers to the space already allocated.
* This can cause problems if the envp, the environment pointer, is accessed
* elsewhere in the program (because the vector's strings will contain '\0'
* where they used to contain '='). I don't foresee any need for envp[] to
* be used elsewhere. Even if we did need to use the environment, we could
* access the environ variable or use getenv().
*
* I don't care what the current DOS "switch" character is -- I always
* let the user give either.
*/
char *helpArguments[] = {"QH", "/u", "NMAKE.EXE", NULL };
void NEAR
parseCommandLine(argc, argv)
unsigned argc;
char *argv[];
{
extern char *makeStr;
STRINGLIST *p;
char *s;
char *t;
FILE *out;
BOOL fHelp = FALSE;
BOOL fQuestion = FALSE;
for (; argc; --argc, ++argv) {
if (**argv == '@') /* cmdfile*/
readCommandFile((char*)*argv+1);
else if (**argv == '-'|| **argv == '/') { /* switch */
s = *argv + 1;
if (!_ftcsicmp(s, "help")) {
fHelp = TRUE;
break;
}
// if '-' and '/' specified then ignores it
for (; *s; ++s) {
if (!_ftcsicmp(s, "nologo")) {
setFlags(s[2], TRUE);
break;
}
#ifdef HEAP
else if (!_ftcsicmp(s, "debug")) {
fHeapChk = TRUE;
break;
}
#endif
else if (*s == '?') {
fQuestion = TRUE;
break;
}
else if (*s == 'f' || *s == 'F') {
char *mkfl = s+1;
//if '/ffoo' then use 'foo'; else use next argument
if (!*mkfl && (!--argc || !*++argv || !*(mkfl = *argv)))
makeError(0, CMDLINE_F_NO_FILENAME);
p = makeNewStrListElement();
p->text = makeString(mkfl);
appendItem(&makeFiles, p);
break;
}
else if (*s == 'x' || *s == 'X') {
char *errfl = s+1;
//if '/xfoo' then use 'foo'; else use next argument
if (!*errfl && (!--argc || !*++argv || !*(errfl = *argv)))
makeError(0, CMDLINE_X_NO_FILENAME);
if (*errfl == '-' && !errfl[1])
_dup2(_fileno(stdout), _fileno(stderr));
else {
#if 0 /* C5 runtime bug */
if (freopen(errfl, "wt", stderr) == NULL)
makeError(0, CANT_OPEN_FILE, errfl);
#else
if ((out = fopen(errfl, "wt")) == NULL)
makeError(0, CANT_WRITE_FILE, errfl);
_dup2(_fileno(out), _fileno(stderr));
fclose(out);
#endif
}
break;
}
else
setFlags(*s, TRUE);
} // of for
}
else {
if (s = _ftcschr(*argv, '=')) { /* macro */
if (s == *argv)
//User has specified "=value"
makeError(0, CMDLINE_NO_MACRONAME);
*s = '\0';
for (t = s++ - 1; WHITESPACE(*t); --t)
;
*(t+1) = '\0';
fInheritUserEnv = (BOOL)TRUE;
defineMacro(makeString(*argv+_ftcsspn(*argv, " \t")),
makeString( s+_ftcsspn(s," \t")),
M_NON_RESETTABLE);
}
else {
removeTrailChars(*argv);
if (**argv) {
p = makeNewStrListElement(); /* target */
p->text = makeString(*argv); /* needs to be on heap [rm]*/
appendItem(&makeTargets, p);
}
}
*argv = NULL; /* so we won't try to free*/
} /* this space if process-*/
} /* ing command file stuff*/
if (fHelp) {
#ifdef QUICKHELP
int rc = _spawnvp(P_WAIT, "QH.EXE", helpArguments);
//Qh /u returns error code 3 if a cmd line topic is not found
//If the spawn fails spawnvp will return -1 and we need -help
//message, also
//Qh never returns -1
if (rc == 3 || rc == -1) {
usage();
}
#else
usage();
#endif
exit(0);
}
else if (fQuestion) {
usage();
exit(0);
}
}
/*** useDefaultMakefile -- tries to use the default makefile *******************
*
* Scope:
* Local
*
* Purpose:
* When no makefile has been specified by the user, set up the default makefile
* to be used.
*
* Input:
* Output:
* Errors/Warnings:
* CMDLINE_NO_MAKEFILE -- 'makefile' does not exist & no target specified
*
* Assumes:
* Modifies Globals:
* makeTargets -- if 'makefile' does not exist then the first target is removed
* from this list,
* makeFiles -- if 'makefile' does not exist then the first target is attached
* to this list.
*
* Uses Globals:
* makeTargets -- the list of targets to be made
*
* Notes:
* Given a commandline not containing a '-f makefile', this is how NMAKE
* behaves --
* If ['makefile' exists] then use it as the makefile,
* if [(the first target exists and has no extension) or
* (if it exists and has an extension for which no inference rule
* exists)]
* then use it as the makefile.
*
*******************************************************************************/
LOCAL void NEAR
useDefaultMakefile(void)
{
STRINGLIST *p;
char *s,
*ext;
char nameBuf[MAXNAME];
void *dBuf = _alloca(resultbuf_size);
//if 'makefile' exists then use it
if (!_access("makefile", READ)) {
p = makeNewStrListElement();
p->text = makeString("makefile");
makeFiles = p;
}
//check first target
else if (makeTargets) {
s = makeTargets->text;
if (_access(s, READ) || //1st target does not exist
((ext = _ftcsrchr(s, '.'))
&& findRule(nameBuf, s, ext, dBuf))) { //has no ext or inf rule
return;
}
p = makeTargets;
makeTargets = makeTargets->next; //one less target
makeFiles = p; //1st target is the makefile
}
//if -p and no makefile, simply give information ...
else if (OFF(gFlags, F1_PRINT_INFORMATION))
makeError(0, CMDLINE_NO_MAKEFILE); //no 'makefile' or target
}
/* ----------------------------------------------------------------------------
* setFlags()
*
* arguments: line current line number in makefile (or 0
* if still parsing commandline)
* c letter presumed to be a commandline option
* value TRUE if flag should be turned on, FALSE for off
*
* actions: checks to see if c is a valid option-letter
* if no, error, halt
* if value is TRUE, sets corresponding flag bit
* and adds flag letter to MAKEFLAGS macro def
* else if flag is resettable, clears corresponding bit
* and removes letter from MAKEFLAGS macro def
*
* modifies: flags external resettable-flags
* gFlags external non-resettable flags
* (MAKEFLAGS nmake internal macrodefs)
*
* Only the flags w/in the "flags" variable can be turned off. Once the
* bits in "gFlags" are set, they remain unchanged. The bits in "flags"
* are modified via the !CMDSWITCHES directive.
*/
void NEAR
setFlags(c, value)
char c;
BOOL value;
{
/*
* Use lexer's line count. If this gets called w/in
* mkfil, might be from directive, which never makes it
* to the parser, so parser's line count might be out
* of sync.
*/
char d = c;
UCHAR arg;
UCHAR *f;
char *s;
extern char *makeStr;
extern MACRODEF * NEAR pMacros;
extern STRINGLIST * NEAR pValues;
f = &flags;
switch(c = (char) _totupper(c)) {
case 'A': arg = F2_FORCE_BUILD; break;
case 'B': fRebuildOnTie = TRUE; return;
case 'C': arg = F1_CRYPTIC_OUTPUT;
f = &gFlags;
bannerDisplayed = TRUE;
break;
case 'D': arg = F2_DISPLAY_FILE_DATES; break;
case 'E': arg = F1_USE_ENVIRON_VARS; f = &gFlags; break;
case 'I': arg = F2_IGNORE_EXIT_CODES; break;
case 'K': fOptionK = TRUE; return;
case 'L': arg = F1_NO_LOGO;
f = &gFlags;
bannerDisplayed = TRUE;
break;
#if defined(DOS) && !defined(FLAT)
case 'M': fNoEmsXms = TRUE; return;
#endif
case 'N': arg = F2_NO_EXECUTE; break;
case 'O': fDescRebuildOrder = TRUE; return;
case 'P': arg = F1_PRINT_INFORMATION; f = &gFlags; break;
case 'Q': arg = F1_QUESTION_STATUS; f = &gFlags; break;
case 'R': arg = F1_IGNORE_EXTERN_RULES; f = &gFlags; break;
case 'S': arg = F2_NO_ECHO; break;
case 'T': arg = F1_TOUCH_TARGETS; f = &gFlags; break;
#if defined(SELF_RECURSE)
case 'V': fInheritMacros = TRUE; return;
#endif
#ifndef NO_OPTION_Z
case 'Z':
//Silently ignore /Z in protect mode
#if defined(DOS) && !defined(FLAT)
arg = F1_REVERSE_BATCH_FILE;
f = &gFlags;
bannerDisplayed = TRUE;
#endif
break;
#endif
case ' ': return; /* recursive make problem */
default: makeError(0, CMDLINE_BAD_OPTION, d);
}
if (!pMacros) {
pMacros = findMacro("MAKEFLAGS");
pValues = pMacros->values;
}
if (value) {
SET(*f, arg); /* set bit in flags variable */
if (c == 'Q') SET(*f, F1_CRYPTIC_OUTPUT);
if (!_ftcschr(pValues->text, c)) { /* don't want to dup any chars*/
if (s = _ftcschr(pValues->text, ' ')) /*append ch to MAKEFLAGS */
*s = c;
if (PutEnv(makeString(makeflags)) == -1) /*pValues->text pts into makeflags*/
makeError(line, OUT_OF_ENV_SPACE);
}
}
else if (f == &flags
#ifndef NO_OPTION_Z
|| ON(gFlags, F1_REVERSE_BATCH_FILE)
#endif
) {
/* make sure pointer is valid (we can't change gFlags, except if /Z */
CLEAR(*f, arg);
if (s = _ftcschr(pValues->text, c)) /* adjust MAKEFLAGS */
do {
*s = *(s+1); /* move remaining chars over */
} while (*(++s));
if (PutEnv(makeString(makeflags)) == -1)
makeError(line, OUT_OF_ENV_SPACE);
}
}
#if defined(SELF_RECURSE)
extern void NEAR freeList(STRINGLIST*);
extern void NEAR freeMacroTable(MACRODEF *table[]);
LOCAL void NEAR
freeStructures(void)
{
unsigned num;
MAKEOBJECT *tmpObjectT;
MAKEOBJECT *objectT;
BUILDLIST *buildL, *tmpBuildL;
freeMacroTable(macroTable);
freeRules(rules, FALSE); //don't warn about rules in .SUFFIXES
rules = NULL;
for (num=0;(num < MAXTARGET);num++) {
objectT = targetTable[num];
while (tmpObjectT = objectT) {
objectT = objectT->next;
buildL = tmpObjectT->buildList;
while (tmpBuildL = buildL) {
buildL = buildL->next;
block = tmpBuildL->buildBlock;
//
// 15-May-92 BryanT Macros are freed from the macroTable.
// Don't do it here... Commands and
// dependents are freed by endNameList.
// Not here
//
// freeList(block->dependents);
// freeList(block->buildCommands);
// freeList(block->dependentMacros);
// freeList(block->buildMacros);
FREE(block);
FREE(tmpBuildL);
}
FREE(tmpObjectT->name);
FREE(tmpObjectT);
}
}
freeList(inlineFileList); //The Global inline file list
freeList(dotSuffixList);
FREE(fName);
}
#endif
/*
* chkPrecious -- handle ^c or ^Break
*
* Actions: unlink all non-precious files and unrequired scriptFiles
* quit with error message (makeError unlinks temp. files)
*/
#ifdef OS2_SIGNALS
void pascal
#else
LOCAL void __cdecl
#endif
chkPrecious(
#ifdef OS2_SIGNALS
USHORT usSigArg,
USHORT usSigNum
#else
int sig
#endif
) {
extern UCHAR okToDelete;
#ifdef OS2_SIGNALS
USHORT fAction;
#endif
#ifdef DOS
//change directory to startup directory; ignore error code ... we
//cannot handle it
chdir(startupDir);
#endif
/* disable ctrl-C during handler */
#ifdef OS2_SIGNALS
DOSSETSIGHANDLER(NULL, NULL, &fAction, SIGA_IGNORE, SIG_CTRLC);
if (_osmode == OS2_MODE) {
DOSSETSIGHANDLER(NULL, NULL, &fAction, SIGA_IGNORE, SIG_CTRLBREAK);
DOSSETSIGHANDLER(NULL, NULL, &fAction, SIGA_IGNORE, SIG_KILLPROCESS);
}
#endif
signal(SIGINT, SIG_IGN);
signal(SIGTERM, SIG_IGN);
delScriptFiles();
#ifdef OS2_SIGNALS
DosExit(EXIT_PROCESS, 0L);
#endif
if (okToDelete
#ifndef NO_OPTION_Z
&& OFF(gFlags, F1_REVERSE_BATCH_FILE)
#endif
&& OFF(flags, F2_NO_EXECUTE)
&& OFF(gFlags, F1_TOUCH_TARGETS)
&& dollarAt
&& _access(dollarAt, 0x00) // existence check
&& !isPrecious(dollarAt))
if (_unlink(dollarAt) == 0)
makeError(line, REMOVED_TARGET, dollarAt);
makeError(0, USER_INTERRUPT);
}
LOCAL UCHAR NEAR
isPrecious(p)
char *p;
{
STRINGLIST *temp;
for (temp = dotPreciousList; temp; temp = temp->next)
if (!_ftcsicmp(temp->text, p))
return(1);
return(0);
}
/*** delScriptFiles -- deletes script files ************************************
*
* Scope:
* Global
*
* Purpose:
* Since script files may be reused in the makefile the script files which have
* NOKEEP action specified are deleted at the end of the make.
*
* Input:
*
* Output:
*
* Errors/Warnings:
*
* Assumes:
*
* Modifies Globals:
*
* Uses Globals:
* delList -- the list of script files to be deleted
*
* Notes:
* We ignore the exit code as a result of a delete because the system will
* inform the user that a delete failed.
*
*******************************************************************************/
void NEAR
delScriptFiles(void)
{
STRINGLIST *del;
#ifndef NO_OPTION_Z
STRINGLIST *revCmd;
#endif
_fcloseall();
#ifndef NO_OPTION_Z
if (ON(gFlags, F1_REVERSE_BATCH_FILE)) {
revCmd = makeNewStrListElement();
revCmd->text = makeString(":ABEND");
prependItem(&revList, revCmd);
}
#endif
for (del = delList; del;del = del->next) {
#ifndef NO_OPTION_Z
if (ON(gFlags, F1_REVERSE_BATCH_FILE)) {
revCmd = makeNewStrListElement();
revCmd->text = (char *)allocate(5 + _ftcslen(del->text) + 5 + 1);
sprintf(revCmd->text, "@del %s >nul", del->text);
//UNDONE: Is the next one more efficient than prev ? Investigate
//_ftcscat(_ftcscat(_ftcscpy(revCmd->text, "del "), del->text), " >nul");
prependItem(&revList, revCmd);
}
else
#endif
_unlink(del->text);
//UNDONE: Investigate whether next is really needed
if (ON(flags, F2_NO_EXECUTE)) {
printf("\tdel %s\n", del->text);
fflush(stdout);
}
}
}
/*** removeTrailChars - removes trailing blanks and dots ***********************
*
* Scope:
* Local.
*
* Purpose:
* OS/2 1.2 filenames dictate removal of trailing blanks and periods. This
* function removes them from filenames provided to it.
*
* Input:
* szFile - name of file
*
* Output:
*
* Errors/Warnings:
*
* Assumes:
*
* Modifies Globals:
*
* Uses Globals:
*
* Notes:
* This function handles Quoted filenames as well. It maintains the quotes if
* they were present. This is basically for OS/2 1.2 filename support.
*
*******************************************************************************/
void NEAR
removeTrailChars(szFile)
char *szFile;
{
char *t = szFile + _ftcslen(szFile) - 1;
BOOL fQuoted = FALSE;
if (*szFile == '"' && *t == '"') {
//Quoted so set flag
t--;
fQuoted = TRUE;
}
//Scan backwards for trailing characters
while (t > szFile && (*t == ' ' || *t == '.'))
t--;
//t points to last non-trailing character
//If it was quoted add quotes to the end
if (fQuoted)
*++t = '"';
t[1] = '\0';
}