UCHAR
processIncludeFile(
char *s
)
{
MACRODEF *m;
struct _finddata_t finddata;
NMHANDLE searchHandle;
char *t, *p, *u;
int c = 0;
int i;
if (!*s || *s == '#') {
makeError(line, SYNTAX_NO_NAME);
}
if ((t = _tcspbrk(s,"\t#"))) {
if (*t == '#') {
c = *t;
}
*t = '\0';
if (!c) {
for (u = t; *++u;) { // check for extra
if (*u == '#') {
break; // text on line
}
if (!WHITESPACE(*u)) {
makeError(line, SYNTAX_UNEXPECTED_TOKEN, u);
}
}
}
} else {
t = s + _tcslen(s);
}
// remove trailing white space
while (t > s) {
char *prev;
prev = _tcsdec(s, t);
if (!WHITESPACE(*prev))
break;
t = prev;
}
*t = '\0';
if (*s == '<' && *(t-1) == '>') {
char *pt;
*--t = '\0';
p = removeMacros(++s);
p = p == s ? makeString(s) : p;
t = (m = findMacro("INCLUDE")) ? m->values->text : (char*) NULL;
if (t != NULL) { // expand INCLUDE macro before passing it on
char * pt1;
pt1= makeString(t);
pt = removeMacros(pt1);
if (pt != pt1) {
FREE(pt1); // we've got a new string, free old one
}
} else {
pt = NULL;
}
if (!(u = searchPath(pt, p, &finddata, &searchHandle))) {
makeError(line, CANT_OPEN_FILE, p);
}
if (pt) {
FREE(pt);
}
FREE(p);
s = u;
} else {
if (*s == '"' && *(t-1) == '"') {
*--t = '\0';
++s;
}
p = removeMacros(s);
p = p == s ? makeString(s) : p;
if (!findFirst(p, &finddata, &searchHandle)) {
if (!_tcspbrk(p, "\\/:")) {
//use C sematics for include
for (i = incTop;i >= 0;i--) {
t = (i == incTop) ? fName : incStack[i].name;
if (!(t = getPath(t)))
continue;
u = (char *)allocate(_tcslen(t) + 1 + _tcslen(p) + 1);
_tcscat(_tcscat(_tcscpy(u, t), PATH_SEPARATOR), p);
if (findFirst(u, &finddata, &searchHandle)) {
s = u;
FREE(t);
break;
}
FREE(t);
FREE(u);
}
FREE(p);
if (i < 0) {
makeError(line, CANT_OPEN_FILE, s);
}
} else {
makeError(line, CANT_OPEN_FILE, p);
}
}
}
for (i = 0; i < incTop; ++i) { // test for cycles
if (!_tcsicmp(s,incStack[i].name)) {
makeError(line, CYCLE_IN_INCLUDES, s);
}
}
incStack[incTop].file = file; // push info on stack
incStack[incTop].line = line;
incStack[incTop++].name = fName;
currentLine = 0;
if (!(file = OpenValidateMakefile(s,"rt"))) { // read, text mode
makeError(line,CANT_OPEN_FILE,s);
}
fName = makeString(s);
line = 1;
colZero = TRUE; // parser needs to see some kind of
c = lgetc(); // newline to initialize it for this
if ((colZero = (BOOL) !WHITESPACE(c))) { // file
UngetTxtChr(c,file);
line=0; // We did not start reading the file
return(NEWLINE);
}
return(NEWLINESPACE);
}
BOOL
putMacro(
char *name,
char *value,
UCHAR flags
)
{
MACRODEF *p;
STRINGLIST *q;
BOOL defined = FALSE;
BOOL fSyntax = TRUE;
// Convert path separators to the native path separator.
// Do that with a copy of the original string so we don't change
// the original.
value = makeString(value);
#if PLATFORM_UNIX
char *tmp = value;
while ((tmp = FindFirstPathSeparator(tmp))) {
*tmp++ = PATH_SEPARATOR_CHAR;
}
#endif // PLATFORM_UNIX
// 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.
return(TRUE);
}
return(TRUE);
}
