parse.c

   1 #include <ctype.h>
   2 #include <stdbool.h>
   3 #include <stdlib.h>
   4 #include <stdio.h>
   5 #include <string.h>
   6
   7 #include "error.h"
   8 #include "jack.h"
   9 #include "parse.h"
  10 #include "token.h"
  11
  12 void parse_class()
  13 {
  14         if(settings.tokens)
  15         {
  16                 token_print("class", OPEN);
  17                 space_count++;
  18         }
  19
  20         if(has_more_tokens(pC) == true)
  21         {
  22                 pC = advance(pC, pT);
  23                 tk = token_type(pT);
  24         } else {
  25                 compiler_error(40, "Incomplete Class Declaration", pS, pC, pT);
  26         }
  27
  28         if(strcmp(pT, "class") == 0 ) {
  29         if(settings.tokens) { token_print("keyword", BOTH); }
  30         } else {
  31                 compiler_error(43, "Incorrect Token Found: Must be 'class'", pS, pC, pT);
  32         }
  33
  34         /* look for class name */
  35         if(has_more_tokens(pC) == true)
  36         {
  37                 pC = advance(pC, pT);
  38                 tk = token_type(pT);
  39         } else {
  40                         compiler_error(40, "Incomplete Class Declaration", pS, pC, pT);
  41         }
  42
  43         if (tk == IDENTIFIER){
  44                 if(settings.tokens) { token_print("identifier", BOTH); }
  45         } else {
  46                 compiler_error(44, "Could Not Find Class Name or Subroutine Name at This Location", pS, pC, pT);
  47         }
  48
  49         /* look for '{' symbol */
  50         if(has_more_tokens(pC) == true)
  51         {
  52                 pC = advance(pC, pT);
  53                 tk = token_type(pT);
  54         } else {
  55                         compiler_error(40, "Incomplete Class Declaration", pS, pC, pT);
  56         }
  57
  58         if (tk == SYMBOL)
  59         {
  60                 if(settings.tokens) { token_print("symbol", BOTH); }
  61         } else {
  62                 compiler_error(44, "Could Not Find Class Name or Subroutine Name at This Location", pS, pC, pT);
  63         }
  64
  65         if(has_more_tokens(pC) == true)
  66         {
  67                 pC = advance(pC, pT);
  68                 tk = token_type(pT);
  69         } else {
  70                 compiler_error(40, "Incomplete Class Declaration", pS, pC, pT);
  71         }
  72
  73         while(strcmp(pT, "static") == 0 || strcmp(pT, "field") == 0)
  74         {
  75                 parse_class_var_dec();
  76                 if(has_more_tokens(pC) == true)
  77                 {
  78                         pC = advance(pC, pT);
  79                         tk = token_type(pT);
  80                 } else {
  81                         compiler_error(40, "Incomplete Class Declaration", pS, pC, pT);
  82                 }
  83         }
  84
  85         while(strcmp(pT, "constructor") == 0 || strcmp(pT, "function") == 0 || strcmp(pT, "method") == 0)
  86         {
  87                 parse_subroutine();
  88                 if(has_more_tokens(pC) == true)
  89                 {
  90                         pC = advance(pC, pT);
  91                         tk = token_type(pT);
  92                 } else {
  93                         compiler_error(40, "Incomplete Class Declaration", pS, pC, pT);
  94                 }
  95         }
  96
  97         if(*pT == '}')
  98         {
  99                 if(settings.tokens) { token_print("symbol", BOTH); }
 100         } else {
 101                 compiler_error(40, "Incomplete Class Declaration", pS, pC, pT);
 102         }
 103
 104         if(settings.tokens)
 105         {
 106                 space_count--;
 107                 token_print("class", CLOSE);
 108         }
 109 }
 110
 111 void parse_class_var_dec()
 112 {
 113         if(settings.tokens)
 114         {
 115                 token_print("classVarDec", OPEN);
 116                 space_count++;
 117         }
 118
 119         /* look for 'static' or 'field' */
 120         if(settings.tokens) { token_print("keyword", BOTH); }
 121         if(has_more_tokens(pC) == true)
 122         {
 123                 pC = advance(pC, pT);
 124                 tk = token_type(pT);
 125         } else {
 126                 compiler_error(40, "Incomplete Class Declaration", pS, pC, pT);
 127         }
 128
 129         /* look for type */
 130         if(tk == IDENTIFIER) {
 131                 if(settings.tokens) { token_print("identifier", BOTH); }
 132         } else if (tk == KEYWORD) {
 133                 if(strcmp(pT, "int") == 0 || strcmp(pT, "char") == 0 || strcmp(pT, "boolean") == 0) {
 134                         if(settings.tokens) { token_print("keyword", BOTH); }
 135                 } else {
 136                         compiler_error(41, "Token Must be Data Type.", pS, pC, pT);
 137                 }
 138         } else {
 139                 compiler_error(41, "Token Must be Data Type", pS, pC, pT);
 140         }
 141
 142         /* look or variable name */
 143         if(has_more_tokens(pC) == true)
 144         {
 145                 pC = advance(pC, pT);
 146                 tk = token_type(pT);
 147         } else {
 148                 compiler_error(40, "Incomplete Class Declaration", pS, pC, pT);
 149         }
 150         if(tk == IDENTIFIER) {
 151                 if(settings.tokens) { token_print("identifier", BOTH); }
 152         } else {
 153                 compiler_error(42, "Token Must be Variable Name", pS, pC, pT);
 154         }
 155
 156         /* look for ',' */
 157         if(has_more_tokens(pC) == true)
 158         {
 159                 pC = advance(pC, pT);
 160                 tk = token_type(pT);
 161         } else {
 162                 compiler_error(40, "Incomplete Class Declaration", pS, pC, pT);
 163         }
 164
 165         if(*pT == ',') {
 166                 do {
 167                         if(settings.tokens) { token_print("symbol", BOTH); }
 168                         if(has_more_tokens(pC) == true)
 169                         {
 170                                 pC = advance(pC, pT);
 171                                 tk = token_type(pT);
 172                         } else {
 173                                 compiler_error(40, "Incomplete Class Declaration", pS, pC, pT);
 174                         }
 175                         if(tk == IDENTIFIER) {
 176                                 if(settings.tokens) { token_print("identifier", BOTH); }
 177                         } else {
 178                                 compiler_error(42, "Token Must be Variable Name", pS, pC, pT);
 179                         }
 180                         if(has_more_tokens(pC) == true)
 181                         {
 182                                 pC = advance(pC, pT);
 183                                 tk = token_type(pT);
 184                         } else {
 185                                 compiler_error(40, "Incomplete Class Declaration", pS, pC, pT);
 186                         }
 187                 } while (*pT == ',');
 188         }
 189
 190         if(*pT == ';') {
 191                 if(settings.tokens) { token_print("symbol", BOTH); }
 192         } else {
 193                 compiler_error(33, "Could Not Find ';' Symbol At This Location", pS, pC, pT);
 194         }
 195
 196         if(settings.tokens)
 197         {
 198                 space_count--;
 199                 token_print("classVarDec", CLOSE);
 200         }
 201 }
 202
 203 void parse_subroutine()
 204 {
 205         if(settings.tokens)
 206         {
 207                 token_print("subroutineDec", OPEN);
 208                 space_count++;
 209         }
 210
 211         if(tk == KEYWORD) {
 212                 if(strcmp(pT, "constructor") == 0 || strcmp(pT, "function") == 0 || strcmp(pT, "method") == 0)
 213                 {
 214                         if(settings.tokens) { token_print("keyword", BOTH); }
 215                 } else {
 216                         compiler_error(8, "Incorrect Token Found: Must be 'constructor', 'function', or 'method'", pS, pC, pT);
 217                 }
 218         }
 219
 220         /* look for return type of function */
 221         if(has_more_tokens(pC) == true)
 222         {
 223                 pC = advance(pC, pT);
 224                 tk = token_type(pT);
 225                 if(tk == KEYWORD || tk == IDENTIFIER)
 226                 {
 227                         if(strcmp(pT, "void") == 0)
 228                         {
 229                                 if(settings.tokens) { token_print("keyword", BOTH); }
 230                         } else {
 231                                 if(settings.tokens) { token_print("identifier", BOTH); }
 232                         }
 233                 } else {
 234                         compiler_error(9, "Could Not Complete Parse Tree of Subroutine. Incomplete Program", pS, pC, pT);
 235                 }
 236         } else {
 237                 compiler_error(29, "Incorrect Token Type", pS, pC, pT);
 238         }
 239
 240         /* look for subroutine name */
 241         if(has_more_tokens(pC) == true)
 242         {
 243                 pC = advance(pC, pT);
 244                 tk = token_type(pT);
 245                 if(tk == IDENTIFIER)
 246                 {
 247                         if(settings.tokens) { token_print("identifier", BOTH); }
 248                 } else {
 249                         compiler_error(9, "Could Not Complete Parse Tree of Subroutine. Incomplete Program", pS, pC, pT);
 250                 }
 251         } else {
 252                 compiler_error(10, "Incorrect Token Type. Looking for Keyword or Identifier.", pS, pC, pT);
 253         }
 254
 255         /* look for symbol '(' that specifies beginning of parameter list */
 256         if(has_more_tokens(pC) == true)
 257         {
 258                 pC = advance(pC, pT);
 259                 tk = token_type(pT);
 260                 if(*pT == '(')
 261                 {
 262                         if(settings.tokens) { token_print("symbol", BOTH); }
 263                         parse_params();
 264                 } else {
 265                         compiler_error(12, "Parameter List for Function Missing", pS, pC, pT);
 266                 }
 267         } else {
 268                 compiler_error(11, "Name of Function Must be an Identifier", pS, pC, pT);
 269         }
 270
 271         /* look for end of parameter list */
 272         if(*pT == ')')
 273         {
 274                 if(settings.tokens)
 275                 {
 276                         token_print("symbol", BOTH);
 277                         token_print("subroutineBody", OPEN);
 278                         space_count++;
 279                 }
 280         } else {
 281                 compiler_error(13, "Could Not Complete Parameter List for Function", pS, pC, pT);
 282         }
 283
 284         /* look for opening brace for block */
 285         if(has_more_tokens(pC) == true)
 286         {
 287                 pC = advance(pC, pT);
 288                 tk = token_type(pT);
 289                 if(*pT == '{')
 290                 {
 291                         if(settings.tokens) { token_print("symbol", BOTH); }
 292                         if(has_more_tokens(pC) == true)
 293                         {
 294                                 pC = advance(pC, pT);
 295                                 tk = token_type(pT);
 296                         } else {
 297                                 compiler_error(17, "Could Not Complete Variable List of Subroutine. Incomplete Program", pS, pC, pT);
 298                         }
 299                         parse_var_dec();
 300                 }
 301         } else {
 302                 compiler_error(9, "Could Not Complete Parse Tree of Subroutine. Incomplete Program", pS, pC, pT);
 303         }
 304
 305         parse_statements();
 306
 307         if(*pT == '}')
 308         {
 309                 if(settings.tokens) { token_print("symbol", BOTH); }
 310         } else {
 311                 compiler_error(17, "Could Not Complete Subroutine. Incomplete Program", pS, pC, pT);
 312         }
 313
 314         if(settings.tokens)
 315         {
 316                 space_count--;
 317                 token_print("subroutineBody", CLOSE);
 318                 space_count--;
 319                 token_print("subroutineDec", CLOSE);
 320         }
 321 }
 322
 323 void parse_params()
 324 {
 325         if(*pT == '(') { if(settings.tokens) { token_print("parameterList", OPEN); space_count++; } }
 326
 327         /* look for datatype in parameter list */
 328         if(has_more_tokens(pC) == true)
 329         {
 330                 pC = advance(pC, pT);
 331                 tk = token_type(pT);
 332                 if(tk == KEYWORD) {
 333                         if(strcmp(pT, "int") == 0 || strcmp(pT, "char") == 0 || strcmp(pT, "boolean") == 0)
 334                         {
 335                                 if(settings.tokens) { token_print("keyword", BOTH); }
 336                         } else {
 337                                 compiler_error(14, "Incorrect Token Type in Parameter List. Looking for Datatype name.", pS, pC, pT);
 338                         }
 339                 } else if(tk == SYMBOL && *pT == ')') {
 340                         if(settings.tokens)
 341                         {
 342                                 space_count--;
 343                                 token_print("parameterList", CLOSE);
 344                         }
 345                         return;
 346                 }
 347         } else {
 348                 compiler_error(13, "Could Not Complete Parameter List for Function", pS, pC, pT);
 349         }
 350
 351         /* look for identifier for this parameter */
 352         if(has_more_tokens(pC) == true)
 353         {
 354                 pC = advance(pC, pT);
 355                 tk = token_type(pT);
 356                 if(tk == IDENTIFIER) {
 357                         if(settings.tokens) { token_print("identifier", BOTH); }
 358                 } else {
 359                         compiler_error(15, "Incorrect Token Type in Parameter List. Looking for Variable Identifier.", pS, pC, pT);
 360                 }
 361         } else {
 362                 compiler_error(13, "Could Not Complete Parameter List for Function", pS, pC, pT);
 363         }
 364
 365         /* are there more parameters? */
 366         if(has_more_tokens(pC) == true)
 367         {
 368                 pC = advance(pC, pT);
 369                 tk = token_type(pT);
 370                 if(*pT == ',') {
 371                         if(settings.tokens) { token_print("symbol", BOTH); }
 372                         parse_params();
 373                 } else if (*pT == ')') { /* exit parse_params */
 374                         if(settings.tokens)
 375                         {
 376                                 space_count--;
 377                                 token_print("parameterList", CLOSE);
 378                         }
 379                         return;
 380                 } else {
 381                         compiler_error(16, "Incorrect Token Type in Parameter List. Looking for ',' or ')'", pS, pC, pT);
 382                 }
 383         } else {
 384                 compiler_error(13, "Could Not Complete Parameter List for Function", pS, pC, pT);
 385         }
 386 }
 387
 388 void parse_var_dec()
 389 {
 390         /* look for token named 'var' */
 391         if(strcmp(pT, "var") == 0)
 392         {
 393                 if(settings.tokens)
 394                 {
 395                         token_print("varDec", OPEN);
 396                         token_print("symbol", BOTH);
 397                 }
 398         } else { return; }
 399
 400         /* look for variable data type */
 401         if(has_more_tokens(pC) == true)
 402         {
 403                 pC = advance(pC, pT);
 404                 tk = token_type(pT);
 405                 if(strcmp(pT, "int") == 0 || strcmp(pT, "char") == 0 || strcmp(pT, "boolean") == 0 || strcmp(pT, "Array") == 0)
 406                 {
 407                         if(settings.tokens) { token_print("identifier", BOTH); }
 408
 409                 } else if (tk == IDENTIFIER) { /* could also be a custom class name */
 410                         if(settings.tokens) { token_print("identifier", BOTH); }
 411                 } else {
 412                         compiler_error(17, "Could Not Complete Variable List of Subroutine. Incomplete Program", pS, pC, pT);
 413                 }
 414         }
 415
 416         /* look for identifier(s) for variable(s) */
 417         do {
 418                 if(has_more_tokens(pC) == true)
 419                 {
 420                         pC = advance(pC, pT);
 421                         tk = token_type(pT);
 422                 } else {
 423                         compiler_error(17, "Could Not Complete Variable List of Subroutine. Incomplete Program", pS, pC, pT);
 424                 }
 425                 if(tk == IDENTIFIER)
 426                 {
 427                         if(settings.tokens) { token_print("identifier", BOTH); }
 428                 }
 429
 430                 if(has_more_tokens(pC) == true)
 431                 {
 432                         pC = advance(pC, pT);
 433                         tk = token_type(pT);
 434                 } else {
 435                         compiler_error(17, "Could Not Complete Variable List of Subroutine. Incomplete Program", pS, pC, pT);
 436                 }
 437                 if(tk == SYMBOL)
 438                 {
 439                         if(settings.tokens) { token_print("symbol", BOTH); }
 440                 }
 441         } while (*pT == ',');
 442
 443         if(has_more_tokens(pC) == true)
 444         {
 445                 pC = advance(pC, pT);
 446                 tk = token_type(pT);
 447         } else {
 448                 compiler_error(17, "Could Not Complete Variable List of Subroutine. Incomplete Program", pS, pC, pT);
 449         }
 450         parse_var_dec();
 451 }
 452
 453 void parse_statements()
 454 {
 455         if(settings.tokens)
 456         {
 457                 token_print("statements", OPEN);
 458                 space_count++;
 459         }
 460         do {
 461                 if(strcmp(pT, "let") == 0)
 462                 {
 463                         parse_let();
 464                 } else if(strcmp(pT, "if") == 0)
 465                 {
 466                         parse_if();
 467                 } else if(strcmp(pT, "while") == 0)
 468                 {
 469                         parse_while();
 470                 } else if(strcmp(pT, "do") == 0)
 471                 {
 472                         parse_do();
 473                 } else if(strcmp(pT, "return") == 0)
 474                 {
 475                         parse_return();
 476                 }
 477
 478                 if(has_more_tokens(pC) == true)
 479                 {
 480                         pC = advance(pC, pT);
 481                         tk = token_type(pT);
 482                 }
 483
 484         } while (strcmp(pT, "let") == 0 || strcmp(pT, "if") == 0 || strcmp(pT, "while") == 0 || \
 485                          strcmp(pT, "do") == 0  || strcmp(pT, "return") == 0 );
 486         if(settings.tokens)
 487         {
 488                 space_count--;
 489                 token_print("statements", CLOSE);
 490         }
 491 }
 492
 493 void parse_do()
 494 {
 495         if(settings.tokens)
 496         {
 497                 token_print("doStatement", OPEN);
 498                 space_count++;
 499                 token_print("keyword", BOTH);
 500         }
 501
 502         if(has_more_tokens(pC) == true)
 503         {
 504                 pC = advance(pC, pT);
 505                 tk = token_type(pT);
 506         } else {
 507                 compiler_error(20, "Could Not Complete Do Statement. Incomplete Program", pS, pC, pT);
 508         }
 509
 510         /* must be an identifier */
 511         if(tk == IDENTIFIER) {
 512                 parse_subroutine_call();
 513         } else {
 514                 compiler_error(30, "Subroutine Name Must Be Listed Here", pS, pC, pT);
 515         }
 516
 517         if(*pT == ';')
 518         {
 519                 if(settings.tokens) { token_print("symbol", BOTH); }
 520         } else {
 521                 compiler_error(33, "Could Not Find ';' Symbol At This Location.", pS, pC, pT);
 522         }
 523
 524         if(settings.tokens)
 525         {
 526                 space_count--;
 527                 token_print("doStatement", CLOSE);
 528         }
 529 }
 530
 531 void parse_let()
 532 {
 533         int found_array = 0;
 534         if(settings.tokens)
 535         {
 536                 token_print("letStatement", OPEN);
 537                 space_count++;
 538                 token_print("keyword", BOTH);
 539         }
 540
 541         if(has_more_tokens(pC) == true)
 542         {
 543                 pC = advance(pC, pT);
 544                 tk = token_type(pT);
 545         } else {
 546                 compiler_error(20, "Could Not Complete Let Statement. Incomplete Program", pS, pC, pT);
 547         }
 548
 549         /* look for an identifier - must be a variable name */
 550         if(tk == IDENTIFIER)
 551         {
 552                 if(settings.tokens) { token_print("identifier", BOTH); }
 553         } else {
 554                 compiler_error(31, "Could Not Find Identifier At This Location", pS, pC, pT);
 555         }
 556
 557         /* optional '[' for an array offset value */
 558         if(has_more_tokens(pC) == true)
 559         {
 560                 pC = advance(pC, pT);
 561                 tk = token_type(pT);
 562         } else {
 563                 compiler_error(20, "Could Not Complete Let Statement. Incomplete Program", pS, pC, pT);
 564         }
 565
 566         if(*pT == '[')
 567         {
 568                 found_array++;
 569                 if(settings.tokens) { token_print("symbol", BOTH); }
 570                 if(has_more_tokens(pC) == true)
 571                 {
 572                         pC = advance(pC, pT);
 573                         tk = token_type(pT);
 574                 } else {
 575                         compiler_error(20, "Could Not Complete Let Statement. Incomplete Program", pS, pC, pT);
 576                 }
 577                 parse_expression();
 578         }
 579
 580         /* should be closing ']' here if variable was array */
 581         if(found_array && *pT == ']')
 582         {
 583                 if(settings.tokens) { token_print("symbol", BOTH); }
 584                 if(has_more_tokens(pC) == true)
 585                 {
 586                         pC = advance(pC, pT);
 587                         tk = token_type(pT);
 588                 } else {
 589                         compiler_error(20, "Could Not Find ']' Symbol At This Location", pS, pC, pT);
 590                 }
 591         }
 592
 593         if(*pT == '=')
 594         {
 595                 if(settings.tokens) { token_print("symbol", BOTH); }
 596         } else {
 597                 compiler_error(32, "Could Not Find '=' Symbol At This Location", pS, pC, pT);
 598         }
 599
 600         if(has_more_tokens(pC) == true)
 601         {
 602                 pC = advance(pC, pT);
 603                 tk = token_type(pT);
 604         } else {
 605                 compiler_error(20, "Could Not Complete Let Statement. Incomplete Program", pS, pC, pT);
 606         }
 607
 608         parse_expression();
 609
 610         if(*pT == ';')
 611         {
 612                 if(settings.tokens) { token_print("symbol", BOTH); }
 613         } else {
 614                 compiler_error(33, "Could Not Find ';' Symbol At This Location", pS, pC, pT);
 615         }
 616
 617         if(settings.tokens)
 618         {
 619                 space_count--;
 620                 token_print("letStatement", CLOSE);
 621         }
 622 }
 623
 624 void parse_while()
 625 {
 626         if(settings.tokens)
 627         {
 628                 token_print("whileStatement", OPEN);
 629                 space_count++;
 630                 token_print("keyword", BOTH);
 631         }
 632
 633         if(has_more_tokens(pC) == true)
 634         {
 635                 pC = advance(pC, pT);
 636                 tk = token_type(pT);
 637         } else {
 638                 compiler_error(47, "Could Not Complete While Statement. Incomplete Program", pS, pC, pT);
 639         }
 640
 641         if(*pT == '(')
 642         {
 643                 if(settings.tokens) { token_print("symbol", BOTH); }
 644         } else {
 645                 compiler_error(39, "Could Not Find '(' Symbol At This Location", pS, pC, pT);
 646         }
 647
 648         if(has_more_tokens(pC) == true)
 649         {
 650                 pC = advance(pC, pT);
 651                 tk = token_type(pT);
 652         } else {
 653                 compiler_error(47, "Could Not Complete While Statement. Incomplete Program", pS, pC, pT);
 654         }
 655
 656         parse_expression();
 657
 658         if(*pT == ')')
 659         {
 660                 if(settings.tokens) { token_print("symbol", BOTH); }
 661         } else {
 662                 compiler_error(38, "Could Not Find ')' Symbol At This Location", pS, pC, pT);
 663         }
 664
 665         if(has_more_tokens(pC) == true)
 666         {
 667                 pC = advance(pC, pT);
 668                 tk = token_type(pT);
 669         } else {
 670                 compiler_error(47, "Could Not Complete While Statement. Incomplete Program", pS, pC, pT);
 671         }
 672
 673         if(*pT == '{')
 674         {
 675                 if(settings.tokens) { token_print("symbol", BOTH); }
 676         } else {
 677                 compiler_error(45, "Could Not Find '{' Symbol At This Location", pS, pC, pT);
 678         }
 679
 680         if(has_more_tokens(pC) == true)
 681         {
 682                 pC = advance(pC, pT);
 683                 tk = token_type(pT);
 684         } else {
 685                 compiler_error(47, "Could Not Complete While Statement. Incomplete Program", pS, pC, pT);
 686         }
 687
 688         parse_statements();
 689
 690         if(*pT == '}')
 691         {
 692                 if(settings.tokens) { token_print("symbol", BOTH); }
 693         } else {
 694                 compiler_error(46, "Could Not Find '}' Symbol At This Location", pS, pC, pT);
 695         }
 696
 697         if(settings.tokens)
 698         {
 699                 space_count--;
 700                 token_print("whileStatement", CLOSE);
 701         }
 702 }
 703
 704 void parse_return()
 705 {
 706         if(settings.tokens)
 707         {
 708                 token_print("returnStatement", OPEN);
 709                 space_count++;
 710                 token_print("keyword", BOTH);
 711         }
 712
 713         /* look for ';' */
 714         if(has_more_tokens(pC) == true)
 715         {
 716                 pC = advance(pC, pT);
 717                 tk = token_type(pT);
 718         } else {
 719                 compiler_error(20, "Could Not Complete Let Statement. Incomplete Program", pS, pC, pT);
 720         }
 721
 722         if (*pT != ';') { parse_expression(); }
 723
 724         if(*pT == ';')
 725         {
 726                 if(settings.tokens) { token_print("symbol", BOTH); }
 727         } else {
 728                 compiler_error(33, "Could Not Find ';' Symbol At This Location", pS, pC, pT);
 729         }
 730         if(settings.tokens)
 731         {
 732                 space_count--;
 733                 token_print("returnStatement", CLOSE);
 734         }
 735 }
 736
 737 void parse_if()
 738 {
 739         if(settings.tokens)
 740         {
 741                 token_print("ifStatement", OPEN);
 742                 space_count++;
 743                 token_print("keyword", BOTH);
 744         }
 745
 746         if(has_more_tokens(pC) == true)
 747         {
 748                 pC = advance(pC, pT);
 749                 tk = token_type(pT);
 750         } else {
 751                 compiler_error(47, "Could Not Complete If Statement. Incomplete Program", pS, pC, pT);
 752         }
 753
 754         if(*pT == '(')
 755         {
 756                 if(settings.tokens) { token_print("symbol", BOTH); }
 757         } else {
 758                 compiler_error(39, "Could Not Find '(' Symbol At This Location", pS, pC, pT);
 759         }
 760
 761         if(has_more_tokens(pC) == true)
 762         {
 763                 pC = advance(pC, pT);
 764                 tk = token_type(pT);
 765         } else {
 766                 compiler_error(47, "Could Not Complete If Statement. Incomplete Program", pS, pC, pT);
 767         }
 768
 769         parse_expression();
 770
 771         if(*pT == ')')
 772         {
 773                 if(settings.tokens) { token_print("symbol", BOTH); }
 774         } else {
 775                 compiler_error(38, "Could Not Find ')' Symbol At This Location", pS, pC, pT);
 776         }
 777
 778         if(has_more_tokens(pC) == true)
 779         {
 780                 pC = advance(pC, pT);
 781                 tk = token_type(pT);
 782         } else {
 783                 compiler_error(47, "Could Not Complete If Statement. Incomplete Program", pS, pC, pT);
 784         }
 785
 786         if(*pT == '{')
 787         {
 788                 if(settings.tokens) { token_print("symbol", BOTH); }
 789         } else {
 790                 compiler_error(45, "Could Not Find '{' Symbol At This Location", pS, pC, pT);
 791         }
 792
 793         if(has_more_tokens(pC) == true)
 794         {
 795                 pC = advance(pC, pT);
 796                 tk = token_type(pT);
 797         } else {
 798                 compiler_error(47, "Could Not Complete If Statement. Incomplete Program", pS, pC, pT);
 799         }
 800
 801         parse_statements();
 802
 803         if(*pT == '}')
 804         {
 805                 if(settings.tokens) { token_print("symbol", BOTH); }
 806         } else {
 807                 compiler_error(46, "Could Not Find '}' Symbol At This Location", pS, pC, pT);
 808         }
 809
 810         if(settings.tokens)
 811         {
 812                 space_count--;
 813                 token_print("ifStatement", CLOSE);
 814         }
 815 }
 816
 817 void parse_expression()
 818 {
 819         if(settings.tokens)
 820         {
 821                 token_print("expression", OPEN);
 822                 space_count++;
 823         }
 824         parse_term();
 825
 826         if(strchr(BINARY_OP, *pT) != NULL)
 827         {
 828                 if(settings.tokens) { token_print("operator", BOTH); }
 829                         if(has_more_tokens(pC) == true)
 830                         {
 831                                 pC = advance(pC, pT);
 832                                 tk = token_type(pT);
 833                         } else {
 834                                 compiler_error(34, "Could Not Parse Expression. Incomplete Program", pS, pC, pT);
 835                         }
 836                         parse_expression();
 837         }
 838         if(settings.tokens)
 839         {
 840                 space_count--;
 841                 token_print("expression", CLOSE);
 842         }
 843 }
 844
 845 void parse_term()
 846 {
 847         if(settings.tokens)
 848         {
 849                 token_print("term", OPEN);
 850                 space_count++;
 851         }
 852
 853         if(tk == INT_CONST)
 854         {
 855                 if(settings.tokens) { token_print("intConst", BOTH); }
 856                 if(has_more_tokens(pC) == true)
 857                 {
 858                         pC = advance(pC, pT);
 859                         tk = token_type(pT);
 860                 } else {
 861                         compiler_error(25, "Could Not Complete Term. Incomplete Program", pS, pC, pT);
 862                 }
 863                 return;
 864         }
 865
 866         if(strchr(UNARY_OP, *pT) != NULL)
 867         {
 868                 if(settings.tokens) { token_print("unaryOperator", BOTH); }
 869                 if(has_more_tokens(pC) == true)
 870                 {
 871                         pC = advance(pC, pT);
 872                         tk = token_type(pT);
 873                 } else {
 874                         compiler_error(25, "Could Not Complete Term. Incomplete Program", pS, pC, pT);
 875                 }
 876                 parse_term();
 877         }
 878
 879         if(tk == KEYWORD)
 880         {
 881                 if(settings.tokens) { token_print("keyword", BOTH); }
 882
 883                 if(has_more_tokens(pC) == true)
 884                 {
 885                         pC = advance(pC, pT);
 886                         tk = token_type(pT);
 887                 } else {
 888                         compiler_error(25, "Could Not Complete Term. Incomplete Program", pS, pC, pT);
 889                 }
 890         }
 891
 892         if(tk == IDENTIFIER)
 893         {
 894                 if(settings.tokens) { token_print("identifier", BOTH); }
 895
 896                 if(has_more_tokens(pC) == true)
 897                 {
 898                         pC = advance(pC, pT);
 899                         tk = token_type(pT);
 900                 } else {
 901                         compiler_error(25, "Could Not Complete Term. Incomplete Program", pS, pC, pT);
 902                 }
 903         }
 904
 905         switch(*pT)
 906         {
 907                 case '[':
 908                         if(settings.tokens) { token_print("symbol", BOTH); }
 909
 910                         if(has_more_tokens(pC) == true)
 911                         {
 912                                 pC = advance(pC, pT);
 913                                 tk = token_type(pT);
 914                         } else {
 915                                 compiler_error(25, "Could Not Complete Term. Incomplete Program", pS, pC, pT);
 916                         }
 917                         parse_expression();
 918                         if(*pT == ']')
 919                         {
 920                                 if(settings.tokens) { token_print("symbol", BOTH); }
 921                                 /* parse_expression(); */
 922                                 } else {
 923                                         compiler_error(26, "Improperly Terminated Array Expression. Symbol ']' Required at this Location.", pS, pC, pT);
 924                         }
 925
 926                         if(has_more_tokens(pC) == true)
 927                         {
 928                                 pC = advance(pC, pT);
 929                                 tk = token_type(pT);
 930                         } else {
 931                                 compiler_error(25, "Could Not Complete Term. Incomplete Program", pS, pC, pT);
 932                         }
 933                         break;
 934                 case '(':
 935                         if(settings.tokens) { token_print("symbol", BOTH); }
 936
 937                         if(has_more_tokens(pC) == true)
 938                         {
 939                                 pC = advance(pC, pT);
 940                                 tk = token_type(pT);
 941                         } else {
 942                                 compiler_error(25, "Could Not Complete Term. Incomplete Program", pS, pC, pT);
 943                         }
 944
 945                         parse_expression();
 946
 947                         if (*pT == ')') {
 948                                 if(settings.tokens) { token_print("symbol", BOTH); }
 949                         } else {
 950                                 compiler_error(38, "Could Not Find Symbol ')' At This Location", pS, pC, pT);
 951                         }
 952
 953                         if(has_more_tokens(pC) == true)
 954                         {
 955                                 pC = advance(pC, pT);
 956                                 tk = token_type(pT);
 957                         } else {
 958                                 compiler_error(25, "Could Not Complete Term. Incomplete Program", pS, pC, pT);
 959                         }
 960                         break;
 961                 case '.':
 962                         if(settings.tokens) { token_print("symbol", BOTH); }
 963
 964                         if(has_more_tokens(pC) == true)
 965                         {
 966                                 pC = advance(pC, pT);
 967                                 tk = token_type(pT);
 968                         } else {
 969                                 compiler_error(25, "Could Not Complete Term. Incomplete Program", pS, pC, pT);
 970                         }
 971
 972                         parse_subroutine_call();
 973                         break;
 974         }
 975
 976         if(settings.tokens)
 977         {
 978                 space_count--;
 979                 token_print("term", CLOSE);
 980         }
 981 }
 982
 983 void parse_subroutine_call()
 984 {
 985         if(tk == IDENTIFIER)
 986         {
 987                 if(settings.tokens) { token_print("identifier", BOTH); }
 988         } else {
 989                 compiler_error(35, "Could Not Find Class Name or Subroutine Name at This Location", pS, pC, pT);
 990         }
 991
 992         if(has_more_tokens(pC) == true)
 993         {
 994                 pC = advance(pC, pT);
 995                 tk = token_type(pT);
 996         } else {
 997                 compiler_error(36, "Could Not Complete Subroutine Call. Incomplete Program", pS, pC, pT);
 998         }
 999
1000         if (*pT == '.') {
1001                         if(settings.tokens) { token_print("symbol", BOTH); }
1002                         if(has_more_tokens(pC) == true)
1003                         {
1004                                 pC = advance(pC, pT);
1005                                 tk = token_type(pT);
1006                         } else {
1007                                 compiler_error(36, "Could Not Complete Subroutine Call. Incomplete Program", pS, pC, pT);
1008                         }
1009                         if(tk == IDENTIFIER)
1010                         {
1011                                 if(settings.tokens) { token_print("identifier", BOTH); }
1012                         } else {
1013                                 compiler_error(37, "Could Not Find Method Name or Subroutine Name at This Location", pS, pC, pT);
1014                         }
1015         }
1016
1017         if(*pT != '(') /* this for calls with no class name at beginning */
1018         {
1019                 if(has_more_tokens(pC) == true)
1020                 {
1021                         pC = advance(pC, pT);
1022                         tk = token_type(pT);
1023                 } else {
1024                         compiler_error(36, "Could Not Complete Subroutine Call. Incomplete Program", pS, pC, pT);
1025                 }
1026         }
1027
1028         if(*pT == '(')
1029         {
1030                 if(settings.tokens) { token_print("symbol", BOTH); }
1031         } else {
1032                 compiler_error(39, "Could Not Find Symbol '(' At This Location", pS, pC, pT);
1033         }
1034
1035         if(has_more_tokens(pC) == true)
1036         {
1037                 pC = advance(pC, pT);
1038                 tk = token_type(pT);
1039         } else {
1040                 compiler_error(36, "Could Not Complete Subroutine Call. Incomplete Program", pS, pC, pT);
1041         }
1042
1043         parse_expr_lst();
1044
1045         if(*pT == ')')
1046         {
1047                 if(settings.tokens) { token_print("symbol", BOTH); }
1048         } else {
1049                 compiler_error(38, "Could Not Find Symbol ')' At This Location", pS, pC, pT);
1050         }
1051
1052         if(has_more_tokens(pC) == true)
1053         {
1054                         pC = advance(pC, pT);
1055                         tk = token_type(pT);
1056         } else {
1057                 compiler_error(24, "Could Not Complete Subroutine Call. Incomplete Program", pS, pC, pT);
1058         }
1059 }
1060
1061 void parse_expr_lst()
1062 {
1063         if(settings.tokens) { token_print("expressionList", OPEN); }
1064         while(*pT != ')')
1065         {
1066                 if(*pT == ',')
1067                 {
1068                         if(settings.tokens) { token_print("symbol", BOTH); }
1069                         if(has_more_tokens(pC) == true)
1070                         {
1071                                         pC = advance(pC, pT);
1072                                         tk = token_type(pT);
1073                         } else {
1074                                 compiler_error(24, "Could Not Complete Expression List. Incomplete Program", pS, pC, pT);
1075                         }
1076                 } else {
1077                         parse_expression();
1078                 }
1079         }
1080         if(settings.tokens) { token_print("expressionList", CLOSE); }
1081 }