_native_scope = scope;

_scope = scope;

_got_command = false;

_in_for = false;

_if_nesting = (IfNesting *)NULL;

_block_nesting = (BlockNesting *)NULL;

_write_state = new WriteState;

filename.set_text();

ifstream in;

if (!filename.open_read(in)) {

cerr << "Unable to open " << filename << ".\n";

errors_occurred = true;

return false;

}

if (verbose) {

cerr << "Reading (cmd) \"" << filename << "\"\n";

}

return read_stream(in, filename);

PushFilename pushed(_scope, filename);

if (!read_stream(in)) {

if (!in.eof()) {

cerr << "Error reading " << filename << ".\n";

errors_occurred = true;

}

return false;

}

return true;

string line;

getline(in, line);

begin_read();

while (!in.fail() && !in.eof()) {

if (!read_line(line)) {

return false;

}

getline(in, line);

}

if (!end_read()) {

return false;

}

return true;

// First things first: strip off any comment in the line.

// We only recognize comments that are proceeded by whitespace, or

// that start at the beginning of the line.

size_t comment = line.find(begin_comment);

while (comment != string::npos &&

!(comment == 0 || isspace(line[comment - 1]))) {

comment = line.find(begin_comment, comment + begin_comment.length());

}

if (comment != string::npos) {

// Also strip any whitespace leading up to the comment.

while (comment > 0 && isspace(line[comment - 1])) {

comment--;

}

line = line.substr(0, comment);

}

// If the comment was at the beginning of the line, ignore the whole

// line, including its whitespace.

if (comment != 0) {

// We also strip off whitespace at the end of the line, since this

// is generally invisible and almost always just leads to trouble.

size_t eol = line.length();

while (eol > 0 && (isspace(line[eol - 1]) || line[eol - 1] == '\r')) {

eol--;

}

line = line.substr(0, eol);

if (_in_for) {

// Save up the lines for later execution if we're within a #forscopes.

_saved_lines.push_back(line);

}

if (_got_command) {

return handle_command(line);

} else {

// Find the beginning of the line--skip initial whitespace.

size_t p = 0;

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

p++;

}

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

// The line is empty. Make it truly empty.

line = "";

} else {

if (((p+1) < line.length()) && (line[p] == COMMAND_PREFIX) &&

isalpha(line[p + 1])) {

// This is a special command.

return handle_command(line.substr(p + 1));

}

}

if (!_in_for && !failed_if()) {

if (line.length() > p + 1 && line[p + 1] == COMMAND_PREFIX) {

// double prefix at start of line indicates echo single prefix, like '\\' in C

line.erase(0, 1);

}

return _write_state->write_line(_scope->expand_string(line));

}

}

}

return true;

bool okflag = true;

if (_if_nesting != (IfNesting *)NULL) {

cerr << "Unclosed if\n";

errors_occurred = true;

_if_nesting = (IfNesting *)NULL;

okflag = false;

}

if (_block_nesting != (BlockNesting *)NULL) {

switch (_block_nesting->_state) {

case BS_begin:

cerr << "Unclosed begin " << _block_nesting->_name << "\n";

errors_occurred = true;

break;

case BS_while:

case BS_nested_while:

cerr << "Unclosed while " << _block_nesting->_name << "\n";

errors_occurred = true;

break;

case BS_forscopes:

case BS_nested_forscopes:

cerr << "Unclosed forscopes " << _block_nesting->_name << "\n";

errors_occurred = true;

break;

case BS_foreach:

case BS_nested_foreach:

cerr << "Unclosed foreach " << _block_nesting->_name << "\n";

errors_occurred = true;

break;

case BS_formap:

case BS_nested_formap:

cerr << "Unclosed formap " << _block_nesting->_name << "\n";

errors_occurred = true;

break;

case BS_defsub:

cerr << "Unclosed defsub " << _block_nesting->_name << "\n";

errors_occurred = true;

break;

case BS_defun:

cerr << "Unclosed defun " << _block_nesting->_name << "\n";

errors_occurred = true;

break;

case BS_output:

cerr << "Unclosed output " << _block_nesting->_name << "\n";

errors_occurred = true;

break;

}

_block_nesting = (BlockNesting *)NULL;

okflag = false;

}

