/*****************************************************************************/
-/* Code */
+/* Helper functions */
/*****************************************************************************/
-static int statement (void);
-/* Forward decl */
+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.
+ */
+{
+ if (CurTok.Tok != Tok) {
+ Error (Msg);
+ } else if (PendingToken) {
+ *PendingToken = 1;
+ } else {
+ NextToken ();
+ }
+}
+
+
+
+static void CheckSemi (int* PendingToken)
+/* Helper function for Statement. Will call CheckTok with the parameters
+ * for a semicolon.
+ */
+{
+ CheckTok (TOK_SEMI, "`;' expected", PendingToken);
+}
+
+
+
+static void SkipPending (int PendingToken)
+/* Skip the pending token if we have one */
+{
+ if (PendingToken) {
+ NextToken ();
+ }
+}
+
+
+
+/*****************************************************************************/
+/* Code */
+/*****************************************************************************/
-static int doif (void)
-/* Handle 'if' statement here */
+static int IfStatement (void)
+/* Handle an 'if' statement */
{
- int flab1;
- int flab2;
- int gotbreak;
+ unsigned Label1;
+ int GotBreak;
/* Skip the if */
NextToken ();
/* Generate a jump label and parse the condition */
- flab1 = GetLabel ();
- test (flab1, 0);
+ Label1 = GetLocalLabel ();
+ test (Label1, 0);
/* Parse the if body */
- gotbreak = statement ();
+ GotBreak = Statement (0);
/* Else clause present? */
- if (curtok != TOK_ELSE) {
+ if (CurTok.Tok != TOK_ELSE) {
+
+ g_defcodelabel (Label1);
- g_defloclabel (flab1);
/* Since there's no else clause, we're not sure, if the a break
* statement is really executed.
*/
} else {
- /* Skip the else */
+ /* Generate a jump around the else branch */
+ unsigned Label2 = GetLocalLabel ();
+ g_jump (Label2);
+
+ /* Skip the else */
NextToken ();
- /* If we had some sort of break statement at the end of the if clause,
- * there's no need to generate an additional jump around the else
- * clause, since the jump is never reached.
- */
- if (!gotbreak) {
- flab2 = GetLabel ();
- g_jump (flab2);
- } else {
- /* Mark the label as unused */
- flab2 = 0;
- }
- g_defloclabel (flab1);
- gotbreak &= statement ();
+ /* 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 */
- if (flab2) {
- g_defloclabel (flab2);
- }
+ g_defcodelabel (Label2);
/* Done */
- return gotbreak;
+ return GotBreak;
}
}
-static void dowhile (char wtype)
-/* Handle 'while' statement here */
+static void DoStatement (void)
+/* Handle the 'do' statement */
{
- int loop;
- int lab;
+ /* Get the loop control labels */
+ unsigned loop = GetLocalLabel ();
+ unsigned lab = GetLocalLabel ();
+ /* Skip the while token */
NextToken ();
- loop = GetLabel ();
- lab = GetLabel ();
+
+ /* Add the loop to the loop stack */
AddLoop (oursp, loop, lab, 0, 0);
- g_defloclabel (loop);
- if (wtype == 'w') {
-
- /* While loop */
- test (lab, 0);
-
- /* If the statement following the while loop is empty, that is, we have
- * something like "while (1) ;", the test function ommitted the jump as
- * an optimization. Since we know, the condition codes are set, we can
- * do another small optimization here, and use a conditional jump
- * instead an absolute one.
- */
- if (curtok == TOK_SEMI) {
- /* Shortcut */
- NextToken ();
- /* Use a conditional jump */
- g_truejump (CF_NONE, loop);
- } else {
- /* There is code inside the while loop */
- statement ();
- g_jump (loop);
- g_defloclabel (lab);
- }
- } else {
+ /* Define the head label */
+ g_defcodelabel (loop);
- /* Do loop */
- statement ();
- Consume (TOK_WHILE, "`while' expected");
- test (loop, 1);
- ConsumeSemi ();
- g_defloclabel (lab);
+ /* Parse the loop body */
+ Statement (0);
+ /* Parse the end condition */
+ Consume (TOK_WHILE, "`while' expected");
+ test (loop, 1);
+ ConsumeSemi ();
+
+ /* Define the break label */
+ g_defcodelabel (lab);
+
+ /* Remove the loop from the loop stack */
+ DelLoop ();
+}
+
+
+
+static void WhileStatement (void)
+/* Handle the 'while' statement */
+{
+ int PendingToken;
+
+ /* Get the loop control labels */
+ unsigned loop = GetLocalLabel ();
+ unsigned lab = GetLocalLabel ();
+
+ /* Skip the while token */
+ NextToken ();
+
+ /* Add the loop to the loop stack */
+ AddLoop (oursp, loop, lab, 0, 0);
+
+ /* Define the head label */
+ g_defcodelabel (loop);
+
+ /* Test the loop condition */
+ test (lab, 0);
+
+ /* If the statement following the while loop is empty, that is, we have
+ * something like "while (1) ;", the test function ommitted the jump as
+ * an optimization. Since we know, the condition codes are set, we can
+ * do another small optimization here, and use a conditional jump
+ * instead an absolute one.
+ */
+ if (CurTok.Tok == TOK_SEMI) {
+ /* Use a conditional jump */
+ g_truejump (CF_NONE, loop);
+ /* Shortcut */
+ NextToken ();
+ } else {
+ /* There is code inside the while loop, parse the body */
+ Statement (&PendingToken);
+ g_jump (loop);
+ g_defcodelabel (lab);
+ SkipPending (PendingToken);
}
+
+ /* Remove the loop from the loop stack */
DelLoop ();
}
-static void doreturn (void)
-/* Handle 'return' statement here */
+static void ReturnStatement (void)
+/* Handle the 'return' statement */
{
struct expent lval;
- unsigned Flags = 0; /* Code generator flags */
- int HaveVal = 0; /* Do we have a return value in ax? */
-
NextToken ();
- if (curtok != TOK_SEMI) {
+ if (CurTok.Tok != TOK_SEMI) {
if (HasVoidReturn (CurrentFunc)) {
Error ("Returning a value in function with return type void");
}
- if (evalexpr (CF_NONE, hie0, &lval) == 0) {
- /* Constant value */
- Flags = CF_CONST;
- } else {
- /* Value in the primary register */
- HaveVal = 1;
- }
+
+ /* Evaluate the return expression. Result will be in primary */
+ expression (&lval);
/* Convert the return value to the type of the function result */
if (!HasVoidReturn (CurrentFunc)) {
- Flags |= (assignadjust (GetReturnType (CurrentFunc), &lval) & ~CF_CONST) | CF_REG;
+ assignadjust (GetReturnType (CurrentFunc), &lval);
}
} else if (!HasVoidReturn (CurrentFunc)) {
Error ("Function `%s' must return a value", GetFuncName (CurrentFunc));
}
- RestoreRegVars (HaveVal);
- g_leave (Flags, lval.e_const);
+
+ /* Cleanup the stack in case we're inside a block with locals */
+ g_space (oursp - GetTopLevelSP (CurrentFunc));
+
+ /* Output a jump to the function exit code */
+ g_jump (GetRetLab (CurrentFunc));
}
-static void dobreak (void)
-/* Handle 'break' statement here */
+static void BreakStatement (void)
+/* Handle the 'break' statement */
{
LoopDesc* L;
-static void docontinue (void)
-/* Handle 'continue' statement here */
+static void ContinueStatement (void)
+/* Handle the 'continue' statement */
{
LoopDesc* L;
-static void cascadeswitch (struct expent* eval)
+static void CascadeSwitch (struct expent* eval)
/* Handle a switch statement for chars with a cmp cascade for the selector */
{
- unsigned ExitLab; /* Exit label */
- unsigned NextLab; /* Next case label */
+ unsigned ExitLab; /* Exit label */
+ unsigned NextLab; /* Next case label */
unsigned CodeLab; /* Label that starts the actual selector code */
int HaveBreak; /* Remember if we exited with break */
int HaveDefault; /* Remember if we had a default label */
/* Create a loop so we may break out, init labels */
- ExitLab = GetLabel ();
+ ExitLab = GetLocalLabel ();
AddLoop (oursp, 0, ExitLab, 0, 0);
/* Setup some variables needed in the loop below */
/* Parse the labels */
lcount = 0;
- while (curtok != TOK_RCURLY) {
+ while (CurTok.Tok != TOK_RCURLY) {
- if (curtok == TOK_CASE || curtok == TOK_DEFAULT) {
+ if (CurTok.Tok == TOK_CASE || CurTok.Tok == TOK_DEFAULT) {
/* If the code for the previous selector did not end with a
* break statement, we must jump over the next selector test.
if (!HaveBreak) {
/* Define a label for the code */
if (CodeLab == 0) {
- CodeLab = GetLabel ();
+ CodeLab = GetLocalLabel ();
}
g_jump (CodeLab);
}
/* If we have a cascade label, emit it */
if (NextLab) {
- g_defloclabel (NextLab);
+ g_defcodelabel (NextLab);
NextLab = 0;
}
- while (curtok == TOK_CASE || curtok == TOK_DEFAULT) {
+ while (CurTok.Tok == TOK_CASE || CurTok.Tok == TOK_DEFAULT) {
/* Parse the selector */
- if (curtok == TOK_CASE) {
+ if (CurTok.Tok == TOK_CASE) {
/* Count labels */
++lcount;
case T_SCHAR:
/* Signed char */
if (Val < -128 || Val > 127) {
- Error ("Range error");
- }
- break;
-
- case T_UCHAR:
- if (Val < 0 || Val > 255) {
- Error ("Range error");
- }
- break;
-
- case T_INT:
- if (Val < -32768 || Val > 32767) {
- Error ("Range error");
- }
- break;
-
- case T_UINT:
- if (Val < 0 || Val > 65535) {
- Error ("Range error");
- }
- break;
-
- default:
+ Error ("Range error");
+ }
+ break;
+
+ case T_UCHAR:
+ if (Val < 0 || Val > 255) {
+ Error ("Range error");
+ }
+ break;
+
+ case T_INT:
+ if (Val < -32768 || Val > 32767) {
+ Error ("Range error");
+ }
+ break;
+
+ case T_UINT:
+ if (Val < 0 || Val > 65535) {
+ Error ("Range error");
+ }
+ break;
+
+ default:
Internal ("Invalid type: %02X", *eval->e_tptr & 0xFF);
}
- /* Skip the colon */
- ConsumeColon ();
-
/* Emit a compare */
g_cmp (Flags, Val);
/* If another case follows, we will jump to the code if
* the condition is true.
*/
- if (curtok == TOK_CASE) {
- /* Create a code label if needed */
- if (CodeLab == 0) {
- CodeLab = GetLabel ();
- }
- g_falsejump (CF_NONE, CodeLab);
- } else if (curtok != TOK_DEFAULT) {
+ if (CurTok.Tok == TOK_CASE) {
+ /* Create a code label if needed */
+ if (CodeLab == 0) {
+ CodeLab = GetLocalLabel ();
+ }
+ g_falsejump (CF_NONE, CodeLab);
+ } else if (CurTok.Tok != TOK_DEFAULT) {
/* No case follows, jump to next selector */
if (NextLab == 0) {
- NextLab = GetLabel ();
+ NextLab = GetLocalLabel ();
}
- g_truejump (CF_NONE, NextLab);
+ g_truejump (CF_NONE, NextLab);
}
+ /* Skip the colon */
+ ConsumeColon ();
+
} else {
/* Default case */
NextToken ();
- /* Skip the colon */
- ConsumeColon ();
-
/* Handle the pathologic case: DEFAULT followed by CASE */
- if (curtok == TOK_CASE) {
+ if (CurTok.Tok == TOK_CASE) {
if (CodeLab == 0) {
- CodeLab = GetLabel ();
+ CodeLab = GetLocalLabel ();
}
- g_jump (CodeLab);
+ g_jump (CodeLab);
}
+ /* Skip the colon */
+ ConsumeColon ();
+
/* Remember that we had a default label */
HaveDefault = 1;
}
/* Emit a code label if we have one */
if (CodeLab) {
- g_defloclabel (CodeLab);
+ g_defcodelabel (CodeLab);
CodeLab = 0;
}
/* Parse statements */
- if (curtok != TOK_RCURLY) {
- HaveBreak = statement ();
+ if (CurTok.Tok != TOK_RCURLY) {
+ HaveBreak = Statement (0);
}
}
Warning ("No case labels");
}
- /* Eat the closing curly brace */
- NextToken ();
-
/* Define the exit label and, if there's a next label left, create this
* one, too.
*/
if (NextLab) {
- g_defloclabel (NextLab);
+ g_defcodelabel (NextLab);
}
- g_defloclabel (ExitLab);
+ g_defcodelabel (ExitLab);
+
+ /* Eat the closing curly brace */
+ NextToken ();
/* End the loop */
DelLoop ();
-static void tableswitch (struct expent* eval)
+static void TableSwitch (struct expent* eval)
/* Handle a switch statement via table based selector */
{
/* Entry for one case in a switch statement */
int lcount; /* Label count */
int HaveBreak; /* Last statement has a break */
int HaveDefault; /* Remember if we had a default label */
- unsigned Flags; /* Code generator flags */
+ unsigned Flags; /* Code generator flags */
struct expent lval; /* Case label expression */
struct swent *p;
struct swent *swtab;
HaveBreak = 0; /* Keep gcc silent */
HaveDefault = 0; /* No default case until now */
dlabel = 0; /* init */
- lab = GetLabel (); /* get exit */
+ lab = GetLocalLabel (); /* get exit */
p = swtab;
AddLoop (oursp, 0, lab, 0, 0);
/* Jump behind the code for the CASE labels */
- g_jump (lcase = GetLabel ());
+ g_jump (lcase = GetLocalLabel ());
lcount = 0;
- while (curtok != TOK_RCURLY) {
- if (curtok == TOK_CASE || curtok == TOK_DEFAULT) {
+ while (CurTok.Tok != TOK_RCURLY) {
+ if (CurTok.Tok == TOK_CASE || CurTok.Tok == TOK_DEFAULT) {
if (lcount >= CASE_MAX) {
Fatal ("Too many case labels");
}
- label = GetLabel ();
+ label = GetLocalLabel ();
do {
- if (curtok == TOK_CASE) {
+ if (CurTok.Tok == TOK_CASE) {
NextToken ();
constexpr (&lval);
if (!IsClassInt (lval.e_tptr)) {
HaveDefault = 1;
}
ConsumeColon ();
- } while (curtok == TOK_CASE || curtok == TOK_DEFAULT);
- g_defloclabel (label);
+ } while (CurTok.Tok == TOK_CASE || CurTok.Tok == TOK_DEFAULT);
+ g_defcodelabel (label);
HaveBreak = 0;
}
- if (curtok != TOK_RCURLY) {
- HaveBreak = statement ();
+ if (CurTok.Tok != TOK_RCURLY) {
+ HaveBreak = Statement (0);
}
}
}
/* Actual selector code goes here */
- g_defloclabel (lcase);
+ g_defcodelabel (lcase);
/* Create the call to the switch subroutine */
Flags = TypeOf (eval->e_tptr);
g_defdata (CF_INT | CF_CONST, -((int)lcount)-1, 0);
/* Create the case selector table */
- AddCodeHint ("casetable");
p = swtab;
while (lcount) {
g_case (Flags, p->sw_lab, p->sw_const); /* Create one label */
if (dlabel) {
g_jump (dlabel);
}
- g_defloclabel (lab);
+ g_defcodelabel (lab);
DelLoop ();
/* Free the allocated space for the labels */
-static void doswitch (void)
-/* Handle 'switch' statement here */
+static void SwitchStatement (void)
+/* Handle a 'switch' statement */
{
- struct expent eval; /* Switch statement expression */
+ struct expent eval; /* Switch statement expression */
/* Eat the "switch" */
NextToken ();
ConsumeLCurly ();
/* Now decide which sort of switch we will create: */
- if (IsTypeChar (eval.e_tptr) || (FavourSize == 0 && IsClassInt (eval.e_tptr))) {
- cascadeswitch (&eval);
+ if (IsTypeChar (eval.e_tptr) || (CodeSizeFactor >= 200 && IsClassInt (eval.e_tptr))) {
+ CascadeSwitch (&eval);
} else {
- tableswitch (&eval);
+ TableSwitch (&eval);
}
}
-static void dofor (void)
-/* Handle 'for' statement here */
+static void ForStatement (void)
+/* Handle a 'for' statement */
{
- int loop;
- int lab;
- int linc;
- int lstat;
struct expent lval1;
struct expent lval2;
struct expent lval3;
+ int PendingToken;
+
+ /* Get several local labels needed later */
+ unsigned TestLabel = GetLocalLabel ();
+ unsigned lab = GetLocalLabel ();
+ unsigned IncLabel = GetLocalLabel ();
+ unsigned lstat = GetLocalLabel ();
+ /* Skip the FOR token */
NextToken ();
- loop = GetLabel ();
- lab = GetLabel ();
- linc = GetLabel ();
- lstat = GetLabel ();
- AddLoop (oursp, loop, lab, linc, lstat);
+
+ /* Add the loop to the loop stack */
+ AddLoop (oursp, TestLabel, lab, IncLabel, lstat);
+
+ /* Skip the opening paren */
ConsumeLParen ();
- if (curtok != TOK_SEMI) { /* exp1 */
+
+ /* Parse the initializer expression */
+ if (CurTok.Tok != TOK_SEMI) {
expression (&lval1);
}
ConsumeSemi ();
- g_defloclabel (loop);
- if (curtok != TOK_SEMI) { /* exp2 */
- boolexpr (&lval2);
- g_truejump (CF_NONE, lstat);
- g_jump (lab);
+
+ /* Label for the test expressions */
+ g_defcodelabel (TestLabel);
+
+ /* Parse the test expression */
+ if (CurTok.Tok != TOK_SEMI) {
+ boolexpr (&lval2);
+ g_truejump (CF_NONE, lstat);
+ g_jump (lab);
} else {
- g_jump (lstat);
+ g_jump (lstat);
}
ConsumeSemi ();
- g_defloclabel (linc);
- if (curtok != TOK_RPAREN) { /* exp3 */
+
+ /* Label for the increment expression */
+ g_defcodelabel (IncLabel);
+
+ /* Parse the increment expression */
+ if (CurTok.Tok != TOK_RPAREN) {
expression (&lval3);
}
+
+ /* Jump to the test */
+ g_jump (TestLabel);
+
+ /* Skip the closing paren */
ConsumeRParen ();
- g_jump (loop);
- g_defloclabel (lstat);
- statement ();
- g_jump (linc);
- g_defloclabel (lab);
+
+ /* Loop body */
+ g_defcodelabel (lstat);
+ Statement (&PendingToken);
+
+ /* 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);
+
+ /* Remove the loop from the loop stack */
DelLoop ();
}
-static int statement (void)
-/* Statement parser. Called whenever syntax requires a statement.
- * This routine performs that statement and returns 1 if it is a branch,
- * 0 otherwise
+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.
+ */
+{
+ int GotBreak;
+
+ /* Remember the stack at block entry */
+ int OldStack = oursp;
+
+ /* Enter a new lexical level */
+ EnterBlockLevel ();
+
+ /* Parse local variable declarations if any */
+ DeclareLocals ();
+
+ /* Now process statements in this block */
+ GotBreak = 0;
+ while (CurTok.Tok != TOK_RCURLY) {
+ if (CurTok.Tok != TOK_CEOF) {
+ GotBreak = Statement (0);
+ } else {
+ break;
+ }
+ }
+
+ /* Clean up the stack. */
+ if (!GotBreak) {
+ g_space (oursp - OldStack);
+ }
+ oursp = OldStack;
+
+ /* Emit references to imports/exports for this block */
+ EmitExternals ();
+
+ /* Leave the lexical level */
+ LeaveBlockLevel ();
+
+ return GotBreak;
+}
+
+
+
+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.
*/
{
struct expent lval;
+ int GotBreak;
- /* */
- if (curtok == TOK_IDENT && nxttok == TOK_COLON) {
+ /* 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 */
DoLabel ();
} else {
- switch (curtok) {
+ switch (CurTok.Tok) {
case TOK_LCURLY:
- return compound ();
+ NextToken ();
+ GotBreak = CompoundStatement ();
+ CheckTok (TOK_RCURLY, "`{' expected", PendingToken);
+ return GotBreak;
case TOK_IF:
- return doif ();
+ return IfStatement ();
case TOK_WHILE:
- dowhile ('w');
- break;
+ WhileStatement ();
+ break;
case TOK_DO:
- dowhile ('d');
- break;
+ DoStatement ();
+ break;
case TOK_SWITCH:
- doswitch ();
- break;
+ SwitchStatement ();
+ break;
case TOK_RETURN:
- doreturn ();
- ConsumeSemi ();
- return 1;
+ ReturnStatement ();
+ CheckSemi (PendingToken);
+ return 1;
case TOK_BREAK:
- dobreak ();
- ConsumeSemi ();
+ BreakStatement ();
+ CheckSemi (PendingToken);
return 1;
case TOK_CONTINUE:
- docontinue ();
- ConsumeSemi ();
+ ContinueStatement ();
+ CheckSemi (PendingToken);
return 1;
case TOK_FOR:
- dofor ();
+ ForStatement ();
break;
case TOK_GOTO:
- DoGoto ();
- ConsumeSemi ();
+ GotoStatement ();
+ CheckSemi (PendingToken);
return 1;
case TOK_SEMI:
- /* ignore it. */
+ /* Ignore it */
NextToken ();
break;
break;
default:
- AddCodeHint ("stmt:start");
+ /* Actual statement */
expression (&lval);
- AddCodeHint ("stmt:end");
- ConsumeSemi ();
+ CheckSemi (PendingToken);
}
}
return 0;
-int compound (void)
-/* Compound statement. Allow any number of statements, inside braces. */
-{
- static unsigned CurrentLevel = 0;
-
- int isbrk;
- int oldsp;
-
- /* eat LCURLY */
- NextToken ();
-
- /* Remember the stack at block entry */
- oldsp = oursp;
-
- /* If we're not on function level, enter a new lexical level */
- if (CurrentLevel++ > 0) {
- /* A nested block */
- EnterBlockLevel ();
- }
-
- /* Parse local variable declarations if any */
- DeclareLocals ();
-
- /* Now process statements in the function body */
- isbrk = 0;
- while (curtok != TOK_RCURLY) {
- if (curtok == TOK_CEOF)
- break;
- else {
- isbrk = statement ();
- }
- }
-
- /* Emit references to imports/exports for this block */
- EmitExternals ();
-
- /* If this is not the top level compound statement, clean up the stack.
- * For a top level statement this will be done by the function exit code.
- */
- if (--CurrentLevel != 0) {
- /* Some sort of nested block */
- LeaveBlockLevel ();
- if (isbrk) {
- oursp = oldsp;
- } else {
- g_space (oursp - oldsp);
- oursp = oldsp;
- }
- }
-
- /* Eat closing brace */
- ConsumeRCurly ();
-
- return isbrk;
-}
-
-
-