/* Copyright 2015.  Los Alamos National Security, LLC. This material was produced
 * under U.S. Government contract DE-AC52-06NA25396 for Los Alamos National 
 * Laboratory (LANL), which is operated by Los Alamos National Security, LLC
 * for the U.S. Department of Energy. The U.S. Government has rights to use,
 * reproduce, and distribute this software.  NEITHER THE GOVERNMENT NOR LOS
 * ALAMOS NATIONAL SECURITY, LLC MAKES ANY WARRANTY, EXPRESS OR IMPLIED, OR
 * ASSUMES ANY LIABILITY FOR THE USE OF THIS SOFTWARE.  If software is modified
 * to produce derivative works, such modified software should be clearly marked,
 * so as not to confuse it with the version available from LANL.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy
 * of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed
 * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
 * CONDITIONS OF ANY KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations under the License.
 *
 * Under this license, it is required to include a reference to this work. We
 * request that each derivative work contain a reference to LANL Copyright
 * Disclosure C15076/LA-CC-15-054 so that this work's impact can be roughly
 * measured.
 *
 * This is LANL Copyright Disclosure C15076/LA-CC-15-054
 */

/*
 *  PowerParser is a general purpose input file parser for software applications.
 *
 *  Authors: Chuck Wingate   XCP-2   caw@lanl.gov
 *           Robert Robey    XCP-2   brobey@lanl.gov
 */

// ***************************************************************************
// ***************************************************************************
// This class holds command lines broken up into words.
// The term command is used in a general sense, it includes variable
// assignments, do loops, usual commands, etc.
// ***************************************************************************
// ***************************************************************************
#include <iostream>
#include <iomanip>
#include <fstream>
#include <string>
#include <vector>
#include <deque>
#include <sstream>
#include <map>
#include <algorithm>
#include <math.h>
#include <assert.h>

#include "Parser_utils.hh"
#include "Variable.hh"
#include "Function.hh"
#include "Word.hh"
#include "Parser_math.hh"
#include "Cmd.hh"

