/*****************************************************************************/
/* */
-/* stmt.c */
+/* stmt.c */
/* */
-/* Parse a statement */
+/* Parse a statement */
/* */
/* */
/* */
-/* (C) 1998-2008 Ullrich von Bassewitz */
-/* Roemerstrasse 52 */
-/* D-70794 Filderstadt */
-/* EMail: uz@cc65.org */
+/* (C) 1998-2010, Ullrich von Bassewitz */
+/* Roemerstrasse 52 */
+/* D-70794 Filderstadt */
+/* EMail: uz@cc65.org */
/* */
/* */
/* This software is provided 'as-is', without any expressed or implied */
/*****************************************************************************/
-/* Helper functions */
+/* Helper functions */
/*****************************************************************************/
-static void CheckLabelWithoutStatement (void)
+static int CheckLabelWithoutStatement (void)
/* Called from Statement() after a label definition. Will check for a
- * following closing curly brace. This means that a label is not followed
- * by a statement which is required by the standard. Output an error if so.
- */
+** following closing curly brace. This means that a label is not followed
+** by a statement which is required by the standard. Output an error if so.
+*/
{
if (CurTok.Tok == TOK_RCURLY) {
Error ("Label at end of compound statement");
+ return 1;
+ } else {
+ return 0;
}
}
static void CheckTok (token_t Tok, const char* Msg, int* PendingToken)
/* Helper function for Statement. Will check for Tok and print Msg if not
- * found. If PendingToken is NULL, it will the skip the token, otherwise
- * it will store one to PendingToken.
- */
+** found. If PendingToken is NULL, it will the skip the token, otherwise
+** it will store one to PendingToken.
+*/
{
if (CurTok.Tok != Tok) {
- Error (Msg);
+ Error ("%s", Msg);
} else if (PendingToken) {
- *PendingToken = 1;
+ *PendingToken = 1;
} else {
- NextToken ();
+ NextToken ();
}
}
static void CheckSemi (int* PendingToken)
/* 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.
- */
+** 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.
+*/
{
int HaveToken = (CurTok.Tok == TOK_SEMI);
if (!HaveToken) {
- Error ("`;' expected");
+ Error ("';' expected");
/* Try to be smart about errors */
if (CurTok.Tok == TOK_COLON || CurTok.Tok == TOK_COMMA) {
HaveToken = 1;
/* Skip the pending token if we have one */
{
if (PendingToken) {
- NextToken ();
+ NextToken ();
}
}
/*****************************************************************************/
-/* Code */
+/* Code */
/*****************************************************************************/
/* Else clause present? */
if (CurTok.Tok != TOK_ELSE) {
- g_defcodelabel (Label1);
+ g_defcodelabel (Label1);
- /* Since there's no else clause, we're not sure, if the a break
- * statement is really executed.
- */
- return 0;
+ /* Since there's no else clause, we're not sure, if the a break
+ ** statement is really executed.
+ */
+ return 0;
} else {
- /* Generate a jump around the else branch */
- unsigned Label2 = GetLocalLabel ();
- g_jump (Label2);
+ /* Generate a jump around the else branch */
+ unsigned Label2 = GetLocalLabel ();
+ g_jump (Label2);
- /* Skip the else */
- NextToken ();
+ /* Skip the else */
+ NextToken ();
/* If the if expression was always true, the code in the else branch
- * is never executed. Output a warning if this is the case.
- */
+ ** is never executed. Output a warning if this is the case.
+ */
if (TestResult == TESTEXPR_TRUE) {
Warning ("Unreachable code");
}
- /* Define the target for the first test */
- g_defcodelabel (Label1);
+ /* Define the target for the first test */
+ g_defcodelabel (Label1);
- /* Total break only if both branches had a break. */
- GotBreak &= Statement (0);
+ /* Total break only if both branches had a break. */
+ GotBreak &= Statement (0);
- /* Generate the label for the else clause */
- g_defcodelabel (Label2);
+ /* Generate the label for the else clause */
+ g_defcodelabel (Label2);
- /* Done */
- return GotBreak;
+ /* Done */
+ return GotBreak;
}
}
g_defcodelabel (ContinueLabel);
/* Parse the end condition */
- Consume (TOK_WHILE, "`while' expected");
+ Consume (TOK_WHILE, "'while' expected");
TestInParens (LoopLabel, 1);
ConsumeSemi ();
static void WhileStatement (void)
/* Handle the 'while' statement */
{
- int PendingToken;
+ int PendingToken;
+ CodeMark CondCodeStart; /* Start of condition evaluation code */
+ CodeMark CondCodeEnd; /* End of condition evaluation code */
+ CodeMark Here; /* "Here" location of code */
/* Get the loop control labels */
unsigned LoopLabel = GetLocalLabel ();
unsigned BreakLabel = GetLocalLabel ();
+ unsigned CondLabel = GetLocalLabel ();
/* Skip the while token */
NextToken ();
- /* 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);
+ /* Add the loop to the loop stack. In case of a while loop, the condition
+ ** label is used for continue statements.
+ */
+ AddLoop (BreakLabel, CondLabel);
- /* Define the head label */
- g_defcodelabel (LoopLabel);
+ /* We will move the code that evaluates the while condition to the end of
+ ** the loop, so generate a jump here.
+ */
+ g_jump (CondLabel);
+
+ /* Remember the current position */
+ GetCodePos (&CondCodeStart);
/* Test the loop condition */
- TestInParens (BreakLabel, 0);
+ TestInParens (LoopLabel, 1);
+
+ /* Remember the end of the condition evaluation code */
+ GetCodePos (&CondCodeEnd);
+
+ /* Define the head label */
+ g_defcodelabel (LoopLabel);
/* Loop body */
Statement (&PendingToken);
- /* Jump back to loop top */
- g_jump (LoopLabel);
+ /* Emit the while condition label */
+ g_defcodelabel (CondLabel);
+
+ /* Move the test code here */
+ GetCodePos (&Here);
+ MoveCode (&CondCodeStart, &CondCodeEnd, &Here);
/* Exit label */
g_defcodelabel (BreakLabel);
/* Eat remaining tokens that were delayed because of line info
- * correctness
- */
+ ** correctness
+ */
SkipPending (PendingToken);
/* Remove the loop from the loop stack */
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 */
- hie0 (&Expr);
+ /* Evaluate the return expression */
+ hie0 (&Expr);
- /* Ignore the return expression if the function returns void */
- if (!F_HasVoidReturn (CurrentFunc)) {
-
- /* Convert the return value to the type of the function result */
- TypeConversion (&Expr, F_GetReturnType (CurrentFunc));
+ /* If we return something in a void function, print an error and
+ ** ignore the value. Otherwise convert the value to the type of the
+ ** return.
+ */
+ if (F_HasVoidReturn (CurrentFunc)) {
+ Error ("Returning a value in function with return type void");
+ } else {
+ /* 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);
- }
+ /* 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));
+ Error ("Function '%s' must return a value", F_GetFuncName (CurrentFunc));
}
+ /* Mark the function as having a return statement */
+ F_ReturnFound (CurrentFunc);
+
/* Cleanup the stack in case we're inside a block with locals */
g_space (StackPtr - F_GetTopLevelSP (CurrentFunc));
/* Check if we are inside a loop */
if (L == 0) {
- /* Error: No current loop */
- Error ("`break' statement not within loop or switch");
- return;
+ /* Error: No current loop */
+ Error ("'break' statement not within loop or switch");
+ return;
}
/* Correct the stack pointer if needed */
/* Get the current loop descriptor */
L = CurrentLoop ();
if (L) {
- /* Search for a loop that has a continue label. */
- do {
- if (L->ContinueLabel) {
- break;
- }
- L = L->Next;
- } while (L);
+ /* Search for a loop that has a continue label. */
+ do {
+ if (L->ContinueLabel) {
+ break;
+ }
+ L = L->Next;
+ } while (L);
}
/* Did we find it? */
if (L == 0) {
- Error ("`continue' statement not within a loop");
- return;
+ Error ("'continue' statement not within a loop");
+ return;
}
/* Correct the stackpointer if needed */
NextToken ();
/* Add the loop to the loop stack. A continue jumps to the start of the
- * the increment condition.
- */
+ ** the increment condition.
+ */
AddLoop (BreakLabel, IncLabel);
/* Skip the opening paren */
/* Parse the initializer expression */
if (CurTok.Tok != TOK_SEMI) {
- Expression0 (&lval1);
+ Expression0 (&lval1);
}
ConsumeSemi ();
/* Parse the test expression */
if (CurTok.Tok != TOK_SEMI) {
Test (BodyLabel, 1);
- g_jump (BreakLabel);
+ g_jump (BreakLabel);
} else {
- g_jump (BodyLabel);
+ g_jump (BodyLabel);
}
ConsumeSemi ();
/* Parse the increment expression */
HaveIncExpr = (CurTok.Tok != TOK_RPAREN);
if (HaveIncExpr) {
- Expression0 (&lval3);
+ Expression0 (&lval3);
}
/* Jump to the test */
Statement (&PendingToken);
/* If we had an increment expression, move the code to the bottom of
- * the loop. In this case we don't need to jump there at the end of
- * the loop body.
- */
+ ** the loop. In this case we don't need to jump there at the end of
+ ** the loop body.
+ */
if (HaveIncExpr) {
CodeMark Here;
GetCodePos (&Here);
- MoveCode (&IncExprStart, &IncExprEnd, &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 */
static int CompoundStatement (void)
/* Compound statement. Allow any number of statements inside braces. The
- * function returns true if the last statement was a break or return.
- */
+** function returns true if the last statement was a break or return.
+*/
{
int GotBreak;
/* Remember the stack at block entry */
int OldStack = StackPtr;
+ unsigned OldBlockStackSize = CollCount (&CurrentFunc->LocalsBlockStack);
/* Enter a new lexical level */
EnterBlockLevel ();
/* Now process statements in this block */
GotBreak = 0;
while (CurTok.Tok != TOK_RCURLY) {
- if (CurTok.Tok != TOK_CEOF) {
- GotBreak = Statement (0);
- } else {
- break;
- }
+ if (CurTok.Tok != TOK_CEOF) {
+ GotBreak = Statement (0);
+ } else {
+ break;
+ }
}
/* Clean up the stack. */
if (!GotBreak) {
- g_space (StackPtr - OldStack);
+ g_space (StackPtr - OldStack);
+ }
+
+ /* If the segment had autoinited variables, let's pop it of a stack
+ ** of such blocks.
+ */
+ if (OldBlockStackSize != CollCount (&CurrentFunc->LocalsBlockStack)) {
+ CollPop (&CurrentFunc->LocalsBlockStack);
}
+
StackPtr = OldStack;
/* Emit references to imports/exports for this block */
int Statement (int* PendingToken)
/* Statement parser. Returns 1 if the statement does a return/break, returns
- * 0 otherwise. If the PendingToken pointer is not NULL, the function will
- * not skip the terminating token of the statement (closing brace or
- * semicolon), but store true if there is a pending token, and false if there
- * is none. The token is always checked, so there is no need for the caller to
- * check this token, it must be skipped, however. If the argument pointer is
- * NULL, the function will skip the token.
- */
+** 0 otherwise. If the PendingToken pointer is not NULL, the function will
+** not skip the terminating token of the statement (closing brace or
+** semicolon), but store true if there is a pending token, and false if there
+** is none. The token is always checked, so there is no need for the caller to
+** check this token, it must be skipped, however. If the argument pointer is
+** NULL, the function will skip the token.
+*/
{
ExprDesc Expr;
int GotBreak;
/* Assume no pending token */
if (PendingToken) {
- *PendingToken = 0;
+ *PendingToken = 0;
}
- /* Check for a label */
- if (CurTok.Tok == TOK_IDENT && NextTok.Tok == TOK_COLON) {
-
- /* Special handling for a label */
- DoLabel ();
- CheckLabelWithoutStatement ();
-
- } else {
-
- switch (CurTok.Tok) {
-
- case TOK_LCURLY:
- NextToken ();
- GotBreak = CompoundStatement ();
- CheckTok (TOK_RCURLY, "`{' expected", PendingToken);
- return GotBreak;
-
- case TOK_IF:
- return IfStatement ();
-
- case TOK_WHILE:
- WhileStatement ();
- break;
-
- case TOK_DO:
- DoStatement ();
- break;
-
- case TOK_SWITCH:
- SwitchStatement ();
- break;
-
- case TOK_RETURN:
- ReturnStatement ();
- CheckSemi (PendingToken);
- return 1;
-
- case TOK_BREAK:
- BreakStatement ();
- CheckSemi (PendingToken);
- return 1;
-
- case TOK_CONTINUE:
- ContinueStatement ();
- CheckSemi (PendingToken);
- return 1;
-
- case TOK_FOR:
- ForStatement ();
- break;
-
- case TOK_GOTO:
- GotoStatement ();
- CheckSemi (PendingToken);
- return 1;
-
- case TOK_SEMI:
- /* Ignore it */
- CheckSemi (PendingToken);
- break;
-
- case TOK_PRAGMA:
- DoPragma ();
- break;
-
- case TOK_CASE:
- CaseLabel ();
- CheckLabelWithoutStatement ();
- break;
+ /* Check for a label. A label is always part of a statement, it does not
+ ** replace one.
+ */
+ while (CurTok.Tok == TOK_IDENT && NextTok.Tok == TOK_COLON) {
+ /* Handle the label */
+ DoLabel ();
+ if (CheckLabelWithoutStatement ()) {
+ return 0;
+ }
+ }
- case TOK_DEFAULT:
- DefaultLabel ();
- CheckLabelWithoutStatement ();
- break;
+ switch (CurTok.Tok) {
- default:
- /* Remember the current code position */
- GetCodePos (&Start);
- /* Actual statement */
- 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);
- }
+ case TOK_LCURLY:
+ NextToken ();
+ GotBreak = CompoundStatement ();
+ CheckTok (TOK_RCURLY, "'{' expected", PendingToken);
+ return GotBreak;
+
+ case TOK_IF:
+ return IfStatement ();
+
+ case TOK_WHILE:
+ WhileStatement ();
+ break;
+
+ case TOK_DO:
+ DoStatement ();
+ break;
+
+ case TOK_SWITCH:
+ SwitchStatement ();
+ break;
+
+ case TOK_RETURN:
+ ReturnStatement ();
+ CheckSemi (PendingToken);
+ return 1;
+
+ case TOK_BREAK:
+ BreakStatement ();
+ CheckSemi (PendingToken);
+ return 1;
+
+ case TOK_CONTINUE:
+ ContinueStatement ();
+ CheckSemi (PendingToken);
+ return 1;
+
+ case TOK_FOR:
+ ForStatement ();
+ break;
+
+ case TOK_GOTO:
+ GotoStatement ();
+ CheckSemi (PendingToken);
+ return 1;
+
+ case TOK_SEMI:
+ /* Ignore it */
+ CheckSemi (PendingToken);
+ break;
+
+ case TOK_PRAGMA:
+ DoPragma ();
+ break;
+
+ case TOK_CASE:
+ CaseLabel ();
+ CheckLabelWithoutStatement ();
+ break;
+
+ case TOK_DEFAULT:
+ DefaultLabel ();
+ CheckLabelWithoutStatement ();
+ break;
+
+ default:
+ /* Remember the current code position */
+ GetCodePos (&Start);
+ /* Actual statement */
+ 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) &&
+ IS_Get (&WarnNoEffect)) {
+ Warning ("Statement has no effect");
+ }
+ CheckSemi (PendingToken);
}
return 0;
}
-
-
-
-
projects / cc65 / blobdiff