return okflag;

if (_got_command) {

// If we were still processing a command from last time, keep

// going; this line is just a continuation. But skip any initial

// whitespace.

size_t p = 0;

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

p++;

}

_params += ' ';

_params += line.substr(p);

} else {

// This is the first line of a new command.

// Pull off the first word and the rest of the line.

size_t p = 0;

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

p++;

}

_command = line.substr(0, p);

// Skip whitespace between the command and its arguments.

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

p++;

}

_params = line.substr(p);

}

if (!_params.empty() && _params[_params.length() - 1] == '\\') {

// If the line ends with a backslash, there's more to come before

// we can process the command.

_got_command = true;

// Truncate off the backslash, and any whitespace before it.

size_t p = _params.length() - 1;

while (p > 0 && isspace(_params[p - 1])) {

p--;

}

_params = _params.substr(0, p);

return true;

}

// We're completely done scanning the command now.

_got_command = false;

if (_command == "if") {

return handle_if_command();

} else if (_command == "elif") {

return handle_elif_command();

} else if (_command == "else") {

return handle_else_command();

} else if (_command == "endif") {

return handle_endif_command();

} else if (failed_if()) {

// If we're in the middle of a failed #if, we ignore all commands

// except for the if-related commands, above.

return true;

} else if (_command == "begin") {

return handle_begin_command();

} else if (_command == "while") {

return handle_while_command();

} else if (_command == "for") {

return handle_for_command();

} else if (_command == "forscopes") {

return handle_forscopes_command();

} else if (_command == "foreach") {

return handle_foreach_command();

} else if (_command == "formap") {

return handle_formap_command();

} else if (_command == "defsub") {

return handle_defsub_command(true);

} else if (_command == "defun") {

return handle_defsub_command(false);

} else if (_command == "output") {

return handle_output_command();

} else if (_command == "end") {

return handle_end_command();

} else if (_in_for) {

// If we're currently saving up lines within a block sequence, we

// ignore all commands except for the block-related commands,

// above.

return true;

} else if (_command == "format") {

return handle_format_command();

} else if (_command == "print") {

return handle_print_command();

} else if (_command == "printvar") {

return handle_printvar_command();

} else if (_command == "include") {

return handle_include_command();

} else if (_command == "sinclude") {

return handle_sinclude_command();

} else if (_command == "copy") {

return handle_copy_command();

} else if (_command == "call") {

return handle_call_command();

} else if (_command == "error") {

return handle_error_command();

} else if (_command == "mkdir") {

return handle_mkdir_command();

} else if (_command == "defer") {

return handle_defer_command();

} else if (_command == "define") {

return handle_define_command();

} else if (_command == "set") {

return handle_set_command();

} else if (_command == "map") {

return handle_map_command();

} else if (_command == "addmap") {

return handle_addmap_command();

} else if (_command == "push") {

return handle_push_command();

}

cerr << "Invalid command: " << COMMAND_PREFIX << _command << "\n";

errors_occurred = true;

return false;

if (failed_if()) {

// If we're *already* inside a failed if, we don't have to

// evaluate this one, but we do need to record the nesting level.

IfNesting *nest = new IfNesting(IS_done);

nest->push(this);

} else {

// If the parameter string evaluates to empty, the case is false.

// Otherwise the case is true. However, if we're currently

// scanning #forscopes or something, we don't evaluate this at

// all, because it doesn't matter.

bool is_empty = true;

if (!_in_for) {

_params = _scope->expand_string(_params);

string::const_iterator si;

for (si = _params.begin(); si != _params.end() && is_empty; ++si) {

is_empty = isspace(*si);

}

}

IfState state = is_empty ? IS_off : IS_on;

IfNesting *nest = new IfNesting(state);

nest->push(this);

}

return true;

if (_if_nesting == (IfNesting *)NULL) {

cerr << "elif encountered without if.\n";

errors_occurred = true;

return false;

}

if (_if_nesting->_state == IS_else) {

cerr << "elif encountered after else.\n";

errors_occurred = true;

return false;

}

if (_if_nesting->_state == IS_on || _if_nesting->_state == IS_done) {

// If we passed the #if above, we don't need to evaluate the #elif.

_if_nesting->_state = IS_done;

return true;

}

