parser Class Reference

#include <parse.hpp>

List of all members.

Public Types
enum	kind {   eof, identifier, number, plus = '+',   minus = '-', times = '*', slash = '/', lparen = '(',   rparen = ')', equal = '=' }
Public Member Functions
	parser (std::istream &input)
bool	get_expr (node &result)
Private Member Functions
std::string	charify (char c)
bool	get_number (std::string const &token, node &result)
bool	get_add_expr (node &result)
bool	get_mul_expr (node &result)
bool	get_primary (node &result)
bool	get_unary (node &result)
kind	get_token (std::string &token)
void	get_identifier (std::string &identifier)
void	push_back (std::string const &token, kind k)
bool	isalpha (char c) const
bool	isalnum (char c) const
bool	isdigit (char c) const
bool	isprint (char c) const
Private Attributes
std::istream &	input_
	Share the input stream.
std::ctype< char > const &	ctype_
	Cache the ctype facet for checking character categories.
std::string	token_
	One token push-back.
kind	kind_
	The kind of token that was pushed back.

---

Detailed Description

Parser class template. The parser reads tokens from an input stream. A token can be a keyword, numeric literal, identifier, or symbol (operator or punctuator). Symbols can have multiple characters (e.g., :=).

Because the recursive-descent parser can examine too many tokens from the input stream, it keeps a push-back token. Once the parser knows it has gone too far, it pushes back the most recently read token. The next call to get_token() retrieves the pushed-back token.

Only one push-back is available, which limits the complexity of the syntax.

Definition at line 30 of file parse.hpp.

---

Member Enumeration Documentation

enum parser::kind

Token kind. Declare a name for each single-character token, to ensure the enumerated type can represent any operator or punctuator character.

Enumerator:

eof
identifier
number
plus
minus
times
slash
lparen
rparen
equal

Definition at line 36 of file parse.hpp.

            { eof, identifier, number,
    plus='+', minus='-', times='*', slash='/', lparen = '(', rparen=')', equal='=' };

---

Constructor & Destructor Documentation

parser::parser

(

std::istream &

input

)

Constructor. Save the input stream.

Parameters:

input

The input stream

Definition at line 6 of file parse.cpp.

: input_(input),
  ctype_(std::use_facet<std::ctype<char> >(input.getloc())),
  token_(),
  kind_()
{}

---

Member Function Documentation

bool parser::get_expr

(

node &

result

)

Read one expression and store the parse tree in result.

Parameters:

result

Where to store the parse tree.

Returns:

true to continue or false to end the loop

Exceptions:

parse_error

for various syntax and other errors

Definition at line 143 of file parse.cpp.

References eof, get_add_expr(), get_token(), identifier, and push_back().

Referenced by get_primary(), and parse_loop().

{
  std::string token;
  kind k(get_token(token));
  if (k == eof)
    return false;

  if (k == identifier and token == "var") {
    std::string name;
    // Define a variable.
    k = get_token(name);
    if (k != identifier)
      throw parse_error("syntax error: expected IDENTIFIER, but got " + name);
    k = get_token(token);
    if (k != '=')
      throw parse_error("syntax error: expected =, but got " + token);
    if (not get_add_expr(result))
      throw parse_error("syntax error: expected additive-exprssion in assignment");
    result = node(node(name), result);
    return true;
  }

  if (k == identifier and token == "quit")
    std::exit(0);

  push_back(token, k);
  if (not get_add_expr(result))
    throw parse_error("syntax error: expected an additive-expression");

  return true;
}

std::string parser::charify

(

char

c

)

[private]

Convert a characer to a readable form.

Parameters:

c

The character

Returns:

A C++-style character literal that ensures c is readable.

Definition at line 13 of file parse.cpp.

References isprint().

Referenced by get_identifier(), and get_token().

{
  if (c == '\a') return "\'\\a\'";
  if (c == '\b') return "\'\\b\'";
  if (c == '\f') return "\'\\f\'";
  if (c == '\n') return "\'\\n\'";
  if (c == '\r') return "\'\\r\'";
  if (c == '\t') return "\'\\t\'";
  if (c == '\v') return "\'\\v\'";
  if (c == '\'') return "\'\\'\'";
  if (c == '\\') return "\'\\\\\'";

  if (isprint(c))
    return std::string("\'") + c + '\'';
  else {
    std::ostringstream stream;
    stream << "'\\x" << std::hex;
    stream.fill('0');
    stream.width(2);
    stream << (std::char_traits<char>::to_int_type(c) & 0xFF) << '\'';
    return stream.str();
  }
}

bool parser::get_number	(	std::string const &	token,
		node &	result
	)			[private]

Parse a floating number.

Parameters:

	token	The token to parse
	result	Store the number here

