Category : C Source Code
Archive   : OHLMAKE.ZIP
Filename : EXPAND.C

 
Output of file : EXPAND.C contained in archive : OHLMAKE.ZIP
/* Variable expansion functions for GNU Make.
Copyright (C) 1988, 1989 Free Software Foundation, Inc.
This file is part of GNU Make.

GNU Make is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option)
any later version.

GNU Make is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Make; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */

/*
* MS-DOS port (c) 1990 by Thorsten Ohl
*
* To this port, the same copying conditions apply as to the
* original release.
*
* IMPORTANT:
* This file is not identical to the original GNU release!
* You should have received this code as patch to the official
* GNU release.
*
* MORE IMPORTANT:
* This port comes with ABSOLUTELY NO WARRANTY.
*
* $Header: e:/gnu/make/RCS/expand.c'v 3.58.0.1 90/07/17 00:59:05 tho Exp $
*/

#include "make.h"
#include "commands.h"
#include "file.h"
#include "variable.h"

#ifdef MSDOS
static char *recursively_expand (struct variable *v);
#endif /* MSDOS */

/* Recursively expand V. The returned string is malloc'd. */

static char *
recursively_expand (v)
register struct variable *v;
{
char *value;

if (v->expanding)
fatal ("%s:%u: Recursive variable `%s' references itself (eventually)",
reading_filename, *reading_lineno_ptr, v->name);

v->expanding = 1;
value = allocated_variable_expand (v->value);
v->expanding = 0;

return value;
}

/* Scan LINE for variable references and expansion-function calls.
Build in `variable_buffer' the result of expanding the references and calls.
Return the address of the resulting string, which is null-terminated
and is valid only until the next time this function is called. */

