Parser Class Reference

Class for parsing input files. More...

#include <Parser.h>

Public Member Functions
	Parser (const std::vector< std::string > &input_filenames, const std::optional< std::vector< std::string >> &input_text={})
	Constructor given a list of input files, given in input_filenames. More...
	Parser (const std::string &input_filename, const std::optional< std::string > &input_text={})
	Constructor, given a file in input_filename. More...
void	parse ()
	Parses the inputs. More...
void	extractParams (const std::string &prefix, InputParameters &p)
	This function attempts to extract values from the input file based on the contents of the passed parameters objects. More...
hit::Node *	root ()
const std::vector< std::string > &	getInputFileNames () const
const std::string &	getAppType () const
void	setAppType (const std::string &app_type)
const std::string &	getLastInputFileName () const
std::filesystem::path	getLastInputFilePath () const

Private Attributes
std::unique_ptr< hit::Node >	_root
	The root node, which owns the whole tree. More...
const std::vector< std::string >	_input_filenames
	The input file names. More...
const std::optional< std::vector< std::string > >	_input_text
	The optional input text contents (to support not reading by file) More...
std::string	_app_type
	The application types extracted from [Application] block. More...

Detailed Description

Class for parsing input files.

This class utilizes the GetPot library for actually tokenizing and parsing files. It is not currently designed for extensibility. If you wish to build your own parser, please contact the MOOSE team for guidance.

Definition at line 100 of file Parser.h.

Constructor & Destructor Documentation

Parser() [1/2]

Parser::Parser	(	const std::vector< std::string > &	input_filenames,
		const std::optional< std::vector< std::string >> &	input_text = {}
	)

Constructor given a list of input files, given in input_filenames.

Optionally, the file contents can be provided via text in input_text.

Definition at line 155 of file Parser.C.

  : _root(nullptr),
    _input_filenames(input_filenames),
    _input_text(input_text),
    _app_type(std::string())
{
}

Parser() [2/2]

Parser::Parser	(	const std::string &	input_filename,
		const std::optional< std::string > &	input_text = {}
	)

Constructor, given a file in input_filename.

Optionally, the file contents can be provided via text in input_text.

Definition at line 164 of file Parser.C.

  : Parser(std::vector<std::string>{input_filename},
           input_text ? std::optional<std::vector<std::string>>({*input_text})
                      : std::optional<std::vector<std::string>>())
{
}

Member Function Documentation

extractParams()

void Parser::extractParams	(	const std::string &	prefix,
		InputParameters &	p
	)

This function attempts to extract values from the input file based on the contents of the passed parameters objects.

It handles a number of various types with dynamic casting including vector types

getAppType()

const std::string& Parser::getAppType ( ) const

inline

Definition at line 144 of file Parser.h.

{ return _app_type; }

getInputFileNames()

const std::vector<std::string>& Parser::getInputFileNames ( ) const

inline

Returns

The names of the inputs

Definition at line 139 of file Parser.h.

Referenced by parse().

{ return _input_filenames; }

getLastInputFileName()

const std::string & Parser::getLastInputFileName

(

)

const

Returns

The file name of the last input

Definition at line 291 of file Parser.C.

Referenced by getLastInputFilePath().

{
  if (_input_filenames.empty())
    mooseError("Parser::getLastInputFileName(): No inputs are set");
  return _input_filenames.back();
}

getLastInputFilePath()

std::filesystem::path Parser::getLastInputFilePath ( ) const

inline

Returns

The path of the last input

Definition at line 159 of file Parser.h.

{ return getLastInputFileName(); }

parse()

void Parser::parse

(

)

Parses the inputs.

Definition at line 299 of file Parser.C.