Returns:

true if token is a valid number or false for an error

Definition at line 129 of file parse.cpp.

Referenced by get_primary().

{
  std::istringstream stream(token);
  // If the value overflows or is otherwise invalid, return false.
  double value;
  if (not (stream >> value))
    return false;
  result = node(value);
  return true;
}

bool parser::get_add_expr

(

node &

result

)

[private]

Parse an addition expression

     ADD_EXPR ::= MUL_EXPR | ADD_EXPR + MUL_EXPR | ADD_EXPR - MUL_EXPR
     

Parameters:

result

Store the result here

Returns:

true to continue parsing or false to stop (end of file or error)

Definition at line 178 of file parse.cpp.

References get_mul_expr(), get_token(), and push_back().

Referenced by get_expr().

{
  if (not get_mul_expr(result))
    return false;
  std::string token;
  while (kind k = get_token(token)) {
    if (k != '+' and k != '-') {
      push_back(token, k);
      return true;
    } else {
      node right;
      if (not get_mul_expr(right))
        throw parse_error("syntax error: unterminated expression. Expected a multiplicative-expression after " + token);
      result = node(result, k, right);
    }
  }
  return true;
}

bool parser::get_mul_expr

(

node &

result

)

[private]

Parse a multiplicative expression.

     MUL_EXPR ::= UNARY | MUL_EXPR + UNARY | MUL_EXPR - UNARY
     

Parameters:

result

Store the result here

Returns:

true to continue parsing or false to stop (end of file or error)

Definition at line 200 of file parse.cpp.

References get_token(), get_unary(), and push_back().

Referenced by get_add_expr().

{
  if (not get_unary(result))
    return false;
  std::string token;
  while (kind k = get_token(token)) {
    if (k != '*' and k != '/') {
      push_back(token, k);
      return true;
    } else {
      node right;
      if (not get_unary(right))
        throw parse_error("syntax error: unterminated expression. Expected a unary-expression after " + token);
      result = node(result, k, right);
    }
  }
  return true;
}

bool parser::get_primary

(

node &

result

)

[private]

Parse a primary expression.

     PRIMARY ::= NUMBER | IDENTIFIER | '(' EXPR ')'
     

Parameters:

result

Store the result here

Returns:

true to continue parsing or false to stop (end of file or error)

Definition at line 244 of file parse.cpp.

References eof, get_expr(), get_number(), get_token(), identifier, and number.

Referenced by get_unary().

{
  std::string token;
  if (kind k = get_token(token)) {
    if (k == '(') {
      if (not get_expr(result))
        return false;
      k = get_token(token);
      if (k == eof)
        throw parse_error("syntax error: EOF when expecting ')'");
      else if (k != ')')
        throw parse_error("syntax error: expected ')', but got " + token);
      else
        return true;
    } else if (k == number) {
      if (not get_number(token, result))
        throw parse_error("Invalid numeric literal: " + token);
      return true;
    } else if (k == identifier) {
      result = node(token);
      return true;
    } else {
      throw parse_error("syntax error: expected a primary, but got " + token);
    }
  }
  return false;
}

bool parser::get_unary

(

node &

result

)

[private]

Parse a unary expression.

     UNARY ::= '-' PRIMARY | '+' PRIMARY | PRIMARY
     

Parameters:

result

Store the result here

Returns:

true to continue parsing or false to stop (end of file or error)

Definition at line 222 of file parse.cpp.

References get_primary(), get_token(), and push_back().

Referenced by get_mul_expr().

{
  std::string token;
  if (kind k = get_token(token)) {
    if (k == '-') {
      if (not get_primary(result))
        return false;
      result = node(k, result);
      return true;
    } else if (k == '+') {
      return get_primary(result);
    } else {
      push_back(token, k);
      return get_primary(result);
    }
  }
  return false;
}

parser::kind parser::get_token

(

std::string &

token

)

[private]

Parse a token. A token can be a keyword, a literal or a symbol.

     TOKEN ::= IDENTIFIER | NUMBER | SYMBOL
     IDENTIIFER ::= ALPHA (ALPHA | DIGIT)*
     NUMBER ::= DIGIT+ ('.' DIGITS+)? ('E' SIGN? DIGITS+)?
     SYMBOL ::= '+' | '-' | '*' | '/' | '%' | '(' | ')' | '='
     

Parameters:

token

Store the text of the token here.

Returns:

the token kind

Definition at line 56 of file parse.cpp.

References charify(), eof, get_identifier(), identifier, input_, isalpha(), kind_, number, and token_.

Referenced by get_add_expr(), get_expr(), get_mul_expr(), get_primary(), and get_unary().