char *
variable_expand (line)
register char *line;
{
register struct variable *v;
register char *p, *o, *p1;

p = line;
o = initialize_variable_output ();

while (1)
{
/* Copy all following uninteresting chars all at once to the
variable output buffer, and skip them. Uninteresting chars end
at the next $ or the end of the input. */

p1 = index (p, '$');

o = variable_buffer_output (o, p, p1 != 0 ? p1 - p : strlen (p) + 1);

if (p1 == 0)
break;
p = p1 + 1;

/* Dispatch on the char that follows the $. */

switch (*p)
{
case '$':
/* $$ seen means output one $ to the variable output buffer. */
o = variable_buffer_output (o, p, 1);
break;

case '(':
case '{':
/* $(...) or ${...} is the general case of substitution. */
{
char openparen = *p;

char closeparen = (openparen == '(') ? ')' : '}';
register char *beg = p + 1;
char *op, *begp;
char *end;

op = o;
begp = p;
if (handle_function (&op, &begp))
{
o = op;
p = begp;
break;
}

/* Is there a variable reference inside the parens or braces?
If so, expand it before expanding the entire reference. */

p1 = index (beg, closeparen);
if (p1 != 0)
p1 = lindex (beg, p1, '$');
if (p1 != 0)
{
/* BEG now points past the opening paren or brace.
Count parens or braces until it is matched. */
int count = 0;
for (p = beg; *p != '\0'; ++p)
{
if (*p == openparen)
++count;
else if (*p == closeparen && --count < 0)
break;
}
/* If count is >= 0, there were unmatched opening parens
or braces, so we go to the simple case of a variable name
such as `$($(a)'. */
if (count < 0)
{
char *name = expand_argument (beg, p);
static char start[3] = { '$', }, end[2];
start[1] = openparen;
end[0] = closeparen;
p1 = concat (start, name, end);
free (name);
name = allocated_variable_expand (p1);
o = variable_buffer_output (o, name, strlen (name));
free (name);
break;
}
}

/* This is not a reference to a built-in function and
it does not contain any variable references inside.
There are several things it could be. */

p = index (beg, ':');
if (p != 0 && lindex (beg, p, closeparen) == 0)
{
/* This is a substitution reference: $(FOO:A=B). */
int count;
char *subst_beg, *replace_beg;
unsigned int subst_len, replace_len;

v = lookup_variable (beg, p - beg);

subst_beg = p + 1;
count = 0;
for (p = subst_beg; *p != '\0'; ++p)
{
if (*p == openparen)
++count;
else if (*p == closeparen)
--count;
else if (*p == '=' && count <= 0)
break;
}
if (count > 0)
/* There were unmatched opening parens. */
return initialize_variable_output ();
subst_len = p - subst_beg;

replace_beg = p + 1;
count = 0;
for (p = replace_beg; *p != '\0'; ++p)
{
if (*p == openparen)
++count;
else if (*p == closeparen && --count < 0)
break;
}
if (count > 0)
/* There were unmatched opening parens. */
return initialize_variable_output ();
end = p;
replace_len = p - replace_beg;

if (v != 0 && *v->value != '\0')
{
char *value = (v->recursive ? recursively_expand (v)
: v->value);
if (lindex (subst_beg, subst_beg + subst_len, '%') != 0)
{
p = savestring (subst_beg, subst_len);
p1 = savestring (replace_beg, replace_len);
o = patsubst_expand (o, value, p, p1,
index (p, '%'), index (p1, '%'));
free (p);
free (p1);
}
else
o = subst_expand (o, value, subst_beg, replace_beg,
subst_len, replace_len, 0, 1);
if (v->recursive)
free (value);
}
}

/* No, this must be an ordinary variable reference. */
else
{
/* Look up the value of the variable. */
end = index (beg, closeparen);
if (end == 0)
return initialize_variable_output ();
v = lookup_variable (beg, end - beg);

if (v != 0 && *v->value != '\0')
{
char *value = (v->recursive ? recursively_expand (v)
: v->value);
o = variable_buffer_output (o, value, strlen (value));
if (v->recursive)
free (value);
}
}

/* Advance p past the variable reference to resume scan. */
p = end;
}
break;

case '\0':
case '\t':
case ' ':
break;

default:
/* A $ followed by a random char is a variable reference:
$a is equivalent to $(a). */
{
/* We could do the expanding here, but this way
avoids code repetition at a small performance cost. */
char name[5];
name[0] = '$';
name[1] = '(';
name[2] = *p;
name[3] = ')';
name[4] = '\0';
p1 = allocated_variable_expand (name);
o = variable_buffer_output (o, p1, strlen (p1));
free (p1);
}

break;
}

if (*p == '\0')
break;
else
++p;
}

(void) variable_buffer_output (o, "", 1);
return initialize_variable_output ();
}

/* Expand an argument for an expansion function.
The text starting at STR and ending at END is variable-expanded
into a null-terminated string that is returned as the value.
This is done without clobbering `variable_buffer' or the current
variable-expansion that is in progress. */

char *
expand_argument (str, end)
char *str, *end;
{
char *tmp = savestring (str, end - str);
char *value = allocated_variable_expand (tmp);

free (tmp);

return value;
}

/* Expand LINE for FILE. Error messages refer to the file and line where
FILE's commands were found. Expansion uses FILE's variable set list. */

char *
variable_expand_for_file (line, file)
char *line;
register struct file *file;
{
char *result;
struct variable_set_list *save;

if (file == 0)
return variable_expand (line);

save = current_variable_set_list;
current_variable_set_list = file->variables;
reading_filename = file->cmds->filename;
reading_lineno_ptr = &file->cmds->lineno;
result = variable_expand (line);
current_variable_set_list = save;
reading_filename = 0;
reading_lineno_ptr = 0;

return result;
}

/* Like variable_expand, but the returned string is malloc'd. */
char *
allocated_variable_expand (line)
char *line;
{
#ifdef MSDOS
return allocated_var_exp_for_file (line, (struct file *) 0);
#else
return allocated_variable_expand_for_file (line, (struct file *) 0);
#endif /* MSDOS */

}

/* Like variable_expand_for_file, but the returned string is malloc'd. */

