|
|
// NMAKE.H -- main header file
//
// Copyright (c) 1988-1990, Microsoft Corporation. All rights reserved.
//
// Purpose:
// This file is the main header file for NMAKE and contains global typedef and
// macros. Global constants are also defined here. Global data is in global.h
//
// 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*()
// 23-Jun-1993 HV Kill the near keyword
// 01-Jun-1993 HV Change #ifdef KANJI to _MBCS
// 10-May-1993 HV Add _MBCS version of the string library.
// 10-Jul-1992 SB Port to NTMIPS
// 08-Jun-1992 SS Port to DOSX32
// 02-Feb-1990 SB add definition of FILEOPEN
// 04-Dec-1989 SB Changed definition of PFV to have prototype of function
// which it dereferences
// 01-Dec-1989 SB Contains an hack #ifdef'ed for Overlayed version
// also defined REALLOC
// 22-Nov-1989 SB #define FREE
// 13-Nov-1989 SB Definitions CCHMAXPATH(COMP) conform with bsedos.h
// 02-Oct-1989 SB added support for dynamic inline files
// 14-Sep-1989 SB added inLines field to block
// 04-Sep-1989 SB Added M_COMMAND_LINE but not used
// 24-Aug-1989 SB Add A_DEPENDENT for NMAKE to know that it is to look for a
// dependent
// 16-May-1989 SB NOLOGO flag /L set up for passing to recursive builds
// 24-Apr-1989 SB added CCHMAXPATH & CCHMAXPATHCOMP for OS/2 ver 1.2 support
// & removed FILEINFO typedef's (not needed anymore)
// 22-Feb-1989 SB changed value of MAXCMDLINELENGTH to 2k
// 03-Feb-1989 SB Added struct for FILEINFO for OS2 ver 1.2
// 02-Feb-1989 SB Redefined SPAWNV(P) and SYSTEM as NMAKE was really not
// supporting KANJI
// 31-Jan-1989 SB Changed MAXNAME to 257 for OS2 Ver 1.2 support
// 21-Dec-1988 SB Added SCRIPTLIST and makeNewScriptListElement() to allow
// multiple script fileseach with its KEEP/NOKEEP action
// 06-Dec-1988 SB Updated Comment about bits corr to flags set
// 05-Dec-1988 SB Added #define CDECL; NMAKE now uses Pascal Calling
// Add SIG_IGN to handle compiler problem
// 30-Nov-1988 SB Added suppport for 'z' option in setFlags()
// 23-Nov-1988 SB Defined MAXCMDLINELENGTH for extmake syntax
// 10-Nov-1988 SB Changed BOOL as 'unsigned short' as in 'os2.h'
// 17-Aug-1988 RB Clean up.
// 14-Jul-1988 rj Added dateTime to BUILDBLOCK def to support multiple
// targets with the same command block.
// 07-Jul-1988 rj Added targetFlag parameter to findMacro, findTarget
// 15-Jun-1988 rj Add definition of EScapeCHaracter.
// 25-May-1988 rb Clean up definition of LOCAL.
// Better char-type defs for ECS.
// Include from the LANGAPI (shared components) project
#include <assert.h>
#include <direct.h>
#include <dos.h>
#include <errno.h>
#include <io.h>
#include <limits.h>
#include <malloc.h>
#include <mbctype.h>
#include <process.h>
#include <share.h>
#include <signal.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <tchar.h>
#include "getmsg.h"
#define STRICT
#define NOMINMAX // windef.h
#define NOGDI // wingdi.h
#define NOIME // ime.h
#define NOUSER // winuser.h
#define NOHELP
#define NOPROFILER
#define NOSYSPARAMSINFO
#define NONLS // winnls.h
#define NOSERVICE // winsvc.h
#include <windows.h>
#define FILEOPEN open_file
#define FREE_STRINGLIST free_stringlist
#define ALLOC_STRINGLIST(type) (STRINGLIST *)alloc_stringlist()
#define FREE free
#define REALLOC realloc
typedef char CHAR;typedef unsigned char UCHAR;typedef unsigned short USHORT;typedef unsigned long ULONG;
#define NMHANDLE INT_PTR
typedef void (*PFV) (void); // pointer to void function
// size constants for buffers
//
// I impose an arbitrary limit of 128 bytes for a macro or target name.
// This should be much larger than any intelligent user would need.
// The value of a macro can be longer -- up to MAXBUF in length.
//
// The hash table for macros was only 64 pointers long. That seemed a
// reasonable number, since most makefiles have fewer than 64 variables
// defined. Measurements on real makefiles (P1) showed that we had almost
// 8 elements per chain, so it was increased to 256 on FLAT architectures.
// The hashing algorithm isn't perfect, but it should be good
// enough. Even if the macro we're looking up is in a bucket w/ more
// than one entry, we'll only have to chain one or two links down the
// list to find it. When we add macros a bucket's list we prepend them,
// so we don't have to chain at all there.
#define MAXNAME 257
#define MAXMACRO 256
#define MAXTARGET 128
#define MAXBUF 1024
#define MAXSEGMENT 65535
#define MAXARG MAXNAME / 2 - 1
#define CHUNKSIZE 8
#define MAXCMDLINELENGTH 8192
// constants used by error.c
//
// error numbers are of the form Unxxx, where the 'U' stands for utility,
// n is the 1st digit of one of the values below indicating the type of
// error, and xxx is the number of the error (error messages aren't in any
// order right now -- related ones should probably be grouped together
// when all error messages have been added)
#define FATAL_ERR 1000
#define NONFATAL_ERR 2000
#define WARNING_ERR 4000
// other constants
#define WRITE 2 // READ,WRITE,APPEND used by
#define APPEND 3 // redirect() in build.c
#define READ 4 // also value for access()
#define ESCH '^' // general escape character
typedef struct INCLUDEINFO{ unsigned line; char *name; FILE *file;} INCLUDEINFO;
#define MAXINCLUDE 16
// STRINGLIST structure is used to construct lists that keep track of the
// makefiles to read, the targets to update, the dependency list for each
// target, the list of build commands for each target, and the values
// for a macro.
typedef struct strlist { struct strlist *next; char *text;} STRINGLIST;
typedef struct inlinelist { struct inlinelist *next; char *text; char *name; BOOL fKeep; unsigned size;} INLINELIST;
typedef struct scrptlist { // List used to handle multiple
struct scrptlist *next; // scriptfiles
char *sFile; // -- Script file name & its
BOOL fKeep; // -- keep status (default nokeep)
} SCRIPTLIST;
typedef struct BLOCK { STRINGLIST *dependents; // dependents of the target
STRINGLIST *dependentMacros; //
STRINGLIST *buildCommands; // command list to build target
STRINGLIST *buildMacros; UCHAR flags; time_t dateTime;} BUILDBLOCK;
typedef struct bldlist { struct bldlist *next; BUILDBLOCK *buildBlock;} BUILDLIST;
typedef struct BATCH { // State info for deferred batch commands
struct BATCH *next; struct RULE *pRule; // batch inference rule
UCHAR flags; // build flags
STRINGLIST *nameList; // list of names to be "touched" (nmake -t)
STRINGLIST *dollarLt; // list for constructing batch $<
} BATCHLIST;
typedef struct OBJECT { struct OBJECT *next; char *name; UCHAR flags2; UCHAR flags3; time_t dateTime; BUILDLIST *buildList; BATCHLIST **ppBatch; // batch list that contains this object,
// if being built in batch-mode
} MAKEOBJECT;
typedef struct iobject { // used for dependents NOT in
struct object *next; // the makefile. We add them
char *name; // to the target table w/ a
UCHAR flags2; // flag that says "already
UCHAR flags3; // built" and then we never
long datetime; // have to time-stamp again
} IMPLIEDOBJECT;
typedef struct RULE { struct RULE *next; struct RULE *back; // doubly-link rules for ease
char *name; // in sorting later . . .
STRINGLIST *buildCommands; // (# of rules is mostly small
STRINGLIST *buildMacros; // so not much memory used
BOOL fBatch; // TRUE if batch rule (doublecolon)
} RULELIST;
typedef struct deplist { struct deplist *next; char *name; time_t depTime;} DEPLIST;
// Bits in flags/gFlags indicate which cmdline options are set
//
// -a sets FORCE_BUILD
// -c sets CRYPTIC_OUTPUT (only fatal errors get displayed)
// -d sets DISPLAY_FILE_DATES
// -e sets USE_ENVIRON_VARS
// -i sets IGNORE_EXIT_CODES
// -n sets NO_EXECUTE
// -p sets PRINT_INFORMATION
// -q sets QUESTION_STATUS
// -r sets IGNORE_EXTERN_RULES
// -s sets NO_ECHO
// -t sets TOUCH_TARGETS
// -z sets REVERSE_BATCH_FILE (Required by PWB)
// -l sets NO_LOGO (internally /l actually -nologo)
//
// Also included are bits for
//
// BUILDING_THIS_ONE - to detect cycles in dependencies
// DOUBLECOLON - to indicate type of separator found between
// the targets and dependencies (':' or '::')
// ALREADY_BUILT - to indicate that a target has been built
// OUT_OF_DATE - to indicate that this target is out of date
#define F1_PRINT_INFORMATION 0x01 // "global" flags that affect
#define F1_IGNORE_EXTERN_RULES 0x02 // all targets (it doesn't
#define F1_USE_ENVIRON_VARS 0x04 // make sense to allow the
#define F1_QUESTION_STATUS 0x08 // user to change these)
#define F1_TOUCH_TARGETS 0x10
#define F1_CRYPTIC_OUTPUT 0x20
#define F1_NO_BATCH 0x40 // disable batching functionality
#define F1_NO_LOGO 0x80
#define F2_DISPLAY_FILE_DATES 0x01 // these are resettable w/in
#define F2_IGNORE_EXIT_CODES 0x02 // the makefile
#define F2_NO_EXECUTE 0x04 // each target keeps own copy
#define F2_NO_ECHO 0x08
#define F2_FORCE_BUILD 0x10 // build even if up-to-date
#define F2_DOUBLECOLON 0x20 // indicates separator type
#define F2_DUMP_INLINE 0x40 // dump inline files
#define F3_BUILDING_THIS_ONE 0x01 // finds cyclical dependencies
#define F3_ALREADY_BUILT 0x02
#define F3_OUT_OF_DATE 0x04 // reuse :: bit after target
// has been built
#define F3_ERROR_IN_CHILD 0x08 // used to implement slash k
// ----------------------------------------------------------------------------
// MACRODEF structure is used to make a list of macro definitions from the
// commandline, makefile, TOOLS.INI file, and environment. It contains
// a flag which is set for macros defined in the command line so that
// a later definition of the same macro will be ignored. It also contains
// a flag that gets set when NMAKE is expanding the macro so that recursive
// definitions can be detected.
///
typedef struct macro { struct macro *next; char *name; STRINGLIST *values; // can just be list of size 1
UCHAR flags;} MACRODEF;
// Bits in flags field for macros. We really only need to know if a macro
// was defined on the commandline (in which case we ignore all redefinitions),
// or if we're currently expanding macros in its value (so when we look
// up a macro and that bit is set we can tell that the macro is defined
// recursively).
#define M_EXPANDING_THIS_ONE 0x01
#define M_NON_RESETTABLE 0x02
#define M_ENVIRONMENT_DEF 0x04
#define M_WARN_IF_RESET 0x08
#define M_UNDEFINED 0x10
#define M_COMMAND_LINE 0x20
#define M_LITERAL 0x40 // value contains no other macros
// treat $ literary
// macros to simplify dealing w/ bits in flags, allocating memory, and
// testing characters
#define SET(A,B) ((A) |= (UCHAR)(B)) // turn bit B on in A
#define CLEAR(A,B) ((A) &= (UCHAR)(~B)) // turn bit B off in A
#define ON(A,B) ((A) & (UCHAR)(B)) // is bit B on in A?
#define OFF(A,B) (!ON(A,B)) // is bit B off in A?
#define FLIP(A,B) (ON(A,B)) ? (CLEAR(A,B)) : (SET(A,B))
#define CANT_REDEFINE(A) (ON((A)->flags,M_NON_RESETTABLE) \
|| (ON(gFlags,F1_USE_ENVIRON_VARS) \ && ON((A)->flags,M_ENVIRONMENT_DEF)))
#define ALLOCATE_OBJECT(type) ((type *) allocate(sizeof(type)))
#define makeNewStrListElement() ALLOC_STRINGLIST(STRINGLIST)
#define makeNewInlineListElement() ALLOCATE_OBJECT(INLINELIST)
#define makeNewScriptListElement() ALLOCATE_OBJECT(SCRIPTLIST)
#define makeNewMacro() ALLOCATE_OBJECT(MACRODEF)
#define makeNewObject() ALLOCATE_OBJECT(MAKEOBJECT)
#define makeNewImpliedObject() ALLOCATE_OBJECT(MAKEOBJECT)
#define makeNewBuildBlock() ALLOCATE_OBJECT(BUILDBLOCK)
#define makeNewBldListElement() ALLOCATE_OBJECT(BUILDLIST)
#define makeNewRule() ALLOCATE_OBJECT(RULELIST)
#define MakeNewDepListElement() ALLOCATE_OBJECT(DEPLIST)
#define makeNewBatchListElement() ALLOCATE_OBJECT(BATCHLIST)
#define WHITESPACE(A) ((A) == ' ' || (A) == '\t')
#if 1 //JdR see charmap.h
// #define MACRO_CHAR(A) IS_MACROCHAR(A)
// Modified MACRO_CHAR to fix handling of mbcs characters.
// 'A' may combine the bytes of the mbcs char in a single value and
// end up being >= 256. All values >=128 can be treated as
// valid macro characters [vc98 #9973 georgiop 9/19/97]
#define MACRO_CHAR(A) (IS_MACROCHAR(A) || ((unsigned)(A)) >= 128)
#else
#define MACRO_CHAR(A) ((A) == '_' || _istalnum(A) || ((unsigned)(A)) >= 128)
#endif
#define PATH_SEPARATOR(A) ((A) == '\\' || (A) == '/')
#define DYNAMIC_DEP(A) ((A)[2] == '(' \
&& (A)[3] == '@' \ && (A)[5] == ')' \ && (((A)[4] == 'F' \ || (A)[4] == 'D' \ || (A)[4] == 'B' \ || (A)[4] == 'R')))
// values passed to getSpecialValue() to indicate which type of macro
// we're expanding
#define SPECIAL_MACRO 0x01 // $* $@ $? $< $**
#define DYNAMIC_MACRO 0x02 // $$@
#define X_SPECIAL_MACRO 0x03 // $(*F) $(@D) etc.
#define X_DYNAMIC_MACRO 0x04 // $$(@F) $$(@D)
#define DOLLAR_MACRO 0x05 // $$ -> $
// Bits in elements placed in the stack (ifStack) that keeps state
// information about if/else/endif directives. Here "if" directive
// includes if/ifdef/ifndef/if defined().
// -- used in routine lgetc() in ifexpr.c
#define NMIFELSE 0x01 // set for if/ifdef etc...reset for else
#define NMCONDITION 0x02 // set if condition part of if is true
#define NMIGNORE 0x04 // set if if/endif block is to be ignored/skipped
#define NMELSEIF 0x08 // set for else if/ifdef etc...reset for else
// Values to record which of if/ifdef/ifndef/etc was seen to decide
// the kind of processing to be done.
#define IF_TYPE 0x01
#define ELSE_TYPE 0x02
#define ELSE_IF_TYPE 0x03
#define ELSE_IFDEF_TYPE 0x04
#define ELSE_IFNDEF_TYPE 0x05
#define IFDEF_TYPE 0x06
#define IFNDEF_TYPE 0x07
#define ENDIF_TYPE 0x08
// Values to indicate if we are reading from the raw stream or thru'
// the routine lgetc() which preprocesses directives. These are used
// by a routine common to lgetc() module and the lexer.
#define FROMLOCAL 0x00
#define FROMSTREAM 0x01
// macros to simplify accessing hash tables
// find() returns a STRINGLIST pointer, which is then cast to a pointer
// of the appropriate structure type
#define findTarget(A) (MAKEOBJECT*) find(A, MAXTARGET, \
(STRINGLIST**)targetTable, \ (BOOL)TRUE)
// "action" flags for building target-table entries
// if any of the bits in A_SUFFIX to A_RULE is set, the action routines
// WON'T build a targetblock for the current target (really pseudotarget
// or rule)
// A_TARGET says expand names on input (dependent names get expanded when
// target is built) */
#define A_SUFFIX 0x01
#define A_SILENT 0x02
#define A_IGNORE 0x04
#define A_PRECIOUS 0x08
#define A_RULE 0x10
#define A_TARGET 0x20
#define A_STRING 0x40
#define A_DEPENDENT 0x80
// "build" flags used by recursive target-building function
#define B_COMMANDS 0x01
#define B_BUILD 0x02
#define B_INMAKEFILE 0x04
#define B_NOTARGET 0x08
#define B_ADDDEPENDENT 0x10
#define B_DOUBLECOLON 0x20
#define B_DEP_OUT_OF_DATE 0x40
// "command" flags used by doCommand function
#define C_SILENT 0x01
#define C_IGNORE 0x02
#define C_ITERATE 0x04
#define C_EXECUTE 0x08
#define C_EXPANDED 0x10
// keyword for better profiling, normally set to "static".
#ifndef LOCAL
#define LOCAL static
#endif
// GetTxtChr and UngetTxtChr are the MBCS counterparts of getc and ungetc.
#ifdef _MBCS
extern int GetTxtChr(FILE*);extern int UngetTxtChr(int, FILE*);#else
#define GetTxtChr(a) getc(a)
#define UngetTxtChr(c,f) ungetc(c,f)
#endif
#define strend(p) (p + _tcslen(p))
#include "charmap.h"
|
