_named_scopes(named_scopes)

{

_directory = (PPDirectory *)NULL;

_parent_scope = (PPScope *)NULL;

if (p_set_variable(varname, definition)) {

return true;

}

// Check the scopes on the stack for the variable definition.

ScopeStack::reverse_iterator si;

for (si = _scope_stack.rbegin(); si != _scope_stack.rend(); ++si) {

if ((*si)->p_set_variable(varname, definition)) {

return true;

}

}

// If the variable isn't defined, we check the environment.

const char *env = getenv(varname.c_str());

if (env != (const char *)NULL) {

// It is defined in the environment; thus, it is implicitly

// defined here at the global scope: the bottom of the stack.

PPScope *bottom = this;

if (!_scope_stack.empty()) {

bottom = _scope_stack.front();

}

bottom->define_variable(varname, definition);

return true;

}

// The variable isn't defined anywhere. Too bad.

return false;

size_t p = definition.find(VARIABLE_OPEN_NESTED);

if (p != string::npos && definition[definition.length() - 1] == VARIABLE_CLOSE_NESTED) {

size_t q = definition.length() - 1;

string scope_names = definition.substr(p + 1, q - (p + 1));

string key_varname = definition.substr(0, p);

define_map_variable(varname, key_varname, scope_names);

} else {

// No scoping; not really a map variable.

define_map_variable(varname, definition, "");

}

const string &scope_names) {

MapVariableDefinition &def = _map_variables[varname];

def.clear();

define_variable(varname, "");

if (_named_scopes == (PPNamedScopes *)NULL) {

return;

}

if (key_varname.empty()) {

return;

}

vector<string> names;

tokenize_whitespace(scope_names, names);

// Get all of the named scopes.

PPNamedScopes::Scopes scopes;

vector<string>::const_iterator ni;

for (ni = names.begin(); ni != names.end(); ++ni) {

const string &name = (*ni);

_named_scopes->get_scopes(name, scopes);

}

if (scopes.empty()) {

return;

}

// Now go through the scopes and build up the results.

vector<string> results;

PPNamedScopes::Scopes::const_iterator si;

for (si = scopes.begin(); si != scopes.end(); ++si) {

PPScope *scope = (*si);

string key_string = scope->expand_variable(key_varname);

vector<string> keys;

tokenize_whitespace(key_string, keys);

if (!keys.empty()) {

vector<string>::const_iterator ki;

results.insert(results.end(), keys.begin(), keys.end());

for (ki = keys.begin(); ki != keys.end(); ++ki) {

def[*ki] = scope;

}

}

}

// Also define a traditional variable along with the map variable.

define_variable(varname, repaste(results, " "));

PPScope *scope) {

MapVariableDefinition &def = find_map_variable(varname);

if (&def == &_null_map_def) {

cerr << "Warning: undefined map variable: " << varname << "\n";

return;

}

def[key] = scope;

// We need to do all this work to define the traditional expansion.

// Maybe not a great idea.

vector<string> results;

MapVariableDefinition::const_iterator di;

for (di = def.begin(); di != def.end(); ++di) {

results.push_back((*di).first);

}

set_variable(varname, repaste(results, " "));

const vector<string> &formals, const string &actuals) {

vector<string> actual_words;

tokenize_params(actuals, actual_words, true);

if (actual_words.size() < formals.size()) {

cerr << "Warning: not all parameters defined for " << subroutine_name

<< ": " << actuals << "\n";

} else if (actual_words.size() > formals.size()) {

cerr << "Warning: more parameters defined for " << subroutine_name

<< " than actually exist: " << actuals << "\n";

}

for (int i = 0; i < (int)formals.size(); i++) {

if (i < (int)actual_words.size()) {

define_variable(formals[i], actual_words[i]);

} else {

define_variable(formals[i], string());

}

}

// Is it a user-defined function?

const PPSubroutine *sub = PPSubroutine::get_func(varname);

if (sub != (const PPSubroutine *)NULL) {

return expand_function(varname, sub, string());

}

// cerr << "getvar arg is: '" << varname << "'" << endl;

string result;

if (p_get_variable(varname, result)) {

return result;

}

// Check the scopes on the stack for the variable definition.

ScopeStack::reverse_iterator si;

for (si = _scope_stack.rbegin(); si != _scope_stack.rend(); ++si) {

if ((*si)->p_get_variable(varname, result)) {

return result;

}

}

// If the variable isn't defined, we check the environment.

const char *env = getenv(varname.c_str());

if (env != (const char *)NULL) {

return env;

}

// It's not defined anywhere, so it's implicitly empty.

return string();

// Split the string up into tokens based on the commas.

vector<string> tokens;

tokenize_params(params, tokens, true);

if (tokens.size() != 1) {

cerr << "error: defined requires one parameter.\n";

errors_occurred = true;

return string();

}

string varname = tokens[0];

string falsestr;

string truestr = "1";

// Is it a user-defined function?

const PPSubroutine *sub = PPSubroutine::get_func(varname);

string nullstr;

if (sub != (const PPSubroutine *)NULL) {

if(nullstr != expand_function(varname, sub, string())) {

return truestr;

}

}

string result;

if (p_get_variable(varname, result)) {

return truestr;

}

// Check the scopes on the stack for the variable definition.

ScopeStack::reverse_iterator si;

for (si = _scope_stack.rbegin(); si != _scope_stack.rend(); ++si) {

if ((*si)->p_get_variable(varname, result)) {

return truestr;

}

}

// If the variable isn't defined, we check the environment.

const char *env = getenv(varname.c_str());

if (env != (const char *)NULL) {

return truestr;

}

// It's not defined anywhere, so it's implicitly empty.

return falsestr;

string result = r_expand_string(str, (ExpandedVariable *)NULL);

if (debug_expansions > 0 && str != result) {

// Look for the str in our table--how many times has this

// particular string been expanded?

ExpandResultCount &result_count = debug_expand[str];

// Then, how many times has it expanded to this same result?

// First, assuming this is the first time it has expanded to this

// result, try to insert the result string with an initial count

// of 1.

pair<ExpandResultCount::iterator, bool> r =

result_count.insert(ExpandResultCount::value_type(result, 1));

if (!r.second) {

// If the result string was not successfully inserted into the

// map, it was already there--so increment the count.

ExpandResultCount::iterator rci = r.first;

(*rci).second++;

}

}

return result;

// Look for a simple reference to the named variable. A more

// complex reference, like a computed variable name or something

// equally loopy, won't work with this simple test. Too bad.

string reference;

reference += VARIABLE_PREFIX;

reference += VARIABLE_OPEN_BRACE;

reference += varname;

reference += VARIABLE_CLOSE_BRACE;

string result;

size_t p = 0;

size_t q = str.find(reference, p);

while (q != string::npos) {

result += str.substr(p, q - p);

p = q;

result += r_expand_variable(str, p, (ExpandedVariable *)NULL);

q = str.find(reference, p);

}

result += str.substr(p);

return result;

bool expand) {

size_t p = 0;

while (p < str.length()) {

// Skip initial whitespace.

while (p < str.length() && isspace(str[p])) {

p++;

}

string token;

while (p < str.length() && str[p] != FUNCTION_PARAMETER_SEPARATOR) {

if (p + 1 < str.length() && str[p] == VARIABLE_PREFIX &&

str[p + 1] == VARIABLE_OPEN_BRACE) {

// Skip a nested variable reference.

if (expand) {

token += r_expand_variable(str, p, (ExpandedVariable *)NULL);

} else {

token += r_scan_variable(str, p);

}

} else {

token += str[p];

p++;

}

}

// Back up past trailing whitespace.

size_t q = token.length();

while (q > 0 && isspace(token[q - 1])) {

q--;

}

tokens.push_back(token.substr(0, q));

p++;

if (p == str.length()) {

// In this case, we have just read past a trailing comma symbol

// at the end of the string, so we have one more empty token.

tokens.push_back(string());

}

}

vector<string> words;

tokenize_params(str, words, true);

if (words.size() != 2) {

cerr << words.size() << " parameters supplied when two were expected:\n"

<< str << "\n";

errors_occurred = true;

return false;

}

double results[2];

for (int i = 0; i < 2; i++) {

const char *param = words[i].c_str();

char *n;

results[i] = strtod(param, &n);

if (*n != '\0') {

// strtod failed--not a numeric representation.

cerr << "Warning: " << words[i] << " is not a number.\n";

if (n == param) {

results[i] = 0.0;

}

}

}

a = results[0];

b = results[1];

return true;

vector<string> words;

tokenize_params(str, words, true);

vector<string>::const_iterator wi;

for (wi = words.begin(); wi != words.end(); ++wi) {

const char *param = (*wi).c_str();

char *n;

int result = strtol(param, &n, 0);

if (*n != '\0') {

// strtol failed--not an integer.

cerr << "Warning: " << param << " is not an integer.\n";

if (n == param) {

result = 0;

}

}

tokens.push_back(result);

}

return true;

size_t p = start;

while (p < str.length() && !isspace(str[p])) {

string token;

if (p + 1 < str.length() && str[p] == VARIABLE_PREFIX &&

str[p + 1] == VARIABLE_OPEN_BRACE) {

// Skip a nested variable reference.

r_scan_variable(str, p);

} else {

p++;

}

}

return p;

char buffer[32];

sprintf(buffer, "%d", num);

return buffer;

Variables::iterator vi;

vi = _variables.find(varname);

if (vi != _variables.end()) {

(*vi).second = definition;

return true;

}

if (_parent_scope != (PPScope *)NULL) {

return _parent_scope->p_set_variable(varname, definition);

}

return false;

Variables::const_iterator vi;

vi = _variables.find(varname);

if (vi != _variables.end()) {

result = (*vi).second;

return true;

}

if (varname == "RELDIR" &&

_directory != (PPDirectory *)NULL &&

current_output_directory != (PPDirectory *)NULL) {

// $[RELDIR] is a special variable name that evaluates to the

// relative directory of the current scope to the current output

// directory.

result = current_output_directory->get_rel_to(_directory);

return true;

}

if (varname == "DEPENDS_INDEX" &&

_directory != (PPDirectory *)NULL) {

// $[DEPENDS_INDEX] is another special variable name that

// evaluates to the numeric sorting index assigned to this

// directory based on its dependency relationship with other

// directories. It's useful primarily for debugging.

char buffer[32];

sprintf(buffer, "%d", _directory->get_depends_index());

result = buffer;

return true;

}

if (_parent_scope != (PPScope *)NULL) {

return _parent_scope->p_get_variable(varname, result);

}

return false;

string result;

// Search for a variable reference.

size_t p = 0;

while (p < str.length()) {

if (p + 1 < str.length() && str[p] == VARIABLE_PREFIX &&

str[p + 1] == VARIABLE_OPEN_BRACE) {

// Here's a nested variable! Expand it fully.

result += r_expand_variable(str, p, expanded);

} else {

result += str[p];

p++;

}

}

return result;

// Search for the end of the variable name: an unmatched square

// bracket.

size_t start = vp;

size_t p = vp + 2;

while (p < str.length() && str[p] != VARIABLE_CLOSE_BRACE) {

if (p + 1 < str.length() && str[p] == VARIABLE_PREFIX &&

str[p + 1] == VARIABLE_OPEN_BRACE) {

// Here's a nested variable! Scan past it, matching braces

// properly.

r_scan_variable(str, p);

} else {

p++;

}

}

if (p < str.length()) {

assert(str[p] == VARIABLE_CLOSE_BRACE);

p++;

} else {

cerr << "Warning! Unclosed variable reference:\n"

<< str.substr(vp) << "\n";

}

vp = p;

return str.substr(start, vp - start);

PPScope::ExpandedVariable *expanded) {

string varname;

size_t whitespace_at = 0;

size_t open_nested_at = 0;

// Search for the end of the variable name: an unmatched square

// bracket.

size_t p = vp + 2;

while (p < str.length() && str[p] != VARIABLE_CLOSE_BRACE) {

if (p + 1 < str.length() && str[p] == VARIABLE_PREFIX &&

str[p + 1] == VARIABLE_OPEN_BRACE) {

if (whitespace_at != 0) {

// Once we have encountered whitespace, we don't expand

// variables inline anymore. These are now function

// parameters, and might need to be expanded in some other

// scope.

varname += r_scan_variable(str, p);

} else {

varname += r_expand_variable(str, p, expanded);

}

} else {

if (open_nested_at == 0 && str[p] == VARIABLE_OPEN_NESTED) {

open_nested_at = p - (vp + 2);

}

if (open_nested_at == 0 && whitespace_at == 0 && isspace(str[p])) {

whitespace_at = p - (vp + 2);

}

varname += str[p];

p++;

}

}

if (p < str.length()) {

assert(str[p] == VARIABLE_CLOSE_BRACE);

p++;

} else {

cerr << "Warning! Unclosed variable reference:\n"

<< str.substr(vp) << "\n";

}

vp = p;

// Check for a function expansion.

if (whitespace_at != 0) {

string funcname = varname.substr(0, whitespace_at);

p = whitespace_at;

while (p < varname.length() && isspace(varname[p])) {

p++;

}

string params = varname.substr(p);

// Is it a user-defined function?

const PPSubroutine *sub = PPSubroutine::get_func(funcname);

if (sub != (const PPSubroutine *)NULL) {