Parser Class Reference

Class for parsing input files. More...

#include <Parser.h>

Classes
struct	Error

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...
hit::Node &	getRoot ()
const std::vector< std::string > &	getInputFileNames () const
const std::vector< std::string > &	getInputText () const
const std::string &	getAppType () const
void	setAppType (const std::string &app_type)
void	setCommandLineParams (const std::vector< std::string > &params)
	Sets the HIT parameters from the command line. More...
const std::string &	getLastInputFileName () const
std::filesystem::path	getLastInputFilePath () const
void	setThrowOnError (const bool throw_on_error)
	Set whether or not to throw Parse::Error on errors. More...
bool	getThrowOnError () const
const std::set< std::string > &	getExtractedVars () const
void	parseError (std::vector< hit::ErrorMessage > messages) const
	Helper for throwing an error with the given messages. More...
const hit::Node *	queryRoot () const
hit::Node *	queryRoot ()
const hit::Node *	queryCommandLineRoot () const
hit::Node *	queryCommandLineRoot ()
const hit::Node &	getCommandLineRoot () const
hit::Node &	getCommandLineRoot ()

Static Public Member Functions
static std::string	joinErrorMessages (const std::vector< hit::ErrorMessage > &error_messages)
	Helper for combining error messages into a single, newline separated message. More...
static void	appendErrorMessages (std::vector< hit::ErrorMessage > &to, const std::vector< hit::ErrorMessage > &from)
	Helper for accumulating errors from a walker into an accumulation of errors. More...
static void	appendErrorMessages (std::vector< hit::ErrorMessage > &to, const hit::Error &error)

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...
std::vector< std::string >	_input_text
	The input text (may be filled during parse()) More...
std::unique_ptr< hit::Node >	_cli_root
	The root node for command line hit arguments. More...
std::string	_app_type
	The application types extracted from [Application] block. More...
bool	_throw_on_error
	Whether or not to throw on error. More...
std::optional< std::vector< std::string > >	_command_line_params
	The command line HIT parameters (if any) More...
std::set< std::string >	_extracted_vars
	Variables that have been extracted during brace expansion. 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 87 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 143 of file Parser.C.

  : _root(nullptr),
    _input_filenames(input_filenames),
    _input_text(input_text ? *input_text : std::vector<std::string>()),
    _cli_root(nullptr),
    _throw_on_error(false)
{
  if (input_text && _input_filenames.size() != input_text->size())
    mooseError("Parser: Input text not the same length as input filenames");
}

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 155 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

appendErrorMessages() [1/2]

void Parser::appendErrorMessages ( std::vector< hit::ErrorMessage > &  to, const std::vector< hit::ErrorMessage > &  from  )

static

Helper for accumulating errors from a walker into an accumulation of errors.

Definition at line 471 of file Parser.C.

Referenced by appendErrorMessages(), Moose::Builder::errorCheck(), parse(), Moose::Builder::setMapParameter(), Moose::Builder::setScalarComponentParameter(), Moose::Builder::setScalarParameter(), Moose::Builder::setVectorComponentParameter(), and Moose::Builder::setVectorParameter().

{
  to.insert(to.end(), from.begin(), from.end());
}

appendErrorMessages() [2/2]

void Parser::appendErrorMessages ( std::vector< hit::ErrorMessage > &  to, const hit::Error &  error  )

static

Definition at line 478 of file Parser.C.

{
  appendErrorMessages(to, error.error_messages);
}

getAppType()

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

inline

Definition at line 165 of file Parser.h.

{ return _app_type; }

getCommandLineRoot() [1/2]

const hit::Node & Parser::getCommandLineRoot

(

)

const

Returns

The root command line HIT node, with error checking on if it exists

If it doesn't exist, it means we haven't parsed yet

Definition at line 457 of file Parser.C.

Referenced by Moose::Builder::errorCheck(), parse(), and parseError().

{
  if (!queryCommandLineRoot())
    mooseError("Parser::getCommandLineRoot(): command line root is not set");
  return *queryCommandLineRoot();
}

getCommandLineRoot() [2/2]

hit::Node & Parser::getCommandLineRoot

(

)

Definition at line 465 of file Parser.C.

{
  return const_cast<hit::Node &>(std::as_const(*this).getCommandLineRoot());
}

getExtractedVars()

const std::set<std::string>& Parser::getExtractedVars ( ) const

inline

Returns

The variables that have been extracted so far.

These are the variables that have been used during brace expansion.

Definition at line 206 of file Parser.h.

Referenced by Moose::Builder::build().

{ return _extracted_vars; }

getInputFileNames()

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

inline

Returns

The names of the inputs

Definition at line 155 of file Parser.h.

Referenced by parse().

{ return _input_filenames; }

getInputText()

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

inline

Returns

The input file contents

Definition at line 160 of file Parser.h.

Referenced by parse().

{ return _input_text; }

getLastInputFileName()

const std::string & Parser::getLastInputFileName

(

)

const

Returns

