| /* 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 |
| */ |
| |
| #ifndef CMDHHINCLUDE |
| #define CMDHHINCLUDE |
| |
| // *************************************************************************** |
| // *************************************************************************** |
| // Generalized command class. |
| // *************************************************************************** |
| // *************************************************************************** |
| |
| #include <string> |
| #include <deque> |
| #include <vector> |
| #include <map> |
| #include <sstream> |
| #include "Variable.hh" |
| #include "Function.hh" |
| |
| namespace PP |
| { |
| using std::string; |
| using std::deque; |
| using std::vector; |
| using std::map; |
| using std::stringstream; |
| |
| //class Variable; |
| //class Function; |
| |
| class Cmd |
| { |
| public: |
| 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); |
| |
| void set_index_base(int base); |
| void set_case_sensitive(bool case_sensitive_in); |
| |
| void add_word(string str, int lnum, int file_lnum, string fname); |
| void erase_word(int iw); |
| void erase_last_word(); |
| void reset_name_type(); |
| void delete_words(int i1, int i2); |
| void check_ppmm(stringstream &serr, int &ierr); |
| void remove_commas(); |
| void handle_two_words(); |
| bool check_input_end(bool kill_run, stringstream &serr, int &ierr); |
| void print_duplicate_line(int iw, stringstream &ss, int fn_width, |
| int lnum_width, string after_lnum); |
| void get_duplicate_sizes(int iw, int &fn_width, int &lnum_width); |
| |
| string get_cmd_filename(stringstream &ssfiles); |
| void handle_quotes(stringstream &serr, int &ierr); |
| void handle_exe_args(string &sout); |
| void deprecated_input01(string action, stringstream &serr, int &ierr); |
| void fatal_error(int iw, stringstream &serr, int &ierr); |
| void warning(int iw, stringstream &serr, int &ierr); |
| |
| void 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); |
| |
| void 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); |
| |
| void 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); |
| |
| void 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); |
| |
| void 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); |
| |
| void 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); |
| |
| void get_size(vector<int> &size, stringstream &serr, int &ierr); |
| void get_sizeb(vector<int> &size, stringstream &serr, int &ierr); |
| |
| // Handle unary minus and plus in command lines. |
| void handle_cmd_unary_minus(stringstream &serr, int &ierr); |
| void handle_cmd_unary_plus(stringstream &serr, int &ierr); |
| |
| // Handle multiplicity in command lines, i.e. a(1)=15*3.0 |
| void handle_cmd_multiplicity(stringstream &serr, int &ierr); |
| |
| // Handle variables. |
| bool check_for_dimension(stringstream &serr, int &ierr); |
| bool check_for_var_description(stringstream &serr, int &ierr); |
| void substitute_variables(stringstream &serr, int &ierr); |
| void set_variables(stringstream &serr, int &ierr); |
| |
| // Math evaluation. |
| void math_eval(stringstream &serr, int &ierr); |
| void check_misplaced_math(stringstream &serr, int &ierr); |
| |
| // Handle comments. |
| void single_line_comments(); |
| void multi_line_comments(int &level); |
| |
| // Handle processed flags. |
| void clear_processed(); |
| void set_processed(bool ip); |
| void check_processed(bool &good, stringstream &serr, int &ierr); |
| |
| // If statements. |
| void handle_if(bool &skip, deque<bool> &skip_level, |
| deque<bool> &satisfied, |
| stringstream &serr, int &ierr); |
| |
| // Do loops. |
| void handle_do(bool &skip, deque<int> &do_start, int &cdex, |
| bool &end_do_loop, stringstream &serr, int &ierr); |
| bool find_matching_enddo(int &dlev, bool &stop_checking); |
| |
| // Subroutines |
| void handle_subroutines(bool &skip, |
| bool &go_to_sub, string &sub_name, |
| bool &go_to_call, |
| stringstream &serr, int &ierr); |
| bool find_subroutine(string &sub_name); |
| void get_call_args(vector<string> &sargs, vector<bool> &sargs_isvar, |
| stringstream &serr, int &ierr); |
| void get_sub_args(vector<string> &sargs, vector<bool> &sargs_isvar); |
| void copy_call_args(vector<string> &sargs, vector<bool> &sargs_isvar); |
| void copy_sub_args(vector<string> &sargs, vector<bool> &sargs_isvar); |
| |
| // Accessor functions. |
| string get_cmd_name() { return cmd_name; } |
| string get_cmd_type() { return cmd_type; } |
| int get_nwords() { return words.size(); } |
| string get_string(int iw) { |
| if ((int)words.size() <= iw) return ""; |
| return words[iw].get_string(); |
| } |
| string get_original_str() { return original_str; } |
| |
| int get_line_number(int iw) { return words[iw].get_line_number(); } |
| int get_file_line_number(int iw) { return words[iw].get_file_line_number(); } |
| string get_filename(int iw) { return words[iw].get_filename(); } |
| string get_filename() { return filename; } |
| deque<string> *get_lines() { return lines; } |
| |
| void set_filename(string fn) { |
| filename = fn; |
| for (int iw=0; iw<(int)words.size(); iw++) { |
| words[iw].set_filename(fn); |
| } |
| } |
| |
| bool is_include() { if(words[0].get_string() == "include") return true; |
| return false; } |
| |
| // Debug |
| void print_all_words(); |
| void print_all_words(stringstream &ss); |
| void print_using_words(stringstream &ss); |
| void print_using_words_fm(stringstream &ss); |
| void print_original_string(stringstream &ss); |
| |
| |
| private: |
| // Initialization method for this class. |
| void init(); |
| |
| void process_string(string in_str, stringstream &serr, int &ierr); |
| bool extract_next_word(int &istart, string &str, string &word, |
| stringstream &serr, int &ierr); |
| int find_closing_symbol(string opensym, string closesym, int i1); |
| bool handle_innermost_parens(int &i1, int &i2, int &iwres, int &nargs, |
| bool remp, stringstream &serr, int &ierr); |
| void evaluate_function(int iw1, int &i2, int &nargs, |
| stringstream &serr, int &ierr); |
| void seval(int &i1, int &i2, stringstream &serr, int &ierr); |
| void handle_unary_op(int i1, int &i2, string utype, |
| stringstream &serr, int &ierr); |
| void do_unary_op(int ip, string utype); |
| void handle_star_star(); // ** exponentiation |
| void handle_ops(); |
| |
| void subvar_w0(int i1, int &i2, stringstream &serr, int &ierr); |
| void subvar0(int vardex, string &varname, int increment, |
| stringstream &serr, int &ierr); |
| bool evaluate_variable(int iw1, int &i2, int &nargs, |
| stringstream &serr, int &ierr); |
| |
| int find(int i1, int i2, string s); |
| int find_last(string s, int i1, int i2); |
| int find_any_char(int i1, int i2, string s); |
| void replace_words(int i1, int i2, Word &w); |
| void replace_words(int i1, int i2, vector<Word> &vw); |
| void merge_words(int i1, int i2); |
| bool separate_str(string &subs, string &fstr, vector<string> &vs); |
| int find_equals(); |
| |
| bool check_syntax(vector<int> &istart, stringstream &serr, int &ierr); |
| bool get_nvals(vector<int> &istart, const vector<int> &size, |
| int &nvals, stringstream &serr, int &ierr); |
| void debug_print_words(string s); |
| |
| void fatal_error2(stringstream &serr, int &ierr); |
| void 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); |
| |
| |
| // This is needed for telling the user what line in the input |
| // file or include file the error occurred on. |
| // |
| // line_number The line_number corresponding to this command, this is |
| // an index into lines and starts from 1, not 0. |
| // lines Pointer to the deque of original lines. This contains all |
| // the lines from the input file and any include files. |
| // file_line_number The line number in the input file or include file. |
| // filename The name of the input file or include file. |
| // |
| // file_line_number and filename are needed to that the user can open |
| // the file and go to the line in error. |
| int line_number, file_line_number; |
| string filename; |
| deque<string> *lines; |
| |
| // index base, generally 1 for Fortran style and 0 for C/C++, default 1 |
| // int index_base; -- using static variable instead |
| |
| // The original string before processing. |
| string original_str; |
| |
| // Pointer to the map of variables. |
| map<string, Variable> *vmap; |
| |
| // Pointer to the map of functions. |
| map<string, Function> *fmap; |
| |
| // Definitions of white space, delimiters, etc. |
| string white_space; |
| string delims; |
| |
| // Storage for all the words on the line. |
| deque <Word> words; |
| |
| // The name and type of the command. |
| string cmd_name; |
| string cmd_type; |
| |
| // Used for subroutines. |
| vector<string> call_args, sub_args; |
| vector<bool> call_args_isvar, sub_args_isvar; |
| }; |
| |
| |
| } // end of PP namespace |
| |
| #endif |
| |
