OS_Develop/Windows-Server-2003
OS_Develop/Windows-Server-2003
1
0
Fork 0
Code Pull Requests Activity
master
Windows-Server-2003/sdktools/nmake/action.cpp

945 lines
29 KiB
C++
Raw Permalink Blame History

// ACTION.C -- routines called by the parser
//
// Copyright (c) 1988-1990, Microsoft Corporation. All rights reserved.
//
// Purpose:
// This module contains the routines called during parsing of a makefile.
//
// Revision History:
// 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*
// 13-Feb-1990 SB nextComponent() missed out mixed case of quoted/non-quote list
// 02-Feb-1990 SB Add nextComponent() for Longfilename handling
// 08-Dec-1989 SB removed local used without initialization warnings for -Oes
// 07-Dec-1989 SB removed register to compile using C6 -Oes (warning gone)
// 06-Dec-1989 SB changed expandFileNames() type to void instead of void *
// 22-Nov-1989 SB Changed free() to FREE()
// 13-Nov-1989 SB Removed an unreferenced local in endNameList()
// 02-Oct-1989 SB add dynamic inline file handling support
// 04-Sep-1989 SB Add A_DEPENDENT and fix macro inheritance
// 24-Aug-1989 SB Allow $* on dependency lines
// 14-Jul-1989 SB Environment macro was getting updated even when CMDLINE
// macro was present
// 29-Jun-1989 SB addItemToList() now maintains Global inline file List
// 26-Jun-1989 SB Fixed -e for recursive NMAKE
// 22-May-1989 SB NZ options work independently. -NZ does both stuff now
// 13-May-1989 SB Changed delList to contain just names of files and no "del "
// 14-Apr-1989 SB made targetList NEAR, no 'del inlinefile' cmd for -n now
// 05-Apr-1989 SB Added parameters to makeRule() & makeTarget(); this get rid
// of globals
// 03-Apr-1989 SB changed all functions to NEAR to get them into one module
// 21-Mar-1989 SB changed assignDependents() and assignCommands() to handle
// multiple target case correctly.
// 20-Mar-1989 SB startNamelist() doesn't flag error if target macro is null
// and >1 target given; commented startNameList()
// 16-Feb-1989 SB addItemToList() now appends to delList instead of List so
// that all 'del scriptFile' cmds can be at the end of the make
// 29-Jan-1989 SB added targList but not used as yet
// 19-Jan-1989 SB changed startNameList() to avoid GP fault, bug# 162
// 18-Jan-1989 SB modified endNameList(), added makeList() and makeBuildList()
// and added a parameter to makeTarget() for bug# 161
// 21-Dec-1988 SB use scriptFileList to handle multiple scriptFiles
// Improve KEEP/NOKEEP;each file can have its own action
// 16-Dec-1988 SB addItemToList() is now equipped for KEEP/NOKEEP
// 14-Dec-1988 SB addItemToList() modified for 'Z' option -- adds a delete
// command for deleting temporary script files
// 5-Nov-1988 RB Fixed macro inheritance for recursive definitions.
// 27-Oct-1988 SB put malloc for allocate in putEnvStr() -- error checking
// 23-Oct-1988 SB Using putEnvStr() for putenv() to simplify code
// 21-Oct-1988 SB Added fInheritUserEnv flag modifications to makeMacro()
// and putMacro() for macro inheritance
// 19-Sep-1988 RB Remove warning for MAKE redefinition.
// 22-Aug-1988 RB Clean up for !UNDEF'ed macros.
// 17-Aug-1988 RB Clean up.
// 14-Jul-1988 rj Added initialization of dateTime field of BUILDBLOCKs.
// 7-Jul-1988 rj Added targetFlag parameter to hash() calls.
// Fixed bug: redefined macros didn't get flags reset.
// 09-May-1988 rb Don't swallow no-match wildcards.
#include "precomp.h"
#pragma hdrstop
void startNameList(void);
void makeRule(STRINGLIST *, BOOL fBatch);
void makeTarget(char*, BOOL, BUILDBLOCK**);
void appendPseudoTargetList(STRINGLIST**, STRINGLIST*);
void clearSuffixes(void);
BOOL doSpecial(char*);
BUILDLIST * makeBuildList(BUILDBLOCK *);
char * nextComponent(char **);
// created by endNameList() & freed by assignBuildCommands(). In use because
// although global 'list' has this list is used by too many routines and the
// complete sequence of actions on 'list' is unknown
STRINGLIST * targetList; // corr to a dependency block
// makeName -- create copy of a name seen by lexer
//
// Purpose:
// Create a copy of a macro or 1st name in a target/dependency list. It also
// does the groundwork for expansion of macros in name and saves values.
//
// Assumes: That the lexical routines save the token in buf
//
// Modifies Globals:
// name -- the pointer to the copy created, gets allocated memory
// macros -- the list of macro values in name. Used later by startNameList()
// to expand macros in name and get expanded target name.
//
// Uses Globals:
// buf -- the lexical routines return a token in this
//
// Notes:
// The token in buf could be part of a macrodefinition or a target list. The
// next token determines if it is a macrodefn or a targetlist we are parsing.
// The next token would overwrite the current token and so it is saved in name.
void
makeName()
{
findMacroValues(buf, &macros, NULL, NULL, 0, 0, 0);
name = makeString(buf);
}
// don't expand build lines for rules now -- expand after everything read in
// that way CC and CFLAGS used in rules from tools.ini but not defined until
// the makefile will have appropriate values. Redefining macros for use
// in targets w/o explicit build commands doesn't work. Macros in rules have
// the value of their last definition in the makefile.
void
addItemToList()
{
STRINGLIST *p; // from lexer
STRINGLIST *NewList;
if (name) {
SET(actionFlags, A_TARGET);
startNameList();
name = NULL;
}
if (ON(actionFlags, A_TARGET)) {
if (isRule(buf)) {
if (ON(actionFlags, A_RULE))
makeError(currentLine, TOO_MANY_RULE_NAMES);
makeError(currentLine, MIXED_RULES);
}
}
p = makeNewStrListElement();
if (ON(actionFlags, A_STRING)) { // we collect macros
p->text = string; // for dependents &
string = NULL; // build lines for
} else // non-implicit rules
p->text = makeString(buf);
NewList = p; // build lines for
if (OFF(actionFlags, A_RULE) // rules get expanded
|| ON(actionFlags, A_TARGET)) // after entire make-
{
findMacroValues(p->text, &macros, NULL, NULL, 0, 0, 0); // file parsed
}
if (ON(actionFlags, A_TARGET)) {
p = macros;
expandFileNames("$", &NewList, &macros);
expandFileNames("*?", &NewList, NULL);
while (macros = p) {
p = p->next;
FREE_STRINGLIST(macros);
}
}
appendItem(&list, NewList);
}
// startNameList -- puts in the first element into list
//
// Scope: Local.
//
// Purpose: Puts in the first name seen into a list
//
// Errors/Warnings: TARGET_MACRO_IS_NULL -- if the macro used as a target expands to null
//
// Assumes:
// The global 'list' is originally a null list, & the global 'macro' points to
// a list of values used for expanding the macros in global 'name'.
//
// Modifies Globals:
// list -- the list of names; set to contain the first name here or to a
// list of values if 'name' contains a macro invocation.
// macros -- the list of values reqd for macro expansion; the list is
// freed and macros is made NULL
// currentFlags -- the flags for current target; set to global flags
// actionFlags -- determine actions to be done; if the name is a rule then set
// the rule bit
//
// Uses Globals:
// name -- the first name seen in a list of names.
// flags -- the global flags setup by the options specified
// actionFlags -- if handling targets then no error as we have > 1 target
//
// Notes:
// If there is more than one target then actionFlags has A_TARGET flag set and
// startNameList() is called from addItemToList. In this case don't flag error.
void
startNameList()
{
STRINGLIST *p;
currentFlags = flags; // set flags for cur target
p = makeNewStrListElement();
p->text = name;
list = p; // list contains name
p = macros;
expandFileNames("$", &list, &macros); // expand macros in name
expandFileNames("*?", &list, NULL); // expand wildcards
while (macros = p) { // free macro list
p = p->next;
FREE_STRINGLIST(macros);
}
if (!list && OFF(actionFlags, A_TARGET))
makeError(line, TARGET_MACRO_IS_NULL, name); // target null & 1 target
if (list && isRule(list->text))
SET(actionFlags, A_RULE);
}
// endNameList -- semantic actions when a list is fully seen
//
// Purpose:
// When the parser has seen an entire list then it needs to do some semantic
// actions. It calls endNameList() to do these actions. The action depends on
// the values in certain globals.
//
// Modifies Globals: actionFlags --
//
// Uses Globals:
// name -- The first element seen (if non null)
// actionFlags -- The flag determining semantic & data structure actions
// buf -- The delimiter seen after list
// list -- The list of elements seen
void
endNameList()
{
if (name) { // if only one name to left of :
startNameList(); // it hasn't been put in list yet
name = NULL;
} else
CLEAR(actionFlags, A_TARGET); // clear target flag
if (buf[1])
SET(currentFlags, F2_DOUBLECOLON); // so addItemToList()
if (!list) // won't expand names
makeError(currentLine, SYNTAX_NO_TARGET_NAME); // of dependents
if (ON(actionFlags, A_RULE)) {
BOOL fBatch;
// A rule with a doublecolon on the dependency line
// is a "batch rule", i.e., a rule that applies the
// command block in batch mode for all affected
// dependents.
fBatch = !!(ON(currentFlags, F2_DOUBLECOLON));
makeRule(list, fBatch);
FREE_STRINGLIST(list);
}
else if (!(list->next) && doSpecial(list->text)) { // special pseudotarget ...
FREE(list->text); // don't need ".SUFFIXES" etc
FREE_STRINGLIST(list);
}
else // regular target
targetList = list;
list = NULL;
// We are now looking for a dependent
SET(actionFlags, A_DEPENDENT);
}
BOOL
doSpecial(
char *s)
{
BOOL status = FALSE;
if (!_tcsicmp(s, silent)) {
SET(actionFlags, A_SILENT);
setFlags('s', TRUE);
status = TRUE;
}
if (!_tcsicmp(s, ignore)) {
SET(actionFlags, A_IGNORE);
setFlags('i', TRUE);
status = TRUE;
}
else if (!_tcscmp(s, suffixes)) {
SET(actionFlags, A_SUFFIX);
status = TRUE;
}
else if (!_tcscmp(s, precious)) {
SET(actionFlags, A_PRECIOUS);
status = TRUE;
}
return(status);
}
void
expandFileNames(
char *string,
STRINGLIST **sourceList,
STRINGLIST **macroList
)
{
char *s,
*t = NULL;
STRINGLIST *p; // Main list pointer
STRINGLIST *pNew, // Pointer to new list
*pBack; // Pointer to one element back
char *saveText = NULL;
for (pBack = NULL, p = *sourceList; p;) {
// If no expand-character is found, continue to next list element.
if (!_tcspbrk(p->text, string)) {
pBack = p;
p = pBack->next;
continue;
}
// Either expand macros or wildcards.
if (*string == '$') {
t = expandMacros(p->text, macroList);
FREE(p->text);
} else {
// If the wildcard string does not expand to anything, go to
// next list elment. Do not remove p from the original list
// else we must check for null elsewhere.
// CAVIAR 3912 -- do not attempt to expand wildcards that
// occur in inference rules [rm]
if (isRule(p->text) || (pNew = expandWildCards(p->text)) == NULL) {
pBack = p;
p = pBack->next;
continue;
}
saveText = p->text;
}
// At this point we have a list of expanded names to replace p with.
if (pBack) {
pBack->next = p->next;
FREE_STRINGLIST(p);
p = pBack->next;
} else {
*sourceList = p->next;
FREE_STRINGLIST(p);
p = *sourceList;
}
if (*string == '$') { // if expanding macros
char *str = t;
if (s = nextComponent(&str)) {
do { // put expanded names
pNew = makeNewStrListElement(); // at front of list
pNew->text = makeString(s); // so we won't try to
prependItem(sourceList, pNew); // re-expand them
if (!pBack)
pBack = pNew;
} while (s = nextComponent(&str));
}
FREE(t);
continue;
}
else if (pNew) { // if matches for * ?
// Wild cards within Quoted strings will fail
if (!pBack)
for (pBack = pNew; pBack->next; pBack = pBack->next)
;
appendItem(&pNew, *sourceList); // put at front of old list
*sourceList = pNew;
}
FREE(saveText);
}
}
// nextComponent - returns next component from expanded name
//
// Scope: Local (used by expandFilenames)
//
// Purpose:
// Given a target string (target with macros expanded) this function returns a
// name component. Previously _tcstok(s, " \t") was used but with the advent of
// quoted filenames this is no good.
//
// Input: szExpStr - the target name with macros expanded
//
// Output: Returns pointer to next Component; NULL means no more components left.
//
// Assumes: That that two quoted strings are seperated by whitespace.
char *
nextComponent(
char **szExpStr
)
{
char *t, *next;
t = *szExpStr;
while (WHITESPACE(*t))
t++;
next = t;
if (!*t)
return(NULL);
if (*t == '"') {
for (; *++t && *t != '"';)
;
} else {
for (; *t && *t != ' ' && *t != '\t'; t++)
;
}
if (WHITESPACE(*t)) {
*t = '\0';
} else if (*t == '"') {
t++;
if(*t=='\0') t--; // If this is the end of the string, backup a byte, so we don't go past next time
else *t = '\0'; // else stop here for this time.
} else if (!*t) {
// If at end of string then backup a byte so that next time we don't go past
t--;
}
*szExpStr = t+1;
return(next);
}
// append dependents to existing ones (if any)
void
assignDependents()
{
const char *which = NULL;
if (ON(actionFlags, A_DEPENDENT))
CLEAR(actionFlags, A_DEPENDENT);
if (ON(actionFlags, A_RULE)) {
if (list)
makeError(currentLine, DEPENDENTS_ON_RULE);
}
else if (ON(actionFlags, A_SILENT) || ON(actionFlags, A_IGNORE)) {
if (list) {
if (ON(actionFlags, A_SILENT))
which = silent;
else if (ON(actionFlags, A_IGNORE))
which = ignore;
makeError(currentLine, DEPS_ON_PSEUDO, which);
}
}
else if (ON(actionFlags, A_SUFFIX)) {
if (!list)
clearSuffixes();
else
appendPseudoTargetList(&dotSuffixList, list);
}
else if (ON(actionFlags, A_PRECIOUS)) {
if (list)
appendPseudoTargetList(&dotPreciousList, list);
}
else {
block = makeNewBuildBlock();
block->dependents = list;
block->dependentMacros = macros;
}
list = NULL;
macros = NULL;
SET(actionFlags, A_STRING); // expecting build cmd
}
void
assignBuildCommands()
{
BOOL okToFreeList = TRUE;
BOOL fFirstTarg = (BOOL)TRUE;
STRINGLIST *p;
const char *which = NULL;
if (ON(actionFlags, A_RULE)) // no macros found yet for inference rules
rules->buildCommands = list;
else if (ON(actionFlags, A_SILENT) ||
ON(actionFlags, A_IGNORE) ||
ON(actionFlags, A_PRECIOUS) ||
ON(actionFlags, A_SUFFIX)
) {
if (list) {
if (ON(actionFlags, A_SILENT))
which = silent;
else if (ON(actionFlags, A_IGNORE))
which = ignore;
else if (ON(actionFlags, A_PRECIOUS))
which = precious;
else if (ON(actionFlags, A_SUFFIX))
which = suffixes;
makeError(currentLine, CMDS_ON_PSEUDO, which);
}
} else {
block->buildCommands = list;
block->buildMacros = macros;
block->flags = currentFlags;
while (p = targetList) { // make a struct for each targ
if (doSpecial(p->text)) // in list, freeing list when
makeError(currentLine, MIXED_TARGETS);
makeTarget(p->text, fFirstTarg, &block); // done, don't free name
if (!makeTargets) { // field -- it's still in use
makeTargets = p; // if no targs given on cmdlin
okToFreeList = FALSE; // put first target(s) from
} // mkfile in makeTargets list
targetList = p->next; // (makeTargets defined in
if (okToFreeList) // nmake.c)
FREE_STRINGLIST(p);
if (fFirstTarg)
fFirstTarg = (BOOL)FALSE;
}
}
targetList = NULL;
list = NULL;
macros = NULL;
block = NULL;
actionFlags = 0;
}
// makeMacro -- define macro with name and string taken from global variables
//
// Modifies:
// fInheritUserEnv set to TRUE
//
// Notes:
// Calls putMacro() to place expanded Macros in the NMAKE table. By setting
// fInheritUserEnv those definitions that change Environment variables are
// inherited by the environment.
void
makeMacro()
{
STRINGLIST *q;
char *t;
if (_tcschr(name, '$')) { // expand name
q = macros;
t = expandMacros(name, &macros); // name holds result
if (!*t) // error if macro to left of = is undefined
makeError(currentLine, SYNTAX_NO_MACRO_NAME);
while (macros = q) {
q = q->next;
FREE_STRINGLIST(macros);
}
FREE(name);
name = t;
}
for (t = name; *t && MACRO_CHAR(*t); t = _tcsinc (t)) // Check for illegal chars
;
if (*t)
makeError(currentLine, SYNTAX_BAD_CHAR, *t);
fInheritUserEnv = (BOOL)TRUE;
// Put Env Var in Env & macros in table.
if (!putMacro(name, string, 0)) {
FREE(name);
FREE(string);
}
name = string = NULL;
}
// defineMacro -- check macro's syntax for illegal chars., then define it
//
// actions: check all of macro's characters
// if one's bad and it's an environment macro, bag it
// else flag error
// call putMacro to do the real work
//
// can't use macro invocation to left of = in macro def from commandline
// it doesn't make sense to do that, because we're not in a makefile
// the only way to get a comment char into the makefile w/o having it really
// mark a comment is to define a macro A=# on the command line
BOOL
defineMacro(
char *s, // commandline or env definitions
char *t,
UCHAR flags
)
{
char *u;
for (u = s; *u && MACRO_CHAR(*u); u = _tcsinc(u)) // check for illegal
;
if (*u) {
if (ON(flags, M_ENVIRONMENT_DEF)) { // ignore bad macros
return(FALSE);
}
makeError(currentLine, SYNTAX_BAD_CHAR, *u); // chars, bad syntax
}
return(putMacro(s, t, flags)); // put macro in table
}
// putMacro - Put the macro definition into the Macro Table / Environmnet
//
// Scope:
// Global.
//
// Purpose:
// putMacro() inserts a macro definition into NMAKE's macro table and also into
// the environment. If a macro name is also an environment variable than its
// value is inherited into the environment. While replacing older values by new
// values NMAKE needs to follow the precedence of macro definitions which is
// as per the notes below.
//
// Input:
// name - Name of the macro
// value - Value of the macro
// flags - Flags determining Precedence of Macro definitions (see Notes)
//
// Output:
//
// Errors/Warnings:
// OUT_OF_ENV_SPACE - If putenv() returns failure in adding to the environment.
//
// Assumes:
// Whatever it assumes
//
// Modifies Globals:
// fInheritUserEnv - Set to False.
//
// Uses Globals:
// fInheritUserEnv - If True then Inherit definition to the Environment.
// gFlags - Global Options Flag. If -e specified then Environment Vars
// take precedence.
// macroTable - NMAKE's internal table of Macro Definitions.
//
// Notes:
// 1> If the same macro is defined in more than one place then NMAKE uses the
// following order of Precedence (highest to lowest) --
//
// -1- Command line definitions
// -2- Description file/Include file definitions
// -3- Environment definitions
// -4- TOOLS.INI definitions
// -5- Predefined Values (e.g. for CC, AS, BC, RC)
// If -e option is specified then -3- precedes -2-.
//
// 2> Check if the macro already exists in the Macro Table. If the macro is not
// redefinable (use order of precedence) then return. Make a new string
// element to hold macro's new value. If the macro does not exist then create
// new entry in the Macro table. Set Macro's flag to be union of Old and new
// values. Add the new value to macro's value entry. If a new macro then add
// it to the macro table. Test for Cyclic definitions.
//
// Undone/Incomplete:
// 1> Investigate into possibility of removing fInheritUserEnv variable.
// Can be done. Use CANT_REDEFINE(p) || OFF((A)->flags,M_ENVIRONMENT_DEF)
// 2> Probably should warn when $(MAKE) is being changed.
BOOL
putMacro(
char *name,
char *value,
UCHAR flags
)
{
MACRODEF *p;
STRINGLIST *q;
BOOL defined = FALSE;
BOOL fSyntax = TRUE;
// Inherit macro definitions. Call removeMacros() to expand sub-macro
// definitions. Must be done before macro is put in table, else
// recursive definitions won't work.
if (ON(flags, M_NON_RESETTABLE)) {
if (*value)
if ((putEnvStr(name,removeMacros(value)) == -1))
makeError(currentLine, OUT_OF_ENV_SPACE);
} else
if (fInheritUserEnv &&
OFF(gFlags, F1_USE_ENVIRON_VARS) &&
getenv(name)
) {
if (p = findMacro(name)) { // don't let user
if (CANT_REDEFINE(p)) // redefine cmdline
return(FALSE); // macros, MAKE, etc.
}
if ((putEnvStr(name,removeMacros(value)) == -1))
makeError(currentLine, OUT_OF_ENV_SPACE);
}
fInheritUserEnv = (BOOL)FALSE;
if (p = findMacro(name)) { // don't let user
if (CANT_REDEFINE(p)) // redefine cmdline
return(FALSE); // macros, MAKE, etc.
}
q = makeNewStrListElement();
q->text = value;
if (!p) {
p = makeNewMacro();
p->name = name;
assert(p->flags == 0);
assert(p->values == NULL);
} else
defined = TRUE;
p->flags &= ~M_UNDEFINED; // Is no longer undefined
p->flags |= flags; // Set flags to union of old and new
prependItem((STRINGLIST**)&(p->values), (STRINGLIST*)q);
if (!defined)
insertMacro((STRINGLIST*)p);
if (OFF(flags, M_LITERAL) && _tcschr(value, '$')) { // Check for cyclic Macro Definitions
SET(p->flags, M_EXPANDING_THIS_ONE);
// NULL -> don't build list
fSyntax = findMacroValues(value, NULL, NULL, name, 1, 0, flags);
CLEAR(p->flags, M_EXPANDING_THIS_ONE);
}
if (!fSyntax) {
p->values = NULL;
p->flags |= M_UNDEFINED;
//return(FALSE);
// return TRUE since p has been added to the macro table
// Otherwise the caller may free name and value leaving
// dangling pointers in the macro table. [DS 18040]
return(TRUE);
}
return(TRUE);
}
// makeRule -- makes an inference rule
//
// Scope:
// Local
//
// Purpose:
// Allocates space for an inference rule and adds rule to the beginning of the
// doubly linked inference rule list. The name of the rule is also added.
//
// Input:
// rule -- The name of the inference rule
// fBatch -- True if command block should be executed in batch mode
//
// Output:
//
// Errors/Warnings:
//
// Assumes:
//
// Modifies Globals:
// rules -- The doubly linked inference rule list to which the rule is added
//
// Uses Globals:
//
// Notes:
// The syntax of an inference rule is --
//
// {frompath}.fromext{topath}.toext: # Name of the inference rule
// command ... # command block of the inference rule
void
makeRule(
STRINGLIST *rule,
BOOL fBatch
)
{
RULELIST *rList;
rList = makeNewRule();
rList->name = rule->text;
rList->fBatch = fBatch;
prependItem((STRINGLIST**)&rules, (STRINGLIST*)rList);
if (rList->next)
rList->next->back = rList;
}
// makeTarget -- add target to targetTable
//
// actions: if no block defined, create one and initialize it
// make new build list entry for this target
// if the target's already in the table,
// flag error if : and :: mixed
// else add new buildlist object to target's current buildlist
// else allocate new object, initialize it, and stick it in table
void
makeTarget(
char *s,
BOOL firstTarg,
BUILDBLOCK **block
)
{
BUILDLIST *build;
MAKEOBJECT *object;
if (!*block)
*block = makeNewBuildBlock();
if (firstTarg) {
build = makeNewBldListElement();
build->buildBlock = *block;
} else
build = makeBuildList(*block);
if (object = findTarget(s)) {
if (ON(object->flags2, F2_DOUBLECOLON) != ON(currentFlags, F2_DOUBLECOLON))
makeError(currentLine, MIXED_SEPARATORS);
appendItem((STRINGLIST**)&(object->buildList), (STRINGLIST*)build);
FREE(s);
} else {
build->next = NULL;
object = makeNewObject();
object->name = s;
object->buildList = build;
object->flags2 = currentFlags;
prependItem((STRINGLIST**)targetTable+hash(s, MAXTARGET, (BOOL)TRUE),
(STRINGLIST*)object);
}
}
void
clearSuffixes()
{
STRINGLIST *p;
while (p = dotSuffixList) {
dotSuffixList = dotSuffixList->next;
FREE(p->text);
FREE_STRINGLIST(p);
}
}
void
appendPseudoTargetList(
STRINGLIST **pseudo,
STRINGLIST *list
)
{
STRINGLIST *p, *q, *r;
char *t, *u;
while (p = list) {
if (!_tcschr(p->text, '$')) {
list = list->next;
p->next = NULL;
appendItem(pseudo, p);
} else {
r = macros;
t = expandMacros(p->text, &macros);
while (r != macros) {
q = r->next;
FREE_STRINGLIST(r);
r = q;
}
for (u = _tcstok(t, " \t"); u; u = _tcstok(NULL, " \t")) {
q = makeNewStrListElement();
q->text = makeString(u);
appendItem(pseudo, q);
}
FREE(t);
FREE(p->text);
list = list->next;
FREE_STRINGLIST(p);
}
}
}
// putEnvStr -- Extends putenv() standard function
//
// Purpose:
// Library function putenv() expects one string argument of the form
// "NAME=value"
// Most of the times when putenv() is to be used we have two strings
// name -- of the variable to add to the environment, and
// value -- to be set
// putEnvStr takes these 2 parameters and calls putenv with the reqd
// format
//
// Input:
// name -- of var to add to the env
// value -- reqd to be set
//
// Output:
// Same as putenv()
int
putEnvStr(
char *name,
char *value
)
{
char *envPtr;
envPtr = (char *)rallocate(_tcslen(name)+1+_tcslen(value)+1);
// ^ ^
// for '=' for '\0'
return(PutEnv(_tcscat(_tcscat(_tcscpy(envPtr, name), "="), value)));
}
// makeBuildList -- takes a build block and copies into a buildlist
//
// Purpose:
// Routine creates a copy of a buildlist and returns a pointer to a copy.
// When multiple targets have the same description block then there is a
// need for each of them to get seperate build blocks. makeBuildList()
// helps achieve this by creating a copy for each target.
//
// Input:
// bBlock -- the build block whose copy is to be added to a build block
//
// Output:
// Returns a pointer to the copy of buildlist it creates
BUILDLIST *
makeBuildList(
BUILDBLOCK *bBlock
)
{
BUILDLIST *tList = makeNewBldListElement();
BUILDBLOCK *tBlock = makeNewBuildBlock();
tBlock->dependents = bBlock->dependents;
tBlock->dependentMacros = bBlock->dependentMacros;
tBlock->buildCommands = bBlock->buildCommands;
tBlock->buildMacros = bBlock->buildMacros;
tBlock->flags = bBlock->flags;
tBlock->dateTime = bBlock->dateTime;
tList->buildBlock = tBlock;
return(tList);
}
View Git Blame Copy Permalink