char *
#ifdef MSDOS
allocated_var_exp_for_file (line, file)
#else
allocated_variable_expand_for_file (line, file)
#endif /* MSDOS */
char *line;
struct file *file;
{
char *save;
char *value;

save = save_variable_output ();

value = variable_expand_for_file (line, file);
value = savestring (value, strlen (value));

restore_variable_output (save);

return value;
}
/* Variable expansion functions for GNU Make.
Copyright (C) 1988, 1989 Free Software Foundation, Inc.
This file is part of GNU Make.

GNU Make is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option)
any later version.

GNU Make is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Make; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */

#include "make.h"
#include "commands.h"
#include "file.h"
#include "variable.h"


/* Recursively expand V. The returned string is malloc'd. */

static char *
recursively_expand (v)
register struct variable *v;
{
char *value;

if (v->expanding)
fatal ("%s:%u: Recursive variable `%s' references itself (eventually)",
reading_filename, *reading_lineno_ptr, v->name);

v->expanding = 1;
value = allocated_variable_expand (v->value);
v->expanding = 0;

return value;
}

/* Scan LINE for variable references and expansion-function calls.
Build in `variable_buffer' the result of expanding the references and calls.
Return the address of the resulting string, which is null-terminated
and is valid only until the next time this function is called. */

char *
variable_expand (line)
register char *line;
{
register struct variable *v;
register char *p, *o, *p1;

p = line;
o = initialize_variable_output ();

while (1)
{
/* Copy all following uninteresting chars all at once to the
variable output buffer, and skip them. Uninteresting chars end
at the next $ or the end of the input. */

p1 = index (p, '$');

o = variable_buffer_output (o, p, p1 != 0 ? p1 - p : strlen (p) + 1);

if (p1 == 0)
break;
p = p1 + 1;

/* Dispatch on the char that follows the $. */

switch (*p)
{
case '$':
/* $$ seen means output one $ to the variable output buffer. */
o = variable_buffer_output (o, p, 1);
break;

case '(':
case '{':
/* $(...) or ${...} is the general case of substitution. */
{
char openparen = *p;
char closeparen = (openparen == '(') ? ')' : '}';
register char *beg = p + 1;
char *op, *begp;
char *end;

op = o;
begp = p;
if (handle_function (&op, &begp))
{
o = op;
p = begp;
break;
}

/* Is there a variable reference inside the parens or braces?
If so, expand it before expanding the entire reference. */

p1 = index (beg, closeparen);
if (p1 != 0)
p1 = lindex (beg, p1, '$');
if (p1 != 0)
{
/* BEG now points past the opening paren or brace.
Count parens or braces until it is matched. */
int count = 0;
for (p = beg; *p != '\0'; ++p)
{
if (*p == openparen)
++count;
else if (*p == closeparen && --count < 0)
break;
}
/* If count is >= 0, there were unmatched opening parens
or braces, so we go to the simple case of a variable name
such as `$($(a)'. */
if (count < 0)
{
char *name = expand_argument (beg, p);
static char start[3] = { '$', }, end[2];
start[1] = openparen;
end[0] = closeparen;
p1 = concat (start, name, end);
free (name);
name = allocated_variable_expand (p1);
o = variable_buffer_output (o, name, strlen (name));
free (name);
break;
}
}

/* This is not a reference to a built-in function and
it does not contain any variable references inside.
There are several things it could be. */

p = index (beg, ':');
if (p != 0 && lindex (beg, p, closeparen) == 0)
{
/* This is a substitution reference: $(FOO:A=B). */
int count;
char *subst_beg, *replace_beg;
unsigned int subst_len, replace_len;

v = lookup_variable (beg, p - beg);

subst_beg = p + 1;
count = 0;
for (p = subst_beg; *p != '\0'; ++p)
{
if (*p == openparen)
++count;
else if (*p == closeparen)
--count;
else if (*p == '=' && count <= 0)
break;
}
if (count > 0)
/* There were unmatched opening parens. */
return initialize_variable_output ();
subst_len = p - subst_beg;

replace_beg = p + 1;
count = 0;
for (p = replace_beg; *p != '\0'; ++p)
{
if (*p == openparen)
++count;
else if (*p == closeparen && --count < 0)
break;
}
if (count > 0)
/* There were unmatched opening parens. */
return initialize_variable_output ();
end = p;
replace_len = p - replace_beg;

if (v != 0 && *v->value != '\0')
{
char *value = (v->recursive ? recursively_expand (v)
: v->value);
if (lindex (subst_beg, subst_beg + subst_len, '%') != 0)
{
p = savestring (subst_beg, subst_len);
p1 = savestring (replace_beg, replace_len);
o = patsubst_expand (o, value, p, p1,
index (p, '%'), index (p1, '%'));
free (p);
free (p1);
}
else
o = subst_expand (o, value, subst_beg, replace_beg,
subst_len, replace_len, 0, 1);
if (v->recursive)
free (value);
}
}

/* No, this must be an ordinary variable reference. */
else
{
/* Look up the value of the variable. */
end = index (beg, closeparen);
if (end == 0)
return initialize_variable_output ();
v = lookup_variable (beg, end - beg);

if (v != 0 && *v->value != '\0')
{
char *value = (v->recursive ? recursively_expand (v)
: v->value);
o = variable_buffer_output (o, value, strlen (value));
if (v->recursive)
free (value);
}
}

/* Advance p past the variable reference to resume scan. */
p = end;
}
break;

case '\0':
case '\t':
case ' ':
break;

default:
/* A $ followed by a random char is a variable reference:
$a is equivalent to $(a). */
{
/* We could do the expanding here, but this way
avoids code repetition at a small performance cost. */
char name[5];
name[0] = '$';
name[1] = '(';
name[2] = *p;
name[3] = ')';
name[4] = '\0';
p1 = allocated_variable_expand (name);
o = variable_buffer_output (o, p1, strlen (p1));
free (p1);
}

break;
}

if (*p == '\0')
break;
else
++p;
}

(void) variable_buffer_output (o, "", 1);
return initialize_variable_output ();
}

