X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;ds=sidebyside;f=src%2Fcc65%2Fstmt.c;h=67742113cdda5532c7e9540d6d3a48042118702f;hb=57c2e0cc0bcda3d08692abc60f5c85510801801d;hp=3ab5fd1d6100f0cfc633a42b5b71318ac18a51ee;hpb=a96da498f559cc9e794d26924ce0fb7c81c459a0;p=cc65 diff --git a/src/cc65/stmt.c b/src/cc65/stmt.c index 3ab5fd1d6..67742113c 100644 --- a/src/cc65/stmt.c +++ b/src/cc65/stmt.c @@ -6,9 +6,9 @@ /* */ /* */ /* */ -/* (C) 1998-2001 Ullrich von Bassewitz */ -/* Wacholderweg 14 */ -/* D-70597 Stuttgart */ +/* (C) 1998-2004 Ullrich von Bassewitz */ +/* Römerstraße 52 */ +/* D-70794 Filderstadt */ /* EMail: uz@cc65.org */ /* */ /* */ @@ -51,13 +51,17 @@ #include "global.h" #include "goto.h" #include "litpool.h" +#include "loadexpr.h" #include "locals.h" #include "loop.h" #include "pragma.h" #include "scanner.h" +#include "stackptr.h" #include "swstmt.h" #include "symtab.h" #include "stmt.h" +#include "testexpr.h" +#include "typeconv.h" @@ -74,22 +78,40 @@ static void CheckTok (token_t Tok, const char* Msg, int* PendingToken) */ { if (CurTok.Tok != Tok) { - Error (Msg); + Error (Msg); } else if (PendingToken) { - *PendingToken = 1; + *PendingToken = 1; } else { - NextToken (); + NextToken (); } } static void CheckSemi (int* PendingToken) -/* Helper function for Statement. Will call CheckTok with the parameters - * for a semicolon. +/* Helper function for Statement. Will check for a semicolon and print an + * error message if not found (plus some error recovery). If PendingToken is + * NULL, it will the skip the token, otherwise it will store one to + * PendingToken. + * This function is a special version of CheckTok with the addition of the + * error recovery. */ { - CheckTok (TOK_SEMI, "`;' expected", PendingToken); + int HaveToken = (CurTok.Tok == TOK_SEMI); + if (!HaveToken) { + Error ("`;' expected"); + /* Try to be smart about errors */ + if (CurTok.Tok == TOK_COLON || CurTok.Tok == TOK_COMMA) { + HaveToken = 1; + } + } + if (HaveToken) { + if (PendingToken) { + *PendingToken = 1; + } else { + NextToken (); + } + } } @@ -114,6 +136,7 @@ static int IfStatement (void) /* Handle an 'if' statement */ { unsigned Label1; + unsigned TestResult; int GotBreak; /* Skip the if */ @@ -121,7 +144,7 @@ static int IfStatement (void) /* Generate a jump label and parse the condition */ Label1 = GetLocalLabel (); - test (Label1, 0); + TestResult = TestInParens (Label1, 0); /* Parse the if body */ GotBreak = Statement (0); @@ -138,21 +161,28 @@ static int IfStatement (void) } else { - /* Generate a jump around the else branch */ + /* Generate a jump around the else branch */ unsigned Label2 = GetLocalLabel (); - g_jump (Label2); + g_jump (Label2); - /* Skip the else */ + /* Skip the else */ NextToken (); - /* Define the target for the first test */ - g_defcodelabel (Label1); + /* If the if expression was always true, the code in the else branch + * is never executed. Output a warning if this is the case. + */ + if (TestResult == TESTEXPR_TRUE) { + Warning ("Unreachable code"); + } - /* Total break only if both branches had a break. */ + /* Define the target for the first test */ + g_defcodelabel (Label1); + + /* Total break only if both branches had a break. */ GotBreak &= Statement (0); /* Generate the label for the else clause */ - g_defcodelabel (Label2); + g_defcodelabel (Label2); /* Done */ return GotBreak; @@ -165,28 +195,32 @@ static void DoStatement (void) /* Handle the 'do' statement */ { /* Get the loop control labels */ - unsigned loop = GetLocalLabel (); - unsigned lab = GetLocalLabel (); + unsigned LoopLabel = GetLocalLabel (); + unsigned BreakLabel = GetLocalLabel (); + unsigned ContinueLabel = GetLocalLabel (); /* Skip the while token */ NextToken (); /* Add the loop to the loop stack */ - AddLoop (oursp, loop, lab, 0, 0); + AddLoop (BreakLabel, ContinueLabel); - /* Define the head label */ - g_defcodelabel (loop); + /* Define the loop label */ + g_defcodelabel (LoopLabel); /* Parse the loop body */ Statement (0); + /* Output the label for a continue */ + g_defcodelabel (ContinueLabel); + /* Parse the end condition */ Consume (TOK_WHILE, "`while' expected"); - test (loop, 1); + TestInParens (LoopLabel, 1); ConsumeSemi (); /* Define the break label */ - g_defcodelabel (lab); + g_defcodelabel (BreakLabel); /* Remove the loop from the loop stack */ DelLoop (); @@ -200,29 +234,31 @@ static void WhileStatement (void) int PendingToken; /* Get the loop control labels */ - unsigned loop = GetLocalLabel (); - unsigned lab = GetLocalLabel (); + unsigned LoopLabel = GetLocalLabel (); + unsigned BreakLabel = GetLocalLabel (); /* Skip the while token */ NextToken (); - /* Add the loop to the loop stack */ - AddLoop (oursp, loop, lab, 0, 0); + /* Add the loop to the loop stack. In case of a while loop, the loop head + * label is used for continue statements. + */ + AddLoop (BreakLabel, LoopLabel); /* Define the head label */ - g_defcodelabel (loop); + g_defcodelabel (LoopLabel); /* Test the loop condition */ - test (lab, 0); + TestInParens (BreakLabel, 0); /* Loop body */ Statement (&PendingToken); /* Jump back to loop top */ - g_jump (loop); + g_jump (LoopLabel); /* Exit label */ - g_defcodelabel (lab); + g_defcodelabel (BreakLabel); /* Eat remaining tokens that were delayed because of line info * correctness @@ -238,27 +274,35 @@ static void WhileStatement (void) static void ReturnStatement (void) /* Handle the 'return' statement */ { - ExprDesc lval; + ExprDesc Expr; NextToken (); if (CurTok.Tok != TOK_SEMI) { + + /* Check if the function has a return value declared */ if (F_HasVoidReturn (CurrentFunc)) { Error ("Returning a value in function with return type void"); } - /* Evaluate the return expression. Result will be in primary */ - expression (&lval); + /* Evaluate the return expression */ + hie0 (&Expr); - /* Convert the return value to the type of the function result */ + /* Ignore the return expression if the function returns void */ if (!F_HasVoidReturn (CurrentFunc)) { - assignadjust (F_GetReturnType (CurrentFunc), &lval); + + /* Convert the return value to the type of the function result */ + TypeConversion (&Expr, F_GetReturnType (CurrentFunc)); + + /* Load the value into the primary */ + LoadExpr (CF_NONE, &Expr); } + } else if (!F_HasVoidReturn (CurrentFunc) && !F_HasOldStyleIntRet (CurrentFunc)) { Error ("Function `%s' must return a value", F_GetFuncName (CurrentFunc)); } /* Cleanup the stack in case we're inside a block with locals */ - g_space (oursp - F_GetTopLevelSP (CurrentFunc)); + g_space (StackPtr - F_GetTopLevelSP (CurrentFunc)); /* Output a jump to the function exit code */ g_jump (F_GetRetLab (CurrentFunc)); @@ -285,10 +329,10 @@ static void BreakStatement (void) } /* Correct the stack pointer if needed */ - g_space (oursp - L->StackPtr); + g_space (StackPtr - L->StackPtr); /* Jump to the exit label of the loop */ - g_jump (L->Label); + g_jump (L->BreakLabel); } @@ -304,10 +348,10 @@ static void ContinueStatement (void) /* Get the current loop descriptor */ L = CurrentLoop (); if (L) { - /* Search for the correct loop */ + /* Search for a loop that has a continue label. */ do { - if (L->Loop) { - break; + if (L->ContinueLabel) { + break; } L = L->Next; } while (L); @@ -320,14 +364,10 @@ static void ContinueStatement (void) } /* Correct the stackpointer if needed */ - g_space (oursp - L->StackPtr); + g_space (StackPtr - L->StackPtr); - /* Output the loop code */ - if (L->linc) { - g_jump (L->linc); - } else { - g_jump (L->Loop); - } + /* Jump to next loop iteration */ + g_jump (L->ContinueLabel); } @@ -336,7 +376,6 @@ static void ForStatement (void) /* Handle a 'for' statement */ { ExprDesc lval1; - ExprDesc lval2; ExprDesc lval3; int HaveIncExpr; CodeMark IncExprStart; @@ -344,23 +383,25 @@ static void ForStatement (void) int PendingToken; /* Get several local labels needed later */ - unsigned TestLabel = GetLocalLabel (); - unsigned lab = GetLocalLabel (); - unsigned IncLabel = GetLocalLabel (); - unsigned lstat = GetLocalLabel (); + unsigned TestLabel = GetLocalLabel (); + unsigned BreakLabel = GetLocalLabel (); + unsigned IncLabel = GetLocalLabel (); + unsigned BodyLabel = GetLocalLabel (); /* Skip the FOR token */ NextToken (); - /* Add the loop to the loop stack */ - AddLoop (oursp, TestLabel, lab, IncLabel, lstat); + /* Add the loop to the loop stack. A continue jumps to the start of the + * the increment condition. + */ + AddLoop (BreakLabel, IncLabel); /* Skip the opening paren */ ConsumeLParen (); /* Parse the initializer expression */ if (CurTok.Tok != TOK_SEMI) { - expression (&lval1); + Expression0 (&lval1); } ConsumeSemi (); @@ -369,16 +410,15 @@ static void ForStatement (void) /* Parse the test expression */ if (CurTok.Tok != TOK_SEMI) { - boolexpr (&lval2); - g_truejump (CF_NONE, lstat); - g_jump (lab); + Test (BodyLabel, 1); + g_jump (BreakLabel); } else { - g_jump (lstat); + g_jump (BodyLabel); } ConsumeSemi (); /* Remember the start of the increment expression */ - IncExprStart = GetCodePos(); + GetCodePos (&IncExprStart); /* Label for the increment expression */ g_defcodelabel (IncLabel); @@ -386,20 +426,20 @@ static void ForStatement (void) /* Parse the increment expression */ HaveIncExpr = (CurTok.Tok != TOK_RPAREN); if (HaveIncExpr) { - expression (&lval3); + Expression0 (&lval3); } /* Jump to the test */ g_jump (TestLabel); /* Remember the end of the increment expression */ - IncExprEnd = GetCodePos(); + GetCodePos (&IncExprEnd); /* Skip the closing paren */ ConsumeRParen (); /* Loop body */ - g_defcodelabel (lstat); + g_defcodelabel (BodyLabel); Statement (&PendingToken); /* If we had an increment expression, move the code to the bottom of @@ -407,17 +447,19 @@ static void ForStatement (void) * the loop body. */ if (HaveIncExpr) { - MoveCode (IncExprStart, IncExprEnd, GetCodePos()); + CodeMark Here; + GetCodePos (&Here); + MoveCode (&IncExprStart, &IncExprEnd, &Here); } else { - /* Jump back to the increment expression */ - g_jump (IncLabel); + /* Jump back to the increment expression */ + g_jump (IncLabel); } /* Skip a pending token if we have one */ SkipPending (PendingToken); /* Declare the break label */ - g_defcodelabel (lab); + g_defcodelabel (BreakLabel); /* Remove the loop from the loop stack */ DelLoop (); @@ -433,7 +475,7 @@ static int CompoundStatement (void) int GotBreak; /* Remember the stack at block entry */ - int OldStack = oursp; + int OldStack = StackPtr; /* Enter a new lexical level */ EnterBlockLevel (); @@ -453,9 +495,9 @@ static int CompoundStatement (void) /* Clean up the stack. */ if (!GotBreak) { - g_space (oursp - OldStack); + g_space (StackPtr - OldStack); } - oursp = OldStack; + StackPtr = OldStack; /* Emit references to imports/exports for this block */ EmitExternals (); @@ -478,8 +520,9 @@ int Statement (int* PendingToken) * NULL, the function will skip the token. */ { - ExprDesc lval; + ExprDesc Expr; int GotBreak; + CodeMark Start, End; /* Assume no pending token */ if (PendingToken) { @@ -551,8 +594,23 @@ int Statement (int* PendingToken) break; default: + /* Remember the current code position */ + GetCodePos (&Start); /* Actual statement */ - expression (&lval); + ExprWithCheck (hie0, &Expr); + /* Load the result only if it is an lvalue and the type is + * marked as volatile. Otherwise the load is useless. + */ + if (ED_IsLVal (&Expr) && IsQualVolatile (Expr.Type)) { + LoadExpr (CF_NONE, &Expr); + } + /* If the statement didn't generate code, and is not of type + * void, emit a warning. + */ + GetCodePos (&End); + if (CodeRangeIsEmpty (&Start, &End) && !IsTypeVoid (Expr.Type)) { + Warning ("Statement has no effect"); + } CheckSemi (PendingToken); } }