namespace PP
{
using std::cout;
using std::endl;
using std::string;
using std::deque;
using std::vector;
using std::stringstream;
using std::pair;
using std::ifstream;
using std::ios;
using std::setw;

// index base, generally 1 for Fortran style and 0 for C/C++, default 1
static int index_base = 1;
static bool case_sensitive = false;

// ===========================================================================
// Default constructor.
// ===========================================================================
Cmd::Cmd() 
{
    init();
}


// ===========================================================================
// Constructor including map of variables.
// ===========================================================================
Cmd::Cmd(string s, map<string, Variable> *v, map<string, Function> *f,
         deque<string> *lstr, int lnum, int file_lnum, string fname,
         stringstream &serr, int &ierr)
{
    init();
    vmap = v;
    fmap = f;
    original_str = s;
    line_number = lnum;
    file_line_number = file_lnum;
    filename = fname;
    lines = lstr;
    process_string(s, serr, ierr);
}


// ===========================================================================
// Add a word to this cmd.
// ===========================================================================
void Cmd::add_word(string str, int lnum, int file_lnum, string fname)
{
    Word w(str, lnum, file_lnum, fname, lines);
    words.push_back(w);
}


// ===========================================================================
// Erase a word from this cmd.
// ===========================================================================
void Cmd::erase_word(int iw)
{
    words.erase(words.begin()+iw);
}
void Cmd::erase_last_word()
{
    words.erase(words.begin()+(int)words.size()-1);
}


// ===========================================================================
// Remove words that are commas.
// ===========================================================================
void Cmd::remove_commas()
{
    for (int i=0; i<(int)words.size(); i++) {
        if (words[i].is_comma()) {
            words.erase(words.begin()+i);
            i -= 1;
        }
    }
}


// ===========================================================================
// Initialize various private data.
// ===========================================================================
void Cmd::init()
{
    original_str = "";
    //processed = false;
    white_space = " \t";
    delims = " \t()[],*/+-=!#";
    vmap = NULL;
    fmap = NULL;
    line_number = 0;
    file_line_number = 0;
    filename = "";
}


// ===========================================================================
// Set index base for input file indexing. 1 -- Fortran like, 0 -- Other
//   languages
// ===========================================================================
void Cmd::set_index_base(int base)
{
    //cout << "Info:: Setting index base to " << base << endl;
    index_base = base;
}

// ===========================================================================
// Set case sensitivity for input file commands.
// ===========================================================================
void Cmd::set_case_sensitive(bool case_sensitive_in)
{
    case_sensitive = case_sensitive_in;
}

// ===========================================================================
// Process a string.
// Break the string into words and copy each word to a double ended queue.
// ===========================================================================
void Cmd::process_string(string in_str, stringstream &serr, int &ierr)
{
    //cout << "&&&&& Original line = " << endl;
    //cout << in_str << endl;
    //cout << "01234567890123456789012345678901234567890123456789" << endl;
    //cout << "0         1         2         3         4         " << endl;

    string s;
    int istart = 0;
    bool found = false;
    //int plevel = 0;
    for (;;) {
        delims = " \t()[],*/+-=!#";

        // Extract the next word from the line.
        found = extract_next_word(istart, in_str, s, serr, ierr);
        if (!found) break;

        // Create a new word using the word that was found.
        // This removes quotes if there are any and types the word.
        Word w(s, line_number, file_line_number, filename, lines);

        // Copy the word to the end of the queue.
        words.push_back(w);
    }

    // Set the command name and type.
    reset_name_type();
}


// ===========================================================================
// Given a string, str, and a starting position in
// that string, istart, extract the next word and
// pass it back as a string.
// ===========================================================================
bool Cmd::extract_next_word(int &istart, string &str, string &word,
                            stringstream &serr, int &ierr)
{
    // To suppress compiler warnings of unused parameters
    //assert(serr == serr);
    assert(ierr == ierr);

    // If istart is out of bounds then there is nothing to do.
    if (istart < 0) return false;
    if (istart >= (int)str.size()) return false;

    // Find the next non blank character.
    int i1 = str.find_first_not_of(white_space, istart);

    // If a non whitespace character was not found then there are no more
    // words to extract.
    if (i1 == (int)string::npos) return false;

    // If the non blank character that was found is a delimiter, like
    // ()[]+-/* ... then it needs to be a word by itself.
    if (delims.find(str[i1], 0) != string::npos) {
        word = str[i1];
        istart = i1+1;
        return true;
    }

    // At this point we have found the start of a word. The end of the
    // word will be one of the delimiters like ()[]+=-*/spacetab ...
    string wend = delims;

    // A word delimited by quotes is handled differently. If the i1
    // position in the string is a beginning quotes then we need to search
    // for an ending quotes. Anything between quotes is part of the word
    // including delimters.
    bool quotes = false;
    if (str[i1] == '"') {
        quotes = true;
        wend = "\"";
    }
    if (str[i1] == '\'') {
        quotes = true;
        wend = "\'";
    }

    // Search for the end of the word by finding the next delimiter. The
    // delimiter is one index past the end of the word.
    // But if the next delimiter is + or - then we have to consider that
    // this could be a floating point number in which case we continue
    // past the + or - to find the next delimiter.
    int i2;
    int i1_start = i1+1;
    for(;;) {
        i2 = str.find_first_of(wend, i1_start);

        // If a delimiter was not found then the word extends to the end
        // of the line.
        if (i2 == (int)string::npos) {
            i2 = str.size();
            break;
        }
        else {
            // Check for a floating point number (fpn). For example
            //       1.34e+14  or -3.8E-19
            // i2 might point to the + or - in e+14 or E-19, so we check
            // for that case. Note that if the + or - is not found, then it
            // could be a number like 1.e14 but then i2 would point to
            // something after e14 and we would be ok.
            // If we do find +e or -e, then everything in front of it needs
            // to be a digit, if not then this is not a number.
            bool fpn = false;
            if (str[i2] == '+' || str[i2] == '-') {
                if (str[i2-1] == 'e' || str[i2-1] == 'E' ||
                    str[i2-1] == 'd' || str[i2-1] == 'D') {
                    fpn = true;
                    for (int j=i1; j<=i2-2; j++) {
                        if (!isdigit(str[j]) && str[j] != '.') {
                            fpn = false;
                            break;
                        }
                    }
                }
            }

            if (!fpn) break;
            i1_start = i2+1;
        }
    }

    // If the word is quoted then it should end in quotes.
    // We do not check for quotes matching here because at this
    // point we might be in a comment region where quotes mismatch
    // is allowed. We check for quotes mismatch later.
    if (quotes) {
        if (i2 >= (int)str.size()) i2 = (int)str.size() - 1;
    }
    /*
    if (quotes) {
        bool missing = false;
        if (i2 >= (int)str.size()) missing = true;
        else if (str[i1] == '\"' && str[i2] != '\"') missing = true;
        else if (str[i1] == '\'' && str[i2] != '\'') missing = true;
        else if (str[i1] == '\"' && str[i2] == '\'') missing = true;
        else if (str[i1] == '\'' && str[i2] == '\"') missing = true;
        if (missing) {
            fatal_error2(serr, ierr);
            serr << "Quotes mismatch found." << endl;
            serr << "A starting quotes must have a closing quotes." << endl;
            serr << "Double quotes, \", must be matched with double quotes." << endl;
            serr << "Single quotes, \', must be matched with single quotes." << endl;
            ierr = 2;
            return false;
        }
    }
    */

    // We include the quotes symbols in the word. The quote symbols will
    // be removed elsewhere.
    if (quotes) i2 += 1;

    // The word is now delimited by i1 and i2-1, return it in word.
    word = str.substr(i1, i2 - i1);

    // Update the starting point for finding the next word.
    istart = i2;

    // A word was successfully found so return true.
    return true;
}


// ===========================================================================
// Reset the command name and type. Consider the following command:
//      * lasdkj */ cmd = 5.0
// The original command name is "*", but after the multi-line comment is
// removed, the command name should be "cmd".
// ===========================================================================
void Cmd::reset_name_type()
{
    if ((int)words.size() == 0) {
        cmd_name = " ";
        cmd_type = " ";
        return;
    }
    cmd_name = words[0].get_string();
    if (! case_sensitive) {
       transform(cmd_name.begin(), cmd_name.end(), cmd_name.begin(), tolower);
    }
    cmd_type = "command";
    if (words[0].is_variable()) cmd_type = "assignment";
    if (cmd_name == "parser_list_variables") cmd_type = "debug";
    if (cmd_name == "parser_list_functions") cmd_type = "debug";
    if (cmd_name == "parser_print_fbuffer")  cmd_type = "debug";
    if (cmd_name == "if")      cmd_type = "internal_cmd";
    if (cmd_name == "elseif")  cmd_type = "internal_cmd";
    if (cmd_name == "endif")   cmd_type = "internal_cmd";
    if (cmd_name == "do")      cmd_type = "internal_cmd";
    if (cmd_name == "return")  cmd_type = "internal_cmd";
    if (cmd_name == "enddo")   cmd_type = "internal_cmd";
    if (cmd_name == "stop")    cmd_type = "internal_cmd";
    if (cmd_name == "when")    cmd_type = "internal_cmd";
    if (cmd_name == "endwhen") cmd_type = "internal_cmd";
}


// ===========================================================================
// Given a line like
//    include filename1 filename2 filename3 ...
// Find the first filename that exists and return that.
// This should only be called on the io processor.
// ===========================================================================
string Cmd::get_cmd_filename(stringstream &ssfiles)
{
    for (int i=1; i<(int)words.size(); i++) {
        string fn = words[i].get_string();

        // The quotes may still be on the word, strip them off if they are
        // present.
        int len = (int)fn.size();
        if ((fn[len-1] == '\"') || (fn[len-1] == '\'')) {
            fn.erase(fn.end() - 1);
        }
        if ((fn[0] == '\"') || (fn[0] == '\'')) {
            fn.erase(fn.begin());
        }

        ssfiles << "    " << fn << endl;

        // Open the file to test if it exists.
        ifstream instm(fn.c_str(), ios::in);
        instm.close();
        if( instm.fail() ) continue;
        return fn;
    }
    return "";
}


// ===========================================================================
// Handle unary minus in a command line (not in math(..))
// ===========================================================================
void Cmd::handle_cmd_unary_minus(stringstream &serr, int &ierr)
{
    int ipstart = 0;
    for (;;) {
        int ip = find(ipstart, (int)words.size()-1, "-");

        // If we do not find any more minus signs then we are done.
        if (ip == -1) return;

        // The word after the minus sign must be a number.
        if (!words[ip+1].is_number()) {
            words[ip+1].fatal_error(serr, ierr);
            serr << "Expected the object following the unary - to"
                " be a number." << endl;
            serr << "Instead, it was " << words[ip+1].get_string() << endl;
            ierr = 2;
            return;
        }

        // Actually do the negate operation.
        do_unary_op(ip, "-");
        ipstart = ip+1;
        continue;
    }
}
         

// ===========================================================================
// Handle unary plus in a command line (not in math(..))
// ===========================================================================
void Cmd::handle_cmd_unary_plus(stringstream &serr, int &ierr)
{
    int ipstart = 0;
    for (;;) {
        int ip = find(ipstart, (int)words.size()-1, "+");

        // If we do not find any more minus signs then we are done.
        if (ip == -1) return;

        // The word after the plus sign must be a number.
        if (!words[ip+1].is_number()) {
            words[ip+1].fatal_error(serr, ierr);
            serr << "Expected the object following the unary + to"
                " be a number." << endl;
            serr << "Instead, it was " << words[ip+1].get_string() << endl;
            ierr = 2;
            return;
        }

        // The + sign is not needed.
        delete_words(ip, ip);
        ipstart = ip+1;
        continue;
    }
}
         

// ===========================================================================
// The following type of command is allowed:
//      a(1) = 15*3.0
// meaning that 3.0 is to be replicated 15 times and thus a(1)-a(15) is set
// by this command.
// ===========================================================================
void Cmd::handle_cmd_multiplicity(stringstream &serr, int &ierr)
{
    int ipstart = 0;
    for (;;) {
        int ip = find(ipstart, (int)words.size()-1, "*");

        // If we do not find any more asterisks then we are done.
        if (ip == -1) return;

        if (ip==0) {
            fatal_error2(serr, ierr);
            serr << "Asterisk cannot be at the start of a line." << endl;
            ierr = 2;
            return;
        }

        if (ip == (int)words.size()-1) {
            words[ip].fatal_error(serr, ierr);
            serr << "Asterisk cannot be at the end of a line." << endl;
            ierr = 2;
            return;
        }

        // The word after the asterisk must be a number or a boolean.
        // Wait, why is this? We actually allow strings also, really
        // we allow anything.
        //if (!words[ip+1].is_number() && !words[ip+1].is_bool()) {
        //    words[ip+1].fatal_error(serr, ierr);
        //    serr << "Expected the object following the * to"
        //        " be a number or a logical." << endl;
        //    serr << "Instead, it was " << words[ip+1].get_string() << endl;
        //    ierr = 2;
        //    return;
        //}

        // The word before the asterisk must be a number.
        if (!words[ip-1].is_number()) {
            words[ip-1].fatal_error(serr, ierr);
            serr << "Expected the object before the * to"
                " be a number." << endl;
            serr << "Instead, it was " << words[ip-1].get_string() << endl;
            ierr = 2;
            return;
        }

        // Set the multiplicity.
        int imult = words[ip-1].get_int(serr, ierr);
        words[ip+1].set_multiplicity(imult);
        Word w = words[ip+1];
        replace_words(ip-1, ip+1, w);
        ipstart = ip;
    }
}
         

// ***************************************************************************
// ***************************************************************************
// Functions for getting values from the commands.
// ***************************************************************************
// ***************************************************************************

// ===========================================================================
// Get boolean values. This gets all the words past the = sign,
// converts them to bool (and then to int), and puts them in the output arrays.
//
// The expected commands are:
//    cmdname = .true.                    0d
//    cmdname(5) = false true false       1d
//    cmdname(5,9) = true false true      2d
//    etc.
//
// We also allow
//    cmdname = false true false
// and we will supply the starting indices of (1) or (1,1), etc.
//
// But note that the , is gone at this point, so the 2d command is
//    cmdname ( 5 9 ) = true false true      2d
//
// This function works for any dimension, 0,1,2,3,...
//
// We pass the result back as an int because of the incompatibility between
// fortran logical and c++ bool.
// ===========================================================================
void Cmd::get_bool_int(string &cname, int *array_vals, const vector<int> &size,
                       vector<Cmd *> &dup_cmd1, vector<int> &dup_wdex1,
                       int dup_fatal, vector<int> &dup_vals,
                       bool skip, stringstream &serr, int &ierr)
{
    // Get the dimension of the array, 0,1,2,3,...
    int dim = (int)size.size();

    // Check syntax, for example an equals sign must be present, and set istart.
    // istart   Position in array_vals where we start filling it.
    //          Note that istart starts from index base (default 1, Fortran style)
    //          Use set_index_base_zero for C/C++ index convention
    vector<int> istart(dim,0);
    if (!check_syntax(istart, serr, ierr)) return;

    // If skipping, we don't need to get array values.
    if (skip) {
        set_processed(true);
        return;
    }

    // Get the number of values past the = sign.
    // Also mark the words up to and including the = sign as processed.
    int nvals = 0;
    if (!get_nvals(istart, size, nvals, serr, ierr)) return;

    // 0d is a special case.
    if (dim == 0) {
        bool b = words[2].get_bool(serr, ierr);
        int cvalue = 0;
        if (b) cvalue = 1;
        *array_vals = cvalue;
        return;
    }

    // Get the values and return.
    //int ieqp1 = 5 + dim - 1;
    int ieqp1 = find_equals() + 1;
    Parser_utils putils(index_base);
    int k = putils.start_dex(istart, size);
    for (int i=ieqp1; i<(int)words.size(); i++) {
        bool b = words[i].get_bool(serr, ierr);
        int cvalue = 0;
        if (b) cvalue = 1;
        int imult = words[i].get_multiplicity();
        for (int j=1; j<=imult; j++) {
            error_dup_line(cname, i, k, dup_wdex1, dup_cmd1, dup_vals, 
                           size, dup_fatal, serr, ierr);
            array_vals[k++] = cvalue;
        }
    }
}

// ===========================================================================
// Get boolean values. This gets all the words past the = sign,
// converts them to bool and puts them in the output arrays.
//
// The expected commands are:
//    cmdname = .true.                    0d
//    cmdname(5) = false true false       1d
//    cmdname(5,9) = true false true      2d
//    etc.
//
// We also allow
//    cmdname = false true false
// and we will supply the starting indices of (1) or (1,1), etc.
//
// But note that the , is gone at this point, so the 2d command is
//    cmdname ( 5 9 ) = true false true      2d
//
// This function works for any dimension, 0,1,2,3,...
// ===========================================================================
void Cmd::get_bool(string &cname, bool *array_vals, const vector<int> &size,
                   vector<Cmd *> &dup_cmd1, vector<int> &dup_wdex1,
                   int dup_fatal, vector<int> &dup_vals,
                   bool skip, stringstream &serr, int &ierr)
{
    // Get the dimension of the array, 0,1,2,3,...
    int dim = (int)size.size();

    // Check syntax, for example an equals sign must be present, and set istart.
    // istart   Position in array_vals where we start filling it.
    //          Note that istart starts from index base (default 1, Fortran style)
    //          Use set_index_base_zero for C/C++ index convention
    vector<int> istart(dim,0);
    if (!check_syntax(istart, serr, ierr)) return;

    // If skipping, we don't need to get array values.
    if (skip) {
        set_processed(true);
        return;
    }

    // Get the number of values past the = sign.
    // Also mark the words up to and including the = sign as processed.
    int nvals = 0;
    if (!get_nvals(istart, size, nvals, serr, ierr)) return;

    // 0d is a special case.
    if (dim == 0) {
        bool b = words[2].get_bool(serr, ierr);
        *array_vals = b;
        return;
    }

    // Get the values and return.
    //int ieqp1 = 5 + dim - 1;
    int ieqp1 = find_equals() + 1;
    Parser_utils putils(index_base);
    int k = putils.start_dex(istart, size);
    for (int i=ieqp1; i<(int)words.size(); i++) {
        bool b = words[i].get_bool(serr, ierr);
        int imult = words[i].get_multiplicity();
        for (int j=1; j<=imult; j++) {
            error_dup_line(cname, i, k, dup_wdex1, dup_cmd1, dup_vals, 
                           size, dup_fatal, serr, ierr);
            array_vals[k++] = b;
        }
    }
}


// ===========================================================================
// Get integer values. This gets all the words past the = sign,
// converts them to int, and puts them in the output arrays.
//
// The expected commands are:
//    cmdname = some_int                  0d
//    cmdname(5) = 3, 5, -15, 10          1d
//    cmdname(5,9) = 3, 7, -20, 154       2d
//    etc.
//
// We also allow
//    cmdname = 3, 5, -15, 10
// and we will supply the starting indices of (1) or (1,1), etc.
//
// But note that the , is gone at this point, so the 2d command is
//    cmdname ( 5 9 ) = 3  7  -20  154 ...
//
// This function works for any dimension, 0,1,2,3,...
// ===========================================================================
void Cmd::get_int(string &cname, int *array_vals, const vector<int> &size,
                  vector<Cmd *> &dup_cmd1, vector<int> &dup_wdex1,
                  int dup_fatal, vector<int> &dup_vals,
                  bool skip, stringstream &serr, int &ierr)
{
    // Get the dimension of the array, 0,1,2,3,...
    int dim = (int)size.size();

    // Check syntax, for example an equals sign must be present, and set istart.
    // istart   Position in array_vals where we start filling it.
    //          Note that istart starts from index base (default 1, Fortran style)
    //          Use set_index_base_zero for C/C++ index convention
    vector<int> istart(dim,0);
    if (!check_syntax(istart, serr, ierr)) return;

    // If skipping, we don't need to get array values.
    if (skip) {
        set_processed(true);
        return;
    }

    // Get the number of values past the = sign.
    // Also mark the words up to and including the = sign as processed.
    int nvals = 0;
    if (!get_nvals(istart, size, nvals, serr, ierr)) return;

    // 0d is a special case.
    if (dim == 0) {
        *array_vals = words[2].get_int(serr, ierr);
        return;
    }

    // Get the values and return.
    //int ieqp1 = 5 + dim - 1;
    int ieqp1 = find_equals() + 1;
    Parser_utils putils(index_base);
    int k = putils.start_dex(istart, size);
    for (int i=ieqp1; i<(int)words.size(); i++) {
        int iw = words[i].get_int(serr, ierr);
        int imult = words[i].get_multiplicity();
        for (int j=1; j<=imult; j++) {
            error_dup_line(cname, i, k, dup_wdex1, dup_cmd1, dup_vals, 
                           size, dup_fatal, serr, ierr);
            array_vals[k++] = iw;
        }
    }
}


// ===========================================================================
// Get int64_t values. This gets all the words past the = sign,
// converts them to int, and puts them in the output arrays.
//
// The expected commands are:
//    cmdname = some_int                  0d
//    cmdname(5) = 3, 5, -15, 10          1d
//    cmdname(5,9) = 3, 7, -20, 154       2d
//    etc.
//
// We also allow
//    cmdname = 3, 5, -15, 10
// and we will supply the starting indices of (1) or (1,1), etc.
//
// But note that the , is gone at this point, so the 2d command is
//    cmdname ( 5 9 ) = 3  7  -20  154 ...
//
// This function works for any dimension, 0,1,2,3,...
// ===========================================================================
void Cmd::get_int(string &cname, int64_t *array_vals, const vector<int> &size,
                  vector<Cmd *> &dup_cmd1, vector<int> &dup_wdex1,
                  int dup_fatal, vector<int> &dup_vals,
                  bool skip, stringstream &serr, int &ierr)
{
    // Get the dimension of the array, 0,1,2,3,...
    int dim = (int)size.size();

    // Check syntax, for example an equals sign must be present, and set istart.
    // istart   Position in array_vals where we start filling it.
    //          Note that istart starts from index base (default 1, Fortran style)
    //          Use set_index_base_zero for C/C++ index convention
    vector<int> istart(dim,0);
    if (!check_syntax(istart, serr, ierr)) return;

    // If skipping, we don't need to get array values.
    if (skip) {
        set_processed(true);
        return;
    }

    // Get the number of values past the = sign.
    // Also mark the words up to and including the = sign as processed.
    int nvals = 0;
    if (!get_nvals(istart, size, nvals, serr, ierr)) return;

    // 0d is a special case.
    if (dim == 0) {
        *array_vals = words[2].get_int64_t(serr, ierr);
        return;
    }

    // Get the values and return.
    //int ieqp1 = 5 + dim - 1;
    int ieqp1 = find_equals() + 1;
    Parser_utils putils(index_base);
    int k = putils.start_dex(istart, size);
    for (int i=ieqp1; i<(int)words.size(); i++) {
        int64_t iw = words[i].get_int64_t(serr, ierr);
        int imult = words[i].get_multiplicity();
        for (int j=1; j<=imult; j++) {
            error_dup_line(cname, i, k, dup_wdex1, dup_cmd1, dup_vals, 
                           size, dup_fatal, serr, ierr);
            array_vals[k++] = iw;
        }
    }
}

// ===========================================================================
// Get the real (double) values. This gets all the words past the = sign,
// converts them to doubles, and puts them in the output arrays.
//
// The expected commands are:
//    cmdname = some_double                         0d
//    cmdname(5) = 3.0, 35, -15e20, 10.154          1d
//    cmdname(5,9) = 3.0, 35, -15e20, 10.154        2d
//    etc.
//
// We also allow
//    cmdname = 3.0, 35, -15e20, 10.154
// and we will supply the starting indices of (1) or (1,1), etc.
//
// But note that the , is gone at this point, so the 2d command is
//    cmdname ( 5 9 ) = 3.0  35  -15e20  10.154  ...
//
// This function works for any dimension, 0,1,2,3,...
// ===========================================================================
void Cmd::get_real(string &cname, double *array_vals, const vector<int> &size,
                   vector<Cmd *> &dup_cmd1, vector<int> &dup_wdex1,
                   int dup_fatal, vector<int> &dup_vals,
                   bool skip, stringstream &serr, int &ierr)
{
    // Get the dimension of the array, 0,1,2,3,...
    int dim = (int)size.size();

    // Check syntax, for example an equals sign must be present, and set istart.
    // istart   Position in array_vals where we start filling it.
    //          Note that istart starts from index base (default 1, Fortran style)
    //          Use set_index_base_zero for C/C++ index convention
    vector<int> istart(dim,0);
    if (!check_syntax(istart, serr, ierr)) return;

    // If skipping, we don't need to get array values.
    if (skip) {
        set_processed(true);
        return;
    }

    // Get the number of values past the = sign.
    // Also mark the words up to and including the = sign as processed.
    int nvals = 0;
    if (!get_nvals(istart, size, nvals, serr, ierr)) return;

    // 0d is a special case.
    // Note that we do not increment dup_vals for 0d because duplicate scalar
    // commands are handled differently from array commands.
    if (dim == 0) {
        *array_vals = words[2].get_double(serr, ierr);
        return;
    }

    // All other dimensions.
    //int ieqp1 = 5 + dim - 1;
    int ieqp1 = find_equals() + 1;
    Parser_utils putils(index_base);
    int k = putils.start_dex(istart, size);
    for (int i=ieqp1; i<(int)words.size(); i++) {
        double d = words[i].get_double(serr, ierr);
        int imult = words[i].get_multiplicity();
        for (int j=1; j<=imult; j++) {
            error_dup_line(cname, i, k, dup_wdex1, dup_cmd1, dup_vals, 
                           size, dup_fatal, serr, ierr);
            array_vals[k++] = d;
        }
    }
}


// ===========================================================================
// Get the character values. This gets all the words past the = sign,
// converts them to chars, and puts them in the output arrays.
//
// The expected commands are:
//    cmdname = q                                   0d single character
//    cmdname = char_string                         0d character string
//    cmdname(3) = "May" "the", "force", "be"       1d array of strings
//    cmdname(5,9) = "11" "21" "31"                 2d
//    etc.
//
// We also allow
//    cmdname = "May" "the", "force", "be"
// and we will supply the starting indices of (1) or (1,1), etc.
//
// But note that the , is gone at this point, so the 2d command is
//    cmdname ( 5 9 ) = "11" "21" "31"
//
// This function works for any dimension, 0,1,2,3,...
// For 0d, it has an extra flag to distinguish between single characters
// and a character string.
// ===========================================================================
void Cmd::get_char(string &cname, vector<string> &vstr, const vector<int> &size,
                   bool single_char, vector<Cmd *> &dup_cmd1,
                   vector<int> &dup_wdex1, int dup_fatal,
                   vector<int> &dup_vals, bool skip,
                   stringstream &serr, int &ierr)
{
    // Get the dimension of the array, 0,1,2,3,...
    int dim = (int)size.size();

    // Check syntax, for example an equals sign must be present, and set istart.
    // istart   Position in array_vals where we start filling it.
    //          Note that istart starts from index base (default 1, Fortran style)
    //          Use set_index_base_zero for C/C++ index convention
    vector<int> istart(dim,0);
    if (!check_syntax(istart, serr, ierr)) return;

    // If skipping, we don't need to get array values.
    if (skip) {
        set_processed(true);
        return;
    }

    // Get the number of values past the = sign.
    // Also mark the words up to and including the = sign as processed.
    int nvals = 0;
    if (!get_nvals(istart, size, nvals, serr, ierr)) return;

    // 0d is a special case - get a single char
    if (dim == 0 && single_char) {
        vstr[0] = words[2].get_single_char(serr, ierr);
        return;
    }

    // 0d is a special case - get a single string
    if (dim == 0) {
        vstr[0] = words[2].get_stringp();
        return;
    }

    // Get the value and return, dim > 0.
    // get_stringp is the same as get_string except get_stringp also marks
    // the word as being processed.
    //int ieqp1 = 5 + dim - 1;
    int ieqp1 = find_equals() + 1;
    Parser_utils putils(index_base);
    int k = putils.start_dex(istart, size);
    for (int i=ieqp1; i<(int)words.size(); i++) {
        string s = words[i].get_stringp();
        int imult = words[i].get_multiplicity();
        for (int j=1; j<=imult; j++) {
            error_dup_line(cname, i, k, dup_wdex1, dup_cmd1, dup_vals, 
                           size, dup_fatal, serr, ierr);
            vstr[k++] = s;
        }
    }

}


// ===========================================================================
// Get sizes of arrays, this works for dimensions 1,2,3,...
//
// The size vector contains the sizes (or bounds) of each array dimensions.
// It is assumed in this routine that all but the last size is known (this
// is input) and that this routine will determine the last size. See the
// get_sizeb function below where a different assumption is made.
//
// Suppose, for example, we have a 3d array called a3d which is dimensioned
// a3d(5,3,:). The first two dimensions are known, 5 and 3, the last dimension
// is unknown and will be determined by this routine.
//
// size is a vector of ints of size 3, with elements 5,3,? where the ? is
// to be determined.
//
// Note that this routine is called in a loop over all the lines in the
// input which is why we set the size using maximum.
// ===========================================================================
void Cmd::get_size(vector<int> &size, stringstream &serr, int &ierr)
{
    // Get the dimension of the array, 0,1,2,3,...
    int dim = (int)size.size();

    // Check syntax, also sets istart.
    // istart   Position in array where we start filling it.
    //          Example command might be a3d(3,2,2) = ...  In this case istart
    //          would be a vector of length 3 contining 3,2,2
    //          Note that istart starts from index base (default 1, Fortran style)
    //          Use set_index_base_zero for C/C++ index convention
    vector<int> istart(dim,0);
    if (!check_syntax(istart, serr, ierr)) return;

    // Get the number of values past the = sign.
    int nvals = 0;
    vector<int> size0(dim,0);
    if (!get_nvals(istart, size0, nvals, serr, ierr)) return;

    int sm = 1;
    for (int i=0; i<dim-1; i++) {
        sm *= size[i];
    }

    // Set the size.
    int maxval = istart[dim-1] + (nvals-1)/sm;
    if (maxval > size[dim-1]) {
        size[dim-1] = maxval;
    }
}


// ===========================================================================
// This is a special purpose routine to get sizes for certain 2d arrays.
//
// Suppose we have the following input
//      mults(1,1) = 0. 0.  1. 5.  6. 9.
//      mults(1,2) = 3. 5.  8. 9.  10. 11. 20. 10
//      mults(1,3) = 30. 5. 38. 3.
// In this case we don't know the size of either of the array dimensions, and
// of course the user does not know the size either and thus cannot somehow
// merge the above two lines. 
//
// The purpose of this function is to obtain sizes for both the array
// dimensions so memory allocation of the array can be done.
//
// The size vector contains the sizes (or bounds) of each array dimensions.
// For the above example, this function would determine size[0] to be 8 and
// size[1] to be 3. 8 is just the max of the number of values put in per
// entry and 3 is just the max of the second index.
//
// Note that this routine is called in a loop over all the lines in the
// input which is why we set the size using maximum.
//
// This routine only works for 2d arrays.
// ===========================================================================
void Cmd::get_sizeb(vector<int> &size, stringstream &serr, int &ierr)
{
    // Get the dimension of the array, 0,1,2,3,...
    int dim = (int)size.size();

    // This is a special purpose routine, dim must be 2.
    if (dim != 2) {
        fatal_error2(serr, ierr);
        serr << "Cmd.cc, get_sizeb, internal error." << endl;
        serr << "dim != 2, dim=" << dim << endl << endl;
        ierr = 2;
        return;
    }

    // Check syntax, also sets istart.
    // istart   Position in array where we start filling it.
    //          Example command might be a3d(3,2,2) = ...  In this case istart
    //          would be a vector of length 3 contining 3,2,2
    //          Note that istart starts from index base (default 1, Fortran style)
    //          Use set_index_base_zero for C/C++ index convention
    vector<int> istart(dim,0);
    if (!check_syntax(istart, serr, ierr)) return;

    // Get the number of values past the = sign.
    int nvals = 0;
    vector<int> size0(dim,0);
    if (!get_nvals(istart, size0, nvals, serr, ierr)) return;

    // Set the size vector
    int maxval = istart[0] + nvals - 1;
    if (maxval > size[0]) {
        size[0] = maxval;
    }

    maxval = istart[1];
    if (maxval > size[1]) {
        size[1] = maxval;
    }
}


// ===========================================================================
// Check command syntax for any dimension array. The expected command is:
//    cmdname = .true.                          0d
//    cmdname(5) = 1, 3, -4                     1d
//    cmdname(3,4) = 1.e19, 23., -45.           2d
//    etc.
//
// We also allow
//    cmdname = "May" "the", "force", "be"
// and we will supply the starting indices of (1) or (1,1), etc.
//
// Note that at this point, the commas have been removed so the 2d command
// is actually
//    cmdname ( 3 4 ) = 1.e19 23. -45. 
// ===========================================================================
bool Cmd::check_syntax(vector<int> &istart, stringstream &serr, int &ierr)
{
    // Get the dimension of the array, 0,1,2,3,...
    int dim = (int)istart.size();

    bool skip_check = false;
    if (dim > 0) {
        int ieqt = find_equals();
        if (ieqt == 1) skip_check = true;
    }

    // Must be at least a certain number of words on the line.
    int nw_min = 3;
    int nw_min_wc = 3;
    if (dim > 0 && (!skip_check)) {
        nw_min = 6 + dim - 1;
        nw_min_wc = nw_min + dim - 1;
    }
    if ((int)words.size() < nw_min) {
        fatal_error2(serr, ierr);
        serr << "Expected number words in this line >= " << nw_min_wc << endl;
        serr << "Actual number words = " << words.size() << endl << endl;
        ierr = 2;
        // If there aren't enough words on the line, then it is hopeless.
        return false;
    }


    // Word at index ieq must be an = sign.
    int ieq = 1;
    int ieq_wc = 2;
    if (dim > 0 && (!skip_check)) {
        ieq = 4 + dim -1;
        ieq_wc = ieq + 1 + dim - 1;
    }
    if (words[ieq].get_string() != "=") {
        words[ieq].fatal_error(serr, ierr);
        serr << "Expected an equals sign for symbol " << ieq_wc << endl;
        serr << "Instead symbol " << ieq_wc << " is: " <<
            words[ieq].get_string() << endl << endl;
        ierr = 2;
    }

    // The value must not have any multiplicity, i.e. be just a single value.
    // This only applies to 0d, values for arrays can have multiplicity.
    if (dim == 0) {
        if (words[2].get_multiplicity() != 1) {
            words[2].fatal_error(serr, ierr);
            serr << "Multiplicity not equal 1 for " << words[2].get_string() << endl;
            serr << "Multiplicity is: " << words[2].get_multiplicity() << endl << endl;
            ierr = 2;
        }
    }

    // Nothing more to check for 0d.
    if (dim == 0) return true;

    if (!skip_check) {
        // Word at index 1 must be a "(".
        if (words[1].get_string() != "(") {
            words[1].fatal_error(serr, ierr);
            serr << "Expected an open parenthesis ,(, following the command name"
                " in this line," << endl;
            serr << "For example: " << cmd_name << "(...) = ..." << endl;
            serr << "Instead found: " << words[1].get_string() << endl << endl;
            ierr = 2;
        }

        // There must be a closing parenthses.
        int irp = 3 + dim - 1;
        if (words[irp].get_string() != ")") {
            words[irp].fatal_error(serr, ierr);
            serr << "Expected a close parenthesis ,), following the array indices"
                " in this line," << endl;
            serr << "For example: " << cmd_name << "(...) = ..." << endl;
            serr << "Instead found: " << words[irp].get_string() << endl << endl;
            ierr = 2;
        }
    }


    // istart   Position in array_vals where we start filling it.
    //          Note that istart starts from index base (default 1, Fortran style)
    //          Use set_index_base_zero for C/C++ index convention
    if (skip_check) {
        for (int i=0; i<dim; i++) {
            istart[i] = index_base;
        }
    }
    else {
        int ierr2 = 0;
        for (int i=0; i<dim; i++) {
            int iloc = 2 + i;
            istart[i] = words[iloc].get_int(serr, ierr);
            if (ierr < 2  &&  istart[i] < index_base) {
                words[iloc].fatal_error(serr, ierr);
                serr << "The index for the array must be an integer that is >= " << index_base << endl;
                serr << "Integer includes numbers like 3, 3., 3.0, but not 3.5" << endl;
                serr << "The index input is: " << istart[i] << endl << endl;
                ierr2 = 2;
            }
        }
        if (ierr2 == 2) ierr = 2;
    }

    for (int i=0; i<dim; i++) {
        if (istart[i] < index_base) return false;
    }
    return true;
}


// ===========================================================================
// Get the number of values (nvals) past the = sign.
// Check that nvals does not exceed array size.
// Also mark the words up to and including the = sign as processed.
//
// Works for any array dimension = 0,1,2,3,...
// ===========================================================================
bool Cmd::get_nvals(vector<int> &istart, const vector<int> &size,
                    int &nvals, stringstream &serr, int &ierr)
{
    int nvals_cur;
    // Get the array dimension, 0,1,2,3,...
    int dim = (int)istart.size();

    // 0d is a special case.
    if (dim == 0) {
        nvals = 1;
        //if (size[0] == 0) return true;        
        words[0].set_processed(true);
        words[1].set_processed(true);
        return true;
    }

    // Index of word after equals sign.
    //int ieqp1 = 5 + dim - 1;
    int ieqp1 = find_equals() + 1;

    // nvals    Number of values after the = sign.
    nvals = 0;
    for (int i=ieqp1; i<(int)words.size(); i++) {
        nvals_cur = words[i].get_multiplicity();
        if( nvals_cur <= 0 ){
            fatal_error2(serr, ierr);
            serr << "Count must be positive [" << nvals_cur << "]" << endl;
            ierr = 2;
        }
        nvals += nvals_cur;
    }

    // This is for the get size function. We just want nvals and do not want
    // to do the check or marking as processed.
    if (size[0] == 0) return true;

    // Get the max size of the array.
    //int maxvals = size1*size2;
    int maxvals = size[0];
    for (int i=2; i<=dim; i++) {
        maxvals *= size[i-1];
    }

    //int ip = istart[0]-1;
    //if (dim == 2) {
    //    ip = istart[0]-1 + (istart[1]-1)*size[0];
    //}
    //if (dim == 3) {
    //    ip = istart[0]-1 + (istart[1]-1)*size[0] + (istart[2]-1)*size[0]*size[1];
    //}
    //if (dim == 4) {
    //    ip = istart[0]-1 + (istart[1]-1)*size[0] + (istart[2]-1)*size[0]*size[1] +
    //        (istart[3]-1)*size[0]*size[1]*size[2];
    //}
    //ip += nvals - maxvals;

    // Find the excess, i.e. the max array position the user is trying to
    // fill compared with the max size allowed. 
    Parser_utils putils(index_base);
    int ix = putils.start_dex(istart, size);
    int excess = ix + nvals - maxvals;

    //cout << "&&&&&cw ip = " << ip << "  excess = " << excess << endl;

    // Check that the number of values input by the user does not exceed
    // the array size.
    //int excess = istart1 - 1 + (istart2-1)*size1 + nvals - maxvals;
    if (excess > 0) {
        fatal_error2(serr, ierr);
        serr << "Maximum number of values allowed = " << maxvals << endl;
        serr << "(for multi-dimension arrays this max number is" << endl;
        serr << "     max_dim1 * max_dim2 * ...)" << endl;
        serr << "This command exceeds that value by " <<
             excess << endl << endl;
        ierr = 2;
    }
    
    // If fatal errors, then do not attempt further processing.
    if (ierr == 2) return false;

    // Mark as processed.
    for (int i=0; i<ieqp1; i++) {
        words[i].set_processed(true);
    }

    return true;
}


// ***************************************************************************
// ***************************************************************************
// Handle variables.
// ***************************************************************************
// ***************************************************************************

// ===========================================================================
// Check for the user defining variable dimensions for multi-dimensional
// arrays.
//
// This function works for any dimension, 0,1,2,3,...
// ===========================================================================
bool Cmd::check_for_dimension(stringstream &serr, int &ierr)
{
    // First do some checks.
    string varname = words[0].get_string();
    if (!words[0].is_variable()) return false;

    for (int i=0; i<(int)words.size(); i++) {
        if (words[i].get_string() == "=") {
            return false;
        }
    }

    if (words[1].get_string() != "dimension") return false;

    // Find the variable, if not found, then create it.
    map<string, Variable>::iterator p;
    p = vmap->find(varname);
    if (p == vmap->end()) {
        Variable v(varname);
        vmap->insert(pair<string, Variable>(v.get_varname(), v));
    }
    p = vmap->find(varname);

    // Extract the bounds from the line.
    vector<int> bounds;
    for (int i=2; i<(int)words.size(); i++) {
        if (words[i].get_string() == "(") continue;
        if (words[i].is_comma())          continue;
        if (words[i].get_string() == ":") continue;
        if (words[i].get_string() == ")") break;

        // Get the bounds, note that this also makes sure it is an integer.
        bounds.push_back(words[i].get_int(serr, ierr));
    }

    // Actually set the bounds for the variable.
    int lnum = words[0].get_line_number();
    int file_lnum = words[0].get_file_line_number();
    string fname = words[0].get_filename();
    p->second.set_bounds(bounds, lnum, file_lnum, fname,
                         lines, serr, ierr);

    return true;
}


// ===========================================================================
// Check for the command
//    variable_description variable_name description
// If found, then set the description for the variable.
// Create the variable if necessary.
// ===========================================================================
bool Cmd::check_for_var_description(stringstream &serr, int &ierr)
{
    if (words[0].get_string() != "variable_description") return false;

    // Must be 3 words in the line.
    if (words.size() != 3) {
        words[0].fatal_error(serr, ierr);
        serr << "The variable_description command must have 3 words on the"
            " line" << endl;
        serr << "First word =  variable_description" << endl;
        serr << "Second word =  name of the variable" << endl;
        serr << "Third word =  description (usually some phrase in quotes)" << endl;
        serr << "This command has " << words.size() <<
            " words instead of 3 words." << endl;
        ierr = 2;
        return true;
    }

    // The variable name is word 1.
    string varname = words[1].get_string();
    if (!words[1].is_variable()) {
        words[0].fatal_error(serr, ierr);
        serr << "Expected a variable name as word 2" << endl;
        serr << "Variable names must begin with the $ character." << endl;
        serr << "This variable name does not begin with a $ character." << endl;
        serr << "Note that putting quotes around a variable name makes it" << endl;
        serr << "a string, not a variable." << endl;
        serr << "Variable name = " << varname << endl;
        ierr = 2;
        return true;
    }

    // Get the description.
    string vardes = words[2].get_string();

    // Find the variable, if not found, then create it.
    map<string, Variable>::iterator p;
    p = vmap->find(varname);
    if (p == vmap->end()) {
        Variable v(varname);
        vmap->insert(pair<string, Variable>(v.get_varname(), v));
    }
    p = vmap->find(varname);

    // Cannot change pre-defined variables.
    if (p->second.is_pre_defined()) {
        words[0].fatal_error(serr, ierr);
        serr << "Cannot change the description for a pre-defined"
             " variable" << endl;
        serr << "Variable name = " << varname << " is pre-defined." << endl;
        ierr = 2;
        return true;
    }
    
    // Actually set the description.
    p->second.set_description(vardes);

    return true;
}


// ===========================================================================
// Go through each word on the line (starting after the equals sign if
// present), and replace each variable with its value.
// This is for scalar variables only.
// ===========================================================================
void Cmd::substitute_variables(stringstream &serr, int &ierr)
{
    int irstart = 0;
    for (int i=0; i<(int)words.size(); i++) {
        if (words[i].get_string() == "=") {
            irstart = 1;
            break;
        }
    }
    int nw1 = (int)words.size()-1;
    subvar_w0(irstart, nw1, serr, ierr);
}


// ===========================================================================
// Scan words i1 through i2 inclusive, replace any variables found with
// their value.
// If the variable is followed by ++ or --, handle that also.
// This is for scalar variables only.
// ===========================================================================
void Cmd::subvar_w0(int i1, int &i2, stringstream &serr, int &ierr)
{
    for (int i=i1; i<=i2; i++) {
        string s = words[i].get_string();
        if (words[i].is_variable()) {
            int increment = 0;
            if (i < i2) {
                string ppmm = words[i+1].get_string();
                if (ppmm == "++") increment = 1;
                if (ppmm == "--") increment = -1;
            }
            subvar0(i, s, increment, serr, ierr);
            if (increment != 0) {
                delete_words(i+1,i+1);
                i2 -= 1;
            }
        }
    }
}


// ===========================================================================
// Given a variable name, varname, and its index in the words array, vardex,
// replace it with its value.
// This is for scalar variables only.
// ===========================================================================
void Cmd::subvar0(int vardex, string &varname, int increment,
                  stringstream &serr, int &ierr)
{
    vector<int> adex;

    map<string, Variable>::iterator p;
    p = vmap->find(varname);
    if (p != vmap->end()) {
        int lnum = words[vardex].get_line_number();
        int file_lnum = words[vardex].get_file_line_number();
        string fname = words[vardex].get_filename();
        string svalue = p->second.get_var_value(adex, words[vardex].get_string(),
                                                lnum, file_lnum, fname,
                                                lines, serr, ierr);
        //int increment = words[vardex].get_increment();
        if (increment != 0) p->second.bump_var(adex, increment,
                                               lnum, file_lnum, fname,
                                               lines, serr, ierr);
        //words[vardex].set_increment(0);
        words[vardex].set_value(svalue);
    }
    else {
        // The variable has not been defined yet.
        words[vardex].fatal_error(serr, ierr);
        serr << "Attempted to use a variable before it was defined."
             << endl;
        serr << "Undefined variable = " << varname << endl;
        ierr = 2;
    }
}


// ===========================================================================
// Store the variable value(s), define if needed.
// Examples:
//    $radius = 3.0                         0d
//    $radius(1) = 3.0 4. 5.6e19            1d
//    $radius(3,4) = 3.0 4. 5.6e19 4 5 9    2d
//    ...
//
// This function works for any dimension, 0,1,2,3,...
// ===========================================================================
void Cmd::set_variables(stringstream &serr, int &ierr)
{
    //cout << "&&&&&cw Enter set_variables, words[0] = " << words[0].get_string() << endl;
    int ieq = -1;
    for (int i=0; i<(int)words.size(); i++) {
        if (words[i].get_string() == "=") {
            ieq = i;
            break;
        }
    }

    // If an equals sign was not found on the line, then this is not a
    // variable assignment.
    if (ieq == -1) return;

    // If the first character of the first word is not a $, then this is not
    // a variable assignment.
    string vname = words[0].get_string();
    if (!words[0].is_variable()) return;

    // Define a few common things.
    int lnum = words[0].get_line_number();
    int file_lnum = words[0].get_file_line_number();
    string fname = words[0].get_filename();
    vector<string> valvec;

    int dim = 0;
    if (ieq >= 4) dim = ieq - 3;
    //cout << "&&&&&cw vname=" << vname << "  ieq=" << ieq << "  dim=" << dim << endl;

    // Do some checking.
    if (dim == 0) {
        // Must be 3 words in the line (for example: $radius = 3.0)
        if (words.size() != 3) {
            fatal_error2(serr, ierr);
            serr << "Expected number words in this line = 3" << endl;
            serr << "Actual number words = " << words.size() << endl << endl;
            ierr = 2;
            // If there aren't enough words on the line, then it is hopeless.
            if (words.size() < 3) return;
        }

        // The value must not have any multiplicity, i.e. be just a single value.
        // This only applies to 0d, values for arrays can have multiplicity.
        if (words[2].get_multiplicity() != 1) {
            words[2].fatal_error(serr, ierr);
            serr << "Multiplicity not equal 1 for " << words[2].get_string() << endl;
            serr << "Multiplicity is: " << words[2].get_multiplicity() << endl << endl;
            ierr = 2;
        }
    }

    if (dim > 0) {
        int nw_min = dim + 5;
        int nw_min_wc = nw_min + dim - 1;
        if ((int)words.size() < nw_min) {
            fatal_error2(serr, ierr);
            serr << "Expected number of symbols in this line >= " << nw_min_wc << endl;
            serr << "Actual number of symbols is less than expected." << endl << endl;
            ierr = 2;
            // If there aren't enough words on the line, then it is hopeless.
            return;
        }

        // Word at index 1 must be a "(".
        if (words[1].get_string() != "(") {
            words[1].fatal_error(serr, ierr);
            serr << "Expected an open parenthesis ,(, following the variable name"
                " in this line," << endl;
            serr << "For example: " << vname << "(...) = ..." << endl;
            serr << "Instead found: " << words[1].get_string() << endl << endl;
            ierr = 2;
            return;
        }

        // There must be a closing parenthses.
        int irp = 3 + dim - 1;
        if (words[irp].get_string() != ")") {
            words[irp].fatal_error(serr, ierr);
            serr << "Expected a close parenthesis ,), following the array indices"
                " in this line," << endl;
            serr << "For example: " << vname << "(...) = ..." << endl;
            serr << "Instead found: " << words[irp].get_string() << endl << endl;
            ierr = 2;
            return;
        }
    }

    // Store the values in a vector.
    for (int i=ieq+1; i<(int)words.size(); i++) {
        int imult = words[i].get_multiplicity();
        string s = words[i].get_string();
        for (int j=1; j<=imult; j++) {
            valvec.push_back(s);
        }
    }

    // Store the array indices in a vector.
    vector<int> istart(dim,0);
    int ierr2 = 0;
    for (int d=0; d<dim; d++) {
        istart[d] = words[d+2].get_int(serr, ierr);
        if (istart[d] <= 0) {
            words[d+2].fatal_error(serr, ierr);
            serr << "The index for the array must be an integer that is >= " << index_base << endl;
            serr << "Integer includes numbers like 3, 3., 3.0, but not 3.5" << endl;
            serr << "The index input is: " << istart[d] << endl << endl;
            ierr2 = 2;
        }
    }
    if (ierr2 == 2) {
        ierr = 2;
        return;
    }

    // Find the variable name in the variable map.
    map<string, Variable>::iterator p;
    p = vmap->find(vname);

    // If the variable is found in the variable map, then replace
    // its value with the new value. If the variable is not found
    // in the variable map, then add it as a new variable.
    if (p != vmap->end()) {
        p->second.set_var_value(istart, valvec, lnum, file_lnum, fname,
                                lines, serr, ierr);
    }
    else {
        Variable v(vname, istart, valvec, lnum, file_lnum, fname, lines,
                   serr, ierr);
        vmap->insert(pair<string, Variable>(v.get_varname(), v));
    }
}


// ===========================================================================
// Evaluate a variable.
// We have a word followed by multiple arguments. Find out if the word is
// a variable, use the arguments to get the variable value, replace the
// variable and arguments with its value.
//
// This function works for any dimension, 0,1,2,3,...
// ===========================================================================
bool Cmd::evaluate_variable(int iw1, int &i2, int &nargs,
                            stringstream &serr, int &ierr)
{
    // If there is no map of variables, then we do nothing.
    if (vmap == NULL) return false;

    // Do nothing if the word is not a variable (begins with $).
    if (!words[iw1].is_variable()) return false;

    // Get the variable name.
    string varname = words[iw1].get_string();

    // Find the variable.
    map<string, Variable>::iterator p;
    p = vmap->find(varname);

    // The variable was not found.
    if (p == vmap->end()) {
        words[iw1].fatal_error(serr, ierr);
        serr << "Trying to use a variable before it is defined." << endl;
        serr << "Undefined variable = " << varname << endl;
        serr << "The list of defined variables (at this point) is:" << endl;
        for (p=vmap->begin(); p!=vmap->end(); p++) {
            serr << p->second.get_varname() << endl;
        }
        ierr = 2;
        return true;
    }

    // The variable was found, do the evaluation and replace the words.

    // Check to see if all the variable arguments have a value.
    bool has_value = true;
    for (int i=0; i<nargs; i++) {
        int j = iw1 + 1 + i;
        if (!words[j].is_number()) {
            has_value = false;
            words[j].fatal_error(serr, ierr);
            serr << "Expected a number for variable index " <<
                i+1 << endl;
            serr << "Instead found:   " << words[j].get_string() << endl;
            ierr = 2;
        }
    }
    if (!has_value) return true;

    // Check to see if all the variable arguments are integer.
    bool all_int = true;
    for (int i=0; i<nargs; i++) {
        int j = iw1 + 1 + i;
        if (!words[j].is_integer()) {
            all_int = false;
            words[j].fatal_error(serr, ierr);
            serr << "Expected an integer for variable index " <<
                i+1 << endl;
            serr << "Instead found:   " << words[j].get_string() << endl;
            ierr = 2;
        }
    }
    if (!all_int) return true;

    // All the indices have values and are ints.
    // Load all the arguments into a vector of ints.
    vector<int> vdex;
    for (int i=0; i<nargs; i++) {
        int j = iw1 + 1 + i;
        int iv = words[j].get_int();
        vdex.push_back(iv);
    }

    // Check for ++ or -- following the variable.
    int increment = 0;
    int ippmm = iw1 + nargs + 1;
    if (ippmm <= i2 && ippmm <(int)words.size()) {
        string sppmm = words[ippmm].get_string();
        if (sppmm == "++") increment = 1;
        if (sppmm == "--") increment = -1;
    }

    // Evaluate the variable and replace the words.
    // Works in any dimensionality.
    int ln = words[iw1].get_line_number();
    int file_ln = words[iw1].get_file_line_number();
    string fname = words[iw1].get_filename();
    string result = p->second.get_var_value(vdex, varname, ln, file_ln,
                                            fname, lines, serr, ierr);
    //int increment = words[iw1].get_increment();
    if (increment != 0) p->second.bump_var(vdex, increment, ln, file_ln,
                                           fname, lines, serr, ierr);
    //words[iw1].set_increment(0);
    Word w(result, ln, file_ln, fname, lines);
    replace_words(iw1, iw1+nargs, w);
    i2 -= nargs;

    // If the variable was followed by a ++ or --, then remove the
    // ++ or -- since it has been used.
    if (increment != 0) {
        delete_words(iw1+1, iw1+1);
        i2 -= 1;
    }

    return true;
}


// ***************************************************************************
// ***************************************************************************
// Math evaluation.
// ***************************************************************************
// ***************************************************************************

// ===========================================================================
// Math evaluation driver.
// ===========================================================================
void Cmd::math_eval(stringstream &serr, int &ierr)
{
    // Combine * * into **, i.e. form the exponentiation operator.
    handle_star_star();

    // Ops like .and., .eq., ... can at this point be part of larger words,
    // they need to be extracted as individual words.
    handle_ops();

    //cout << "&&&&&cw Cmd.cc, Enter math_eval" << endl;
    //for (int i=0; i<(int)words.size(); i++) {
    //    cout << words[i].get_string() << endl;
    //}

    int ieq = find_any_char(0, (int)words.size()-1, "=");

    bool ifcmd = false;
    if (words[0].get_string() == "if") {
        ifcmd = true;
        ieq = -1;
    }

    for (int i=0; i<(int)words.size(); i++) {
        if (words[i].get_string() == "(" /*&& i>ieq*/) {
            if (ifcmd && i>1) continue;
            if (i > (int)words.size()-2) {
                words[i].fatal_error(serr, ierr);
                serr << "Expected (...)" << endl;
                serr << "Found " << words[(int)words.size()-2].get_string() <<
                    words[(int)words.size()-1].get_string() << endl;
                ierr = 2;
                return;
            }

            // The starting index of the math expression.
            int istart = i+1;

            // Find the ending index of the math expression.
            int iclose = find_closing_symbol("(", ")", istart);
            if (iclose == -1) {
                words[i+1].fatal_error(serr, ierr);
                serr << "Did not find a closing parenthesis, ), in"
                    " math expression" << endl;
                serr << "Check for unbalanced parentheses in math expression." << endl;
                ierr = 2;
                return;
            }
            int iend = iclose - 1;

            int iwres = 0;
            int nargs = 0;
            for (;;) {
                if (!handle_innermost_parens(istart, iend, iwres, nargs, true,
                                             serr, ierr)) break;
                bool isvar = false;
                bool doit = true;
                if (iwres <= 0) doit = false;
                if (cmd_type == "assignment" && iwres==1) doit = false;
                if (doit) {
                    isvar = evaluate_variable(iwres-1, iend, nargs, serr, ierr);
                }
                if ((iwres > 0) && (!isvar)) {
                    evaluate_function(iwres-1, iend, nargs, serr, ierr);
                }
            }

            // Now set ihip1,2 to the original set of parens and handle those.
            // This will do a math eval inside the parens, handle multiple arguments
            // and possibly remove the parens.
            // We do not remove the parens if this is a command line or an assignment
            // line and we are to the left of the equals because a lot of checks
            // depend on the parens being there.
            int ihip1 = istart-1;
            int ihip2 = iend + 1;
            bool remp = true;
            if (ieq>ihip2 && ihip1==1) remp = false;
            handle_innermost_parens(ihip1, ihip2, iwres, nargs, remp,
                                    serr, ierr);

            // Handle the case of a variable array, i.e. evaluate and replace
            // the variable array reference. We of course do not do this for
            // an assignment statement where we are to the left of the equals.
            //bool isvar = false;
            bool doit = true;
            if (iwres <= 0) doit = false;
            if (cmd_type == "assignment" && iwres==1) doit = false;
            if (doit) {
                // We use ihip3 to account for ++ or -- following a
                // variable array reference.
                int ihip3 = ihip2 + 1;
                //isvar = evaluate_variable(iwres-1, ihip3, nargs, serr, ierr);
                evaluate_variable(iwres-1, ihip3, nargs, serr, ierr);
            }

            // Do not allow a function outside of parens. We could do this
            // but for now all math is inside parens.
            //if ((iwres > 0) && (!isvar)) {
            //    evaluate_function(iwres-1, iend, nargs, serr, ierr);
            //}

        }  // if find (
    } // End of loop through all words on the line.

    //cout << "&&&&&cw Cmd.cc, Exit math_eval" << endl;
}


// ===========================================================================
// Handle the innermost set of parentheses.
// The return value is false if parens were not found or if they were
// unbalanced. If parens were found and handled then true is returned.
// iwres is an output quantity and is the location of the resultant word.
// ===========================================================================
bool Cmd::handle_innermost_parens(int &i1, int &i2, int &iwres, int &nargs,
                                  bool remp, stringstream &serr, int &ierr)
{
    // If no innermost parens are found then iwres is meaningless.
    iwres = -1;

    // Search for the innermost left parens. It is ok if there is no left
    // parens, this line just does not have parens.
    int ip1 = find_last("(", i1, i2);
    if (ip1 == -1) return false;

    // After evaluation, the resultant word will be at ip1.
    iwres = ip1;

    int ipstart = ip1 + 1;
    bool done = false;
    nargs = 1;
    for (;;) {
        int ip2 = find_any_char(ipstart, i2, ",)");
        if (ip2 == -1) {
            words[ipstart].fatal_error(serr, ierr);
            serr << "Did not find a closing parenthesis, ), in"
                " math expression" << endl;
            serr << "Check for unbalanced parentheses in math expression." << endl;
            ierr = 2;
            return false;
        }

        if (words[ip2].get_string() == ")") done = true;
        if (words[ip2].is_comma()) nargs += 1;

        if (remp) {
            delete_words(ip2, ip2);
            i2 -= 1;
        }
        int ip21a = ip2 - 1;
        int ip21 = ip2 - 1;
        seval(ipstart, ip21, serr, ierr);
        i2 -= ip21a - ip21;

        if (done) break;

        ipstart += 1;
    }

    // Delete the leading paren.
    if (remp) {
        delete_words(ip1, ip1);
        i2 -= 1;
    }

    return true;
}


// ===========================================================================
// Simple evaluation of a series of words i1 to i2 inclusive.
// ===========================================================================
void Cmd::seval(int &i1, int &i2, stringstream &serr, int &ierr)
{
    Parser_math pmath;

    subvar_w0(i1, i2, serr, ierr);
    handle_unary_op(i1, i2, "-", serr, ierr);
    handle_unary_op(i1, i2, "+", serr, ierr);

    //     Level   Operators
    //     -----   -----------------------
    //       8     ()
    //       7     ++ --
    //       6     **
    //       5     *  /
    //       4     +  -
    //       3     .gt. .ge. .lt. .le. .eq. .ne.
    //       2     .not.
    //       1     .and.
    //       0     .or.
    for (int level=6; level>=0; level--) {
        for (int i=i1; i<=i2; i+=1) {
            if (words[i].is_operator(level)) {
                int ln = words[i].get_line_number();
                int file_ln = words[i].get_file_line_number();
                string fname = words[i].get_filename();
                Word w("", ln, file_ln, fname, lines);

                string op_type = words[i].get_op_type();
                if (op_type == "arithmetic")
                    pmath.do_op(i-1, i, i+1, words, w, serr, ierr);
                if (op_type == "relational")
                    pmath.do_op_relational(i-1, i, i+1, words, w, serr, ierr);
                if (op_type == "logical" && level == 2)   // .not. is unary
                    pmath.do_op_not(i, i+1, words, w, serr, ierr);
                if (op_type == "logical" && level != 2)
                    pmath.do_op_logical(i-1, i, i+1, words, w, serr, ierr);

                // level 2, .not., is unary and is handled differently.
                if (level == 2) {
                    replace_words(i, i+1, w);
                    i2 -= 1;
                }
                else {
                    replace_words(i-1, i+1, w);
                    i2 -= 2;
                    i -= 1;
                }
                continue;
            }
        }
    }
    //cout << "&&&&&cw Leave seval" << endl;
}


// ===========================================================================
// Handle unary plus and minus.
// utype is either "+" or "-".
// ===========================================================================
void Cmd::handle_unary_op(int i1, int &ipend, string utype,
                          stringstream &serr, int &ierr)
{
    int ipstart = i1;
    for (;;) {
        int ip = find(ipstart, ipend, utype);

        // If we do not find any more plus/minus signs then we are done.
        if (ip == -1) return;

        // Fatal error is the plus/minus sign is the last word on the line.
        if (ip >= ((int)words.size()-1)) {
            words[ip].fatal_error(serr, ierr);
            serr << "Found a " << utype << " sign at the end of a line." << endl;
            serr << "Expected something to the right of the  " << utype
                 << " sign to operate on." << endl;
            ierr = 2;
            return;
        }


        // If the plus/minus sign is the first word on the line, then it has
        // to be a unary op. The word after the plus/minus sign must be a
        // number or variable.
        // This should never happen because we are always inside (...)
        // and will never be word 0, still we should be general and take care
        // of this case.
        if (ip == 0) {
            if (!words[ip+1].is_number()) {
                words[ip+1].fatal_error(serr, ierr);
                serr << "Expected the object following the unary " << utype
                     << " to be a number." << endl;
                serr << "Instead, it was " << words[ip+1].get_string() << endl;
                ierr = 2;
                return;
            }

            // Actually do the negate operation.
            do_unary_op(ip, utype);
            ipstart = ip+1;
            ipend -= 1;
            continue;
        }
         
        // Check to see if the +/- is a binary op. If so, then nothing needs
        // to be done with this +/- sign, binary ops are handled elsewhere.
        if (words[ip-1].is_number() &&
            (words[ip+1].is_number() || words[ip+1].get_string() == "-" ||
             words[ip+1].get_string() == "+")
            ) {
            ipstart = ip+1;
            continue;
        }

        // Check to see if the +/- is a unary op.
        if (!words[ip-1].is_number() && words[ip+1].is_number()) {
            do_unary_op(ip, utype);
            ipstart = ip+1;
            ipend -= 1;
            continue;
        }

        // Check for an error.
        if (!words[ip-1].is_number() &&
            !words[ip+1].is_number()) {
            words[ip-1].fatal_error(serr, ierr);
            serr << "Expected the object following the unary " << utype << " to"
                " be a number." << endl;
            serr << "Instead, it was " << words[ip+1].get_string() << endl;
            ierr = 2;
            return;
        }

        words[ip].fatal_error(serr, ierr);
        serr << "Unknown error with unary " << utype << endl;
        serr << "Error with words: " << endl;
        serr << words[ip].get_string() << words[ip+1].get_string() << endl;
        ierr = 2;
        return;
    }
}


// ===========================================================================
// Do a unary operation.
// The minus sign is at word ip and the word to be negated is at word ip+1.
// After negation, both words get replaced by the new negated word.
// If the unary op is plus then all we need to do is get rid of the + sign.
// ===========================================================================
void Cmd::do_unary_op(int ip, string utype)
{
    if (utype == "+") {
        delete_words(ip,ip);
        return;
    }

    if (utype == "-") {
        if (words[ip+1].is_number()) {
            Word w = words[ip+1];
            w.negate_value();
            replace_words(ip, ip+1, w);
            return;
        }
    }
}


// ===========================================================================
// Check to see that all ++ and -- have been handled and removed.
// ===========================================================================
void Cmd::check_ppmm(stringstream &serr, int &ierr)
{
    for (int i=0; i<(int)words.size(); i++) {
        string s = words[i].get_string();
        if (s == "++" || s == "--") {
            words[i].fatal_error(serr, ierr);
            serr << "Misplaced " << s << " operator." << endl;
            serr << "++ and -- operators must follow a variable or " << endl;
            serr << "an element of an array variable. " << endl;
            ierr = 2;
        }
    }
}


// ===========================================================================
// Evaluate a function.
// ===========================================================================
void Cmd::evaluate_function(int iw1, int &i2, int &nargs,
                            stringstream &serr, int &ierr)
{
    // If there is no map of functions, then we do nothing.
    if (fmap == NULL) return;

    // If the word at iw1 is not a string then it will not be a function.
    if (!words[iw1].is_string()) return;

    // Find the function.
    string s = words[iw1].get_string();
    map<string, Function>::iterator p;
    p = fmap->find(s);

    // The function was not found.
    if (p == fmap->end()) {
        words[iw1].fatal_error(serr, ierr);
        serr << "Expected a function" << endl;
        serr << "Instead found:   " << words[iw1].get_string() << endl;
        serr << "The list of known functions is:" << endl;
        for (p=fmap->begin(); p!=fmap->end(); p++) {
            serr << p->second.get_name() << endl;
        }
        ierr = 2;
        return;
    }

    // The function was found, do the evaluation and replace the words.

    // Common items needed for all types of functions.
    int ln = words[iw1].get_line_number();
    int file_ln = words[iw1].get_file_line_number();
    string fname = words[iw1].get_filename();


    // Is a variable defined or not.
    if (s == "defined") {
        string varname = words[iw1+1].get_string();
        string result = "true";
        map<string, Variable>::iterator p;
        p = vmap->find(varname);
        if (p == vmap->end()) result = "false";
        Word w(result, ln, file_ln, fname, lines);
        replace_words(iw1, iw1+nargs, w);
        i2 -= nargs;
        return;
    }


    // String functions - string arguments, string results.
    if (p->second.get_type() == "string") {
        // Load all the arguments into a vector of strings.
        vector<string> vs;
        for (int i=0; i<nargs; i++) {
            int j = iw1 + 1 + i;
            string s = words[j].get_string();
            vs.push_back(s);
        }

        // Calculate the function and replace the words.
        string result = p->second.evaluate(vs, serr, ierr, ln, file_ln,
                                           fname, lines);
        Word w(result, ln, file_ln, fname, lines);
        replace_words(iw1, iw1+nargs, w);
        i2 -= nargs;
    }


    // Real functions - double arguments, double results.
    if (p->second.get_type() == "real") {
        // Check to see if all the function arguments have a value.
        bool has_value = true;
        for (int i=0; i<nargs; i++) {
            int j = iw1 + 1 + i;
            if (!words[j].is_number()) {
                has_value = false;
                words[j].fatal_error(serr, ierr);
                serr << "Expected a number for function argument number " <<
                    i+1 << endl;
                serr << "Instead found:   " << words[j].get_string() << endl;
                ierr = 2;
            }
        }
        if (!has_value) return;

        // All the arguments have values so we can deal with them
        // as doubles.
        // Load all the arguments into a vector of doubles.
        vector<double> vd;
        for (int i=0; i<nargs; i++) {
            int j = iw1 + 1 + i;
            double d = words[j].get_double();
            vd.push_back(d);
        }

        // Calculate the function and replace the words.
        double result = p->second.evaluate(vd, serr, ierr, ln, file_ln,
                                       fname, lines);
        Word w(result, ln, file_ln, fname, lines);
        replace_words(iw1, iw1+nargs, w);
        i2 -= nargs;
    }
}


// ===========================================================================
// When two "*" characters are together, assume that is the exponentiation
// operator, "**", and replace both "*"'s with "**".
// ===========================================================================
void Cmd::handle_star_star()
{
    for (int i=0; i<(int)words.size()-1; i++) {
        if (words[i].get_string() == "*" && words[i+1].get_string() == "*") {
            int lnum = words[i].get_line_number();
            int file_ln = words[i].get_file_line_number();
            string fname = words[i].get_filename();
            string s = "**";
            Word w(s, lnum, file_ln, fname, lines);
            replace_words(i, i+1, w);
        }
    }
}


// ===========================================================================
// The parser does not automatically separate operators like .eq., .ne., etc.
// For example, the phrase a.eq.b will be one word when it should be 3 words.
// This routine finds those cases and splits the one word into multiple words.
// ===========================================================================
void Cmd::handle_ops()
{
    vector<string> subs;
    subs.push_back(".eq.");
    subs.push_back(".ne.");
    subs.push_back(".gt.");
    subs.push_back(".ge.");
    subs.push_back(".lt.");
    subs.push_back(".le.");
    subs.push_back(".hgeq.");
    subs.push_back(".hgne.");
    subs.push_back(".hggt.");
    subs.push_back(".hgge.");
    subs.push_back(".hglt.");
    subs.push_back(".hgle.");
    subs.push_back(".not.");
    subs.push_back(".and.");
    subs.push_back(".or.");

    for (int i=0; i<(int)words.size(); i++) {
        string fstr = words[i].get_string();
        for (int j=0; j<(int)subs.size(); j++) {
            vector<string> vs;
            bool b = separate_str(subs[j], fstr, vs);
            if (b) {
                vector<Word> vw;
                for (int k=0; k<(int)vs.size(); k++) {
                    int lnum = words[i].get_line_number();
                    int file_lnum = words[i].get_file_line_number();
                    string fname = words[i].get_filename();
                    Word w(vs[k], lnum, file_lnum, fname, lines);
                    vw.push_back(w);
                    //cout << vs[k] << endl;
                }
                replace_words(i, i, vw);
                i--;
                break;
            }
        }


        //int lnum = words[i].get_line_number();
        //string s = "**";
        //Word w(s, lnum, lines);
        //replace_words(i, i+1, w);
    }
}


// ===========================================================================
// After the line has mostly been processed, check for any misplaced math
// operations. For example, the following line
//    xcenter = 1.0 + 2.0
// has a misplaced math op in it, i.e. it should be in parentheses
//    xcenter = (1.0 + 2.0)
// ===========================================================================
void Cmd::check_misplaced_math(stringstream &serr, int &ierr)
{
    for (int i=0; i<(int)words.size(); i++) {
        if (words[i].is_operator()) {
            words[i].fatal_error(serr, ierr);
            serr << "Misplaced math operation." << endl;
            serr << "All math operations must be inside parentheses." << endl;
            ierr = 2;
        }
    }
}


// ***************************************************************************
// ***************************************************************************
// Handle if/elseif/else/endif
// ***************************************************************************
// ***************************************************************************

// ===========================================================================
// Handle if/elseif/else/endif statements.
// ===========================================================================
void Cmd::handle_if(bool &skip, deque<bool> &skip_level,
                    deque<bool> &satisfied, stringstream &serr, int &ierr)
{
    // If's can be nested to any level, the number of levels is determined
    // by the size of skip_level, the size of satisfied would also work here.
    int nlevels = (int)skip_level.size();

    // The endif statement ends a block if.
    if (words[0].get_string() == "endif") {
        if ((int)words.size() > 1) {
            words[1].fatal_error(serr, ierr);
            serr << "The endif (or end if) statement should not have "
                 "anything else on the line." << endl;
            serr << "Found other words on the line." << endl;
            ierr = 2;
        }

        // The if level has ended, just erase it.
        skip_level.erase(skip_level.begin()+nlevels-1);
        satisfied.erase(satisfied.begin()+nlevels-1);
        skip = true;
        return;
    }

    // Else statment.
    if (words[0].get_string() == "else") {
        if ((int)words.size() > 1) {
            words[1].fatal_error(serr, ierr);
            serr << "The else statement should not have "
                 "anything else on the line." << endl;
            serr << "Found other words on the line." << endl;
            ierr = 2;
        }

        // If the if has been satisfied before this else, then just
        // skip the else block. Otherwise the if will be satisfied and
        // we do not skip the else block.
        if (satisfied[nlevels-1]) {
            skip_level[nlevels-1] = true;
        }
        else {
            satisfied[nlevels-1] = true;
            skip_level[nlevels-1] = false;
        }
        skip = true;
        return;
    }

    // If any level is in skip mode, then we will skip this line.
    // This is mostly for non if related lines, but the skip flag is
    // used below.
    skip = false;
    for (int n=0; n<nlevels; n++) {
        if (skip_level[n]) {
            skip = true;
        }
    }


    // Process the elseif statement.
    if (words[0].get_string() == "elseif") {
        if (satisfied[nlevels-1]) {
            skip_level[nlevels-1] = true;
        }
        else {
            // If we are in skip mode at a higher level, then we can ignore this
            // elseif.
            if (skip && !skip_level[nlevels-1]) return;

            // Do some syntax checking.
            int wsize = (int)words.size();

            if (wsize > 1) {
                if (words[1].get_string() != "(") {
                    words[1].fatal_error(serr, ierr);
                    serr << "Expected an open parentheses, (, following " <<
                          words[0].get_string() << endl;
                    serr << "Instead found: " << words[1].get_string() << endl;
                    ierr = 2;
                }
            }

            int nw = wsize-2;
            if (nw >= 0) {
                if (words[nw].get_string() != ")") {
                    words[nw].fatal_error(serr, ierr);
                    serr << "Expected a close parentheses, ), as the next to last "
                        "symbol on the line." << endl;
                    serr << "Instead found: " << words[nw].get_string() << endl;
                    ierr = 2;
                }
            }

            nw = wsize-1;
            if (nw >= 0) {
                if (words[nw].get_string() != "then") {
                    words[nw].fatal_error(serr, ierr);
                    serr << "Expected then as the last word on the line." << endl;
                    serr << "Instead found: " << words[nw].get_string() << endl;
                    ierr = 2;
                }
            }

            // Evaluate the conditional.
            math_eval(serr, ierr);

            if (words[1].get_bool(serr, ierr)) {
                satisfied[nlevels-1] = true;
                skip_level[nlevels-1] = false;
            }
            else {
                skip_level[nlevels-1] = true;
            }

        }

        // Set skip to skip the elseif statement.
        skip = true;
        return;
    }


    if (words[0].get_string() == "if") {
        //cout << "&&&&&cw Cmd.cc, if statment encountered" << endl;

        // If we are in skip mode at a higher level, then we can ignore this
        // if.
        if (skip) {
            skip_level.push_back(true);
            satisfied.push_back(true);
            return;
        }

        // Do some syntax checking.
        int wsize = (int)words.size();

        if (wsize > 1) {
            if (words[1].get_string() != "(") {
                words[1].fatal_error(serr, ierr);
                serr << "Expected an open parentheses, (, following " <<
                    words[0].get_string() << endl;
                serr << "Instead found: " << words[1].get_string() << endl;
                ierr = 2;
            }
        }

        // Evaluate the conditional.
        math_eval(serr, ierr);

        //for (int i=0; i<(int)words.size(); i++) {
        //    cout << words[i].get_string() << endl;
        //}

        // Single line if
        if (words[2].get_string() != "then") {
            if (words[1].get_bool(serr, ierr)) {
                delete_words(0,1);
                reset_name_type();
                skip = false;
            }
            else {
                skip = true;
            }
            return;
        }

        // Multi-block if
        if (words[2].get_string() == "then") {
            if (words[1].get_bool(serr, ierr)) {
                skip_level.push_back(false);
                satisfied.push_back(true);
                skip = true;
            }
            else {
                skip_level.push_back(true);
                satisfied.push_back(false);
                skip = true;
            }
            return;
        }
    }


    //for (int i=0; i<(int)words.size(); i++) {
    //    if (words[i].get_string() == "*" && words[i+1].get_string() == "*") {
    //    }
    //}
}


// ***************************************************************************
// ***************************************************************************
// Handle do loops
// ***************************************************************************
// ***************************************************************************

// ===========================================================================
// Handle do loops.
// ===========================================================================
void Cmd::handle_do(bool &skip, deque<int> &do_start, int &cdex,
                    bool &end_do_loop, stringstream &serr, int &ierr)
{
    // Do's can be nested to any level, the number of levels is determined
    // by the size of do_start.
    int nlevels = (int)do_start.size();

    // End of do loop, go back to do line.
    if (words[0].get_string() == "enddo") {
        //cout << "&&&&&cw Cmd, handle_do, start of enddo, cdex=" << cdex << endl;
        if ((int)words.size() > 1) {
            words[1].fatal_error(serr, ierr);
            serr << "The enddo (or end do) statement should not have "
                 "anything else on the line." << endl;
            serr << "Found other words on the line." << endl;
            ierr = 2;
        }

        cdex = do_start[nlevels-1] - 1;
        skip = true;
        return;
    }


    // Cycle command encountered.
    if (words[0].get_string() == "cycle") {
        if ((int)words.size() > 1) {
            words[1].fatal_error(serr, ierr);
            serr << "The cycle statement should not have "
                 "anything else on the line." << endl;
            serr << "Found other words on the line." << endl;
            ierr = 2;
        }

        cdex = do_start[nlevels-1] - 1;
        skip = true;
        return;
    }

    // Break out of the do loop.
    if (words[0].get_string() == "exit") {
        if ((int)words.size() > 1) {
            words[1].fatal_error(serr, ierr);
            serr << "The exit statement should not have "
                 "anything else on the line." << endl;
            serr << "Found other words on the line." << endl;
            ierr = 2;
        }

        end_do_loop = true;
        return;
    }

    if (words[0].get_string() == "do") {

        //for (int i=0; i<(int)words.size(); i++) {
        //  cout << words[i].get_string() << endl;
        //}

        // Evaluate any math expressions on the do line.
        math_eval(serr, ierr);

        // Replace any simple variables on the line with their values.
        // Of course, do not replace the loop variable.
        int ieq = -1;
        for (int i=0; i<(int)words.size(); i++) {
            if (words[i].get_string() == "=") {
                ieq = i;
                break;
            }
        }
        if (ieq >= 0) {
            int nw1 = (int)words.size()-1;
            subvar_w0(ieq+1, nw1, serr, ierr);
        }

        // Handle unary minus
        handle_cmd_unary_minus(serr, ierr);

        // Number of words on the line after math evaluation.
        int nwords = (int)words.size();

        // Get the loop variable name.
        string do_varname = "$i";
        bool isvar = true;
        if (nwords>1) {
            do_varname = words[1].get_string();
            if (!words[1].is_variable()) isvar = false;
        }

        // Expecting 6 or 8 words, i.e. "do $i = 1 , 10" 
        if (nwords < 6) {
            words[0].fatal_error(serr, ierr);
            serr << "Expected at least 6 words on this line after any math evaluations."
                 << endl;
            serr << "For example, " << endl
                 << "    do " << do_varname << " = 1 , 10" << endl;
            serr << "Instead found " << nwords << " words on the line." << endl;
            serr << "The line (after any math evaluations have been done) is:" << endl;
            serr << "    ";
            for (int iw=0; iw<nwords; iw++) {
                serr << words[iw].get_string() << " ";
            }
            serr << endl;
            ierr = 2;
            return;
        }

        // Variables must begin with a $
        if (!isvar) {
            words[0].fatal_error(serr, ierr);
            serr << "Loop variable names must begin with a $ sign." << endl;
            serr << "Note that putting quotes around a variable name makes it" << endl;
            serr << "a string, not a variable." << endl;
            serr << "Instead found: " << do_varname << endl;
            ierr = 2;
            return;
        }

        // Word 3 must be an = sign.
        if (words[2].get_string() != "=") {
            words[2].fatal_error(serr, ierr);
            serr << "The third word must be an = sign." << endl;
            serr << "Instead found: " << words[2].get_string() << endl;
            ierr = 2;
            return;
        }

        // Word 5 must be a comma.
        if (!words[4].is_comma()) {
            words[4].fatal_error(serr, ierr);
            serr << "The fifth word must be a comma." << endl;
            serr << "Instead found: " << words[4].get_string() << endl;
            ierr = 2;
            return;
        }

        // The get_int functions generate an error if the values are
        // not integer.
        int i1 = words[3].get_int(serr, ierr);
        int i2 = words[5].get_int(serr, ierr);

        // Get the step (increment) if specified.
        int istep = 1;
        if (nwords > 7) istep = words[7].get_int(serr, ierr);

        string s1 = words[3].get_string();
        string s2 = words[5].get_string();

        bool do_continue = false;
        if (nlevels > 0) {
            if (do_start[nlevels-1] == cdex) do_continue = true;
        }

        if (do_continue) {  // This do has already been encountered.
            //cout << "&&&&&cw Cmd, handle_do, do:continue" << endl;

            // Find the variable in the list of variables, increment it, test for
            // ending the loop, and store the incremented value.
            map<string, Variable>::iterator p;
            p = vmap->find(do_varname);
            if (p != vmap->end()) {
                string do_var_value = p->second.get_var_value();
                int lnum = words[0].get_line_number();
                int file_lnum = words[0].get_file_line_number();
                string fname = words[0].get_filename();
                Word w(do_var_value, lnum, file_lnum, filename, lines);
                int ival = w.get_int(serr, ierr);
                ival += istep;
                //cout << "&&&&&cw Cmd, handle_do, do:continue, do_var_value=" << ival << endl;
                if (istep >= 0 && ival > i2) {
                    end_do_loop = true;
                    return;
                }
                if (istep < 0 && ival < i2) {
                    end_do_loop = true;
                    return;
                }
                stringstream ss;
                ss << ival;
                string sval = ss.str();
                vector<string> valvec;
                valvec.push_back(sval);
                vector<int> istart(0,0);
                p->second.set_var_value(istart, valvec, lnum, file_lnum, fname,
                                        lines, serr, ierr);
            }
            else {
                words[1].fatal_error(serr, ierr);
                serr << "The loop variable, " << do_varname <<
                    " was not found in the variable list." << endl;
                serr << "This should not happen, possible code bug?" << endl;
                ierr = 2;
                return;
            }
        }
        else {  // A new do loop has been encountered.
            do_start.push_back(cdex);

            // It is possible that we don't execute the do loop at all.
            if (istep >= 0 && i1 > i2) {
                end_do_loop = true;
                return;
            }
            if (istep < 0 && i1 < i2) {
                end_do_loop = true;
                return;
            }

            //cout << "&&&&&cw Cmd, handle_do, do:start, cdex=" << cdex << endl;
            //cout << "&&&&&cw Cmd, handle_do, do:start, s1=" << s1 << endl;
            //cout << "&&&&&cw Cmd, handle_do, do:start, s2=" << s2 << endl;

            // Store the loop variable, create it if necessary.
            vector<int> istart(0,0);
            int lnum = words[0].get_line_number();
            int file_lnum = words[0].get_file_line_number();
            string fname = words[0].get_filename();
            vector<string> valvec;
            valvec.push_back(s1);
            map<string, Variable>::iterator p;
            p = vmap->find(do_varname);
            if (p != vmap->end()) {
                p->second.set_var_value(istart, valvec, lnum, file_lnum, fname,
                                        lines, serr, ierr);
            }
            else {
                Variable v(do_varname, istart, valvec, lnum, file_lnum, fname,
                           lines, serr, ierr);
                vmap->insert(pair<string, Variable>(v.get_varname(), v));
            }
        }
        skip = true;
        return;
    }
}


// ===========================================================================
// Starting at a do statement, find the matching enddo.
// ===========================================================================
bool Cmd::find_matching_enddo(int &dlev, bool &stop_checking)
{
    if (words[0].get_string() == "enddo") {
        if (dlev == 1) return true;
        dlev -= 1;
        return false;
    }
    if (words[0].get_string() == "do") {
        dlev += 1;
        return false;
    }

    // If we are in main and hit a subroutine statement then that is the
    // end of main and we need to stop checking.
    if (words[0].get_string() == "subroutine") {
        stop_checking = true;
        return false;
    }

    // If we are in a subroutine and hit an endsubroutine statement then
    // we need to stop checking.
    if (words[0].get_string() == "endsubroutine") {
        stop_checking = true;
        return false;
    }

    return false;
}


// ***************************************************************************
// ***************************************************************************
// Subroutines
// ***************************************************************************
// ***************************************************************************

// ===========================================================================
// Handle subroutines.
// ===========================================================================
void Cmd::handle_subroutines(bool &skip, bool &go_to_sub, string &sub_name,
                             bool &go_to_call, stringstream &serr, int &ierr)
{
    // To suppress compiler warnings of unused parameters
    assert(skip == skip);
    //assert(serr == serr);
    assert(ierr == ierr);

    // 
    if (words[0].get_string() == "call") {
        sub_name = words[1].get_string();
        go_to_sub = true;
        return;
    }

    if (words[0].get_string() == "endsubroutine" ||
        words[0].get_string() == "return") {
        go_to_call = true;
        return;
    }

}


// ===========================================================================
// Searching for subroutine sub_name.
// ===========================================================================
bool Cmd::find_subroutine(string &sub_name)
{
    if ((int)words.size() < 2) return false;
    if (words[0].get_string() == "subroutine" &&
        words[1].get_string() == sub_name) return true;
    return false;
}


// ===========================================================================
// A call statement has been encountered, get the arguments, if any.
// The call is expected to be
//      call subname ( arg1, arg2, ...)
// ===========================================================================
void Cmd::get_call_args(vector<string> &sargs, vector<bool> &sargs_isvar,
                        stringstream &serr, int &ierr)
{
    //debug_print_words("Cmd, enter get_call_args");

    // We do not want to modify the words on this line, but we have to
    // temporarily to get the math eval to work right. Therefore store the
    // words on the line and restore them later.
    deque <Word> words_store;
    for (int i=0; i<(int)words.size(); i++) {
        words_store.push_back(words[i]);
    }

    // Erase the call and the subroutine name.
    erase_word(0);
    erase_word(0);

    // Erase the opening and closing parens.
    if ((int)words.size() > 0) {
        if (words[0].get_string() == "(") erase_word(0);
    }
    if ((int)words.size() > 0) {
        if (words[(int)words.size()-1].get_string() == ")") erase_last_word();
    }
    //debug_print_words("Cmd, get_call_args, after erase");

    // Do a math eval to get one word arguments. If the arguments are
    // variables they will not be evaluated, so we will end up with a mix
    // of variables and numbers.
    if ((int)words.size() > 0) {
        math_eval(serr, ierr);
        int wlen = (int)words.size() - 1;
        handle_unary_op(0, wlen, "-", serr, ierr);
        wlen = (int)words.size() - 1;
        handle_unary_op(0, wlen, "+", serr, ierr);
    }

    //debug_print_words("Cmd, get_call_args, after math eval");

    // Store the arguments in the vector of strings, sargs, to be returned
    // to the calling code and also store in the class, call_args.
    call_args.clear();
    call_args_isvar.clear();
    for (int i=0; i<(int)words.size(); i++) {
        if (words[i].is_comma()) continue;
        sargs.push_back(words[i].get_string());
        sargs_isvar.push_back(words[i].is_variable());
        call_args.push_back(words[i].get_string());
        call_args_isvar.push_back(words[i].is_variable());
    }

    // Restore the words before leaving this function.
    words.clear();
    for (int i=0; i<(int)words_store.size(); i++) {
        words.push_back(words_store[i]);
    }
    //debug_print_words("Cmd, get_call_args, after restoring words");
}


// ===========================================================================
// A subroutine statement has been encountered, get the arguments, if any.
// The subroutine statement is expected to be
//      subroutine subname ( arg1, arg2, ...)
// ===========================================================================
void Cmd::get_sub_args(vector<string> &sargs, vector<bool> &sargs_isvar)
{
    sub_args.clear();
    sub_args_isvar.clear();
    for (int i=3; i<(int)words.size(); i+=2) {
        sargs.push_back(words[i].get_string());
        sargs_isvar.push_back(words[i].is_variable());
        sub_args.push_back(words[i].get_string());
        sub_args_isvar.push_back(words[i].is_variable());
    }
}


// ===========================================================================
// Accessor functions for the calling and subroutine arguments.
// ===========================================================================
void Cmd::copy_call_args(vector<string> &sargs, vector<bool> &sargs_isvar)
{
    for (int i=0; i<(int)call_args.size(); i++) {
        sargs.push_back(call_args[i]);
        sargs_isvar.push_back(call_args_isvar[i]);
    }
}

void Cmd::copy_sub_args(vector<string> &sargs, vector<bool> &sargs_isvar)
{
    for (int i=0; i<(int)sub_args.size(); i++) {
        sargs.push_back(sub_args[i]);
        sargs_isvar.push_back(sub_args_isvar[i]);
    }
}


// ***************************************************************************
// ***************************************************************************
// Handle comments.
// ***************************************************************************
// ***************************************************************************

// ===========================================================================
// Process single line comments.
// ===========================================================================
void Cmd::single_line_comments()
{
    for (int i=0; i<(int)words.size()-1; i++) {
        if ((words[i].get_string() == "!") ||
            (words[i].get_string() == "#") ||
            (words[i].get_string() == "/" && words[i+1].get_string() == "/")
            ) {
            words.erase(words.begin()+i, words.begin()+(int)words.size());
            break;
        }
    }

    // Handle the case where the last word might be an ! or a #
    int ilast = (int)words.size()-1; 
    if (ilast < 0) return;
    if ((words[ilast].get_string() == "!") || (words[ilast].get_string() == "#"))
        words.erase(words.begin()+ilast);
}


// ===========================================================================
// Process multi-line comments.
// ===========================================================================
void Cmd::multi_line_comments(int &level)
{
    /*
    cout << "*** Enter multi_line_comments, level=" << level << endl;
    cout << "**** original string: " << original_str << endl;
    stringstream ss;
    print_using_words(ss);
    cout << "     print words before:" << endl;
    cout << "         " << ss.str() << endl;
    */

    int istart = -1;
    if (level > 0) istart = 0;

    for (int i=0; i<(int)words.size()-1; i++) {
        //cout << "Top of i loop, i=" << i << endl;
        if (words[i].get_string() == "/" && words[i+1].get_string() == "*") {
            if (level == 0) istart = i;
            level += 1;
            //cout << "found /*, i=" << i << endl;
            i += 1;
            continue;
        }

        if (words[i].get_string() == "*" && words[i+1].get_string() == "/") {
            if (level == 0) {
                cout << "Error in line " << line_number << " umatched */" << endl;
            }
            //cout << "found */, istart=" << istart << "  words[istart]=" <<
            //    words[istart].get_string() << endl;
            //cout << "found */, i=" << i << "  words[i]=" <<
            //    words[i].get_string() << endl;
            //cout << "found */, i+1=" << i+1 << "  words[i+1]=" <<
            //    words[i+1].get_string() << endl;
            words.erase(words.begin()+istart, words.begin()+i+2);
            level -= 1;
            int ndel = i+1-istart+1;
            //cout << "ndel=" << ndel << "  i=" << i << endl;
            i = i+1-ndel+1;
            //cout << "after changing i, i=" << i << "  words[i]=" <<
            //    words[i].get_string() << endl;
            if (level > 0) istart = i;
            continue;
        }

    }

    if (level > 0) {
        words.erase(words.begin()+istart, words.begin()+(int)words.size());
    }

    /*
    stringstream ss1;
    print_using_words(ss1);
    cout << "     print words after:" << endl;
    cout << "         " << ss1.str() << endl;

    cout << endl << "**********" << endl;
    */
}


// ***************************************************************************
// ***************************************************************************
// Miscellaneous
// ***************************************************************************
// ***************************************************************************


// ===========================================================================
// Go through every word on the line, check for matching quotes, then remove
// them.
// ===========================================================================
void Cmd::handle_quotes(stringstream &serr, int &ierr)
{
    for (int i=0; i<(int)words.size(); i++) {
        words[i].handle_quotes(serr, ierr);
    }
}


// ===========================================================================
// The execution line arguments are expected to be of the form
//     -v r1=5 -v somevar = 14
// The -v is a keyword indicating that a variable setting follows. There is
// no $ because the shell does not allow that.
// At this point the execution line arguments have been parsed into words.
// This function extracts the variable definitions, inserts the $, and turns
// them into separate lines, and returns that in string sout. Then the
// parser can simply add that to the top of the user input file.
// ===========================================================================
void Cmd::handle_exe_args(string &sout)
{
  // We use a stringstream here instead of modifying sout directly so that
  // we can use endl instead of \n since endl is portable and \n is not.
  stringstream ss;
  bool line;
  for (int i=0; i<(int)words.size()-1; i++) {
    // if you hit a -<letter>
    if (words[i].get_string() == "-" &&
        ( words[i+1].get_string() == "v" ||
          words[i+1].get_string() == "l" ) ) {
      // get type of argument
      line = true;
      if( words[i+1].get_string() == "v" ){
        line = false;
      }
      // move in after the -<letter> and stuff line until next -<letter>
      int istart = i+2;
      for (int j=istart; j<(int)words.size(); j++) {
        // stop at next -<letter>
        if (j < (int)words.size()-1) {
          if (words[j].get_string() == "-" &&
              ( words[j+1].get_string() == "v" ||
                words[j+1].get_string() == "l" ) ) {
            break;
          }
        }
        string sj = words[j].get_string();
        if (j == istart && !line) {
          sj.insert(sj.begin(), '$');
        }
        ss << sj << " ";
      }
      ss << endl;
    }
  }
  sout = ss.str();
}


// ===========================================================================
// Consider the following input
//     2.0, 3.0 e15, -7.0
// The issue is with the middle two words, "3.0 e15", the old parser ignored
// the space and treated this as one word, 3.0e15. The new parser treats is
// as two words.
//
// This should have been treated as an input error by the old parser but was
// not, so now we have to deal with it.
//
// This routine detects this situation and allows the calling code to deal
// with it according to the action input, allowed action values are:
//
//    ignore      Treat it as two words and silently continue.
//    fix         Merge the two words into one word, as the old parser did.
//    error       Generate a fatal error, force the user to fix it.
//
// ===========================================================================
void Cmd::deprecated_input01(string action, stringstream &serr, int &ierr)
{
    //if (cmd_name != "depcmd01") return;

    if (cmd_type != "command") return;

    for (int i=0; i<(int)words.size()-2; i++) {
        // A comma must be found first.
        if (!words[i].is_comma()) continue;

        // There could be a unary plus or minus on the next number, if so
        // then skip it. At this point, the unary plus and minus have not
        // been merged with their number.
        int in1 = i+1;
        string spm = words[i+1].get_string();
        string s1;
        if (spm == "+" || spm == "-") {
            s1 = spm;
            in1 += 1;
        }
        s1 += words[in1].get_string();

        // in1 is where the first number is, it needs to be a number.
        if (!words[in1].is_number()) continue;

        // in2 is where the second number is, it needs to be a number.
        int in2 = in1 + 1;
        if (in2 > (int)words.size() - 1) break;
        if (!words[in2].is_number()) continue;
        string s2 = words[in2].get_string();
        s2.erase(s2.begin());

        // The first character of the second number should be an e or E.
        // But at this point we have already detected this and prepended
        // a 1 on to the word. So the first character should be 1 and the
        // second character should be e or E
        char c30 = words[in2].get_string()[0];
        if (c30 != '1') continue;

        char c31 = words[in2].get_string()[1];
        if (c31 != 'e' && c31 != 'E') continue;

        // The next word, if present should be a comma.
        int ic2 = in2 + 1;
        if (ic2 <= (int)words.size()-1) {
            if (!words[ic2].is_comma()) continue;
        }

        // A deprecated input has been found, ignore it, fix it, or
        // generate a fatal error.
        if (action == "ignore") continue;
        if (action == "fix") {
            words[in2].erase_char(0);
            merge_words(in1, in2);
            continue;
        }
        if (action == "error") {
            words[in1].fatal_error(serr, ierr);
            serr << "Possible error, detected the following" << endl;
            serr << "   comma digits space exponent comma" << endl;
            serr << "The digits and exponent are separated by one or more spaces,"
                 << endl;
            serr << "this is not allowed for a single number." << endl;
            serr << "The digits are: " << s1 << "  and the exponent is: "
                 << s2 << endl;
            serr << "If this is one number, then remove the space." << endl;
            serr << "If this is two numbers, then put a comma between the"
                 << " digits and exponent."<< endl;
            serr << "This error (and the same error in subsequent lines) can"
                 << endl;
            serr << "be controlled with the following input file command"
                 << endl;
            serr << "and arguments (put before the lines with errors)" << endl;
            serr << "      depcmd_dse argument" << endl;
            serr << "where argument has one of the following values:" << endl;
            serr << "      fix     Silently remove the space, merge into one number" << endl;
            serr << "      ignore  Silently treat as two numbers" << endl;
            serr << "      error   Generate fatal error (default)" << endl;
            serr << "While the default is to generate an error, if the" << endl;
            serr << "command name is matdef, then the default is fix." << endl;
            ierr = 2;
            continue;
        }
    }
}


// ===========================================================================
// Fatal error
// This is mainly meant to be called from some other class that does not
// know about words.
// ===========================================================================
void Cmd::fatal_error(int iw, stringstream &serr, int &ierr)
{
    // To suppress compiler warnings of unused parameters
    assert(ierr == ierr);

    int lnum = words[iw].get_line_number();
    int file_lnum = words[iw].get_file_line_number();
    string fname = words[iw].get_filename();
    serr << endl;
    serr << "*** FATAL ERROR in line " << file_lnum << ":" << endl;
    serr << "    " << (*lines)[lnum-1] << endl;
    serr << "in file: " << fname << endl;
}

// ===========================================================================
// This is meant to be called from within this class.
// ===========================================================================
void Cmd::fatal_error2(stringstream &serr, int &ierr)
{
    // To suppress compiler warnings of unused parameters
    assert(ierr == ierr);

    serr << endl;
    serr << "*** FATAL ERROR in line " << file_line_number << ":" << endl;
    serr << "    " << (*lines)[line_number-1] << endl;
    serr << "in file: " << filename << endl;
}


// ===========================================================================
// Warning
// ===========================================================================
void Cmd::warning(int iw, stringstream &serr, int &ierr)
{
    // To suppress compiler warnings of unused parameters
    assert(ierr == ierr);

    int lnum = words[iw].get_line_number();
    int file_lnum = words[iw].get_file_line_number();
    string fname = words[iw].get_filename();
    serr << endl;
    serr << "*** WARNING in line " << file_lnum << ":" << endl;
    serr << "    " << (*lines)[lnum-1] << endl;
    serr << "in file: " << fname << endl;
}


// ===========================================================================
// This is used when printing duplicate lines warnings.
// ===========================================================================
void Cmd::print_duplicate_line(int iw, stringstream &ss, int fn_width,
                               int lnum_width, string after_lnum)
{
    int lnum = words[iw].get_line_number();
    int file_lnum = words[iw].get_file_line_number();
    string fname = words[iw].get_filename();
    ss << setw(fn_width) << fname;
    ss << setw(lnum_width) << file_lnum << after_lnum;
    ss << (*lines)[lnum-1];
    //print_using_words_fm(ss);
}


// ===========================================================================
// Get the filename size and line number size for formatting purposes
// when printing duplicate lines warnings.
// ===========================================================================
void Cmd::get_duplicate_sizes(int iw, int &fn_width, int &lnum_width)
{
    int file_lnum = words[iw].get_file_line_number();
    string fname = words[iw].get_filename();
    fn_width = (int)fname.size();
    lnum_width = 1;
    if (file_lnum >= 10)       lnum_width = 2;
    if (file_lnum >= 100)      lnum_width = 3;
    if (file_lnum >= 1000)     lnum_width = 4;
    if (file_lnum >= 10000)    lnum_width = 5;
    if (file_lnum >= 100000)   lnum_width = 6;
    if (file_lnum >= 1000000)  lnum_width = 7;
}


// ===========================================================================
// Look at the places where this function is called to understand the
// following indices.
//     wdex = i    Index into the words array.
//     cdex = k    C index in the output array.
// ===========================================================================
void Cmd::error_dup_line(string &cname, int wdex, int cdex,
                         vector<int> &dup_wdex1, vector<Cmd *> &dup_cmd1,
                         vector<int> &dup_vals, const vector<int> &size,
                         int dup_fatal, stringstream &serr, int &ierr)
{
    if (dup_vals[cdex] == 0) {
        dup_cmd1[cdex] = this;
        dup_wdex1[cdex] = wdex;
    }
    dup_vals[cdex] += 1;
    if (dup_fatal == 0) return;
    if (dup_vals[cdex] > 1) {
        int wdex1 = dup_wdex1[cdex];
        Cmd *cmd = dup_cmd1[cdex];

        // Get the dimension of the array, 0,1,2,3,...
        int dim = (int)size.size();

        if (dup_fatal == 2) words[wdex].fatal_error(serr, ierr);
        if (dup_fatal == 1) words[wdex].warning(serr, ierr);
        int tot_size = 1;
        for (int ts=0; ts<dim; ts++) {
            tot_size *= size[ts];
        }
        vector<int> irdices(dim, 0);
        Parser_utils putils(index_base);
        putils.reverse_dex(cdex, tot_size, irdices, size);
        serr << "A duplicate value has been specified for: " << cname << "(";
        for (int irdex=0; irdex<dim; irdex++) {
            serr << irdices[irdex];
            if (irdex < dim-1) serr << ",";
        }
        serr << ") = " <<
            words[wdex].get_string() << endl;

        serr << "This array element was first specified in line " <<
            cmd->get_file_line_number(wdex1) << endl;
        string fname = cmd->get_filename(wdex1);
        serr << "    " << (*lines)[cmd->get_line_number(wdex1)-1] <<
            endl;
        serr << "in file: " << fname << endl;

        if (dup_fatal == 2) {
            serr << "This fatal error can be turned into a warning with the command " <<
                endl << "    duplicate_array_values = warning" << endl;
        }
        if (dup_fatal == 1) {
            serr << "This warning can be turned into a fatal error with the command " <<
                endl << "    duplicate_array_values = fatal" << endl;
        }
        serr << "Duplicate array value checking can be turned off totally with" <<
            endl << "    duplicate_array_values = none" << endl;
        serr << "This is not recommended since you will lose the opportunity" <<
            endl << "to check for legimate errors in your input." << endl;

        ierr = 1;
        if (dup_fatal == 2) ierr = 3;
    }
}


// ===========================================================================
// There are some commands that can be written as two words such as "end if",
// "else if", and "end do". Find these and combine them into one word.
// ===========================================================================
void Cmd::handle_two_words()
{
    // Handle + + -> ++
    for (int i=0; i<(int)words.size()-1; i++) {
        if (words[i].get_string() == "+" && words[i+1].get_string() == "+") {
            bool combine = false;
            if (i == (int)words.size()-2) combine = true;
            if (i < (int)words.size()-2) {
                if (!words[i+2].is_numvar()) combine = true;
            }
            if (combine) {
                int lnum = words[i].get_line_number();
                int file_lnum = words[i].get_file_line_number();
                string fname = words[i].get_filename();
                string s = "++";
                Word w(s, lnum, file_lnum, fname, lines);
                replace_words(i, i+1, w);
            }
        }
    }

    // Handle - - -> --
    for (int i=0; i<(int)words.size()-1; i++) {
        if (words[i].get_string() == "-" && words[i+1].get_string() == "-") {
            bool combine = false;
            if (i == (int)words.size()-2) combine = true;
            if (i < (int)words.size()-2) {
                if (!words[i+2].is_numvar()) combine = true;
            }
            if (combine) {
                int lnum = words[i].get_line_number();
                int file_lnum = words[i].get_file_line_number();
                string fname = words[i].get_filename();
                string s = "--";
                Word w(s, lnum, file_lnum, fname, lines);
                replace_words(i, i+1, w);
            }
        }
    }


    // The rest of these have at least two words on the line,
    // like "end subroutine".
    if ((int)words.size() < 2) return;

    // Common settings.
    int lnum = words[0].get_line_number();
    int file_lnum = words[0].get_file_line_number();
    string fname = words[0].get_filename();

    // Handle the case where enddo is written as two
    // words, just combine them into one word.
    if (words[0].get_string() == "end" && words[1].get_string() == "do") {
        string s = "enddo";
        Word w(s, lnum, file_lnum, fname, lines);
        replace_words(0, 1, w);
    }

    // Handle the case where endsubroutine is written as two
    // words, just combine them into one word.
    if (words[0].get_string() == "end" && words[1].get_string() == "subroutine") {
        string s = "endsubroutine";
        Word w(s, lnum, file_lnum, fname, lines);
        replace_words(0, 1, w);
    }

    // Handle the case where endwhen is written as two
    // words, just combine them into one word.
    if (words[0].get_string() == "end" && words[1].get_string() == "when") {
        string s = "endwhen";
        Word w(s, lnum, file_lnum, fname, lines);
        replace_words(0, 1, w);
    }

    // Handle the case where endif and elseif are written as two
    // words, just combine them into one word.
    if (words[0].get_string() == "end" && words[1].get_string() == "if") {
        string s = "endif";
        Word w(s, lnum, file_lnum, fname, lines);
        replace_words(0, 1, w);
    }
    if (words[0].get_string() == "else" && words[1].get_string() == "if") {
        string s = "elseif";
        Word w(s, lnum, file_lnum, fname, lines);
        replace_words(0, 1, w);
    }
}


// ===========================================================================
// Check for end of input. There are several ways user input ends:
//    End of file
//    Encounter a stop command
//    Encounter a fatal error command.
// ===========================================================================
bool Cmd::check_input_end(bool kill_run, stringstream &serr, int &ierr)
{
    // To suppress compiler warnings of unused parameters
    assert(kill_run == kill_run);

    if (words[0].get_string() == "fatal_error") {
        int lnum = words[0].get_line_number();
        int file_lnum = words[0].get_file_line_number();
        string fname = words[0].get_filename();
        serr << endl;
        serr << "*** User has issued a fatal_error command in line "
             << file_lnum << ":" << endl;
        serr << "    " << (*lines)[lnum-1] << endl;
        serr << "in file: " << fname << endl;
        serr << endl << "The user supplied fatal_error message is: " << endl;
        serr << "    ";
        string s = (*lines)[lnum-1];
        int i1 = s.find("f", 0);
        for (int i=i1+12; i<(int)s.size(); i++) {
            serr << s[i];
        }
        serr << endl;
        ierr = 2;
        return true;
    }

    if (words[0].get_string() == "stop") return true;
    return false;
}


// ***************************************************************************
// ***************************************************************************
// Operations on the deque of words.
// ***************************************************************************
// ***************************************************************************

// ===========================================================================
// Find the first occurrence of string s in part of the line.
// ===========================================================================
int Cmd::find(int i1, int i2, string s)
{
    for (int i=i1; i<=i2; i++) {
        if (words[i].get_string() == s) {
            return i;
        }
    }
    return -1;
}


// ===========================================================================
// Find the first occurrence of any character in string s in part of
// the line.
// ===========================================================================
int Cmd::find_any_char(int i1, int i2, string s)
{
    for (int i=i1; i<=i2; i++) {
        for (int j=0; j<(int)s.size(); j++) {
            string ssub = s.substr(j, 1);
            if (words[i].get_string() == ssub) {
                return i;
            }
        }
    }
    return -1;
}


// ===========================================================================
// Find the last occurrence of string s in the line.
// ===========================================================================
int Cmd::find_last(string s, int i1, int i2)
{
    int iloc = -1;
    for (int i=i1; i<=i2; i++) {
        if (words[i].get_string() == s) {
            iloc = i;
        }
    }
    return iloc;
}


// ===========================================================================
// Given an input string, fstr, and a sub string, subs, find the first
// occurrence of subs in fstr. Return in the string vector, vs, the string
// to the left of subs, if any, the sub string itself, subs, and the string
// to the right of subs, if any.
// ===========================================================================
bool Cmd::separate_str(string &subs, string &fstr, vector<string> &vs)
{
    // Make sure the return vector is empty.
    vs.clear();

    // Find the sub string, if not found, then nothing more to do.
    int loc = (int)fstr.find(subs,0);
    if (loc == (int)string::npos) return false;

    // If fstr only contains subs and nothing more, then there is nothing
    // to do.
    if (subs == fstr) return false;

    // Anything to the left of the sub string is the first string returned.
    if (loc > 0) {
        string s1 = fstr.substr(0,loc);
        vs.push_back(s1);
    }

    // The sub string itself is the second string returned.
    vs.push_back(subs);

    // Find the number of characters to the right of the sub string.
    int subs_len = (int)subs.size();
    int fstr_len = (int)fstr.size();
    int istart = loc + subs_len;
    int nchar = fstr_len - istart;

    // Anything to the right of the sub string is the third string returned.
    if (nchar > 0) {
        string s2 = fstr.substr(istart,nchar);
        vs.push_back(s2);
    }

    return true;
}


// ===========================================================================
// Find the location of the closing symbol that matches the opening symbol.
// Symbol examples are (), [], {}
// We assume that the opening symbol has been found and we are starting the
// search after the opening symbol location.
// Nesting is handled, for example, (...(...(...)...)...)
// ===========================================================================
int Cmd::find_closing_symbol(string opensym, string closesym, int i1)
{
    int level = 0;
    for (int i=i1; i<(int)words.size(); i++) {
        string w = words[i].get_string();
        if (w == opensym) {
            level += 1;
            continue;
        }
        if (w == closesym) {
            if (level == 0) return i;
            level -= 1;
            continue;
        }
    }
    return -1;
}


// ===========================================================================
// Delete words i1 through i2 inclusive from the deque.
// ===========================================================================
void Cmd::delete_words(int i1, int i2)
{
    deque<Word>::iterator p = words.begin();
    words.erase(p + i1, p + i2 + 1);
}


// ===========================================================================
// Replace words i1 through i2 inclusive with word w.
// ===========================================================================
void Cmd::replace_words(int i1, int i2, Word &w)
{
    delete_words(i1, i2);
    deque<Word>::iterator p = words.begin();
    words.insert(p + i1, w);
}


// ===========================================================================
// Replace words i1 through i2 inclusive with all the words in vector vw.
// ===========================================================================
void Cmd::replace_words(int i1, int i2, vector<Word> &vw)
{
    delete_words(i1, i2);
    for (int i=(int)vw.size()-1; i>=0; i--) {
        deque<Word>::iterator p = words.begin();
        words.insert(p + i1, vw[i]);
    }
}


// ===========================================================================
// Merge words i1 through i2 inclusive into one word located at i1, remove
// words i1+1 through i2 inclusive.
// ===========================================================================
void Cmd::merge_words(int i1, int i2)
{
    int lnum = words[i1].get_line_number();
    int file_lnum = words[i1].get_file_line_number();
    string fname = words[i1].get_filename();
    string s = words[i1].get_string();

    for (int i=i1+1; i<=i2; i++) {
        s += words[i].get_string();
    }

    Word w(s, lnum, file_lnum, fname, lines);
    replace_words(i1, i2, w);
}


// ===========================================================================
// Find the equals sign on the line.
// ===========================================================================
int Cmd::find_equals()
{
    int ieq = -1;
    for (int i=0; i<(int)words.size(); i++) {
        if (words[i].get_string() == "=") {
            ieq = i;
            break;
        }
    }
    return ieq;
}


// ***************************************************************************
// ***************************************************************************
// Handle processed flags.
// ***************************************************************************
// ***************************************************************************

// ===========================================================================
// Set all the processed flags in the line to be false.
// ===========================================================================
void Cmd::clear_processed()
{
    for (int i=0; i<(int)words.size(); i++) {
        words[i].set_processed(false);
    }
}

void Cmd::set_processed(bool ip)
{
    for (int i=0; i<(int)words.size(); i++) {
        words[i].set_processed(ip);
    }
}


// ===========================================================================
// Check processed flags for each word.
// ===========================================================================
void Cmd::check_processed(bool &good, stringstream &serr, int &ierr)
{
    // First we check to see if any of the words on the line have been
    // processed. If none of the words have been processed, then we print
    // the entire line as an error. This saves the user from having to
    // wade through an error print for every word on the line.
    bool p = false;
    for (int i=0; i<(int)words.size(); i++) {
        p = words[i].get_processed();
        if (p) break;
    }

    if (!p) {
        good = false;
        words[0].fatal_error(serr, ierr);
        serr << "This line has not been processed." << endl;
        ierr = 2;

        return;
    }


    // At least one word on the line has been processed.
    // Check all the words on the line, throw an error for any word not
    // processed.
    for (int i=0; i<(int)words.size(); i++) {
        p = words[i].get_processed();

        if (!p) {
            good = false;
            words[i].fatal_error(serr, ierr);
            serr << "A word on this line has not been processed." << endl;
            serr << "Not proccessed word = " << words[i].get_string() << endl;
            ierr = 2;

        }
    }
}


// ***************************************************************************
// ***************************************************************************
// Debug
// ***************************************************************************
// ***************************************************************************

// ===========================================================================
// Print all the words on the line mainly for debugging.
// Output is to a stringstream so the calling method can decide what to do
// with the output - send it to the screen, use it for testing, whatever.
// ===========================================================================
void Cmd::print_all_words()
{
    stringstream ss;
    print_all_words(ss);
    cout << ss.str();
}

void Cmd::print_all_words(stringstream &ss)
{
    ss << "*** Command name = " << cmd_name << endl;
    for (int i=0; i<(int)words.size(); i++) {
        stringstream ss2;
        words[i].print_type(ss2);
        ss << words[i].get_string() << " " << ss2.str() << endl;
    }
    ss << endl;
}


// ===========================================================================
// Print all the words on the line mainly for debugging.
// Output is to a stringstream so the calling method can decide what to do
// with the output - send it to the screen, use it for testing, whatever.
// ===========================================================================
void Cmd::print_using_words(stringstream &ss)
{
    for (int i=0; i<(int)words.size(); i++) {
        bool enc_quote = true;
        if (i == 0) enc_quote = false;
        ss << words[i].get_print_string(enc_quote) << " ";
    }
}

// ===========================================================================
// Another version of printing all the words on the line.
// This version is mainly for printing out the final cmds buffer.
//
// The output is formatted, commas are put back in, spaces are handled better,
// if a line is too long (see nctot_max), it is split into more than one line.
//
// For example, suppose the words on a line were
//     a4d ( 1 1 1 2 ) = -3.4 4.7 5.2 4.6e19
// spaces are used to delimit the words, but it is not very readable. This
// routine will print the above line as
//     a4d(1, 1, 1, 2) = -3.4, 4.7, 5.2, 4.6e19
// This has the added advantage that spaces can be eliminated and a compact
// form can be achieved.
//
// Another example is the line
//    strinsert_cmd01 = Use The Force
// The string "Use The Force" is actually one word, even though it appears to
// be three words. This routine prints this correctly as
//    strinsert_cmd01 = "Use The Force"
// ===========================================================================
void Cmd::print_using_words_fm(stringstream &ss)
{
    //debug_print_words("print_using_words_fm");
    int nctot_max = 75;
    int istart = 0;
    int ieq = -1;
    int ip1 = -1;
    int ip2 = -1;
    for (;;) {
        if (istart > 0) ss << "     ";
        int nctot = 0;
        bool done = false;
        for (int i=istart; i<(int)words.size(); i++) {
            bool enc_quote = true;
            if (i == 0) enc_quote = false;
            string s = words[i].get_print_string(enc_quote);
            if (s == "=") ieq = i;
            if (s == "(") ip1 = i;
            if (s == ")") ip2 = i;
            string sp = "";
            if (i<(int)words.size()-1) {
                sp = words[i+1].get_print_string(enc_quote);
            }
            if (sp == ")") ip2 = i+1;
            int nc = (int)s.size();
            if ((i>istart) && (nc+1+nctot > nctot_max)) {
                istart = i;
                break;
            }
            if (i >= (int)words.size()-1) {
                done = true;
                ss << s;
            }
            else {
                string endstr = " ";
                int endinc = 1;
                if (ieq > -1) {
                    if (i > ieq) {
                        endstr = ", ";
                        endinc = 2;
                    }
                }
                if (ip1 > -1 && (ip2 == -1 || i < ip2)) {
                    if (i > ip1 && (ip2 == -1 || i < ip2-1)) {
                        endstr = ", ";
                        endinc = 2;
                    }
                }                    
                if (endstr == " ") {
                    if (s == "(") {
                        endstr = "";
                        endinc = 0;
                    }
                    if (i == ip2-1) {
                        endstr = "";
                        endinc = 0;
                    }
                    if (i == 0 && sp == "(") {
                        endstr = "";
                        endinc = 0;
                    }
                }
                ss << s << endstr;
                nctot += nc + endinc;
            }
        }
        if (done) break;
        ss << endl;
    }
}


// ===========================================================================
// Print the original command before processing, mainly for debugging.
// Output is to a stringstream so the calling method can decide what to do
// with the output - send it to the screen, use it for testing, whatever.
// ===========================================================================
void Cmd::print_original_string(stringstream &ss)
{
    ss << original_str;
}


// ===========================================================================
// This is mainly for debugging this class. It prints on all procs.
// ===========================================================================
void Cmd::debug_print_words(string s)
{
    cout << s << endl;
    cout << "    ";
    for (int i=0; i<(int)words.size(); i++) {
        bool enc_quote = true;
        if (i == 0) enc_quote = false;
        cout << words[i].get_print_string(enc_quote) << " ";
    }
    cout << endl;
}


} // End of the PP namespace