gcc/python/py-parser.y

   1 %{
   2 /* This file is part of GCC.
   3
   4 GCC is free software; you can redistribute it and/or modify it under
   5 the terms of the GNU General Public License as published by the Free
   6 Software Foundation; either version 3, or (at your option) any later
   7 version.
   8
   9 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  10 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12 for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with GCC; see the file COPYING3.  If not see
  16 <http://www.gnu.org/licenses/>.  */
  17
  18 /* Grammar largely bassed on
  19  * - http://docs.python.org/release/2.5.2/ref/grammar.txt
  20  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "ansidecl.h"
  25 #include "coretypes.h"
  26 #include "opts.h"
  27 #include "tree.h"
  28 #include "gimple.h"
  29 #include "toplev.h"
  30 #include "debug.h"
  31 #include "options.h"
  32 #include "flags.h"
  33 #include "convert.h"
  34 #include "diagnostic-core.h"
  35 #include "langhooks.h"
  36 #include "langhooks-def.h"
  37 #include "target.h"
  38
  39 #include <gmp.h>
  40 #include <mpfr.h>
  41
  42 #include "vec.h"
  43 #include "hashtab.h"
  44
  45 #include "gpython.h"
  46 #include "py-dot-codes.def"
  47 #include "py-dot.h"
  48 #include "py-vec.h"
  49 #include "py-tree.h"
  50 #include "py-runtime.h"
  51
  52 static VEC( gpy_sym,gc ) * gpy_symbol_stack;
  53
  54 extern int yylineno;
  55
  56 // yydebug = 1;
  57
  58 extern int yylex( void );
  59 extern void yyerror( const char * );
  60 %}
  61
  62 %union {
  63   char *string;
  64   long int integer;
  65   enum OPERATOR_T op;
  66   gpy_symbol_obj *symbol;
  67 }
  68
  69 %error-verbose
  70 %start declarations
  71 %debug
  72
  73 %token CLASS "class"
  74 %token DEF "def"
  75 %token BREAK "break"
  76 %token CONTINUE "continue"
  77 %token RETURN "return"
  78 %token FOR "for"
  79 %token WHILE "while"
  80 %token IN "in"
  81 %token PRINT "print"
  82
  83 %token EXCEPT "except"
  84 %token FINALLY "finally"
  85 %token TRY "try"
  86
  87 %token AS "as"
  88 %token ASSERT "assert"
  89 %token DEL "del"
  90 %token EXEC "exec"
  91 %token FROM "from"
  92 %token GLOBAL "global"
  93 %token IMPORT "import"
  94 %token IS "is"
  95 %token LAMBDA "lambda"
  96 %token PASS "pass"
  97 %token RAISE "raise"
  98 %token WITH "with"
  99 %token YIELD "yield"
 100
 101 %token IF "if"
 102 %token ELIF "elif"
 103 %token ELSE "else"
 104
 105 %token OR "or"
 106 %token AND "and"
 107 %token NOT "not"
 108
 109 %token V_TRUE "True"
 110 %token V_FALSE "False"
 111
 112 %token NEWLINE
 113 %token INDENT
 114 %token DEDENT
 115
 116 %token EQUAL_EQUAL
 117 %token NOT_EQUAL
 118 %token LESS
 119 %token GREATER
 120 %token LESS_EQUAL
 121 %token GREATER_EQUAL
 122
 123 %token NONE
 124 %token<string> IDENTIFIER
 125 %token<string> STRING
 126 %token<integer> INTEGER
 127 %token<decimal> DOUBLE
 128
 129 %type<symbol> statement
 130 %type<symbol> compound_stmt
 131 %type<symbol> stmt_list
 132 %type<symbol> simple_stmt
 133 %type<symbol> expression_stmt
 134 %type<symbol> assignment_stmt
 135 %type<symbol> target_list
 136 %type<symbol> target
 137 %type<symbol> expression_list
 138 %type<symbol> funcdef
 139 %type<symbol> classdef
 140 %type<symbol> suite
 141 %type<symbol> suite_statement_list
 142 %type<symbol> indent_stmt
 143 %type<symbol> literal
 144 %type<symbol> m_expr
 145 %type<symbol> a_expr
 146 %type<symbol> u_expr
 147 %type<symbol> atom
 148 %type<symbol> primary
 149 %type<symbol> expression
 150 %type<symbol> conditional_expression
 151 %type<symbol> call
 152 %type<symbol> shift_expr
 153 %type<symbol> comparison
 154 %type<symbol> decl
 155 %type<symbol> argument_list
 156 %type<symbol> argument_list_stmt
 157 %type<symbol> parameter_list
 158 %type<symbol> parameter_list_stmt
 159 %type<symbol> print_stmt
 160 %type<string> funcname
 161 %type<string> classname
 162
 163 %left '-' '+'
 164 %left '*' '/'
 165 %right '='
 166 %nonassoc UMINUS
 167
 168 %%
 169
 170 declarations:
 171             | declarations decl
 172             {
 173               if( $2 )
 174                 {
 175                   debug( "passing decl <%p> type <0x%x>!\n",
 176                          (void*)$2, $2->type );
 177
 178                   gpy_process_decl( $2 );
 179                 }
 180             }
 181             ;
 182
 183 decl: NEWLINE
 184     { $$ = NULL; }
 185     | statement
 186     ;
 187
 188 compound_stmt: funcdef
 189              | classdef
 190              ;
 191
 192 classdef: CLASS classname ':' suite
 193         {
 194            gpy_symbol_obj *sym;
 195            Gpy_Symbol_Init( sym );
 196
 197            sym->identifier = $2;
 198            sym->type = STRUCTURE_OBJECT_DEF;
 199            sym->op_a_t = TYPE_SYMBOL;
 200
 201            sym->op_a.symbol_table= $4;
 202            $$= sym;
 203         }
 204         ;
 205
 206 classname: IDENTIFIER
 207          ;
 208
 209 funcname: IDENTIFIER
 210         ;
 211
 212 parameter_list_stmt:
 213                    { $$=NULL; }
 214                    | parameter_list
 215                    { $$ = VEC_pop( gpy_sym, gpy_symbol_stack ); }
 216                    ;
 217
 218 parameter_list: parameter_list ',' target
 219               {
 220                 $1->next = $3;
 221                 $$ = $3;
 222               }
 223               | target
 224               {
 225                 VEC_safe_push( gpy_sym, gc,
 226                                gpy_symbol_stack, $1 );
 227                 $$ = $1;
 228               }
 229               ;
 230
 231 funcdef: DEF funcname '(' parameter_list_stmt ')' ':' suite
 232        {
 233          gpy_symbol_obj *sym;
 234          Gpy_Symbol_Init( sym );
 235
 236          sym->identifier = $2;
 237          sym->type = STRUCTURE_FUNCTION_DEF;
 238          sym->op_a_t = TYPE_SYMBOL;
 239          sym->op_b_t = TYPE_SYMBOL;
 240
 241          sym->op_a.symbol_table= $7;
 242          sym->op_b.symbol_table = $4;
 243
 244          $$= sym;
 245        }
 246        ;
 247
 248 suite: stmt_list NEWLINE
 249      | NEWLINE INDENT suite_statement_list DEDENT
 250      {
 251        $$ = VEC_pop( gpy_sym, gpy_symbol_stack );
 252        printf("poping suite!\n");
 253      }
 254      ;
 255
 256 suite_statement_list: suite_statement_list indent_stmt
 257                    {
 258                      $1->next = $2;
 259                      $$ = $2;
 260                    }
 261                    | indent_stmt
 262                    {
 263                      VEC_safe_push( gpy_sym, gc,
 264                                     gpy_symbol_stack, $1 );
 265                      $$=$1;
 266                    }
 267                    ;
 268
 269 indent_stmt: statement
 270            ;
 271
 272 statement: stmt_list NEWLINE
 273          | compound_stmt
 274          ;
 275
 276 stmt_list: simple_stmt
 277          ;
 278
 279 simple_stmt: assignment_stmt
 280            | expression_stmt
 281            | print_stmt
 282            ;
 283
 284 argument_list_stmt:
 285                   { $$ = NULL; }
 286                   | argument_list
 287                   { $$ = VEC_pop( gpy_sym, gpy_symbol_stack ); }
 288                   ;
 289
 290 argument_list: argument_list ',' expression
 291              {
 292                $1->next = $3;
 293                $$ = $3;
 294              }
 295              | expression
 296              {
 297                VEC_safe_push( gpy_sym, gc,
 298                               gpy_symbol_stack, $1 );
 299                $$ = $1;
 300              }
 301              ;
 302
 303 print_stmt: PRINT argument_list_stmt
 304           {
 305             gpy_symbol_obj* sym;
 306             Gpy_Symbol_Init( sym );
 307
 308             sym->type= KEY_PRINT;
 309             sym->op_a_t= TYPE_SYMBOL;
 310
 311             sym->op_a.symbol_table= $2;
 312             $$= sym;
 313           }
 314           ;
 315
 316
 317 expression_stmt: expression_list
 318           ;
 319
 320 assignment_stmt: target_list '=' expression_list
 321                {
 322                  gpy_symbol_obj* sym;
 323                  Gpy_Symbol_Init( sym );
 324
 325                  sym->exp= OP_EXPRESS;
 326                  sym->type= OP_ASSIGN_EVAL;
 327                  sym->op_a_t= TYPE_SYMBOL;
 328                  sym->op_b_t= TYPE_SYMBOL;
 329
 330                  sym->op_a.symbol_table= $1;
 331                  sym->op_b.symbol_table= $3;
 332                  $$= sym;
 333                }
 334                ;
 335
 336 target_list: target
 337            ;
 338
 339 target: IDENTIFIER
 340       {
 341         gpy_symbol_obj *sym;
 342         Gpy_Symbol_Init( sym );
 343
 344         sym->exp = OP_EXPRESS;
 345         sym->type= SYMBOL_REFERENCE;
 346         sym->op_a_t= TYPE_STRING;
 347
 348         sym->op_a.string= $1;
 349         $$= sym;
 350       }
 351       ;
 352
 353 expression_list: expression
 354                ;
 355
 356 expression: conditional_expression
 357           ;
 358
 359 conditional_expression: comparison
 360                       ;
 361
 362 u_expr: primary
 363        ;
 364
 365 m_expr: u_expr
 366       | m_expr '*' u_expr
 367       {
 368         gpy_symbol_obj* sym;
 369         Gpy_Symbol_Init( sym );
 370
 371         sym->exp= OP_EXPRESS;
 372         sym->type= OP_BIN_MULTIPLY;
 373         sym->op_a_t= TYPE_SYMBOL;
 374         sym->op_b_t= TYPE_SYMBOL;
 375
 376         sym->op_a.symbol_table= $1;
 377         sym->op_b.symbol_table= $3;
 378         $$= sym;
 379       }
 380       | m_expr '/' u_expr
 381       {
 382         gpy_symbol_obj* sym;
 383         Gpy_Symbol_Init( sym );
 384
 385         sym->exp= OP_EXPRESS;
 386         sym->type= OP_BIN_DIVIDE;
 387         sym->op_a_t= TYPE_SYMBOL;
 388         sym->op_b_t= TYPE_SYMBOL;
 389
 390         sym->op_a.symbol_table= $1;
 391         sym->op_b.symbol_table= $3;
 392         $$= sym;
 393       }
 394       ;
 395
 396 a_expr: m_expr
 397       | a_expr '+' m_expr
 398       {
 399         gpy_symbol_obj* sym;
 400         Gpy_Symbol_Init( sym );
 401
 402         sym->exp= OP_EXPRESS;
 403         sym->type= OP_BIN_ADDITION;
 404         sym->op_a_t= TYPE_SYMBOL;
 405         sym->op_b_t= TYPE_SYMBOL;
 406
 407         sym->op_a.symbol_table= $1;
 408         sym->op_b.symbol_table= $3;
 409         $$= sym;
 410       }
 411       | a_expr '-' m_expr
 412       {
 413         gpy_symbol_obj* sym;
 414         Gpy_Symbol_Init( sym );
 415
 416         sym->exp= OP_EXPRESS;
 417         sym->type= OP_BIN_SUBTRACTION;
 418         sym->op_a_t= TYPE_SYMBOL;
 419         sym->op_b_t= TYPE_SYMBOL;
 420
 421         sym->op_a.symbol_table= $1;
 422         sym->op_b.symbol_table= $3;
 423         $$= sym;
 424       }
 425       ;
 426
 427 shift_expr: a_expr
 428           ;
 429
 430 comparison: shift_expr
 431           ;
 432
 433 literal: INTEGER
 434        {
 435          gpy_symbol_obj *sym;
 436          Gpy_Symbol_Init( sym );
 437
 438          sym->exp = OP_EXPRESS;
 439          sym->type= SYMBOL_PRIMARY;
 440          sym->op_a_t= TYPE_INTEGER;
 441
 442          sym->op_a.integer= $1;
 443          $$= sym;
 444        }
 445        | STRING
 446        {
 447          gpy_symbol_obj *sym;
 448          Gpy_Symbol_Init( sym );
 449
 450          sym->exp = OP_EXPRESS;
 451          sym->type= SYMBOL_PRIMARY;
 452          sym->op_a_t= TYPE_STRING;
 453
 454          sym->op_a.string= $1;
 455          $$= sym;
 456        }
 457        | V_TRUE
 458        {
 459          gpy_symbol_obj *sym;
 460          Gpy_Symbol_Init( sym );
 461
 462          sym->exp = OP_EXPRESS;
 463          sym->type= SYMBOL_PRIMARY;
 464          sym->op_a_t= TYPE_BOOLEAN;
 465
 466          sym->op_a.boolean= true;
 467          $$= sym;
 468        }
 469        | V_FALSE
 470        {
 471          gpy_symbol_obj *sym;
 472          Gpy_Symbol_Init( sym );
 473
 474          sym->exp = OP_EXPRESS;
 475          sym->type= SYMBOL_PRIMARY;
 476          sym->op_a_t= TYPE_BOOLEAN;
 477
 478          sym->op_a.boolean= false;
 479          $$= sym;
 480        }
 481        ;
 482
 483 atom: target
 484     | literal
 485     ;
 486
 487 call: IDENTIFIER '(' argument_list_stmt ')'
 488     {
 489       gpy_symbol_obj *sym= NULL;
 490       Gpy_Symbol_Init( sym );
 491
 492       sym->exp = OP_EXPRESS;
 493       sym->type= OP_CALL_GOTO;
 494       sym->op_a_t= TYPE_STRING;
 495       sym->op_b_t= TYPE_SYMBOL;
 496
 497       sym->op_a.string = $1;
 498       sym->op_b.symbol_table = $3;
 499
 500       $$= sym;
 501     }
 502     ;
 503
 504 primary: atom
 505        | call
 506        ;
 507
 508 %%
 509
 510 void yyerror( const char *msg )
 511 {
 512   error( "%s at line %i\n", msg, yylineno );
 513 }