The file name of the last input

Definition at line 286 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 185 of file Parser.h.

Referenced by Moose::Builder::getPrimaryFileName().

{ return getLastInputFileName(); }

getRoot()

hit::Node & Parser::getRoot

(

)

Returns

The root HIT node with error checking on if it exists

If it doesn't exist, it means we haven't parsed yet

Definition at line 449 of file Parser.C.

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

{
  if (!queryRoot())
    mooseError("Parser::getRoot(): root is not set");
  return *queryRoot();
}

getThrowOnError()

bool Parser::getThrowOnError ( ) const

inline

Returns

Whether or not to throw Parse::Error on errors

This is used by the MooseServer to capture errors while retaining the root if possible

Definition at line 199 of file Parser.h.

Referenced by Moose::Builder::errorCheck().

{ return _throw_on_error; }

joinErrorMessages()

std::string Parser::joinErrorMessages ( const std::vector< hit::ErrorMessage > &  error_messages )

static

Helper for combining error messages into a single, newline separated message.

Definition at line 484 of file Parser.C.

Referenced by Moose::Builder::errorCheck(), and parseError().

{
  std::vector<std::string> values;
  for (const auto & em : error_messages)
    values.push_back(em.prefixed_message);
  return MooseUtils::stringJoin(values, "\n");
}

parse()

void Parser::parse

(

)

Parses the inputs.

Definition at line 299 of file Parser.C.

{
  mooseAssert(!_root && !_cli_root, "Has already parsed");

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

  // Correct filenames (default is to use real path)
  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";
  std::vector<std::string> filenames;
  for (const auto & filename : getInputFileNames())
    filenames.push_back(use_real_paths ? MooseUtils::realpath(filename) : filename);

  // Load each input file if text was not provided
  if (_input_text.empty())
    for (const auto & filename : filenames)
    {
      MooseUtils::checkFileReadable(filename, true);
      std::ifstream f(filename);
      _input_text.push_back(
          std::string((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>()));
    }

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

  // Errors from the duplicate param walker, ran within each input
  // independently first
  std::vector<hit::ErrorMessage> dw_errors;

  for (const auto i : index_range(getInputFileNames()))
  {
    const auto & filename = filenames[i];
    const auto & input = getInputText()[i];

    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::vector<hit::ErrorMessage> syntax_errors;
      std::unique_ptr<hit::Node> root(hit::parse(filename, input, &syntax_errors));

      DupParamWalker dw;
      root->walk(&dw, hit::NodeType::Field);
      appendErrorMessages(dw_errors, dw.errors);

      if (!queryRoot())
        _root = std::move(root);
      else
      {
        root->walk(&opw, hit::NodeType::Field);
        hit::merge(root.get(), &getRoot());
      }

      if (!syntax_errors.empty())
        throw Parser::Error(syntax_errors);

      getRoot().walk(&cpw, hit::NodeType::Field);
    }
    catch (hit::Error & err)
    {
      parseError(err.error_messages);
    }
  }

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

  // If we don't have a root (allow no input files),
  // create an empty one
  if (!queryRoot())
    _root.reset(hit::parse("EMPTY", ""));

  {
    BadActiveWalker bw;
    getRoot().walk(&bw, hit::NodeType::Section);
    if (bw.errors.size())
      parseError(bw.errors);
  }

  {
    FindAppWalker fw;
    getRoot().walk(&fw, hit::NodeType::Field);
    if (fw.getApp())
      setAppType(*fw.getApp());
  }

  // Duplicate parameter errors (within each input file)
  if (dw_errors.size())
    parseError(dw_errors);

  // Merge in command line HIT arguments
  const auto joined_params =
      _command_line_params ? MooseUtils::stringJoin(*_command_line_params) : "";
  try
  {
    _cli_root.reset(hit::parse("CLI_ARGS", joined_params));
    hit::merge(&getCommandLineRoot(), &getRoot());
  }
  catch (hit::Error & err)
  {
    parseError(err.error_messages);
  }

  std::vector<hit::ErrorMessage> errors;

  // expand ${bla} parameter values and mark/include variables
  // used in expansion as "used" (obtained later by the Builder
  // with getExtractedVars())
  {
    hit::RawEvaler raw;
    hit::EnvEvaler env;
    hit::ReplaceEvaler repl;
    FuncParseEvaler fparse_ev;
    UnitsConversionEvaler units_ev;
    hit::BraceExpander exw;
    exw.registerEvaler("raw", raw);
    exw.registerEvaler("env", env);
    exw.registerEvaler("fparse", fparse_ev);
    exw.registerEvaler("replace", repl);
    exw.registerEvaler("units", units_ev);
    getRoot().walk(&exw);
    for (auto & var : exw.used)
      _extracted_vars.insert(var);
    Parser::appendErrorMessages(errors, exw.errors);
  }

  // Collect duplicate parameters now that we've merged inputs
  {
    DupParamWalker dw;
    getRoot().walk(&dw, hit::NodeType::Field);
    Parser::appendErrorMessages(errors, dw.errors);
  }

  // Check bad active now that we've merged inputs
  {
    BadActiveWalker bw;
    getRoot().walk(&bw, hit::NodeType::Section);
    Parser::appendErrorMessages(errors, bw.errors);
  }

  if (errors.size())
    parseError(errors);
}

