git.sur5r.net Git - cc65/blob - src/cc65/stmt.c

   1 /*****************************************************************************/
   2 /*                                                                           */
   3 /*                                  stmt.c                                   */
   4 /*                                                                           */
   5 /*                             Parse a statement                             */
   6 /*                                                                           */
   7 /*                                                                           */
   8 /*                                                                           */
   9 /* (C) 1998-2001 Ullrich von Bassewitz                                       */
  10 /*               Wacholderweg 14                                             */
  11 /*               D-70597 Stuttgart                                           */
  12 /* EMail:        uz@cc65.org                                                 */
  13 /*                                                                           */
  14 /*                                                                           */
  15 /* This software is provided 'as-is', without any expressed or implied       */
  16 /* warranty.  In no event will the authors be held liable for any damages    */
  17 /* arising from the use of this software.                                    */
  18 /*                                                                           */
  19 /* Permission is granted to anyone to use this software for any purpose,     */
  20 /* including commercial applications, and to alter it and redistribute it    */
  21 /* freely, subject to the following restrictions:                            */
  22 /*                                                                           */
  23 /* 1. The origin of this software must not be misrepresented; you must not   */
  24 /*    claim that you wrote the original software. If you use this software   */
  25 /*    in a product, an acknowledgment in the product documentation would be  */
  26 /*    appreciated but is not required.                                       */
  27 /* 2. Altered source versions must be plainly marked as such, and must not   */
  28 /*    be misrepresented as being the original software.                      */
  29 /* 3. This notice may not be removed or altered from any source              */
  30 /*    distribution.                                                          */
  31 /*                                                                           */
  32 /*****************************************************************************/
  33
  34
  35
  36 #include <stdio.h>
  37 #include <string.h>
  38
  39 /* common */
  40 #include "coll.h"
  41 #include "xmalloc.h"
  42
  43 /* cc65 */
  44 #include "asmcode.h"
  45 #include "asmlabel.h"
  46 #include "codegen.h"
  47 #include "datatype.h"
  48 #include "error.h"
  49 #include "expr.h"
  50 #include "function.h"
  51 #include "global.h"
  52 #include "goto.h"
  53 #include "litpool.h"
  54 #include "locals.h"
  55 #include "loop.h"
  56 #include "pragma.h"
  57 #include "scanner.h"
  58 #include "swstmt.h"
  59 #include "symtab.h"
  60 #include "stmt.h"
  61
  62
  63
  64 /*****************************************************************************/
  65 /*                             Helper functions                              */
  66 /*****************************************************************************/
  67
  68
  69
  70 static void CheckTok (token_t Tok, const char* Msg, int* PendingToken)
  71 /* Helper function for Statement. Will check for Tok and print Msg if not
  72  * found. If PendingToken is NULL, it will the skip the token, otherwise
  73  * it will store one to PendingToken.
  74  */
  75 {
  76     if (CurTok.Tok != Tok) {
  77         Error (Msg);
  78     } else if (PendingToken) {
  79         *PendingToken = 1;
  80     } else {
  81         NextToken ();
  82     }
  83 }
  84
  85
  86
  87 static void CheckSemi (int* PendingToken)
  88 /* Helper function for Statement. Will call CheckTok with the parameters
  89  * for a semicolon.
  90  */
  91 {
  92     CheckTok (TOK_SEMI, "`;' expected", PendingToken);
  93 }
  94
  95
  96
  97 static void SkipPending (int PendingToken)
  98 /* Skip the pending token if we have one */
  99 {
 100     if (PendingToken) {
 101         NextToken ();
 102     }
 103 }
 104
 105
 106
 107 /*****************************************************************************/
 108 /*                                   Code                                    */
 109 /*****************************************************************************/
 110
 111
 112
 113 static int IfStatement (void)
 114 /* Handle an 'if' statement */
 115 {
 116     unsigned Label1;
 117     int GotBreak;
 118
 119     /* Skip the if */
 120     NextToken ();
 121
 122     /* Generate a jump label and parse the condition */
 123     Label1 = GetLocalLabel ();
 124     test (Label1, 0);
 125
 126     /* Parse the if body */
 127     GotBreak = Statement (0);
 128
 129     /* Else clause present? */
 130     if (CurTok.Tok != TOK_ELSE) {
 131
 132         g_defcodelabel (Label1);
 133
 134         /* Since there's no else clause, we're not sure, if the a break
 135          * statement is really executed.
 136          */
 137         return 0;
 138
 139     } else {
 140
 141         /* Generate a jump around the else branch */
 142         unsigned Label2 = GetLocalLabel ();
 143         g_jump (Label2);
 144
 145         /* Skip the else */
 146         NextToken ();
 147
 148         /* Define the target for the first test */
 149         g_defcodelabel (Label1);
 150
 151         /* Total break only if both branches had a break. */
 152         GotBreak &= Statement (0);
 153
 154         /* Generate the label for the else clause */
 155         g_defcodelabel (Label2);
 156
 157         /* Done */
 158         return GotBreak;
 159     }
 160 }
 161
 162
 163
 164 static void DoStatement (void)
 165 /* Handle the 'do' statement */
 166 {
 167     /* Get the loop control labels */
 168     unsigned loop = GetLocalLabel ();
 169     unsigned lab = GetLocalLabel ();
 170
 171     /* Skip the while token */
 172     NextToken ();
 173
 174     /* Add the loop to the loop stack */
 175     AddLoop (oursp, loop, lab, 0, 0);
 176
 177     /* Define the head label */
 178     g_defcodelabel (loop);
 179
 180     /* Parse the loop body */
 181     Statement (0);
 182
 183     /* Parse the end condition */
 184     Consume (TOK_WHILE, "`while' expected");
 185     test (loop, 1);
 186     ConsumeSemi ();
 187
 188     /* Define the break label */
 189     g_defcodelabel (lab);
 190
 191     /* Remove the loop from the loop stack */
 192     DelLoop ();
 193 }
 194
 195
 196
 197 static void WhileStatement (void)
 198 /* Handle the 'while' statement */
 199 {
 200     int PendingToken;
 201
 202     /* Get the loop control labels */
 203     unsigned loop = GetLocalLabel ();
 204     unsigned lab = GetLocalLabel ();
 205
 206     /* Skip the while token */
 207     NextToken ();
 208
 209     /* Add the loop to the loop stack */
 210     AddLoop (oursp, loop, lab, 0, 0);
 211
 212     /* Define the head label */
 213     g_defcodelabel (loop);
 214
 215     /* Test the loop condition */
 216     test (lab, 0);
 217
 218     /* Loop body */
 219     Statement (&PendingToken);
 220
 221     /* Jump back to loop top */
 222     g_jump (loop);
 223
 224     /* Exit label */
 225     g_defcodelabel (lab);
 226
 227     /* Eat remaining tokens that were delayed because of line info
 228      * correctness
 229      */
 230     SkipPending (PendingToken);
 231
 232     /* Remove the loop from the loop stack */
 233     DelLoop ();
 234 }
 235
 236
 237
 238 static void ReturnStatement (void)
 239 /* Handle the 'return' statement */
 240 {
 241     ExprDesc lval;
 242
 243     NextToken ();
 244     if (CurTok.Tok != TOK_SEMI) {
 245         if (HasVoidReturn (CurrentFunc)) {
 246             Error ("Returning a value in function with return type void");
 247         }
 248
 249         /* Evaluate the return expression. Result will be in primary */
 250         expression (&lval);
 251
 252         /* Convert the return value to the type of the function result */
 253         if (!HasVoidReturn (CurrentFunc)) {
 254             assignadjust (GetReturnType (CurrentFunc), &lval);
 255         }
 256     } else if (!HasVoidReturn (CurrentFunc)) {
 257         Error ("Function `%s' must return a value", GetFuncName (CurrentFunc));
 258     }
 259
 260     /* Cleanup the stack in case we're inside a block with locals */
 261     g_space (oursp - GetTopLevelSP (CurrentFunc));
 262
 263     /* Output a jump to the function exit code */
 264     g_jump (GetRetLab (CurrentFunc));
 265 }
 266
 267
 268
 269 static void BreakStatement (void)
 270 /* Handle the 'break' statement */
 271 {
 272     LoopDesc* L;
 273
 274     /* Skip the break */
 275     NextToken ();
 276
 277     /* Get the current loop descriptor */
 278     L = CurrentLoop ();
 279
 280     /* Check if we are inside a loop */
 281     if (L == 0) {
 282         /* Error: No current loop */
 283         Error ("`break' statement not within loop or switch");
 284         return;
 285     }
 286
 287     /* Correct the stack pointer if needed */
 288     g_space (oursp - L->StackPtr);
 289
 290     /* Jump to the exit label of the loop */
 291     g_jump (L->Label);
 292 }
 293
 294
 295
 296 static void ContinueStatement (void)
 297 /* Handle the 'continue' statement */
 298 {
 299     LoopDesc* L;
 300
 301     /* Skip the continue */
 302     NextToken ();
 303
 304     /* Get the current loop descriptor */
 305     L = CurrentLoop ();
 306     if (L) {
 307         /* Search for the correct loop */
 308         do {
 309             if (L->Loop) {
 310                 break;
 311             }
 312             L = L->Next;
 313         } while (L);
 314     }
 315
 316     /* Did we find it? */
 317     if (L == 0) {
 318         Error ("`continue' statement not within a loop");
 319         return;
 320     }
 321
 322     /* Correct the stackpointer if needed */
 323     g_space (oursp - L->StackPtr);
 324
 325     /* Output the loop code */
 326     if (L->linc) {
 327         g_jump (L->linc);
 328     } else {
 329         g_jump (L->Loop);
 330     }
 331 }
 332
 333
 334
 335 static void ForStatement (void)
 336 /* Handle a 'for' statement */
 337 {
 338     ExprDesc lval1;
 339     ExprDesc lval2;
 340     ExprDesc lval3;
 341     int HaveIncExpr;
 342     CodeMark IncExprStart;
 343     CodeMark IncExprEnd;
 344     int PendingToken;
 345
 346     /* Get several local labels needed later */
 347     unsigned TestLabel = GetLocalLabel ();
 348     unsigned lab       = GetLocalLabel ();
 349     unsigned IncLabel  = GetLocalLabel ();
 350     unsigned lstat     = GetLocalLabel ();
 351
 352     /* Skip the FOR token */
 353     NextToken ();
 354
 355     /* Add the loop to the loop stack */
 356     AddLoop (oursp, TestLabel, lab, IncLabel, lstat);
 357
 358     /* Skip the opening paren */
 359     ConsumeLParen ();
 360
 361     /* Parse the initializer expression */
 362     if (CurTok.Tok != TOK_SEMI) {
 363         expression (&lval1);
 364     }
 365     ConsumeSemi ();
 366
 367     /* Label for the test expressions */
 368     g_defcodelabel (TestLabel);
 369
 370     /* Parse the test expression */
 371     if (CurTok.Tok != TOK_SEMI) {
 372         boolexpr (&lval2);
 373         g_truejump (CF_NONE, lstat);
 374         g_jump (lab);
 375     } else {
 376         g_jump (lstat);
 377     }
 378     ConsumeSemi ();
 379
 380     /* Remember the start of the increment expression */
 381     IncExprStart = GetCodePos();
 382
 383     /* Label for the increment expression */
 384     g_defcodelabel (IncLabel);
 385
 386     /* Parse the increment expression */
 387     HaveIncExpr = (CurTok.Tok != TOK_RPAREN);
 388     if (HaveIncExpr) {
 389         expression (&lval3);
 390     }
 391
 392     /* Jump to the test */
 393     g_jump (TestLabel);
 394
 395     /* Remember the end of the increment expression */
 396     IncExprEnd = GetCodePos();
 397
 398     /* Skip the closing paren */
 399     ConsumeRParen ();
 400
 401     /* Loop body */
 402     g_defcodelabel (lstat);
 403     Statement (&PendingToken);
 404
 405     /* If we had an increment expression, move the code to the bottom of
 406      * the loop. In this case we don't need to jump there at the end of
 407      * the loop body.
 408      */
 409     if (HaveIncExpr) {
 410         MoveCode (IncExprStart, IncExprEnd, GetCodePos());
 411     } else {
 412         /* Jump back to the increment expression */
 413         g_jump (IncLabel);
 414     }
 415
 416     /* Skip a pending token if we have one */
 417     SkipPending (PendingToken);
 418
 419     /* Declare the break label */
 420     g_defcodelabel (lab);
 421
 422     /* Remove the loop from the loop stack */
 423     DelLoop ();
 424 }
 425
 426
 427
 428 static int CompoundStatement (void)
 429 /* Compound statement. Allow any number of statements inside braces. The
 430  * function returns true if the last statement was a break or return.
 431  */
 432 {
 433     int GotBreak;
 434
 435     /* Remember the stack at block entry */
 436     int OldStack = oursp;
 437
 438     /* Enter a new lexical level */
 439     EnterBlockLevel ();
 440
 441     /* Parse local variable declarations if any */
 442     DeclareLocals ();
 443
 444     /* Now process statements in this block */
 445     GotBreak = 0;
 446     while (CurTok.Tok != TOK_RCURLY) {
 447         if (CurTok.Tok != TOK_CEOF) {
 448             GotBreak = Statement (0);
 449         } else {
 450             break;
 451         }
 452     }
 453
 454     /* Clean up the stack. */
 455     if (!GotBreak) {
 456         g_space (oursp - OldStack);
 457     }
 458     oursp = OldStack;
 459
 460     /* Emit references to imports/exports for this block */
 461     EmitExternals ();
 462
 463     /* Leave the lexical level */
 464     LeaveBlockLevel ();
 465
 466     return GotBreak;
 467 }
 468
 469
 470
 471 int Statement (int* PendingToken)
 472 /* Statement parser. Returns 1 if the statement does a return/break, returns
 473  * 0 otherwise. If the PendingToken pointer is not NULL, the function will
 474  * not skip the terminating token of the statement (closing brace or
 475  * semicolon), but store true if there is a pending token, and false if there
 476  * is none. The token is always checked, so there is no need for the caller to
 477  * check this token, it must be skipped, however. If the argument pointer is
 478  * NULL, the function will skip the token.
 479  */
 480 {
 481     ExprDesc lval;
 482     int GotBreak;
 483
 484     /* Assume no pending token */
 485     if (PendingToken) {
 486         *PendingToken = 0;
 487     }
 488
 489     /* Check for a label */
 490     if (CurTok.Tok == TOK_IDENT && NextTok.Tok == TOK_COLON) {
 491
 492         /* Special handling for a label */
 493         DoLabel ();
 494
 495     } else {
 496
 497         switch (CurTok.Tok) {
 498
 499             case TOK_LCURLY:
 500                 NextToken ();
 501                 GotBreak = CompoundStatement ();
 502                 CheckTok (TOK_RCURLY, "`{' expected", PendingToken);
 503                 return GotBreak;
 504
 505             case TOK_IF:
 506                 return IfStatement ();
 507
 508             case TOK_WHILE:
 509                 WhileStatement ();
 510                 break;
 511
 512             case TOK_DO:
 513                 DoStatement ();
 514                 break;
 515
 516             case TOK_SWITCH:
 517                 SwitchStatement ();
 518                 break;
 519
 520             case TOK_RETURN:
 521                 ReturnStatement ();
 522                 CheckSemi (PendingToken);
 523                 return 1;
 524
 525             case TOK_BREAK:
 526                 BreakStatement ();
 527                 CheckSemi (PendingToken);
 528                 return 1;
 529
 530             case TOK_CONTINUE:
 531                 ContinueStatement ();
 532                 CheckSemi (PendingToken);
 533                 return 1;
 534
 535             case TOK_FOR:
 536                 ForStatement ();
 537                 break;
 538
 539             case TOK_GOTO:
 540                 GotoStatement ();
 541                 CheckSemi (PendingToken);
 542                 return 1;
 543
 544             case TOK_SEMI:
 545                 /* Ignore it */
 546                 CheckSemi (PendingToken);
 547                 break;
 548
 549             case TOK_PRAGMA:
 550                 DoPragma ();
 551                 break;
 552
 553             default:
 554                 /* Actual statement */
 555                 expression (&lval);
 556                 CheckSemi (PendingToken);
 557         }
 558     }
 559     return 0;
 560 }
 561
 562
 563
 564