/* */
/* */
/* */
-/* (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 */
/* */
/* */
#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"
*/
{
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 ();
+ }
+ }
}
/* Handle an 'if' statement */
{
unsigned Label1;
+ unsigned TestResult;
int GotBreak;
/* Skip the if */
/* Generate a jump label and parse the condition */
Label1 = GetLocalLabel ();
- test (Label1, 0);
+ TestResult = TestInParens (Label1, 0);
/* Parse the if body */
GotBreak = Statement (0);
} 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;
/* 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 ();
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
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));
}
/* 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);
}
/* 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);
}
/* 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);
}
/* Handle a 'for' statement */
{
ExprDesc lval1;
- ExprDesc lval2;
ExprDesc lval3;
int HaveIncExpr;
CodeMark IncExprStart;
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 ();
/* 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);
/* 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
* 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 ();
int GotBreak;
/* Remember the stack at block entry */
- int OldStack = oursp;
+ int OldStack = StackPtr;
/* Enter a new lexical level */
EnterBlockLevel ();
/* 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 ();
* NULL, the function will skip the token.
*/
{
- ExprDesc lval;
+ ExprDesc Expr;
int GotBreak;
+ CodeMark Start, End;
/* Assume no pending token */
if (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);
}
}