/* Expand an argument for an expansion function.
The text starting at STR and ending at END is variable-expanded
into a null-terminated string that is returned as the value.
This is done without clobbering `variable_buffer' or the current
variable-expansion that is in progress. */

char *
expand_argument (str, end)
char *str, *end;
{
char *tmp = savestring (str, end - str);
char *value = allocated_variable_expand (tmp);

free (tmp);

return value;
}

/* Expand LINE for FILE. Error messages refer to the file and line where
FILE's commands were found. Expansion uses FILE's variable set list. */

char *
variable_expand_for_file (line, file)
char *line;
register struct file *file;
{
char *result;
struct variable_set_list *save;

if (file == 0)
return variable_expand (line);

save = current_variable_set_list;
current_variable_set_list = file->variables;
reading_filename = file->cmds->filename;
reading_lineno_ptr = &file->cmds->lineno;
result = variable_expand (line);
current_variable_set_list = save;
reading_filename = 0;
reading_lineno_ptr = 0;

return result;
}

/* Like variable_expand, but the returned string is malloc'd. */
char *
allocated_variable_expand (line)
char *line;
{
return allocated_variable_expand_for_file (line, (struct file *) 0);
}

/* Like variable_expand_for_file, but the returned string is malloc'd. */

char *
allocated_variable_expand_for_file (line, file)
char *line;
struct file *file;
{
char *save;
char *value;

save = save_variable_output ();

value = variable_expand_for_file (line, file);
value = savestring (value, strlen (value));

restore_variable_output (save);

return value;
}


  3 Responses to “Category : C Source Code
Archive   : OHLMAKE.ZIP
Filename : EXPAND.C

  1. Very nice! Thank you for this wonderful archive. I wonder why I found it only now. Long live the BBS file archives!

  2. This is so awesome! 😀 I’d be cool if you could download an entire archive of this at once, though.

  3. But one thing that puzzles me is the “mtswslnkmcjklsdlsbdmMICROSOFT” string. There is an article about it here. It is definitely worth a read: http://www.os2museum.com/wp/mtswslnk/