ginac/parser/parser.cpp

   1 #include <stdexcept>
   2 #include <sstream>
   3 #include "parser.h"
   4 #include "lexer.h"
   5 #include "debug.h"
   6 #include "mul.h"
   7 #include "constant.h"
   8
   9 namespace GiNaC
  10 {
  11
  12 /// identifier_expr:  identifier |  identifier '(' expression* ')'
  13 ex parser::parse_identifier_expr()
  14 {
  15         std::string name = scanner->str;
  16         get_next_tok();  // eat identifier.
  17
  18         if (token != '(') // symbol
  19                 return find_or_insert_symbol(name, syms, strict);
  20
  21         // function/ctor call.
  22         get_next_tok();  // eat (
  23         exvector args;
  24         if (token != ')') {
  25                 while (true) {
  26                         ex e = parse_expression();
  27                         args.push_back(e);
  28
  29                         if (token == ')')
  30                                 break;
  31
  32                         if (token != ',')
  33                                 Parse_error("expected ')' or ',' in argument list");
  34
  35                         get_next_tok();
  36                 }
  37         }
  38         // Eat the ')'.
  39         get_next_tok();
  40         prototype the_prototype = make_pair(name, args.size());
  41         prototype_table::const_iterator reader = funcs.find(the_prototype);
  42         if (reader == funcs.end()) {
  43                 Parse_error_("no function \"" << name << "\" with " <<
  44                              args.size() << " arguments");
  45         }
  46         ex ret = reader->second(args);
  47         return ret;
  48 }
  49
  50 /// paren_expr:  '(' expression ')'
  51 ex parser::parse_paren_expr()
  52 {
  53         get_next_tok();  // eat (.
  54         ex e = parse_expression();
  55
  56         if (token != ')')
  57                 Parse_error("expected ')'");
  58         get_next_tok();  // eat ).
  59         return e;
  60 }
  61
  62 extern numeric* _num_1_p;
  63 extern ex _ex0;
  64
  65 /// unary_expr: [+-] expression
  66 ex parser::parse_unary_expr()
  67 {
  68         // Unlike most other parse_* method this one does NOT consume
  69         // current token so parse_binop_rhs() knows what kind of operator
  70         // is being parsed.
  71
  72         // There are different kinds of expressions which need to be handled:
  73         // -a+b
  74         // -(a)
  75         // +a
  76         // +(a)
  77         // Delegete the work to parse_binop_rhs(), otherwise we end up
  78         // duplicating it here.
  79         ex lhs = _ex0; // silly trick
  80         ex e = parse_binop_rhs(0, lhs);
  81         return e;
  82 }
  83
  84 /// primary: identifier_expr | number_expr | paren_expr | unary_expr
  85 ex parser::parse_primary()
  86 {
  87         switch (token) {
  88                 case lexer::token_type::identifier:
  89                          return parse_identifier_expr();
  90                 case lexer::token_type::number:
  91                          return parse_number_expr();
  92                 case '(':
  93                          return parse_paren_expr();
  94                 case '-':
  95                 case '+':
  96                          return parse_unary_expr();
  97                 case lexer::token_type::literal:
  98                          return parse_literal_expr();
  99                 case lexer::token_type::eof:
 100                 default:
 101                          Parse_error("unexpected token");
 102         }
 103 }
 104
 105 /// expression ::= primary binoprhs
 106 ex parser::parse_expression()
 107 {
 108         ex lhs = parse_primary();
 109         ex res = parse_binop_rhs(0, lhs);
 110         return res;
 111 }
 112
 113 /// number_expr: number
 114 ex parser::parse_number_expr()
 115 {
 116         ex n = numeric(scanner->str.c_str());
 117         get_next_tok(); // consume the number
 118         return n;
 119 }
 120
 121 /// literal_expr: 'I' | 'Pi' | 'Euler' | 'Catalan'
 122 ex parser::parse_literal_expr()
 123 {
 124         get_next_tok(); // consume the literal
 125         if (scanner->str == "I")
 126                 return I;
 127         else if (scanner->str == "Pi")
 128                 return Pi;
 129         else if (scanner->str == "Euler")
 130                 return Euler;
 131         else if (scanner->str == "Catalan")
 132                 return Catalan;
 133         bug("unknown literal: \"" << scanner->str << "\"");
 134 }
 135
 136 ex parser::operator()(std::istream& input)
 137 {
 138         scanner->switch_input(&input);
 139         get_next_tok();
 140         ex ret = parse_expression();
 141         // parse_expression() stops if it encounters an unknown token.
 142         // This is not a bug: since the parser is recursive checking
 143         // whether the next token is valid is responsibility of the caller.
 144         // Hence make sure nothing is left in the stream:
 145         if (token != lexer::token_type::eof)
 146                 Parse_error("expected EOF");
 147
 148         return ret;
 149 }
 150
 151 ex parser::operator()(const std::string& input)
 152 {
 153         std::istringstream is(input);
 154         ex ret = operator()(is);
 155         return ret;
 156 }
 157
 158 int parser::get_next_tok()
 159 {
 160         token = scanner->gettok();
 161         return token;
 162 }
 163
 164 parser::parser(const symtab& syms_, const bool strict_,
 165                const prototype_table& funcs_) : strict(strict_),
 166         funcs(funcs_), syms(syms_)
 167 {
 168         scanner = new lexer();
 169 }
 170
 171 parser::~parser()
 172 {
 173         delete scanner;
 174 }
 175
 176 } // namespace GiNaC