| /* 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 information about a variable. It is mostly for use with |
| // the parser. |
| // *************************************************************************** |
| // *************************************************************************** |
| |
| #include <iostream> |
| #include <iomanip> |
| #include <string> |
| #include <sstream> |
| #include <vector> |
| #include <deque> |
| |
| #include "Parser_utils.hh" |
| #include "Word.hh" |
| #include "Variable.hh" |
| |
| namespace PP |
| { |
| using std:: string; |
| using std::cout; |
| using std::endl; |
| using std::stringstream; |
| using std::setprecision; |
| using std::vector; |
| using std::deque; |
| |
| static int index_base = 1; |
| |
| |
| // =========================================================================== |
| // Default constructor. |
| // =========================================================================== |
| Variable::Variable() |
| { |
| name = "__NO_NAME_GIVEN__"; |
| value.push_back("__NO_VALUE_GIVEN__"); |
| ndim = -1; |
| lnum_ndim = 0; |
| lnum_bounds = 0; |
| pre_defined = false; |
| description = ""; |
| temporary = false; |
| } |
| |
| // =========================================================================== |
| // Constructor to reset index base |
| // =========================================================================== |
| Variable::Variable(int base) |
| { |
| index_base = base; |
| } |
| |
| // =========================================================================== |
| // Constructor given a string as input. This constructs a scalar variable. |
| // =========================================================================== |
| Variable::Variable(string nme, string v, bool pred, string tdes) |
| { |
| name = nme; |
| value.push_back(v); |
| ndim = 0; |
| lnum_ndim = 0; |
| lnum_bounds = 0; |
| pre_defined = pred; |
| description = tdes; |
| temporary = false; |
| } |
| |
| |
| // =========================================================================== |
| // Constructor for variables with no value. |
| // =========================================================================== |
| Variable::Variable(string nme) |
| { |
| name = nme; |
| value.push_back("__NO_VALUE_GIVEN__"); |
| ndim = -1; |
| lnum_ndim = 0; |
| lnum_bounds = 0; |
| pre_defined = false; |
| description = ""; |
| temporary = false; |
| } |
| |
| |
| // =========================================================================== |
| // Constructor given a vector of strings as input. |
| // =========================================================================== |
| Variable::Variable(string nme, vector<int> &istart, vector<string> &valvec, |
| int lnum, int file_lnum, string fname, deque<string> *lines, |
| stringstream &serr, int &ierr) |
| { |
| name = nme; |
| ndim = -1; |
| lnum_ndim = 0; |
| lnum_bounds = 0; |
| pre_defined = false; |
| description = ""; |
| temporary = false; |
| set_var_value(istart, valvec, lnum, file_lnum, fname, lines, serr, ierr); |
| } |
| |
| |
| // =========================================================================== |
| // istart gives the starting location in the array for setting values. |
| // The istart indices start from 1 (fortran based). |
| // |
| // This function works for any dimension, 0,1,2,3,... |
| // =========================================================================== |
| void Variable::set_var_value(vector<int> &istart, vector<string> &valvec, |
| int lnum, int file_lnum, string fname, |
| deque<string> *lines, stringstream &serr, int &ierr) |
| { |
| // Cannot redefine a pre-defined variable. |
| if (pre_defined) { |
| serr << endl; |
| serr << "*** FATAL ERROR in line " << file_lnum << ":" << endl; |
| serr << " " << (*lines)[lnum-1] << endl; |
| serr << "in file: " << fname << endl; |
| serr << "Cannot redefine a pre-defined variable." << endl; |
| ierr = 2; |
| return; |
| } |
| |
| // Set the array dimension and make sure the user is not trying to |
| // change it. |
| int ndim_new = (int)istart.size(); |
| if (ndim >= 0) { |
| if (ndim != ndim_new) { |
| // Throw an error |
| serr << endl; |
| serr << "*** FATAL ERROR in line " << file_lnum << ":" << endl; |
| serr << " " << (*lines)[lnum-1] << endl; |
| serr << "in file: " << fname << endl; |
| serr << "Cannot redefine the dimensionality of a variable." << endl; |
| serr << "Original number of dimensions = " << ndim << endl; |
| serr << "New number of dimensions = " << ndim_new << endl; |
| if (lnum_ndim > 0) { |
| serr << "Previously set in line " << lnum_ndim << ":" << endl; |
| serr << " " << (*lines)[lnum_ndim-1] << endl; |
| } |
| ierr = 2; |
| return; |
| } |
| } |
| else { |
| ndim = ndim_new; |
| lnum_ndim = lnum; |
| } |
| |
| int bsize = (int)maxdim.size(); |
| |
| if (ndim == 0 && bsize > 0) { |
| serr << endl; |
| serr << "*** FATAL ERROR in line " << file_lnum << ":" << endl; |
| serr << " " << (*lines)[lnum-1] << endl; |
| serr << "in file: " << fname << endl; |
| serr << "Array boundaries not allowed for scalar variable." << endl; |
| if (lnum_bounds > 0) { |
| serr << "Array boundaries were set in line " << lnum_bounds << ":" << endl; |
| serr << " " << (*lines)[lnum_bounds-1] << endl; |
| } |
| ierr = 2; |
| return; |
| } |
| |
| if (ndim > 0) { |
| if (ndim != bsize+1) { |
| serr << endl; |
| serr << "*** FATAL ERROR in line " << file_lnum << ":" << endl; |
| serr << " " << (*lines)[lnum-1] << endl; |
| serr << "in file: " << fname << endl; |
| serr << "Number of dimensions = " << ndim << endl; |
| serr << "Number of array boundaries + 1 = " << bsize+1 << endl; |
| serr << "These should match but don't. " << endl; |
| ierr = 2; |
| return; |
| } |
| } |
| |
| // Find the 1d starting position given multiple array indices. |
| Parser_utils putils(index_base); |
| int i1 = putils.start_dex(istart, maxdim); |
| |
| // nvals Number of values after the = sign. |
| // Note that multiplicity is already handled, i.e. valvec has already |
| // been expanded to include multiplicites. |
| int nvals = (int)valvec.size(); |
| |
| // Get memory that we need. |
| if (i1+nvals > (int)value.size()) { |
| value.resize(i1+nvals, ""); |
| } |
| |
| // Store the array values. |
| for (int i=i1; i<i1+nvals; i++) { |
| value[i] = valvec[i-i1]; |
| } |
| } |
| |
| |
| // =========================================================================== |
| // Increment (or decrement) a variable value by an integer amount. |
| // =========================================================================== |
| void Variable::bump_var(vector<int> &istart, int increment, |
| int lnum, int file_lnum, string fname, |
| deque<string> *lines, stringstream &serr, int &ierr) |
| { |
| // Find the 1d starting position given multiple array indices. |
| Parser_utils putils(index_base); |
| int i1 = putils.start_dex(istart, maxdim); |
| |
| // We are incrementing an existing variable, so i1 should be valid. |
| if (i1 >= (int)value.size()) { |
| // Fatal Error |
| } |
| |
| Word w1(value[i1], lnum, file_lnum, fname, lines); |
| if (!w1.is_number()) { } // FATAL ERROR |
| |
| stringstream ss; |
| if (w1.is_integer()) { |
| int ia1 = w1.get_int(serr, ierr); |
| int ia = ia1 + increment; |
| ss << ia; |
| } |
| else { |
| double d1 = w1.get_double(serr, ierr); |
| double d = d1 + increment; |
| ss << setprecision(15) << d; |
| } |
| value[i1] = ss.str(); |
| } |
| |
| |
| |
| // =========================================================================== |
| // The problem with multi-dimensional variable arrays is that the user has |
| // to tell us the bounds on every dimension except the last one. This info |
| // is input in the bounds vector and stored. |
| // |
| // This function works for any dimension, 0,1,2,3,... |
| // =========================================================================== |
| void Variable::set_bounds(vector<int> &bounds, int lnum, int file_lnum, |
| string fname, deque<string> *lines, |
| stringstream &serr, int &ierr) |
| |
| { |
| // Cannot redefine a pre-defined variable. |
| if (pre_defined) { |
| serr << endl; |
| serr << "*** FATAL ERROR in line " << file_lnum << ":" << endl; |
| serr << " " << (*lines)[lnum-1] << endl; |
| serr << "in file: " << fname << endl; |
| serr << "Cannot redefine a pre-defined variable." << endl; |
| ierr = 2; |
| return; |
| } |
| |
| // Set the array dimension and make sure the user is not trying to |
| // change it. |
| int ndim_new = (int)bounds.size() + 1; |
| if (ndim >= 0) { |
| if (ndim != ndim_new) { |
| serr << endl; |
| serr << "*** FATAL ERROR in line " << file_lnum << ":" << endl; |
| serr << " " << (*lines)[lnum-1] << endl; |
| serr << "in file: " << fname << endl; |
| serr << "Cannot redefine the dimensionality of a variable " |
| "(set_bounds)." << endl; |
| serr << "Original number of dimensions = " << ndim << endl; |
| serr << "New number of dimensions = " << ndim_new << endl; |
| if (lnum_ndim > 0) { |
| serr << "Previously set in line " << lnum_ndim << ":" << endl; |
| serr << " " << (*lines)[lnum_ndim-1] << endl; |
| } |
| ierr = 2; |
| return; |
| } |
| } |
| else { |
| ndim = ndim_new; |
| lnum_ndim = lnum; // Store line num for better err messages. |
| } |
| |
| // Check to make sure the user is not reseting the bounds. |
| if ((int)maxdim.size() > 0) { |
| serr << endl; |
| serr << "*** FATAL ERROR in line " << file_lnum << ":" << endl; |
| serr << " " << (*lines)[lnum-1] << endl; |
| serr << "in file: " << fname << endl; |
| serr << "The bounds on this array has already been set," << endl; |
| serr << "cannot reset them." << endl; |
| if (lnum_bounds > 0) { |
| serr << "Previously set in line " << lnum_bounds << ":" << endl; |
| serr << " " << (*lines)[lnum_bounds-1] << endl; |
| } |
| ierr = 2; |
| return; |
| } |
| |
| // Store the line num where bounds were set for better err messages. |
| lnum_bounds = lnum; |
| |
| // Store the bounds. |
| maxdim.clear(); |
| for (int i=0; i<(int)bounds.size(); i++) { |
| maxdim.push_back(bounds[i]); |
| } |
| } |
| |
| |
| // =========================================================================== |
| // Given indices, in adex, get the value of the variable. |
| // For example, suppose you want the value of |
| // $var2d(3,5) |
| // The adex vector contains 2 numbers, 3 and 5, for the fortran indices. |
| // The start_dex function is used to get the 1d index into the value array. |
| // |
| // This function works for any dimension, 0,1,2,3,... |
| // =========================================================================== |
| string Variable::get_var_value(vector<int> &adex, string vname, int lnum, |
| int file_lnum, string fname, deque<string> *lines, |
| stringstream &serr, int &ierr) |
| { |
| int adex_size = (int)adex.size(); |
| |
| // Special case for scalar variables. |
| if (ndim == 0 || adex_size == 0) return value[0]; |
| |
| // The adex indices and bounds indices must match. |
| if (adex_size - 1 != (int)maxdim.size()) { |
| serr << endl; |
| serr << "*** FATAL ERROR in line " << file_lnum << ":" << endl; |
| serr << " " << (*lines)[lnum-1] << endl; |
| serr << "in file: " << fname << endl; |
| serr << "The dimensionality of variable " << vname << endl; |
| serr << "does not match what was previously set." << endl; |
| if (lnum_bounds > 0) { |
| serr << "Previous dimensionality set in line " << lnum_bounds << ":" << endl; |
| serr << " " << (*lines)[lnum_bounds-1] << endl; |
| } |
| ierr = 2; |
| return ""; |
| } |
| |
| // Indices cannot exceed max allowed. |
| // Remember that adex if referenced from 1 (fortran index). |
| for (int d=0; d<(int)maxdim.size(); d++) { |
| if (adex[d] > maxdim[d]) { |
| serr << endl; |
| serr << "*** FATAL ERROR in line " << file_lnum << ":" << endl; |
| serr << " " << (*lines)[lnum-1] << endl; |
| serr << "in file: " << fname << endl; |
| serr << "Variable name = " << vname << endl; |
| serr << "The value for dimension " << d+1 << " = " << adex[d] << endl; |
| serr << "This exceeds the max dimension of " << maxdim[d] << endl; |
| if (lnum_bounds > 0) { |
| serr << "The array bounds were set in line " << lnum_bounds << ":" << endl; |
| serr << " " << (*lines)[lnum_bounds-1] << endl; |
| } |
| ierr = 2; |
| } |
| } |
| |
| if (ierr == 2) return ""; |
| |
| // Indices cannot be < 1. |
| for (int d=0; d<(int)adex.size(); d++) { |
| if (adex[d] < 1) { |
| serr << endl; |
| serr << "*** FATAL ERROR in line " << file_lnum << ":" << endl; |
| serr << " " << (*lines)[lnum-1] << endl; |
| serr << "in file: " << fname << endl; |
| serr << "Variable name = " << vname << endl; |
| serr << "Expected index greater than or equal to 1 " << endl; |
| serr << "Instead, index = " << adex[d] << endl; |
| ierr = 2; |
| } |
| } |
| |
| if (ierr == 2) return ""; |
| |
| |
| // Using the indices in adex and the bounds for multi-d arrays, maxdim, |
| // get the 1d index into the value array. |
| Parser_utils putils(index_base); |
| int i1 = putils.start_dex(adex, maxdim); |
| |
| // Check that the value array size has not been exceeded. |
| if (i1 >= (int)value.size()) { |
| serr << endl; |
| serr << "*** FATAL ERROR in line " << file_lnum << ":" << endl; |
| serr << " " << (*lines)[lnum-1] << endl; |
| serr << "in file: " << fname << endl; |
| serr << "Variable name = " << vname << endl; |
| serr << "Exceeded array bounds. Check to make sure you are not" << endl; |
| serr << "requesting an array element you have not yet set." << endl; |
| |
| vector<int> maxdex((int)adex.size(), 0); |
| get_indices((int)value.size()-1, maxdex); |
| for (int d=0; d<(int)adex.size(); d++) { |
| string s = ""; |
| if (adex[d] > maxdex[d]) s = " ERROR, max exceeded"; |
| serr << " Requested index = " << adex[d] |
| << " Max index = " << maxdex[d] << s << endl; |
| } |
| |
| ierr = 2; |
| return ""; |
| } |
| |
| // Return the value. |
| return value[i1]; |
| } |
| |
| |
| |
| // =========================================================================== |
| // Given the 1d index, icdex (starting from 0), find the corresponding |
| // multi dimensional fortran indices (each starting from 1). |
| // |
| // Example 1: Consider a 1d array |
| // var1d(1) = 1 3 5 9 -4 -5 6 |
| // Suppose icdex=3, corresponding to array value 9. |
| // This 1d case is very simple, all we do is add 1 to icdex to get a reference |
| // from 1, thus returning 4. |
| // |
| // Example 1: Consider a 2d array |
| // $var2d(1,1) = 11. 21. 31. 12. 22. 32. 13. 23. 33. |
| // Where the max of the first dimension is 3. Suppose the user specifies |
| // icdex = 5, this corresponds to array value 32. The two indices returned |
| // would be 3,2 (referenced from 1). |
| // |
| // The adex vector contains the output indices, for example 2 this would be 3 |
| // and 2. |
| // |
| // This function works for any dimension, 0,1,2,3,... |
| // =========================================================================== |
| void Variable::get_indices(int icdex, vector<int> &adex) |
| { |
| // Nothing to do for scalar variables. |
| if (ndim == 0) return; |
| |
| // Given icdex, get the indices. |
| int nvalues = (int)value.size(); |
| Parser_utils putils(index_base); |
| putils.reverse_dex(icdex, nvalues, adex, maxdim); |
| } |
| |
| |
| |
| |
| } // End of the PP namespace |
