#include <parse.hpp>

Public Types
enum	kind : int { eof, identifier, number, plus ='+', minus ='-', times ='*', slash ='/', lparen = '(', rparen =')', equal ='=' }

Public Member Functions
	parser (std::istream &input)

bool	get_expr (double &result)

Private Member Functions
std::string	charify (char c)

bool	get_number (std::string const &token, double &result)

bool	get_add_expr (double &result)

bool	get_mul_expr (double &result)

bool	get_primary (double &result)

bool	get_unary (double &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. More...

std::ctype< char > const &	ctype_
	Cache the ctype facet for checking character categories. More...

std::string	token_
	One token push-back. More...

kind	kind_
	The kind of token that was pushed back. More...

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 31 of file parse.hpp.

Member Enumeration Documentation

enum parser::kind : int

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 37 of file parse.hpp.

37 : int { eof, identifier, number,

38 plus='+', minus='-', times='*', slash='/', lparen = '(', rparen=')', equal='=' };

parser::slash

Definition: parse.hpp:38

parser::times

Definition: parse.hpp:38

parser::lparen

Definition: parse.hpp:38

parser::rparen

Definition: parse.hpp:38

parser::plus

Definition: parse.hpp:38

parser::minus

Definition: parse.hpp:38

parser::number

Definition: parse.hpp:37

parser::equal

Definition: parse.hpp:38

parser::eof

Definition: parse.hpp:37

parser::identifier

Definition: parse.hpp:37

Constructor & Destructor Documentation

parser::parser ( std::istream & input )

Constructor. Save the input stream.

Parameters

input The input stream

Definition at line 5 of file parse.cpp.

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

Member Function Documentation

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 12 of file parse.cpp.

References isprint().

Referenced by get_identifier(), and get_token().

 {
   if (c == '\a') return R"('\a')";
   if (c == '\b') return R"('\b')";
   if (c == '\f') return R"('\f')";
   if (c == '\n') return R"('\n')";
   if (c == '\r') return R"('\r')";
   if (c == '\t') return R"('\t')";
   if (c == '\v') return R"('\v')";
   if (c == '\'') return R"('\'')";
   if (c == '\\') return R"('\\')";
 
   if (isprint(c))
     return std::string{"\'"} + std::string(1,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_add_expr ( double & 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 174 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 {
       double right{};
       if (not get_mul_expr(right))
         throw parse_error{"syntax error: unterminated expression. Expected a multiplicative-expression after " + token};
       if (k == '+')
         result += right;
       else
         result -= right;
     }
   }
   return true;
 }

bool parser::get_expr ( double & result )

Read one expression and store the result in result.

Parameters

result Where to store the result of the expression.

Returns: true to continue or false to end the loop

Exceptions

parse_error for various syntax and other errors

Definition at line 142 of file parse.cpp.

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

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"};
     set_variable(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;
 }

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 36 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;
 }

bool parser::get_mul_expr ( double & 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 196 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 {
       double right{};
       if (not get_unary(right))
         throw parse_error{"syntax error: unterminated expression. Expected a unary-expression after " + token};
       if (k == '*')
         result *= right;
       else if (right == 0.0)
         throw parse_error{"division by zero"};
       else
         result /= right;
     }
   }
   return true;
 }

bool parser::get_number	(	std::string const &	token,
		double &	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 135 of file parse.cpp.

Referenced by get_primary().

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

bool parser::get_primary ( double & 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 239 of file parse.cpp.

References eof, get_expr(), get_number(), get_token(), get_variable(), 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 = get_variable(token);
       return true;
     } else {
       throw parse_error{"syntax error: expected a primary, but got " + token};
     }
   }
   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 62 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;
 }

bool parser::get_unary ( double & 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 220 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 = -result;
       return true;
     } else if (k == '+') {
       return get_primary(result);
     } else {
       push_back(token, k);
       return get_primary(result);
     }
   }
   return false;
 }

bool parser::isalnum ( char c ) const

inlineprivate

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

Parameters

c	The character to test.

Definition at line 130 of file parse.hpp.

References ctype_.

Referenced by get_identifier().

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

parser::ctype_

std::ctype< char > const & ctype_

Cache the ctype facet for checking character categories.

Definition: parse.hpp:143

bool parser::isalpha ( char c ) const

inlineprivate

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

Parameters

c	The character to test.

Definition at line 125 of file parse.hpp.

References ctype_.

Referenced by get_identifier(), and get_token().

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

parser::ctype_

std::ctype< char > const & ctype_

Cache the ctype facet for checking character categories.

Definition: parse.hpp:143

bool parser::isdigit ( char c ) const

inlineprivate

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

Parameters

c	The character to test.

Definition at line 135 of file parse.hpp.

References ctype_.

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

parser::ctype_

std::ctype< char > const & ctype_

Cache the ctype facet for checking character categories.

Definition: parse.hpp:143

bool parser::isprint ( char c ) const

inlineprivate

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

Parameters

c	The character to test.

Definition at line 140 of file parse.hpp.

References ctype_.

Referenced by charify().

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

parser::ctype_

std::ctype< char > const & ctype_

Cache the ctype facet for checking character categories.

Definition: parse.hpp:143

void parser::push_back	(	std::string const &	token,
		kind	k
	)

inlineprivate

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 to push back

Definition at line 119 of file parse.hpp.

References kind_, and token_.

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

119 { token_ = token; kind_ = k; }

parser::token_

std::string token_

One token push-back.

Definition: parse.hpp:144

parser::kind_

kind kind_

The kind of token that was pushed back.

Definition: parse.hpp:145

Member Data Documentation

std::ctype<char> const& parser::ctype_

private

Cache the ctype facet for checking character categories.

Definition at line 143 of file parse.hpp.

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

std::istream& parser::input_

private

Share the input stream.

Definition at line 142 of file parse.hpp.

Referenced by get_identifier(), and get_token().

kind parser::kind_

private

The kind of token that was pushed back.

Definition at line 145 of file parse.hpp.

Referenced by get_token(), and push_back().

std::string parser::token_

private

One token push-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:

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation