CondParser Class Reference

Copyright (C) 1997-2015 by Dimitri van Heesch. More...

#include <src/condparser.h>

Collaboration diagram for CondParser:

Public Member Functions
	CondParser ()
bool	parse (const DString &fileName, int lineNr, const DString &expr)
	parses and evaluates the given expression.

Private Types
enum	TOKENTYPE { NOTHING = -1 , DELIMITER , VARIABLE , UNKNOWN }
enum	OPERATOR_ID { UNKNOWN_OP = -1 , AND = 1 , OR , NOT }

Private Member Functions
void	getToken ()
	Get next token in the current string expr.
bool	parseLevel1 ()
	conditional operators AND and OR
bool	parseLevel2 ()
	NOT.
bool	parseLevel3 ()
	parenthesized expression or variable
bool	parseVar ()
bool	evalOperator (const int opId, bool lhs, bool rhs)
	evaluate an operator for given values
bool	evalVariable (const DString &varName)
	evaluate a variable
int	getOperatorId (const DString &opName)
	returns the id of the given operator returns -1 if the operator is not recognized

Private Attributes
DString	m_err
	error state
DString	m_expr
	holds the expression
const char *	m_e
	points to a character in expr
DString	m_token
	holds the token
TOKENTYPE	m_tokenType
	type of the token

Detailed Description

Copyright (C) 1997-2015 by Dimitri van Heesch.

Permission to use, copy, modify, and distribute this software and its documentation under the terms of the GNU General Public License is hereby granted. No representations are made about the suitability of this software for any purpose. It is provided "as is" without express or implied warranty. See the GNU General Public License for more details.

Documents produced by Doxygen are derivative works derived from the input used in their production; they are not affected by this license.

C++ Expression parser for ENABLED_SECTIONS in Doxygen

Features used: Operators: && AND operator || OR operator ! NOT operator

Definition at line 27 of file condparser.h.

Member Enumeration Documentation

OPERATOR_ID

enum CondParser::OPERATOR_ID

private

Enumerator
UNKNOWN_OP
AND
OR
NOT

Definition at line 43 of file condparser.h.

    {
      UNKNOWN_OP = -1,
      AND = 1,
      OR,
      NOT
    };

TOKENTYPE

enum CondParser::TOKENTYPE

private

Enumerator
NOTHING
DELIMITER
VARIABLE
UNKNOWN

Definition at line 36 of file condparser.h.

    {
      NOTHING = -1,
      DELIMITER,
      VARIABLE,
      UNKNOWN
    };

Constructor & Destructor Documentation

CondParser()

CondParser::CondParser ( )

inline

Definition at line 31 of file condparser.h.

: m_e(nullptr), m_tokenType(NOTHING) {}

References m_e, m_tokenType, and NOTHING.

Member Function Documentation

evalOperator()

bool CondParser::evalOperator ( const int opId, bool lhs, bool rhs )

private

evaluate an operator for given values

Definition at line 268 of file condparser.cpp.

{
  switch (opId)
  {
    // level 2
    case AND: return lhs && rhs;
    case OR:  return lhs || rhs;
  }
 
  m_err = "Internal error unknown operator: id="+DString().setNum(opId);
  return false;
}

References AND, DString::DString(), m_err, OR, and DString::setNum().

Referenced by parseLevel1().

evalVariable()

bool CondParser::evalVariable ( const DString & varName )

private

evaluate a variable

Definition at line 284 of file condparser.cpp.

{
  if (varName == "YES") return true;
  if (varName == "NO") return false;
  StringVector list = Config_getList(ENABLED_SECTIONS);
  return std::find(list.begin(),list.end(),varName.str())!=list.end();
}

References Config_getList, and DString::str().

Referenced by parseVar().

getOperatorId()

int CondParser::getOperatorId ( const DString & opName )

private

returns the id of the given operator returns -1 if the operator is not recognized

Definition at line 95 of file condparser.cpp.

{
  // level 2
  if (opName=="&&") { return AND; }
  if (opName=="||") { return OR;  }
 
  // not operator
  if (opName=="!")  { return NOT; }
 
  return UNKNOWN_OP;
}

References AND, NOT, OR, and UNKNOWN_OP.

Referenced by parseLevel1(), and parseLevel2().

getToken()

void CondParser::getToken ( )

private

Get next token in the current string expr.

Uses the data in m_expr pointed to by m_e to produce m_tokenType and m_token, set m_err in case of an error

Definition at line 112 of file condparser.cpp.

{
  m_tokenType = NOTHING;
  m_token.clear();
 
  //printf("\tgetToken e:{%c}, ascii=%i, col=%i\n", *e, *e, e-expr);
 
  // skip over whitespaces
  while (*m_e == ' ' || *m_e == '\t' || *m_e == '\n')     // space or tab or newline
  {
    m_e++;
  }
 
  // check for end of expression
  if (*m_e=='\0')
  {
    // token is still empty
    m_tokenType = DELIMITER;
    return;
  }
 
  // check for parentheses
  if (*m_e == '(' || *m_e == ')')
  {
    m_tokenType = DELIMITER;
    m_token += *m_e++;
    return;
  }
 
  // check for operators (delimiters)
  if (isDelimiter(*m_e))
  {
    m_tokenType = DELIMITER;
    while (isDelimiter(*m_e))
    {
      m_token += *m_e++;
    }
    return;
  }
 
  // check for variables
  if (isAlpha(*m_e))
  {
    m_tokenType = VARIABLE;
    while (isAlphaNumSpec(*m_e))
    {
      m_token += *m_e++;
    }
    return;
  }
 
  // something unknown is found, wrong characters -> a syntax error
  m_tokenType = UNKNOWN;
  while (*m_e)
  {
    m_token += *m_e++;
  }
  m_err = DString("Syntax error in part '")+m_token+"'";
  return;
}

