* as const.
*/
unsigned flags = TypeOf (rhst);
- if (rhs->e_flags & E_MCONST) {
+ if (rhs->e_flags == E_MCONST) {
flags |= CF_CONST;
}
return g_typeadjust (TypeOf (lhst) | CF_CONST, flags);
}
} else if (IsClassInt (rhst)) {
/* Int to pointer assignment is valid only for constant zero */
- if ((rhs->e_flags & E_MCONST) == 0 || rhs->e_const != 0) {
+ if (rhs->e_flags != E_MCONST || rhs->e_const != 0) {
Warning ("Converting integer to pointer without a cast");
}
} else if (IsTypeFuncPtr (lhst) && IsTypeFunc(rhst)) {
{
SymEntry* Entry;
- return curtok == TOK_LPAREN && (
- (nxttok >= TOK_FIRSTTYPE && nxttok <= TOK_LASTTYPE) ||
- (nxttok == TOK_CONST) ||
- (nxttok == TOK_IDENT &&
- (Entry = FindSym (NextTok.Ident)) != 0 &&
- IsTypeDef (Entry))
- );
+ return CurTok.Tok == TOK_LPAREN && (
+ (NextTok.Tok >= TOK_FIRSTTYPE && NextTok.Tok <= TOK_LASTTYPE) ||
+ (NextTok.Tok == TOK_CONST) ||
+ (NextTok.Tok == TOK_IDENT &&
+ (Entry = FindSym (NextTok.Ident)) != 0 &&
+ IsTypeDef (Entry)));
}
}
if (lval->e_test & E_FORCETEST) { /* we testing this value? */
/* debug... */
- AddCodeHint ("forcetest");
flags |= TypeOf (lval->e_tptr);
g_test (flags); /* yes, force a test */
lval->e_test &= ~E_FORCETEST;
}
/* Parse the actual parameter list */
- while (curtok != TOK_RPAREN) {
+ while (CurTok.Tok != TOK_RPAREN) {
unsigned CFlags;
unsigned Flags;
- /* Add a hint for the optimizer */
- AddCodeHint ("param:start");
-
/* Count arguments */
++ParamCount;
ParamSize += ArgSize;
}
- /* Add an optimizer hint */
- AddCodeHint ("param:end");
-
/* Check for end of argument list */
- if (curtok != TOK_COMMA) {
+ if (CurTok.Tok != TOK_COMMA) {
break;
}
NextToken ();
ConsumeLParen ();
/* String literal */
- if (curtok != TOK_SCONST) {
+ if (CurTok.Tok != TOK_SCONST) {
Error ("String literal expected");
} else {
/* The string literal may consist of more than one line of assembler
* code. Separate the single lines and output the code.
*/
- const char* S = GetLiteral (curval);
+ const char* S = GetLiteral (CurTok.IVal);
while (*S) {
/* Allow lines up to 256 bytes */
* will fail if the next token is also a string token, but that's a
* syntax error anyway, because we expect a right paren.
*/
- ResetLiteralPoolOffs (curval);
+ ResetLiteralPoolOffs (CurTok.IVal);
}
/* Skip the string token */
lval->e_test = 0;
/* Character and integer constants. */
- if (curtok == TOK_ICONST || curtok == TOK_CCONST) {
+ if (CurTok.Tok == TOK_ICONST || CurTok.Tok == TOK_CCONST) {
lval->e_flags = E_MCONST | E_TCONST;
- lval->e_tptr = curtype;
- lval->e_const = curval;
+ lval->e_tptr = CurTok.Type;
+ lval->e_const = CurTok.IVal;
NextToken ();
return 0;
}
/* Process parenthesized subexpression by calling the whole parser
* recursively.
*/
- if (curtok == TOK_LPAREN) {
+ if (CurTok.Tok == TOK_LPAREN) {
NextToken ();
memset (lval, 0, sizeof (*lval)); /* Remove any attributes */
k = hie0 (lval);
}
/* Identifier? */
- if (curtok == TOK_IDENT) {
+ if (CurTok.Tok == TOK_IDENT) {
SymEntry* Sym;
ident Ident;
NextToken ();
/* IDENT is either an auto-declared function or an undefined variable. */
- if (curtok == TOK_LPAREN) {
+ if (CurTok.Tok == TOK_LPAREN) {
/* Declare a function returning int. For that purpose, prepare a
* function signature for a function having an empty param list
* and returning int.
}
/* String literal? */
- if (curtok == TOK_SCONST) {
+ if (CurTok.Tok == TOK_SCONST) {
lval->e_flags = E_MCONST | E_TLIT;
- lval->e_const = curval;
- lval->e_tptr = GetCharArrayType (strlen (GetLiteral (curval)));
+ lval->e_const = CurTok.IVal;
+ lval->e_tptr = GetCharArrayType (strlen (GetLiteral (CurTok.IVal)));
NextToken ();
return 0;
}
/* ASM statement? */
- if (curtok == TOK_ASM) {
+ if (CurTok.Tok == TOK_ASM) {
doasm ();
lval->e_tptr = type_void;
lval->e_flags = E_MEXPR;
}
/* __AX__ and __EAX__ pseudo values? */
- if (curtok == TOK_AX || curtok == TOK_EAX) {
- lval->e_tptr = (curtok == TOK_AX)? type_uint : type_ulong;
+ if (CurTok.Tok == TOK_AX || CurTok.Tok == TOK_EAX) {
+ lval->e_tptr = (CurTok.Tok == TOK_AX)? type_uint : type_ulong;
lval->e_flags = E_MREG;
lval->e_test &= ~E_CC;
lval->e_const = 0;
/* Skip the token and check for an identifier */
NextToken ();
- if (curtok != TOK_IDENT) {
+ if (CurTok.Tok != TOK_IDENT) {
Error ("Identifier expected");
lval->e_tptr = type_int;
return 0;
k = primary (lval);
- if (curtok < TOK_LBRACK || curtok > TOK_PTR_REF) {
+ if (CurTok.Tok < TOK_LBRACK || CurTok.Tok > TOK_PTR_REF) {
/* Not for us */
return k;
}
while (1) {
- if (curtok == TOK_LBRACK) {
+ if (CurTok.Tok == TOK_LBRACK) {
/* Array reference */
k = arrayref (k, lval);
- } else if (curtok == TOK_LPAREN) {
+ } else if (CurTok.Tok == TOK_LPAREN) {
/* Function call. Skip the opening parenthesis */
NextToken ();
}
k = 0;
- } else if (curtok == TOK_DOT) {
+ } else if (CurTok.Tok == TOK_DOT) {
if (!IsClassStruct (lval->e_tptr)) {
Error ("Struct expected");
}
k = structref (0, lval);
- } else if (curtok == TOK_PTR_REF) {
+ } else if (CurTok.Tok == TOK_PTR_REF) {
tptr = lval->e_tptr;
if (tptr[0] != T_PTR || (tptr[1] & T_STRUCT) == 0) {
NextToken ();
k = hie10 (lval);
- if (k == 0 && lval->e_flags & E_MCONST) {
+ if (k == 0 && (lval->e_flags & E_MCONST) != 0) {
/* Value is constant */
switch (tok) {
- case TOK_MINUS: lval->e_const = -lval->e_const; break;
+ case TOK_MINUS: lval->e_const = -lval->e_const; break;
case TOK_PLUS: break;
case TOK_COMP: lval->e_const = ~lval->e_const; break;
default: Internal ("Unexpected token: %d", tok);
int k;
type* t;
- switch (curtok) {
+ switch (CurTok.Tok) {
case TOK_INC:
pre_incdec (lval, g_inc);
case TOK_PLUS:
case TOK_MINUS:
case TOK_COMP:
- unaryop (curtok, lval);
+ unaryop (CurTok.Tok, lval);
return 0;
case TOK_BOOL_NOT:
}
k = hie11 (lval);
- switch (curtok) {
+ switch (CurTok.Tok) {
case TOK_INC:
post_incdec (lval, k, g_inc);
return 0;
k = hienext (lval);
*UsedGen = 0;
- while ((Gen = FindGen (curtok, ops)) != 0) {
+ while ((Gen = FindGen (CurTok.Tok, ops)) != 0) {
/* Tell the caller that we handled it's ops */
*UsedGen = 1;
}
/* Remember the operator token, then skip it */
- tok = curtok;
+ tok = CurTok.Tok;
NextToken ();
/* Get the lhs on stack */
k = hienext (lval);
- while ((Gen = FindGen (curtok, ops)) != 0) {
+ while ((Gen = FindGen (CurTok.Tok, ops)) != 0) {
/* Remember the operator token, then skip it */
- tok = curtok;
+ tok = CurTok.Tok;
NextToken ();
/* Get the lhs on stack */
flags = 0;
/* Check for constness on both sides */
- if (k == 0 && lval->e_flags == E_MCONST) {
+ if (k == 0 && (lval->e_flags & E_MCONST) != 0) {
/* The left hand side is a constant. Good. Get rhs */
if (evalexpr (CF_NONE, hie9, &lval2) == 0) {
}
/* Result is constant, condition codes not set */
- lval->e_test = E_MCONST;
+ lval->e_test &= ~E_CC;
} else {
rhst = lval2.e_tptr;
/* Check left hand side */
- if (k == 0 && lval->e_flags & E_MCONST) {
+ if (k == 0 && (lval->e_flags & E_MCONST) != 0) {
/* Both sides are constant, remove generated code */
RemoveCode (Mark1);
}
/* Result is constant, condition codes not set */
- lval->e_flags = E_MCONST;
+ /* lval->e_flags = E_MCONST; ### */
lval->e_test &= ~E_CC;
} else {
/* Process + and - binary operators. */
{
int k = hie9 (lval);
- while (curtok == TOK_PLUS || curtok == TOK_MINUS) {
+ while (CurTok.Tok == TOK_PLUS || CurTok.Tok == TOK_MINUS) {
- if (curtok == TOK_PLUS) {
+ if (CurTok.Tok == TOK_PLUS) {
parseadd (k, lval);
} else {
parsesub (k, lval);
struct expent lval2;
k = hie2 (lval);
- if (curtok == TOK_BOOL_AND) {
+ if (CurTok.Tok == TOK_BOOL_AND) {
/* Tell our caller that we're evaluating a boolean */
*BoolOp = 1;
g_falsejump (CF_NONE, lab);
/* Parse more boolean and's */
- while (curtok == TOK_BOOL_AND) {
+ while (CurTok.Tok == TOK_BOOL_AND) {
/* Skip the && */
NextToken ();
exprhs (CF_FORCECHAR, k, &lval2);
/* Do short circuit evaluation */
- if (curtok == TOK_BOOL_AND) {
+ if (CurTok.Tok == TOK_BOOL_AND) {
g_falsejump (CF_NONE, lab);
} else {
/* Last expression - will evaluate to true */
k = hieAnd (lval, TrueLab, &BoolOp);
/* Any boolean or's? */
- if (curtok == TOK_BOOL_OR) {
+ if (CurTok.Tok == TOK_BOOL_OR) {
/* If the expr hasn't set condition codes, set the force-test flag */
if ((lval->e_test & E_CC) == 0) {
BoolOp = 1;
/* while there's more expr */
- while (curtok == TOK_BOOL_OR) {
+ while (CurTok.Tok == TOK_BOOL_OR) {
/* skip the || */
NextToken ();
*/
#if 0
/* Seems this sometimes generates wrong code */
- if (curtok == TOK_BOOL_OR && !AndOp) {
+ if (CurTok.Tok == TOK_BOOL_OR && !AndOp) {
g_truejump (CF_NONE, TrueLab);
}
#else
k = hieOr (lval);
- if (curtok == TOK_QUEST) {
+ if (CurTok.Tok == TOK_QUEST) {
NextToken ();
if ((lval->e_test & E_CC) == 0) {
/* Condition codes not set, force a test */
/* cc65 does not have full support for handling structs by value. Since
* assigning structs is one of the more useful operations from this
- * familiy, allow it here.
+ * family, allow it here.
*/
if (IsClassStruct (ltype)) {
int k;
k = hieQuest (lval);
- switch (curtok) {
+ switch (CurTok.Tok) {
case TOK_RPAREN:
case TOK_SEMI:
int k;
k = hie1 (lval);
- while (curtok == TOK_COMMA) {
+ while (CurTok.Tok == TOK_COMMA) {
NextToken ();
k = hie1 (lval);
}
/* Load the value into the primary register */
exprhs (CF_FORCECHAR, k, &lval);
- /* Check for the closing brace */
- ConsumeRParen ();
-
/* Generate the jump */
if (cond) {
g_truejump (CF_NONE, label);
* compiler itself is one big hack...): If a semicolon follows, we
* don't have a statement and may omit the jump.
*/
- if (curtok != TOK_SEMI) {
+ if (CurTok.Tok != TOK_SEMI) {
g_falsejump (CF_NONE, label);
}
}
+
+ /* Check for the closing brace */
+ ConsumeRParen ();
}
projects / cc65 / blobdiff