| /* 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 collects various low level utilities for the parser. |
| // *************************************************************************** |
| // *************************************************************************** |
| |
| #include <iostream> |
| #include <iomanip> |
| #include <string> |
| #include <sstream> |
| #include <vector> |
| #include <deque> |
| |
| #include "Parser_utils.hh" |
| |
| namespace PP |
| { |
| using std:: string; |
| using std::cout; |
| using std::endl; |
| using std::stringstream; |
| using std::setprecision; |
| using std::vector; |
| using std::deque; |
| using std::setw; |
| |
| static int index_base = 1; // For Fortran, 0 for C/C++style |
| |
| |
| // =========================================================================== |
| // Default constructor. |
| // =========================================================================== |
| Parser_utils::Parser_utils(int base) |
| { |
| index_base = base; |
| } |
| |
| |
| // =========================================================================== |
| // Given an array command like |
| // cmd(5,3) = 1.0, 3.0, -5.0 |
| // find the starting position in a 1d array. |
| // |
| // The indices in cmd are referenced from 1 (i.e. fortran) while the 1d array |
| // is referenced from 0 (C++). |
| // |
| // This function works for any dimension array, 0,1,2,3,... |
| // |
| // Example 1: Consider a 1d command |
| // cmd(5) = 1.0, 3.4 |
| // We start filling the 1d fortran array at position 5 and put in two values. |
| // Subtract 1 to reference from 0, so this function returns 4. |
| // |
| // Example 2: Consider the 2d command above: |
| // cmd(5,3) = 1.0, 3.0, -5.0 |
| // We also need to know that the max size of the first dimension is say 7. |
| // Since in fortran, the first index varies fastest, the fortran 1d index |
| // would be |
| // 5 + (3-1)*7 = 19 |
| // Subtract 1 to reference from 0, thus the return value is 18. |
| // |
| // The istart vector contains the indices, for example 2 this would be 5 and |
| // 3. The size vector contains the max size of each dimension, for example 2 |
| // this would be 7 and whatever for the second dimension. |
| // =========================================================================== |
| int Parser_utils::start_dex(vector<int> &istart, const vector<int> &size) |
| { |
| // Get the array dimension, 0,1,2,3,... |
| int dim = (int)istart.size(); |
| |
| // 0d is a special case. |
| if (dim == 0) return 0; |
| |
| // Find the index. |
| // Adjustment for base 1 |
| int ix = istart[0]-index_base; |
| for (int i=1; i<dim; i++) { |
| int t = istart[i]-index_base; |
| for (int j=0; j<i; j++) { |
| t *= size[j]; |
| } |
| ix += t; |
| } |
| |
| return ix; |
| } |
| |
| |
| // =========================================================================== |
| // This is the reverse of the start_dex function above. |
| // Given the 1d index, icdex (from 0 to nvals-1), 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 the user inputs 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 istart vector contains the output indices, for example 2 this would be 3 |
| // and 2. The size vector contains the max size of each dimension, for example |
| // 2 this would be 3 and whatever for the second dimension. The number of |
| // elements in size is normally dim-1, but it does not hurt if it has dim |
| // elements (in which case the last element is not referenced or used). |
| // =========================================================================== |
| void Parser_utils::reverse_dex(int icdex, |
| int nvals, |
| vector<int> &istart, |
| const vector<int> &size) |
| { |
| // Get the dimension. |
| int dim = (int)istart.size(); |
| |
| // Nothing to do for scalars. |
| if (dim == 0) return; |
| |
| // Start at 1,1,1,1,1,1,... |
| for (int i=0; i<dim; i++) { |
| istart[i] = index_base; |
| } |
| |
| // Get the first 1d index (referenced from 0) |
| int i1 = start_dex(istart, size); |
| if (i1 == icdex) return; |
| |
| // Go through all indices until the desired one is found. |
| // Yes, this is inefficient, but dim is a small integer, like 2,3,4, so |
| // the efficiency does not really matter. |
| // Perhaps somebody can devise a better algorithm someday. |
| for (int i1dex=0; i1dex<nvals; i1dex++) { |
| for (int i=0; i<dim; i++) { |
| if (i < dim-1) { |
| if (istart[i] == size[i]) { |
| istart[i] = index_base; |
| } |
| else { |
| istart[i] += 1; |
| break; |
| } |
| } |
| else { |
| istart[i] += 1; |
| break; |
| } |
| } |
| |
| i1 = start_dex(istart, size); |
| if (i1 == icdex) return; |
| } |
| } |
| |
| |
| |
| // *************************************************************************** |
| // *************************************************************************** |
| // Utilities for printing to the screen (or to a file). |
| // *************************************************************************** |
| // *************************************************************************** |
| |
| |
| |
| // =========================================================================== |
| |
| |
| // Line |
| // Filename Number Command |
| // ------------ ------ ------------------------------------------------ |
| // test.in 4 some_logical_cmd = false |
| // test.in 28 some_logical_cmd = false |
| // test.in 170 some_logical_cmd = false |
| // test.in 175 some_logical_cmd = true //No space betwe ... |
| // test_inc1.in 2 some_logical_cmd = true |
| // test_inc3.in 2 some_logical_cmd = true |
| // |
| // test.in 442 strinsert_cmd01 = "test duplicates commands" |
| // test.in 456 strinsert_cmd01 = "test duplicates commands" |
| |
| |
| |
| // Given a header row of strings and several data rows of string where each |
| // row consists of the same number of columns, list all the rows with the |
| // columns lined up and the headers centered on the columns. |
| // =========================================================================== |
| void Parser_utils::print_strings(vector< vector<string> > rows, int n_header_rows, |
| int offset, int col_spacing, int line_len_max, |
| stringstream &ss) |
| { |
| // Get the number of columns. |
| int ncol = (int)rows[0].size(); |
| |
| // Find the max number of characters in each column for all the rows. |
| vector<int> maxc(ncol, 0); |
| for (int row=0; row<(int)rows.size(); row++) { |
| for (int c=0; c<ncol; c++) { |
| string s = rows[row][c]; |
| if ((int)s.size() > maxc[c]) maxc[c] = (int)s.size(); |
| } |
| } |
| |
| // Find the column widths. |
| vector<int> col_width(ncol,0); |
| for (int c=0; c<ncol; c++) { |
| if (maxc[c] > col_width[c]) col_width[c] = maxc[c]; |
| } |
| |
| // Spacing between columns. |
| vector<int> cspace(ncol, col_spacing); |
| cspace[0] = offset; |
| |
| // Limit the lines to a max length. |
| if (line_len_max > 0) { |
| int line_len = 0; |
| for (int c=0; c<ncol; c++) { |
| line_len += cspace[c] + col_width[c]; |
| } |
| int excess_c = line_len - line_len_max; |
| |
| if (excess_c > 0) { |
| col_width[ncol-1] -= excess_c; |
| for (int row=0; row<(int)rows.size(); row++) { |
| int len = 0; |
| for (int c=0; c<ncol; c++) { |
| string s = rows[row][c]; |
| if (c < ncol-1) len += cspace[c] + col_width[c]; |
| if (c == ncol-1) len += cspace[c] + (int)s.size(); |
| } |
| if (len <= line_len_max) continue; |
| |
| int c = ncol -1; |
| string s = rows[row][c]; |
| int ec = len - line_len_max; |
| int start = (int)s.size() - ec - 4; |
| if (start < 0) start = 0; |
| int nc = ec+4; |
| if (nc > (int)s.size()) nc = (int)s.size(); |
| s.erase(start, nc); |
| rows[row][c] = s + " ..."; |
| } |
| } |
| } |
| |
| |
| // Write the rows. |
| for (int row=0; row<(int)rows.size(); row++) { |
| |
| // Insert the line of dashes after the header rows. |
| if (row == n_header_rows) { |
| for (int c=0; c<ncol; c++) { |
| for (int i=0; i<cspace[c]; i++) ss << " "; |
| for (int i=0; i<col_width[c]; i++) ss << "-"; |
| } |
| ss << endl; |
| } |
| |
| for (int c=0; c<ncol; c++) { |
| // Use nc to center the headers, but not center the data. |
| int nc = maxc[c]; |
| if (row < n_header_rows) nc = (int)rows[row][c].size(); |
| |
| int nsp_left = 0; |
| int nsp_right = 0; |
| int dsp = col_width[c] - nc; |
| if (dsp > 0) { |
| nsp_left = dsp/2; |
| nsp_right = col_width[c] - nsp_left - nc; |
| } |
| for (int i=0; i<cspace[c]; i++) ss << " "; |
| for (int i=0; i<nsp_left; i++) ss << " "; |
| |
| |
| if (row >= n_header_rows) { |
| if (c < ncol-1) ss << setw(maxc[c]) << rows[row][c]; |
| if (c == ncol-1) ss << rows[row][c]; |
| } |
| else { |
| ss << rows[row][c]; |
| } |
| |
| for (int i=0; i<nsp_right; i++) ss << " "; |
| } |
| ss << endl; |
| } |
| } |
| |
| |
| |
| } // End of the PP namespace |