{
  if (not token_.empty())
  {
    token = token_;
    kind result(kind_);
    token_.clear();
    kind_ = eof;
    return result;
  }

  char c;
  if (not (input_ >> c))
    return eof;
  if (isalpha(c)) {
    input_.unget();
    get_identifier(token);
    return identifier;
  }

  // Get a numeric literal.
  token.clear();
  if (c == '+' or c == '-' or c == '*' or c == '/' or c == '%' or c == '(' or c == ')' or c == '=') {
    token += c;
    return kind(c);
  }

  if (c < '0' or c > '9') {
    input_.unget();
    throw parse_error("syntax error: expected digit, got " + charify(c));
  }
  while (c >= '0' and c <= '9') {
    token += c;
    if (not input_.get(c))
      return number;
  }
  if (c == '.') {
    token += c;
    if (not input_.get(c))
      throw parse_error("unterminated number: expected digit after the decimal point");
    if (c < '0' or c > '9') {
      input_.unget();
      throw parse_error("syntax error: expected digit after decimal point, got " + charify(c));
    }
    while (c >= '0' and c <= '9') {
      token += c;
      if (not input_.get(c))
        return number;
    }
  }
  if (c == 'e' or c == 'E') {
    token += c;
    if (not input_.get(c))
      throw parse_error("unterminated number: expected digit in the exponent");
    if (c == '-' or c == '+') {
      token += c;
      if (not input_.get(c))
        throw parse_error("unterminated number: expected digit after sign in the exponent");
    }
    if (c < '0' or c > '9') {
      input_.unget();
      throw parse_error("syntax error: expected digit in the exponent, got " + charify(c));
    }
    while (c >= '0' and c <= '9') {
      token += c;
      if (not input_.get(c))
        return number;
    }
  }
  input_.unget();
  return number;
}

void parser::get_identifier

(

std::string &

identifier

)

[private]

Parse an identifer.

Parameters:

identifier

Store the identifier here.

Precondition:

first input character is alphabetic

Definition at line 37 of file parse.cpp.

References charify(), input_, isalnum(), and isalpha().

Referenced by get_token().

{
  identifier.clear();
  char c;
  if (not input_.get(c))
    return;
  if (not isalpha(c))
    throw parse_error("syntax error: expected alphabetic, got " + charify(c));
  identifier += c;
  while (input_.get(c)) {
    if (not isalnum(c)) {
      input_.unget();
      return;
    }
    identifier += c;
  }
  return;
}

void parser::push_back	(	std::string const &	token,
		kind	k
	)			[inline, private]

Push back a token. The next call to get_token() will return the pushed-back token.

Parameters:

	token	The token to push back.
	k	The kind of token being pushed back

Definition at line 118 of file parse.hpp.

References kind_, and token_.

Referenced by get_add_expr(), get_expr(), get_mul_expr(), and get_unary().

{ token_ = token; kind_ = k; }

bool parser::isalpha

(

char

c

)

const [inline, private]

Return true if c is alphabetic. Use the locale of the input stream.

Parameters:

c

The character to test.

Definition at line 124 of file parse.hpp.

References ctype_.

Referenced by get_identifier(), and get_token().

{ return ctype_.is(ctype_.alpha, c); }

bool parser::isalnum

(

char

c

)

const [inline, private]

Return true if c is alphanumeric. Use the locale of the input stream.

Parameters:

c

The character to test.

Definition at line 129 of file parse.hpp.

References ctype_.

Referenced by get_identifier().

{ return ctype_.is(ctype_.alnum, c); }

bool parser::isdigit

(

char

c

)

const [inline, private]

Return true if c is a digit. Use the locale of the input stream.

Parameters:

c

The character to test.

Definition at line 134 of file parse.hpp.

References ctype_.

{ return ctype_.is(ctype_.digit, c); }

bool parser::isprint

(

char

c

)

const [inline, private]

Return true if c is printable. Use the locale of the input stream.

Parameters:

c

The character to test.

Definition at line 139 of file parse.hpp.

References ctype_.

Referenced by charify().

{ return ctype_.is(ctype_.print, c); }

---

Member Data Documentation

std::istream& parser::input_ [private]

Share the input stream.

Definition at line 141 of file parse.hpp.

Referenced by get_identifier(), and get_token().

std::ctype<char> const& parser::ctype_ [private]

Cache the ctype facet for checking character categories.

Definition at line 142 of file parse.hpp.

Referenced by isalnum(), isalpha(), isdigit(), and isprint().

std::string parser::token_ [private]

One token push-back.

Definition at line 143 of file parse.hpp.

Referenced by get_token(), and push_back().

kind parser::kind_ [private]

The kind of token that was pushed back.

Definition at line 144 of file parse.hpp.

Referenced by get_token(), and push_back().

---

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

• parse.hpp
• parse.cpp

---