ginac/input_parser.yy

   1 /** @file input_parser.yy
   2  *
   3  *  Input grammar definition for reading expressions.
   4  *  This file must be processed with yacc/bison. */
   5
   6 /*
   7  *  GiNaC Copyright (C) 1999-2002 Johannes Gutenberg University Mainz, Germany
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  */
  23
  24
  25 /*
  26  *  Definitions
  27  */
  28
  29 %{
  30 #include <stdexcept>
  31
  32 #include "input_lexer.h"
  33 #include "ex.h"
  34 #include "relational.h"
  35 #include "operators.h"
  36 #include "symbol.h"
  37 #include "lst.h"
  38 #include "power.h"
  39 #include "exprseq.h"
  40 #include "idx.h"
  41 #include "indexed.h"
  42 #include "matrix.h"
  43 #include "inifcns.h"
  44
  45 namespace GiNaC {
  46
  47 #define YYERROR_VERBOSE 1
  48
  49 // Parsed output expression
  50 ex parsed_ex;
  51
  52 // Last error message returned by parser
  53 static std::string parser_error;
  54
  55 // Prototypes
  56 ex attach_index(const ex & base, ex i, bool covariant);
  57 %}
  58
  59 /* Tokens (T_LITERAL means a literal value returned by the parser, but not
  60    of class numeric or symbol (e.g. a constant or the FAIL object)) */
  61 %token T_NUMBER T_SYMBOL T_LITERAL T_DIGITS T_EQUAL T_NOTEQ T_LESSEQ T_GREATEREQ
  62
  63 /* Operator precedence and associativity */
  64 %right '='
  65 %left T_EQUAL T_NOTEQ
  66 %left '<' '>' T_LESSEQ T_GREATEREQ
  67 %left '+' '-'
  68 %left '*' '/' '%'
  69 %nonassoc NEG
  70 %right '^'
  71 %left '.' '~'
  72 %nonassoc '!'
  73
  74 %start input
  75
  76
  77 /*
  78  *  Grammar rules
  79  */
  80
  81 %%
  82 input   : exp {
  83                 try {
  84                         parsed_ex = $1;
  85                         YYACCEPT;
  86                 } catch (std::exception &err) {
  87                         parser_error = err.what();
  88                         YYERROR;
  89                 }
  90         }
  91         | error         {yyclearin; yyerrok;}
  92         ;
  93
  94 exp     : T_NUMBER              {$$ = $1;}
  95         | T_SYMBOL {
  96                 if (is_lexer_symbol_predefined($1))
  97                         $$ = $1.eval();
  98                 else
  99                         throw (std::runtime_error("unknown symbol '" + get_symbol_name($1) + "'"));
 100         }
 101         | T_LITERAL             {$$ = $1;}
 102         | T_DIGITS              {$$ = $1;}
 103         | T_SYMBOL '(' exprseq ')' {
 104                 std::string n = get_symbol_name($1);
 105                 if (n == "sqrt") {
 106                         if ($3.nops() != 1)
 107                                 throw (std::runtime_error("too many arguments to sqrt()"));
 108                         $$ = sqrt($3.op(0));
 109                 } else {
 110                         unsigned i = function::find_function(n, $3.nops());
 111                         $$ = function(i, ex_to<exprseq>($3)).eval(1);
 112                 }
 113         }
 114         | exp T_EQUAL exp       {$$ = $1 == $3;}
 115         | exp T_NOTEQ exp       {$$ = $1 != $3;}
 116         | exp '<' exp           {$$ = $1 < $3;}
 117         | exp T_LESSEQ exp      {$$ = $1 <= $3;}
 118         | exp '>' exp           {$$ = $1 > $3;}
 119         | exp T_GREATEREQ exp   {$$ = $1 >= $3;}
 120         | exp '+' exp           {$$ = $1 + $3;}
 121         | exp '-' exp           {$$ = $1 - $3;}
 122         | exp '*' exp           {$$ = $1 * $3;}
 123         | exp '/' exp           {$$ = $1 / $3;}
 124         | '-' exp %prec NEG     {$$ = -$2;}
 125         | '+' exp %prec NEG     {$$ = $2;}
 126         | exp '^' exp           {$$ = pow($1, $3);}
 127         | exp '.' exp           {$$ = attach_index($1, $3, true);}
 128         | exp '~' exp           {$$ = attach_index($1, $3, false);}
 129         | exp '!'               {$$ = factorial($1);}
 130         | '(' exp ')'           {$$ = $2;}
 131         | '{' list_or_empty '}' {$$ = $2;}
 132         | '[' matrix ']'        {$$ = lst_to_matrix(ex_to<lst>($2));}
 133         ;
 134
 135 exprseq : exp                   {$$ = exprseq($1);}
 136         | exprseq ',' exp       {exprseq es(ex_to<exprseq>($1)); $$ = es.append($3);}
 137         ;
 138
 139 list_or_empty: /* empty */      {$$ = *new lst;}
 140         | list                  {$$ = $1;}
 141         ;
 142
 143 list    : exp                   {$$ = lst($1);}
 144         | list ',' exp          {lst l(ex_to<lst>($1)); $$ = l.append($3);}
 145         ;
 146
 147 matrix  : '[' row ']'           {$$ = lst($2);}
 148         | matrix ',' '[' row ']' {lst l(ex_to<lst>($1)); $$ = l.append($4);}
 149         ;
 150
 151 row     : exp                   {$$ = lst($1);}
 152         | row ',' exp           {lst l(ex_to<lst>($1)); $$ = l.append($3);}
 153         ;
 154
 155
 156 /*
 157  *  Routines
 158  */
 159
 160 %%
 161 // Attach index to expression
 162 ex attach_index(const ex & base, ex i, bool covariant)
 163 {
 164         // Toggle index variance if necessary
 165         if (is_a<varidx>(i)) {
 166                 const varidx &vi = ex_to<varidx>(i);
 167                 if (vi.is_covariant() != covariant)
 168                         i = vi.toggle_variance();
 169         } else if (!covariant)
 170                 throw (std::runtime_error("index '" + get_symbol_name(i) + "' is not a varidx and cannot be contravariant"));
 171
 172         // Add index to an existing indexed object, or create a new indexed
 173         // object if there are no indices yet
 174         if (is_a<indexed>(base)) {
 175                 const ex &b = base.op(0);
 176                 exvector iv;
 177                 for (unsigned n=1; n<base.nops(); n++)
 178                         iv.push_back(base.op(n));
 179                 iv.push_back(i);
 180                 return indexed(b, iv);
 181         } else
 182                 return indexed(base, i);
 183 }
 184
 185 // Get last error encountered by parser
 186 std::string get_parser_error(void)
 187 {
 188         return parser_error;
 189 }
 190
 191 } // namespace GiNaC
 192
 193 // Error print routine (store error string in parser_error)
 194 int ginac_yyerror(char *s)
 195 {
 196         GiNaC::parser_error = std::string(s) + " at " + std::string(ginac_yytext);
 197         return 0;
 198 }