// If the parameter string evaluates to empty, the case is false.

// Otherwise the case is true.

bool is_empty = true;

if (!_in_for) {

_params = _scope->expand_string(_params);

string::const_iterator si;

for (si = _params.begin(); si != _params.end() && is_empty; ++si) {

is_empty = isspace(*si);

}

}

_if_nesting->_state = is_empty ? IS_off : IS_on;

return true;

if (_if_nesting == (IfNesting *)NULL) {

cerr << "else encountered without if.\n";

errors_occurred = true;

return false;

}

if (_if_nesting->_state == IS_else) {

cerr << "else encountered after else.\n";

errors_occurred = true;

return false;

}

if (_if_nesting->_state == IS_on || _if_nesting->_state == IS_done) {

_if_nesting->_state = IS_done;

return true;

}

_if_nesting->_state = IS_else;

return true;

if (_if_nesting == (IfNesting *)NULL) {

cerr << "endif encountered without if.\n";

errors_occurred = true;

return false;

}

IfNesting *nest = _if_nesting;

nest->pop(this);

if (nest->_block != _block_nesting) {

if (nest->_block != (BlockNesting *)NULL) {

cerr << "If block not closed within scoping block " << nest->_block->_name << ".\n";

errors_occurred = true;

} else {

cerr << "If block not closed within scoping block " << _block_nesting->_name << ".\n";

errors_occurred = true;

}

return false;

}

delete nest;

return true;

string name = trim_blanks(_params);

BlockNesting *nest = new BlockNesting(BS_begin, name);

if (contains_whitespace(name)) {

cerr << "Attempt to define scope named \"" << name

<< "\".\nScope names may not contain whitespace.\n";

errors_occurred = true;

return false;

}

if (name.find(SCOPE_DIRNAME_SEPARATOR) != string::npos) {

cerr << "Attempt to define scope named \"" << name

<< "\".\nScope names may not contain the '"

<< SCOPE_DIRNAME_SEPARATOR << "' character.\n";

errors_occurred = true;

return false;

}

nest->push(this);

PPScope *named_scope = _scope->get_named_scopes()->make_scope(name);

named_scope->set_parent(_scope);

_scope = named_scope;

return true;

BlockState state = _in_for ? BS_nested_while : BS_while;

string name = trim_blanks(_params);

BlockNesting *nest = new BlockNesting(state, name);

nest->push(this);

if (!_in_for) {

_in_for = true;

_saved_lines.clear();

}

return true;

// We get the name of the variable out first.

size_t p = _scope->scan_to_whitespace(_params);

string name = _params.substr(0, p);

if (name.empty()) {

cerr << "#for without varname\n";

errors_occurred = true;

return false;

}

// The rest is the comma-delimited range of values.

vector<string> words;

_scope->tokenize_params(_params.substr(p), words, true);

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

cerr << "Invalid numeric range: '" << _params.substr(p)

<< "' for #for " << name << "\n";

errors_occurred = true;

return false;

}

BlockState state = _in_for ? BS_nested_for : BS_for;

BlockNesting *nest = new BlockNesting(state, name);

nest->push(this);

if (!_in_for) {

_in_for = true;

_saved_lines.clear();

nest->_words.swap(words);

}

return true;

BlockState state = _in_for ? BS_nested_forscopes : BS_forscopes;

string name = trim_blanks(_params);

BlockNesting *nest = new BlockNesting(state, name);

nest->push(this);

if (!_in_for) {

_in_for = true;

_saved_lines.clear();

}

return true;

// Get the parameters of the foreach command. The first word is the

// name of the variable to substitute in (and which should appear on

// the matching #end command), and the remaining words are the

// values to substitute in.

vector<string> words;

tokenize_whitespace(_scope->expand_string(_params), words);

if (words.empty()) {

cerr << "#foreach requires at least one parameter.\n";

errors_occurred = true;

return false;

}

string variable_name = words.front();

BlockState state = _in_for ? BS_nested_foreach : BS_foreach;

BlockNesting *nest = new BlockNesting(state, variable_name);

nest->push(this);

// We insert in all but the first word in the words vector.

nest->_words.insert(nest->_words.end(), words.begin() + 1, words.end());

if (!_in_for) {