/* */
/* */
/* */
-/* (C) 1998-2004 Ullrich von Bassewitz */
-/* Römerstraße 52 */
-/* D-70794 Filderstadt */
-/* EMail: uz@cc65.org */
+/* (C) 1998-2009, Ullrich von Bassewitz */
+/* Roemerstrasse 52 */
+/* D-70794 Filderstadt */
+/* EMail: uz@cc65.org */
/* */
/* */
/* This software is provided 'as-is', without any expressed or implied */
#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 "stmt.h"
#include "swstmt.h"
#include "symtab.h"
-#include "stmt.h"
#include "testexpr.h"
#include "typeconv.h"
+static void 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.
+ */
+{
+ if (CurTok.Tok == TOK_RCURLY) {
+ Error ("Label at end of compound statement");
+ }
+}
+
+
+
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
*/
{
if (CurTok.Tok != Tok) {
- Error (Msg);
+ Error ("%s", Msg);
} else if (PendingToken) {
*PendingToken = 1;
} else {
NextToken ();
/* Add the loop to the loop stack */
- AddLoop (StackPtr, BreakLabel, ContinueLabel);
+ AddLoop (BreakLabel, ContinueLabel);
/* Define the loop label */
g_defcodelabel (LoopLabel);
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
+ /* Add the loop to the loop stack. In case of a while loop, the condition
* label is used for continue statements.
*/
- AddLoop (StackPtr, BreakLabel, LoopLabel);
+ 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);
+
+ /* Emit the code position label */
+ g_defcodelabel (CondLabel);
/* 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);
+ /* Move the test code here */
+ GetCodePos (&Here);
+ MoveCode (&CondCodeStart, &CondCodeEnd, &Here);
/* Exit label */
g_defcodelabel (BreakLabel);
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);
- /* Ignore the return expression if the function returns void */
- if (!F_HasVoidReturn (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 */
- ExprLoad (CF_NONE, &Expr);
+ LoadExpr (CF_NONE, &Expr);
}
} else if (!F_HasVoidReturn (CurrentFunc) && !F_HasOldStyleIntRet (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));
/* Add the loop to the loop stack. A continue jumps to the start of the
* the increment condition.
*/
- AddLoop (StackPtr, BreakLabel, IncLabel);
+ AddLoop (BreakLabel, IncLabel);
/* Skip the opening paren */
ConsumeLParen ();
ConsumeSemi ();
/* Remember the start of the increment expression */
- IncExprStart = GetCodePos();
+ GetCodePos (&IncExprStart);
/* Label for the increment expression */
g_defcodelabel (IncLabel);
g_jump (TestLabel);
/* Remember the end of the increment expression */
- IncExprEnd = GetCodePos();
+ GetCodePos (&IncExprEnd);
/* Skip the closing paren */
ConsumeRParen ();
* 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);
* NULL, the function will skip the token.
*/
{
- ExprDesc lval;
+ ExprDesc Expr;
int GotBreak;
+ CodeMark Start, End;
/* Assume no pending token */
if (PendingToken) {
*PendingToken = 0;
}
- /* Check for a label */
- if (CurTok.Tok == TOK_IDENT && NextTok.Tok == TOK_COLON) {
-
- /* Special handling for a label */
+ /* 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 ();
+ CheckLabelWithoutStatement ();
+ }
- } else {
+ switch (CurTok.Tok) {
- 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;
-
- default:
- /* Actual statement */
- Expression0 (&lval);
- 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)) {
+ Warning ("Statement has no effect");
+ }
+ CheckSemi (PendingToken);
}
return 0;
}
projects / cc65 / blobdiff