References DString::clear(), DELIMITER, DString::DString(), isAlpha(), isAlphaNumSpec(), isDelimiter(), m_e, m_err, m_token, m_tokenType, NOTHING, UNKNOWN, and VARIABLE.

Referenced by parse(), parseLevel1(), parseLevel2(), parseLevel3(), and parseVar().

parse()

bool CondParser::parse	(	const DString &	fileName,
		int	lineNr,
		const DString &	expr )

parses and evaluates the given expression.

Returns

• On error, an error message is returned.
• On success, the result of the expression is either "1" or "0".

Definition at line 41 of file condparser.cpp.

{
  if (expr.empty()) return false;
  m_tokenType = NOTHING;
  m_expr = resolveConfig(fileName, lineNr, expr);
 
  // initialize all variables
  m_e = m_expr.data();    // let m_e point to the start of the expression
 
  bool answer=false;
  getToken();
  if (m_tokenType==DELIMITER && m_token.empty())
  {
    // empty expression: answer==false
  }
  else if (m_err.empty())
  {
    answer = parseLevel1();
  }
  if (!m_err.empty())
  {
    warn(fileName,lineNr,"problem evaluating expression '{}': {}", expr, m_err);
  }
  //printf("expr='%s' answer=%d\n",expr,answer);
  return answer;
}

References DString::data(), DELIMITER, DString::empty(), getToken(), m_e, m_err, m_expr, m_token, m_tokenType, NOTHING, parseLevel1(), resolveConfig(), and warn.

Referenced by handleGuard(), startCondSection(), and startCondSection().

parseLevel1()

bool CondParser::parseLevel1 ( )

private

conditional operators AND and OR

Definition at line 177 of file condparser.cpp.

{
  bool ans = parseLevel2();
  int opId = getOperatorId(m_token);
 
  while (opId==AND || opId==OR)
  {
    getToken();
    ans = evalOperator(opId, ans, parseLevel2());
    opId = getOperatorId(m_token);
  }
 
  return ans;
}

References AND, evalOperator(), getOperatorId(), getToken(), m_token, OR, and parseLevel2().

Referenced by parse(), and parseLevel3().

parseLevel2()

bool CondParser::parseLevel2 ( )

private

NOT.

Definition at line 195 of file condparser.cpp.

{
  int opId = getOperatorId(m_token);
  if (opId == NOT)
  {
    getToken();
    return !parseLevel3();
  }
  else
  {
    return parseLevel3();
  }
}

References getOperatorId(), getToken(), m_token, NOT, and parseLevel3().

Referenced by parseLevel1().

parseLevel3()

bool CondParser::parseLevel3 ( )

private

parenthesized expression or variable

Definition at line 213 of file condparser.cpp.

{
  // check if it is a parenthesized expression
  if (m_tokenType == DELIMITER)
  {
    if (m_token=="(")
    {
      getToken();
      bool ans = parseLevel1();
      if (m_tokenType!=DELIMITER || m_token!=")")
      {
        m_err="Parenthesis ) missing";
        return false;
      }
      getToken();
      return ans;
    }
  }
 
  // if not parenthesized then the expression is a variable
  return parseVar();
}

References DELIMITER, getToken(), m_err, m_token, m_tokenType, parseLevel1(), and parseVar().

Referenced by parseLevel2().

parseVar()

bool CondParser::parseVar ( )

private

Definition at line 237 of file condparser.cpp.

{
  bool ans = false;
  switch (m_tokenType)
  {
    case VARIABLE:
      // this is a variable
      ans = evalVariable(m_token);
      getToken();
      break;
 
    default:
      // syntax error or unexpected end of expression
      if (m_token.empty())
      {
        m_err="Unexpected end of expression";
        return false;
      }
      else
      {
        m_err="Value expected";
        return false;
      }
      break;
  }
  return ans;
}

References DString::empty(), evalVariable(), getToken(), m_err, m_token, m_tokenType, and VARIABLE.

Referenced by parseLevel3().

Member Data Documentation

m_e

const char* CondParser::m_e

private

points to a character in expr

Definition at line 56 of file condparser.h.

Referenced by CondParser(), getToken(), and parse().

m_err

DString CondParser::m_err

private

error state

Definition at line 54 of file condparser.h.

Referenced by evalOperator(), getToken(), parse(), parseLevel3(), and parseVar().

m_expr

DString CondParser::m_expr

private

holds the expression

Definition at line 55 of file condparser.h.

Referenced by parse().

m_token

DString CondParser::m_token

private

holds the token

Definition at line 58 of file condparser.h.

Referenced by getToken(), parse(), parseLevel1(), parseLevel2(), parseLevel3(), and parseVar().

m_tokenType

TOKENTYPE CondParser::m_tokenType

private

type of the token

Definition at line 59 of file condparser.h.

Referenced by CondParser(), getToken(), parse(), parseLevel3(), and parseVar().

---

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

• src/condparser.h
• src/condparser.cpp