parseError()

void Parser::parseError

(

std::vector< hit::ErrorMessage >

messages

)

const

Helper for throwing an error with the given messages.

If throwOnError(), throw a Parser::Error (for the MooseServer). Otherwise, use mooseError() (for standard runs).

Definition at line 493 of file Parser.C.

Referenced by Moose::Builder::build(), Moose::Builder::errorCheck(), Moose::Builder::extractParams(), and parse().

{
  // Few things about command line arguments...
  // 1. We don't care to add line and column context for CLI args, because
  //    it doesn't make sense. We go from the full CLI args and pull out
  //    the HIT parameters so "line" 1 might not even be command line
  //    argument 1. So, remove line/column context from all CLI args.
  // 2. Whenever we have a parameter in input that then gets overridden
  //    by a command line argument, under the hood we're merging two
  //    different HIT trees. However, WASP doesn't currently update the
  //    "filename" context for the updated parameter. Which means that
  //    a param that is in input and then overridden by CLI will have
  //    its location as in input. Which isn't true. So we get around this
  //    by searching the independent CLI args tree for params that we have
  //    errors for. If the associated path is also in CLI args, we manually
  //    set its error to come from CLI args. This should be fixed in
  //    the future with a WASP update.
  for (auto & em : messages)
    if (em.node && queryCommandLineRoot())
      if (getCommandLineRoot().find(em.node->fullpath()))
        em = hit::ErrorMessage(em.message, "CLI_ARGS");

  if (_throw_on_error)
    throw Parser::Error(messages);
  else
    mooseError(joinErrorMessages(messages));
}

queryCommandLineRoot() [1/2]

const hit::Node* Parser::queryCommandLineRoot ( ) const

inline

Returns

The root command line HIT node if it exists

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

Definition at line 138 of file Parser.h.

Referenced by getCommandLineRoot(), and parseError().

{ return _cli_root.get(); }

queryCommandLineRoot() [2/2]

hit::Node* Parser::queryCommandLineRoot ( )

inline

Definition at line 139 of file Parser.h.

{ return _cli_root.get(); }

queryRoot() [1/2]

const hit::Node* Parser::queryRoot ( ) const

inline

Returns

The root HIT node if it exists

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

Definition at line 121 of file Parser.h.

Referenced by getRoot(), and parse().

{ return _root.get(); }

queryRoot() [2/2]

hit::Node* Parser::queryRoot ( )

inline

Definition at line 122 of file Parser.h.

{ return _root.get(); }

setAppType()

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

inline

Definition at line 170 of file Parser.h.

Referenced by parse().

{ _app_type = app_type; }

setCommandLineParams()

void Parser::setCommandLineParams

(

const std::vector< std::string > &

params

)

Sets the HIT parameters from the command line.

Definition at line 279 of file Parser.C.

{
  mooseAssert(!_command_line_params, "Already set");
  _command_line_params = params;
}

setThrowOnError()

void Parser::setThrowOnError ( const bool  throw_on_error )

inline

Set whether or not to throw Parse::Error on errors.

This is used by the MooseServer to capture errors while retaining the root if possible

Definition at line 192 of file Parser.h.

{ _throw_on_error = throw_on_error; }

Member Data Documentation

_app_type

std::string Parser::_app_type

private

The application types extracted from [Application] block.

Definition at line 243 of file Parser.h.

Referenced by getAppType(), and setAppType().

_cli_root

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

private

The root node for command line hit arguments.

Definition at line 240 of file Parser.h.

Referenced by parse(), and queryCommandLineRoot().

_command_line_params

std::optional<std::vector<std::string> > Parser::_command_line_params

private

The command line HIT parameters (if any)

Definition at line 249 of file Parser.h.

Referenced by parse(), and setCommandLineParams().

_extracted_vars

std::set<std::string> Parser::_extracted_vars

private

Variables that have been extracted during brace expansion.

Definition at line 252 of file Parser.h.

Referenced by getExtractedVars(), and parse().

_input_filenames

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

private

The input file names.

Definition at line 234 of file Parser.h.

Referenced by getInputFileNames(), getLastInputFileName(), and Parser().

_input_text

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

private

The input text (may be filled during parse())

Definition at line 237 of file Parser.h.

Referenced by getInputText(), and parse().

_root

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

private

The root node, which owns the whole tree.

Definition at line 231 of file Parser.h.

Referenced by parse(), and queryRoot().

_throw_on_error

bool Parser::_throw_on_error

private

Whether or not to throw on error.

Definition at line 246 of file Parser.h.

Referenced by getThrowOnError(), parseError(), and setThrowOnError().

---

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

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