ginac/parser/parser.cpp

   1 #include <stdexcept>
   2 #include <sstream>
   3 #include "parser.hpp"
   4 #include "lexer.hpp"
   5 #include "debug.hpp"
   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
  64 /// unary_expr: [+-] expression
  65 ex parser::parse_unary_expr(const int s)
  66 {
  67         // consume '-' (or '+')
  68         get_next_tok();
  69         ex v = parse_expression();
  70         switch (s) {
  71                 case '-':
  72                         return (new mul(v, *_num_1_p))->setflag(status_flags::dynallocated);
  73                 case '+':
  74                         return v;
  75                 default:
  76                         Parse_error_("invalid unary operator \"" << char(s) << "\"");
  77         }
  78 }
  79
  80 /// primary: identifier_expr | number_expr | paren_expr | unary_expr
  81 ex parser::parse_primary()
  82 {
  83         switch (token) {
  84                 case lexer::token_type::identifier:
  85                          return parse_identifier_expr();
  86                 case lexer::token_type::number:
  87                          return parse_number_expr();
  88                 case '(':
  89                          return parse_paren_expr();
  90                 case '-':
  91                          return parse_unary_expr('-');
  92                 case '+':
  93                          return parse_unary_expr('+');
  94                 case lexer::token_type::literal:
  95                          return parse_literal_expr();
  96                 case lexer::token_type::eof:
  97                 default:
  98                          Parse_error("unexpected token");
  99         }
 100 }
 101
 102 /// expression ::= primary binoprhs
 103 ex parser::parse_expression()
 104 {
 105         ex lhs = parse_primary();
 106         ex res = parse_binop_rhs(0, lhs);
 107         return res;
 108 }
 109
 110 /// number_expr: number
 111 ex parser::parse_number_expr()
 112 {
 113         ex n = numeric(scanner->str.c_str());
 114         get_next_tok(); // consume the number
 115         return n;
 116 }
 117
 118 /// literal_expr: 'I' | 'Pi' | 'Euler' | 'Catalan'
 119 ex parser::parse_literal_expr()
 120 {
 121         if (scanner->str == "I")
 122                 return I;
 123         else if (scanner->str == "Pi")
 124                 return Pi;
 125         else if (scanner->str == "Euler")
 126                 return Euler;
 127         else if (scanner->str == "Catalan")
 128                 return Catalan;
 129         bug("unknown literal: \"" << scanner->str << "\"");
 130 }
 131
 132 ex parser::operator()(std::istream& input)
 133 {
 134         scanner->switch_input(&input);
 135         get_next_tok();
 136         ex ret = parse_expression();
 137         return ret;
 138 }
 139
 140 ex parser::operator()(const std::string& input)
 141 {
 142         std::istringstream is(input);
 143         ex ret = operator()(is);
 144         return ret;
 145 }
 146
 147 int parser::get_next_tok()
 148 {
 149         token = scanner->gettok();
 150         return token;
 151 }
 152
 153 parser::parser(const symtab& syms_, const bool strict_,
 154                const prototype_table& funcs_) : strict(strict_),
 155         funcs(funcs_), syms(syms_)
 156 {
 157         scanner = new lexer();
 158 }
 159
 160 parser::~parser()
 161 {
 162         delete scanner;
 163 }
 164
 165 } // namespace GiNaC