{
  _root.reset();

  if (_input_text && _input_text->size() != getInputFileNames().size())
    mooseError("Input text is not the same size as the input filenames");

  if (getInputFileNames().size() > 1)
    mooseInfo("Merging inputs ", Moose::stringify(getInputFileNames()));

  CompileParamWalker::ParamMap override_map;
  CompileParamWalker cpw(override_map);
  OverrideParamWalker opw(override_map);

  std::string errmsg;
  std::vector<std::string> dw_errmsg;

  // Whether or not to use real filepaths (from env)
  const std::string use_rel_paths_str =
      std::getenv("MOOSE_RELATIVE_FILEPATHS") ? std::getenv("MOOSE_RELATIVE_FILEPATHS") : "false";
  const auto use_real_paths = use_rel_paths_str == "0" || use_rel_paths_str == "false";

  for (const auto i : index_range(getInputFileNames()))
  {
    const auto & input_filename = getInputFileNames()[i];
    const auto corrected_filename =
        use_real_paths ? MooseUtils::realpath(input_filename) : input_filename;

    // Parse the input text string if provided, otherwise read file from disk
    std::string input;
    std::string errmsg;
    if (_input_text)
      input = (*_input_text)[i];
    else
    {
      MooseUtils::checkFileReadable(corrected_filename, true);
      std::ifstream f(corrected_filename);
      input = std::string((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
    }

    try
    {
      // provide stream to hit parse function to capture any syntax errors,
      // set parser root node, then throw those errors if any were captured
      std::stringstream input_errors;
      std::unique_ptr<hit::Node> root(hit::parse(corrected_filename, input, &input_errors));
      hit::explode(root.get());
      DupParamWalker dw;
      root->walk(&dw, hit::NodeType::Field);
      if (!_root)
        _root = std::move(root);
      else
      {
        root->walk(&opw, hit::NodeType::Field);
        hit::merge(root.get(), _root.get());
      }

      if (!input_errors.str().empty())
        throw hit::ParseError(input_errors.str());

      for (auto & msg : dw.errors)
        errmsg += msg + "\n";

      dw_errmsg.push_back(errmsg);
      _root->walk(&cpw, hit::NodeType::Field);
    }
    catch (hit::ParseError & err)
    {
      mooseError(err.what());
    }
  }

  // warn about overridden parameters in multiple inputs
  if (!opw.warnings.empty())
    mooseInfo(Moose::stringify(opw.warnings), "\n");

  // do as much error checking as early as possible so that errors are more useful instead
  // of surprising and disconnected from what caused them.
  BadActiveWalker bw;
  _root->walk(&bw, hit::NodeType::Section);

  FindAppWalker fw;
  _root->walk(&fw, hit::NodeType::Field);
  if (fw.getApp())
    setAppType(*fw.getApp());

  for (auto & msg : bw.errors)
    errmsg += msg + "\n";

  // Print parse errors related to bad active early
  if (errmsg.size() > 0)
    mooseError(errmsg);

  for (auto & msg : dw_errmsg)
    if (msg.size() > 0)
      mooseError(msg);
}

root()

hit::Node* Parser::root ( )

inline

Returns

The root HIT node, if any

If this is null, it means that we haven't parsed yet

Definition at line 134 of file Parser.h.

Referenced by ActionFactory::create(), and parse().

{ return _root.get(); }

setAppType()

void Parser::setAppType ( const std::string &  app_type )

inline

Definition at line 149 of file Parser.h.

Referenced by parse().

{ _app_type = app_type; }

Member Data Documentation

_app_type

std::string Parser::_app_type

private

The application types extracted from [Application] block.

Definition at line 172 of file Parser.h.

Referenced by getAppType(), and setAppType().

_input_filenames

const std::vector<std::string> Parser::_input_filenames

private

The input file names.

Definition at line 166 of file Parser.h.

Referenced by getInputFileNames(), and getLastInputFileName().

_input_text

const std::optional<std::vector<std::string> > Parser::_input_text

private

The optional input text contents (to support not reading by file)

Definition at line 169 of file Parser.h.

Referenced by parse().

_root

std::unique_ptr<hit::Node> Parser::_root

private

The root node, which owns the whole tree.

Definition at line 163 of file Parser.h.

Referenced by parse(), and root().

---

The documentation for this class was generated from the following files:

• include/parser/Parser.h
• src/parser/Parser.C