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     TestInParens (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     TestInParens (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     TestInParens (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
 246         /* Check if the function has a return value declared */
 247         if (F_HasVoidReturn (CurrentFunc)) {
 248             Error ("Returning a value in function with return type void");
 249         }
 250
 251         /* Evaluate the return expression. Result will be in primary */
 252         expression (&lval);
 253
 254         /* Convert the return value to the type of the function result */
 255         if (!F_HasVoidReturn (CurrentFunc)) {
 256             assignadjust (F_GetReturnType (CurrentFunc), &lval);
 257         }
 258
 259     } else if (!F_HasVoidReturn (CurrentFunc) && !F_HasOldStyleIntRet (CurrentFunc)) {
 260         Error ("Function `%s' must return a value", F_GetFuncName (CurrentFunc));
 261     }
 262
 263     /* Cleanup the stack in case we're inside a block with locals */
 264     g_space (oursp - F_GetTopLevelSP (CurrentFunc));
 265
 266     /* Output a jump to the function exit code */
 267     g_jump (F_GetRetLab (CurrentFunc));
 268 }
 269
 270
 271
 272 static void BreakStatement (void)
 273 /* Handle the 'break' statement */
 274 {
 275     LoopDesc* L;
 276
 277     /* Skip the break */
 278     NextToken ();
 279
 280     /* Get the current loop descriptor */
 281     L = CurrentLoop ();
 282
 283     /* Check if we are inside a loop */
 284     if (L == 0) {
 285         /* Error: No current loop */
 286         Error ("`break' statement not within loop or switch");
 287         return;
 288     }
 289
 290     /* Correct the stack pointer if needed */
 291     g_space (oursp - L->StackPtr);
 292
 293     /* Jump to the exit label of the loop */
 294     g_jump (L->Label);
 295 }
 296
 297
 298
 299 static void ContinueStatement (void)
 300 /* Handle the 'continue' statement */
 301 {
 302     LoopDesc* L;
 303
 304     /* Skip the continue */
 305     NextToken ();
 306
 307     /* Get the current loop descriptor */
 308     L = CurrentLoop ();
 309     if (L) {
 310         /* Search for the correct loop */
 311         do {
 312             if (L->Loop) {
 313                 break;
 314             }
 315             L = L->Next;
 316         } while (L);
 317     }
 318
 319     /* Did we find it? */
 320     if (L == 0) {
 321         Error ("`continue' statement not within a loop");
 322         return;
 323     }
 324
 325     /* Correct the stackpointer if needed */
 326     g_space (oursp - L->StackPtr);
 327
 328     /* Output the loop code */
 329     if (L->linc) {
 330         g_jump (L->linc);
 331     } else {
 332         g_jump (L->Loop);
 333     }
 334 }
 335
 336
 337
 338 static void ForStatement (void)
 339 /* Handle a 'for' statement */
 340 {
 341     ExprDesc lval1;
 342     ExprDesc lval3;
 343     int HaveIncExpr;
 344     CodeMark IncExprStart;
 345     CodeMark IncExprEnd;
 346     int PendingToken;
 347
 348     /* Get several local labels needed later */
 349     unsigned TestLabel = GetLocalLabel ();
 350     unsigned lab       = GetLocalLabel ();
 351     unsigned IncLabel  = GetLocalLabel ();
 352     unsigned lstat     = GetLocalLabel ();
 353
 354     /* Skip the FOR token */
 355     NextToken ();
 356
 357     /* Add the loop to the loop stack */
 358     AddLoop (oursp, TestLabel, lab, IncLabel, lstat);
 359
 360     /* Skip the opening paren */
 361     ConsumeLParen ();
 362
 363     /* Parse the initializer expression */
 364     if (CurTok.Tok != TOK_SEMI) {
 365         expression (&lval1);
 366     }
 367     ConsumeSemi ();
 368
 369     /* Label for the test expressions */
 370     g_defcodelabel (TestLabel);
 371
 372     /* Parse the test expression */
 373     if (CurTok.Tok != TOK_SEMI) {
 374         Test (lstat, 1);
 375         g_jump (lab);
 376     } else {
 377         g_jump (lstat);
 378     }
 379     ConsumeSemi ();
 380
 381     /* Remember the start of the increment expression */
 382     IncExprStart = GetCodePos();
 383
 384     /* Label for the increment expression */
 385     g_defcodelabel (IncLabel);
 386
 387     /* Parse the increment expression */
 388     HaveIncExpr = (CurTok.Tok != TOK_RPAREN);
 389     if (HaveIncExpr) {
 390         expression (&lval3);
 391     }
 392
 393     /* Jump to the test */
 394     g_jump (TestLabel);
 395
 396     /* Remember the end of the increment expression */
 397     IncExprEnd = GetCodePos();
 398
 399     /* Skip the closing paren */
 400     ConsumeRParen ();
 401
 402     /* Loop body */
 403     g_defcodelabel (lstat);
 404     Statement (&PendingToken);
 405
 406     /* If we had an increment expression, move the code to the bottom of
 407      * the loop. In this case we don't need to jump there at the end of
 408      * the loop body.
 409      */
 410     if (HaveIncExpr) {
 411         MoveCode (IncExprStart, IncExprEnd, GetCodePos());
 412     } else {
 413         /* Jump back to the increment expression */
 414         g_jump (IncLabel);
 415     }
 416
 417     /* Skip a pending token if we have one */
 418     SkipPending (PendingToken);
 419
 420     /* Declare the break label */
 421     g_defcodelabel (lab);
 422
 423     /* Remove the loop from the loop stack */
 424     DelLoop ();
 425 }
 426
 427
 428
 429 static int CompoundStatement (void)
 430 /* Compound statement. Allow any number of statements inside braces. The
 431  * function returns true if the last statement was a break or return.
 432  */
 433 {
 434     int GotBreak;
 435
 436     /* Remember the stack at block entry */
 437     int OldStack = oursp;
 438
 439     /* Enter a new lexical level */
 440     EnterBlockLevel ();
 441
 442     /* Parse local variable declarations if any */
 443     DeclareLocals ();
 444
 445     /* Now process statements in this block */
 446     GotBreak = 0;
 447     while (CurTok.Tok != TOK_RCURLY) {
 448         if (CurTok.Tok != TOK_CEOF) {
 449             GotBreak = Statement (0);
 450         } else {
 451             break;
 452         }
 453     }
 454
 455     /* Clean up the stack. */
 456     if (!GotBreak) {
 457         g_space (oursp - OldStack);
 458     }
 459     oursp = OldStack;
 460
 461     /* Emit references to imports/exports for this block */
 462     EmitExternals ();
 463
 464     /* Leave the lexical level */
 465     LeaveBlockLevel ();
 466
 467     return GotBreak;
 468 }
 469
 470
 471
 472 int Statement (int* PendingToken)
 473 /* Statement parser. Returns 1 if the statement does a return/break, returns
 474  * 0 otherwise. If the PendingToken pointer is not NULL, the function will
 475  * not skip the terminating token of the statement (closing brace or
 476  * semicolon), but store true if there is a pending token, and false if there
 477  * is none. The token is always checked, so there is no need for the caller to
 478  * check this token, it must be skipped, however. If the argument pointer is
 479  * NULL, the function will skip the token.
 480  */
 481 {
 482     ExprDesc lval;
 483     int GotBreak;
 484
 485     /* Assume no pending token */
 486     if (PendingToken) {
 487         *PendingToken = 0;
 488     }
 489
 490     /* Check for a label */
 491     if (CurTok.Tok == TOK_IDENT && NextTok.Tok == TOK_COLON) {
 492
 493         /* Special handling for a label */
 494         DoLabel ();
 495
 496     } else {
 497
 498         switch (CurTok.Tok) {
 499
 500             case TOK_LCURLY:
 501                 NextToken ();
 502                 GotBreak = CompoundStatement ();
 503                 CheckTok (TOK_RCURLY, "`{' expected", PendingToken);
 504                 return GotBreak;
 505
 506             case TOK_IF:
 507                 return IfStatement ();
 508
 509             case TOK_WHILE:
 510                 WhileStatement ();
 511                 break;
 512
 513             case TOK_DO:
 514                 DoStatement ();
 515                 break;
 516
 517             case TOK_SWITCH:
 518                 SwitchStatement ();
 519                 break;
 520
 521             case TOK_RETURN:
 522                 ReturnStatement ();
 523                 CheckSemi (PendingToken);
 524                 return 1;
 525
 526             case TOK_BREAK:
 527                 BreakStatement ();
 528                 CheckSemi (PendingToken);
 529                 return 1;
 530
 531             case TOK_CONTINUE:
 532                 ContinueStatement ();
 533                 CheckSemi (PendingToken);
 534                 return 1;
 535
 536             case TOK_FOR:
 537                 ForStatement ();
 538                 break;
 539
 540             case TOK_GOTO:
 541                 GotoStatement ();
 542                 CheckSemi (PendingToken);
 543                 return 1;
 544
 545             case TOK_SEMI:
 546                 /* Ignore it */
 547                 CheckSemi (PendingToken);
 548                 break;
 549
 550             case TOK_PRAGMA:
 551                 DoPragma ();
 552                 break;
 553
 554             default:
 555                 /* Actual statement */
 556                 expression (&lval);
 557                 CheckSemi (PendingToken);
 558         }
 559     }
 560     return 0;
 561 }
 562
 563
 564
 565