ginac/parser/parser.h

   1 /** @file parser.h
   2  *
   3  *  Interface to the parser. */
   4
   5 /*
   6  *  GiNaC Copyright (C) 1999-2011 Johannes Gutenberg University Mainz, Germany
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  21  */
  22
  23 #ifndef GINAC_PARSER_H
  24 #define GINAC_PARSER_H
  25
  26 #include "parse_context.h"
  27 #include "ex.h"
  28
  29 #include <stdexcept>
  30
  31 namespace GiNaC {
  32
  33 class lexer;
  34
  35 class parse_error : public std::invalid_argument
  36 {
  37 public:
  38         const std::size_t line;
  39         const std::size_t column;
  40         parse_error(const std::string& what_,
  41                     const std::size_t line_ = 0,
  42                     const std::size_t column_ = 0) throw () :
  43                 std::invalid_argument(what_), line(line_), column(column_)
  44         { }
  45 };
  46
  47 /**
  48  * Recursive descent parser for GiNaC expressions.
  49  */
  50 class parser
  51 {
  52         // The actual parser rules (in EBNF-alike notation):
  53
  54         /// expression: primary binoprhs
  55         ex parse_expression();
  56
  57         /// primary: indentifier_expr | number_expr | paren_expr | unary_expr
  58         ex parse_primary();
  59
  60         /// binoprhs: ([+*/^-] primary)*
  61         ex parse_binop_rhs(int, ex&);
  62
  63         /// identifier_expr: identifier |
  64         ///                  identifier '(' expression (',' expression)* ')'
  65         ex parse_identifier_expr();
  66
  67         /// paren_expr: '(' expression ')'
  68         ex parse_paren_expr();
  69
  70         /// lst_expr: '{' expression { ',' expression } '}'
  71         ex parse_lst_expr();
  72
  73         /// number_expr: number
  74         ex parse_number_expr();
  75
  76         /// unary_expr: [+-] expression
  77         ex parse_unary_expr();
  78
  79         /// literal_expr: 'I' | 'Pi' | 'Euler' | 'Catalan'
  80         ex parse_literal_expr();
  81
  82 public:
  83         /**
  84          * @param syms_ symbol table.
  85          * @param funcs_ function/ctors table.
  86          * @param strict_ if true, throw an exception if unknown
  87          *        symbol is encountered.
  88          */
  89         parser(const symtab& syms_ = symtab(),
  90                 const bool strict_ = false,
  91                 const prototype_table& funcs_ = get_default_reader());
  92         ~parser();
  93
  94         /// parse the stream @a input
  95         ex operator()(std::istream& input);
  96         /// parse the string @a input
  97         ex operator()(const std::string& input);
  98
  99         /// report the symbol table used by parser
 100         symtab get_syms() const
 101         {
 102                 return syms;
 103         }
 104         /// read/write access to the symbol table
 105         symtab& get_syms()
 106         {
 107                 return syms;
 108         }
 109
 110         /// If true, throw an exception if an unknown symbol is encountered.
 111         bool strict;
 112 private:
 113         /**
 114          * Function/ctor table, maps a prototype (which is a name and number
 115          * arguments) to a C++ function. Used for parsing identifier_expr's
 116          * (see parse_identifier_expr). If expression contains unknown
 117          * prototype, an exception will be thrown.
 118          */
 119         const prototype_table funcs;
 120         /**
 121          * Symbol (variable) table. Used for parsing identifier_expr's
 122          * (see parse_identifier_expr). If parser is strict, exception is
 123          * thrown if an unknown symbol is encountered. Non-strict parser
 124          * appends unknown symbols to the symbol table.
 125          */
 126         symtab syms;
 127         /// token scanner
 128         lexer* scanner;
 129         /// current token the parser is looking at
 130         int token;
 131         /// read the next token from the scanner
 132         int get_next_tok();
 133 };
 134
 135 } // namespace GiNaC
 136
 137 #endif // ndef GINAC_PARSER_H