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.
	Parser (const std::string &input_filename, const std::optional< std::string > &input_text={})
	Constructor, given a file in input_filename.
void	parse ()
	Parses the inputs.
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.
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.
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.
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.
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.
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.
const std::vector< std::string >	_input_filenames
	The input file names.
std::vector< std::string >	_input_text
	The input text (may be filled during parse())
std::unique_ptr< hit::Node >	_cli_root
	The root node for command line hit arguments.
std::string	_app_type
	The application types extracted from [Application] block.
bool	_throw_on_error
	Whether or not to throw on error.
std::optional< std::vector< std::string > >	_command_line_params
	The command line HIT parameters (if any)
std::set< std::string >	_extracted_vars
	Variables that have been extracted during brace expansion.

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 108 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 287 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 299 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 hit::Error &  error  )

static

Definition at line 628 of file Parser.C.

{
  appendErrorMessages(to, error.error_messages);
}

appendErrorMessages() [2/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 621 of file Parser.C.

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

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

getAppType()

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

inline

Definition at line 186 of file Parser.h.

{ return _app_type; }

getCommandLineRoot() [1/2]

hit::Node & Parser::getCommandLineRoot

(

)

Definition at line 615 of file Parser.C.

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

getCommandLineRoot() [2/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 607 of file Parser.C.

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

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

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 227 of file Parser.h.

{ return _extracted_vars; }

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

getInputFileNames()

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

inline

Returns

The names of the inputs

Definition at line 176 of file Parser.h.

{ return _input_filenames; }

Referenced by parse().

getInputText()

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

inline

Returns

The input file contents

Definition at line 181 of file Parser.h.

{ return _input_text; }

Referenced by parse().

getLastInputFileName()

const std::string & Parser::getLastInputFileName

(

)

const

Returns

The file name of the last input

Definition at line 430 of file Parser.C.

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

Referenced by getLastInputFilePath().

getLastInputFilePath()

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

inline

Returns

The path of the last input

Definition at line 206 of file Parser.h.

{ return getLastInputFileName(); }

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

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 599 of file Parser.C.

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

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

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 220 of file Parser.h.

{ return _throw_on_error; }

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

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 634 of file Parser.C.

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

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

parse()

void Parser::parse

(

)

Parses the inputs.

Definition at line 443 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;
    EnumerateEvaler enumerate_ev;
    RangeEvaler range_ev;
    RepeatEvaler repeat_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);
    exw.registerEvaler("enumerate", enumerate_ev);
    exw.registerEvaler("range", range_ev);
    exw.registerEvaler("repeat", repeat_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 643 of file Parser.C.

{
  // 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));
}

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

queryCommandLineRoot() [1/2]

hit::Node * Parser::queryCommandLineRoot ( )

inline

Definition at line 160 of file Parser.h.

{ return _cli_root.get(); }

queryCommandLineRoot() [2/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 159 of file Parser.h.

{ return _cli_root.get(); }

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

queryRoot() [1/2]

hit::Node * Parser::queryRoot ( )

inline

Definition at line 143 of file Parser.h.

{ return _root.get(); }

queryRoot() [2/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 142 of file Parser.h.

{ return _root.get(); }

Referenced by getRoot(), and parse().

setAppType()

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

inline

Definition at line 191 of file Parser.h.

{ _app_type = app_type; }

Referenced by parse().

setCommandLineParams()

void Parser::setCommandLineParams

(

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

params

)

Sets the HIT parameters from the command line.

Definition at line 423 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 213 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 264 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 261 of file Parser.h.

Referenced by parse(), queryCommandLineRoot(), 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 270 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 273 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 255 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 258 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 252 of file Parser.h.

Referenced by parse(), queryRoot(), and queryRoot().

_throw_on_error

bool Parser::_throw_on_error

private

Whether or not to throw on error.

Definition at line 267 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