ext/ply/example/BASIC/basparse.py

   1 # An implementation of Dartmouth BASIC (1964)
   2 #
   3
   4 from ply import *
   5 import basiclex
   6
   7 tokens = basiclex.tokens
   8
   9 precedence = (
  10                ('left', 'PLUS','MINUS'),
  11                ('left', 'TIMES','DIVIDE'),
  12                ('left', 'POWER'),
  13                ('right','UMINUS')
  14 )
  15
  16 #### A BASIC program is a series of statements.  We represent the program as a
  17 #### dictionary of tuples indexed by line number.
  18
  19 def p_program(p):
  20     '''program : program statement
  21                | statement'''
  22
  23     if len(p) == 2 and p[1]:
  24        p[0] = { }
  25        line,stat = p[1]
  26        p[0][line] = stat
  27     elif len(p) ==3:
  28        p[0] = p[1]
  29        if not p[0]: p[0] = { }
  30        if p[2]:
  31            line,stat = p[2]
  32            p[0][line] = stat
  33
  34 #### This catch-all rule is used for any catastrophic errors.  In this case,
  35 #### we simply return nothing
  36
  37 def p_program_error(p):
  38     '''program : error'''
  39     p[0] = None
  40     p.parser.error = 1
  41
  42 #### Format of all BASIC statements.
  43
  44 def p_statement(p):
  45     '''statement : INTEGER command NEWLINE'''
  46     if isinstance(p[2],str):
  47         print p[2],"AT LINE", p[1]
  48         p[0] = None
  49         p.parser.error = 1
  50     else:
  51         lineno = int(p[1])
  52         p[0] = (lineno,p[2])
  53
  54 #### Interactive statements.
  55
  56 def p_statement_interactive(p):
  57     '''statement : RUN NEWLINE
  58                  | LIST NEWLINE
  59                  | NEW NEWLINE'''
  60     p[0] = (0, (p[1],0))
  61
  62 #### Blank line number
  63 def p_statement_blank(p):
  64     '''statement : INTEGER NEWLINE'''
  65     p[0] = (0,('BLANK',int(p[1])))
  66
  67 #### Error handling for malformed statements
  68
  69 def p_statement_bad(p):
  70     '''statement : INTEGER error NEWLINE'''
  71     print "MALFORMED STATEMENT AT LINE", p[1]
  72     p[0] = None
  73     p.parser.error = 1
  74
  75 #### Blank line
  76
  77 def p_statement_newline(p):
  78     '''statement : NEWLINE'''
  79     p[0] = None
  80
  81 #### LET statement
  82
  83 def p_command_let(p):
  84     '''command : LET variable EQUALS expr'''
  85     p[0] = ('LET',p[2],p[4])
  86
  87 def p_command_let_bad(p):
  88     '''command : LET variable EQUALS error'''
  89     p[0] = "BAD EXPRESSION IN LET"
  90
  91 #### READ statement
  92
  93 def p_command_read(p):
  94     '''command : READ varlist'''
  95     p[0] = ('READ',p[2])
  96
  97 def p_command_read_bad(p):
  98     '''command : READ error'''
  99     p[0] = "MALFORMED VARIABLE LIST IN READ"
 100
 101 #### DATA statement
 102
 103 def p_command_data(p):
 104     '''command : DATA numlist'''
 105     p[0] = ('DATA',p[2])
 106
 107 def p_command_data_bad(p):
 108     '''command : DATA error'''
 109     p[0] = "MALFORMED NUMBER LIST IN DATA"
 110
 111 #### PRINT statement
 112
 113 def p_command_print(p):
 114     '''command : PRINT plist optend'''
 115     p[0] = ('PRINT',p[2],p[3])
 116
 117 def p_command_print_bad(p):
 118     '''command : PRINT error'''
 119     p[0] = "MALFORMED PRINT STATEMENT"
 120
 121 #### Optional ending on PRINT. Either a comma (,) or semicolon (;)
 122
 123 def p_optend(p):
 124     '''optend : COMMA
 125               | SEMI
 126               |'''
 127     if len(p)  == 2:
 128          p[0] = p[1]
 129     else:
 130          p[0] = None
 131
 132 #### PRINT statement with no arguments
 133
 134 def p_command_print_empty(p):
 135     '''command : PRINT'''
 136     p[0] = ('PRINT',[],None)
 137
 138 #### GOTO statement
 139
 140 def p_command_goto(p):
 141     '''command : GOTO INTEGER'''
 142     p[0] = ('GOTO',int(p[2]))
 143
 144 def p_command_goto_bad(p):
 145     '''command : GOTO error'''
 146     p[0] = "INVALID LINE NUMBER IN GOTO"
 147
 148 #### IF-THEN statement
 149
 150 def p_command_if(p):
 151     '''command : IF relexpr THEN INTEGER'''
 152     p[0] = ('IF',p[2],int(p[4]))
 153
 154 def p_command_if_bad(p):
 155     '''command : IF error THEN INTEGER'''
 156     p[0] = "BAD RELATIONAL EXPRESSION"
 157
 158 def p_command_if_bad2(p):
 159     '''command : IF relexpr THEN error'''
 160     p[0] = "INVALID LINE NUMBER IN THEN"
 161
 162 #### FOR statement
 163
 164 def p_command_for(p):
 165     '''command : FOR ID EQUALS expr TO expr optstep'''
 166     p[0] = ('FOR',p[2],p[4],p[6],p[7])
 167
 168 def p_command_for_bad_initial(p):
 169     '''command : FOR ID EQUALS error TO expr optstep'''
 170     p[0] = "BAD INITIAL VALUE IN FOR STATEMENT"
 171
 172 def p_command_for_bad_final(p):
 173     '''command : FOR ID EQUALS expr TO error optstep'''
 174     p[0] = "BAD FINAL VALUE IN FOR STATEMENT"
 175
 176 def p_command_for_bad_step(p):
 177     '''command : FOR ID EQUALS expr TO expr STEP error'''
 178     p[0] = "MALFORMED STEP IN FOR STATEMENT"
 179
 180 #### Optional STEP qualifier on FOR statement
 181
 182 def p_optstep(p):
 183     '''optstep : STEP expr
 184                | empty'''
 185     if len(p) == 3:
 186        p[0] = p[2]
 187     else:
 188        p[0] = None
 189
 190 #### NEXT statement
 191
 192 def p_command_next(p):
 193     '''command : NEXT ID'''
 194
 195     p[0] = ('NEXT',p[2])
 196
 197 def p_command_next_bad(p):
 198     '''command : NEXT error'''
 199     p[0] = "MALFORMED NEXT"
 200
 201 #### END statement
 202
 203 def p_command_end(p):
 204     '''command : END'''
 205     p[0] = ('END',)
 206
 207 #### REM statement
 208
 209 def p_command_rem(p):
 210     '''command : REM'''
 211     p[0] = ('REM',p[1])
 212
 213 #### STOP statement
 214
 215 def p_command_stop(p):
 216     '''command : STOP'''
 217     p[0] = ('STOP',)
 218
 219 #### DEF statement
 220
 221 def p_command_def(p):
 222     '''command : DEF ID LPAREN ID RPAREN EQUALS expr'''
 223     p[0] = ('FUNC',p[2],p[4],p[7])
 224
 225 def p_command_def_bad_rhs(p):
 226     '''command : DEF ID LPAREN ID RPAREN EQUALS error'''
 227     p[0] = "BAD EXPRESSION IN DEF STATEMENT"
 228
 229 def p_command_def_bad_arg(p):
 230     '''command : DEF ID LPAREN error RPAREN EQUALS expr'''
 231     p[0] = "BAD ARGUMENT IN DEF STATEMENT"
 232
 233 #### GOSUB statement
 234
 235 def p_command_gosub(p):
 236     '''command : GOSUB INTEGER'''
 237     p[0] = ('GOSUB',int(p[2]))
 238
 239 def p_command_gosub_bad(p):
 240     '''command : GOSUB error'''
 241     p[0] = "INVALID LINE NUMBER IN GOSUB"
 242
 243 #### RETURN statement
 244
 245 def p_command_return(p):
 246     '''command : RETURN'''
 247     p[0] = ('RETURN',)
 248
 249 #### DIM statement
 250
 251 def p_command_dim(p):
 252     '''command : DIM dimlist'''
 253     p[0] = ('DIM',p[2])
 254
 255 def p_command_dim_bad(p):
 256     '''command : DIM error'''
 257     p[0] = "MALFORMED VARIABLE LIST IN DIM"
 258
 259 #### List of variables supplied to DIM statement
 260
 261 def p_dimlist(p):
 262     '''dimlist : dimlist COMMA dimitem
 263                | dimitem'''
 264     if len(p) == 4:
 265         p[0] = p[1]
 266         p[0].append(p[3])
 267     else:
 268         p[0] = [p[1]]
 269
 270 #### DIM items
 271
 272 def p_dimitem_single(p):
 273     '''dimitem : ID LPAREN INTEGER RPAREN'''
 274     p[0] = (p[1],eval(p[3]),0)
 275
 276 def p_dimitem_double(p):
 277     '''dimitem : ID LPAREN INTEGER COMMA INTEGER RPAREN'''
 278     p[0] = (p[1],eval(p[3]),eval(p[5]))
 279
 280 #### Arithmetic expressions
 281
 282 def p_expr_binary(p):
 283     '''expr : expr PLUS expr
 284             | expr MINUS expr
 285             | expr TIMES expr
 286             | expr DIVIDE expr
 287             | expr POWER expr'''
 288
 289     p[0] = ('BINOP',p[2],p[1],p[3])
 290
 291 def p_expr_number(p):
 292     '''expr : INTEGER
 293             | FLOAT'''
 294     p[0] = ('NUM',eval(p[1]))
 295
 296 def p_expr_variable(p):
 297     '''expr : variable'''
 298     p[0] = ('VAR',p[1])
 299
 300 def p_expr_group(p):
 301     '''expr : LPAREN expr RPAREN'''
 302     p[0] = ('GROUP',p[2])
 303
 304 def p_expr_unary(p):
 305     '''expr : MINUS expr %prec UMINUS'''
 306     p[0] = ('UNARY','-',p[2])
 307
 308 #### Relational expressions
 309
 310 def p_relexpr(p):
 311     '''relexpr : expr LT expr
 312                | expr LE expr
 313                | expr GT expr
 314                | expr GE expr
 315                | expr EQUALS expr
 316                | expr NE expr'''
 317     p[0] = ('RELOP',p[2],p[1],p[3])
 318
 319 #### Variables
 320
 321 def p_variable(p):
 322     '''variable : ID
 323               | ID LPAREN expr RPAREN
 324               | ID LPAREN expr COMMA expr RPAREN'''
 325     if len(p) == 2:
 326        p[0] = (p[1],None,None)
 327     elif len(p) == 5:
 328        p[0] = (p[1],p[3],None)
 329     else:
 330        p[0] = (p[1],p[3],p[5])
 331
 332 #### Builds a list of variable targets as a Python list
 333
 334 def p_varlist(p):
 335     '''varlist : varlist COMMA variable
 336                | variable'''
 337     if len(p) > 2:
 338        p[0] = p[1]
 339        p[0].append(p[3])
 340     else:
 341        p[0] = [p[1]]
 342
 343
 344 #### Builds a list of numbers as a Python list
 345
 346 def p_numlist(p):
 347     '''numlist : numlist COMMA number
 348                | number'''
 349
 350     if len(p) > 2:
 351        p[0] = p[1]
 352        p[0].append(p[3])
 353     else:
 354        p[0] = [p[1]]
 355
 356 #### A number. May be an integer or a float
 357
 358 def p_number(p):
 359     '''number  : INTEGER
 360                | FLOAT'''
 361     p[0] = eval(p[1])
 362
 363 #### A signed number.
 364
 365 def p_number_signed(p):
 366     '''number  : MINUS INTEGER
 367                | MINUS FLOAT'''
 368     p[0] = eval("-"+p[2])
 369
 370 #### List of targets for a print statement
 371 #### Returns a list of tuples (label,expr)
 372
 373 def p_plist(p):
 374     '''plist   : plist COMMA pitem
 375                | pitem'''
 376     if len(p) > 3:
 377        p[0] = p[1]
 378        p[0].append(p[3])
 379     else:
 380        p[0] = [p[1]]
 381
 382 def p_item_string(p):
 383     '''pitem : STRING'''
 384     p[0] = (p[1][1:-1],None)
 385
 386 def p_item_string_expr(p):
 387     '''pitem : STRING expr'''
 388     p[0] = (p[1][1:-1],p[2])
 389
 390 def p_item_expr(p):
 391     '''pitem : expr'''
 392     p[0] = ("",p[1])
 393
 394 #### Empty
 395
 396 def p_empty(p):
 397     '''empty : '''
 398
 399 #### Catastrophic error handler
 400 def p_error(p):
 401     if not p:
 402         print "SYNTAX ERROR AT EOF"
 403
 404 bparser = yacc.yacc()
 405
 406 def parse(data):
 407     bparser.error = 0
 408     p = bparser.parse(data)
 409     if bparser.error: return None
 410     return p
 411
 412
 413
 414
 415
 416
 417
 418
 419
 420
 421
 422
 423
 424