-void exprhs (unsigned flags, int k, ExprDesc* lval)
+void exprhs (unsigned Flags, int k, ExprDesc* Expr)
/* Put the result of an expression into the primary register */
{
int f;
- f = lval->Flags;
+ f = Expr->Flags;
if (k) {
/* Dereferenced lvalue */
- flags |= TypeOf (lval->Type);
- if (lval->Test & E_FORCETEST) {
- flags |= CF_TEST;
- lval->Test &= ~E_FORCETEST;
+ Flags |= TypeOf (Expr->Type);
+ if (Expr->Test & E_FORCETEST) {
+ Flags |= CF_TEST;
+ Expr->Test &= ~E_FORCETEST;
}
- if (f & E_MGLOBAL) { /* ref to globalvar */
- /* Generate code */
- flags |= GlobalModeFlags (f);
- g_getstatic (flags, lval->Name, lval->ConstVal);
+ if (f & E_MGLOBAL) {
+ /* Reference to a global variable */
+ Flags |= GlobalModeFlags (f);
+ g_getstatic (Flags, Expr->Name, Expr->ConstVal);
} else if (f & E_MLOCAL) {
- /* ref to localvar */
- g_getlocal (flags, lval->ConstVal);
+ /* Reference to a local variable */
+ g_getlocal (Flags, Expr->ConstVal);
} else if (f & E_MCONST) {
- /* ref to absolute address */
- g_getstatic (flags | CF_ABSOLUTE, lval->ConstVal, 0);
+ /* Reference to an absolute address */
+ g_getstatic (Flags | CF_ABSOLUTE, Expr->ConstVal, 0);
} else if (f == E_MEOFFS) {
- g_getind (flags, lval->ConstVal);
+ /* Reference to address in primary with offset in Expr */
+ g_getind (Flags, Expr->ConstVal);
} else if (f != E_MREG) {
- g_getind (flags, 0);
+ /* Reference with address in primary */
+ g_getind (Flags, 0);
+ }
+ } else {
+ /* An rvalue */
+ if (f == E_MEOFFS) {
+ /* reference not storable */
+ Flags |= TypeOf (Expr->Type);
+ g_inc (Flags | CF_CONST, Expr->ConstVal);
+ } else if ((f & E_MEXPR) == 0) {
+ /* Constant of some sort, load it into the primary */
+ LoadConstant (Flags, Expr);
}
- } else if (f == E_MEOFFS) {
- /* reference not storable */
- flags |= TypeOf (lval->Type);
- g_inc (flags | CF_CONST, lval->ConstVal);
- } else if ((f & E_MEXPR) == 0) {
- /* Constant of some sort, load it into the primary */
- LoadConstant (flags, lval);
}
+
/* Are we testing this value? */
- if (lval->Test & E_FORCETEST) {
+ if (Expr->Test & E_FORCETEST) {
/* Yes, force a test */
- flags |= TypeOf (lval->Type);
- g_test (flags);
- lval->Test &= ~E_FORCETEST;
+ Flags |= TypeOf (Expr->Type);
+ g_test (Flags);
+ Expr->Test &= ~E_FORCETEST;
}
}
/* We have the space already allocated, store in the frame.
* Because of invalid type conversions (that have produced an
* error before), we can end up here with a non aligned stack
- * frame. Since no output will be generated anyway, handle
+ * frame. Since no output will be generated anyway, handle
* these cases gracefully instead of doing a CHECK.
*/
if (FrameSize >= ArgSize) {
-static int hieQuest (ExprDesc *lval)
-/* Parse "lvalue ? exp : exp" */
+static int hieQuest (ExprDesc* lval)
+/* Parse the ternary operator */
{
- int k;
- int labf;
- int labt;
- ExprDesc lval2; /* Expression 2 */
- ExprDesc lval3; /* Expression 3 */
- type* type2; /* Type of expression 2 */
- type* type3; /* Type of expression 3 */
- type* rtype; /* Type of result */
+ int k1, k2, k3;
+ int labf;
+ int labt;
+ ExprDesc Expr2; /* Expression 2 */
+ ExprDesc Expr3; /* Expression 3 */
+ int Expr2IsNULL; /* Expression 2 is a NULL pointer */
+ int Expr3IsNULL; /* Expression 3 is a NULL pointer */
+ type* ResultType; /* Type of result */
- k = Preprocessing? hieOrPP (lval) : hieOr (lval);
+ k1 = Preprocessing? hieOrPP (lval) : hieOr (lval);
if (CurTok.Tok == TOK_QUEST) {
NextToken ();
if ((lval->Test & E_CC) == 0) {
/* Condition codes not set, force a test */
lval->Test |= E_FORCETEST;
}
- exprhs (CF_NONE, k, lval);
+ exprhs (CF_NONE, k1, lval);
labf = GetLocalLabel ();
g_falsejump (CF_NONE, labf);
- /* Parse second expression */
- k = expr (hie1, &lval2);
- type2 = lval2.Type;
- if (!IsTypeVoid (lval2.Type)) {
+ /* Parse second expression. Remember for later if it is a NULL pointer
+ * expression, then load it into the primary.
+ */
+ k2 = expr (hie1, &Expr2);
+ Expr2IsNULL = IsNullPtr (&Expr2);
+ if (!IsTypeVoid (Expr2.Type)) {
/* Load it into the primary */
- exprhs (CF_NONE, k, &lval2);
+ exprhs (CF_NONE, k2, &Expr2);
+ Expr2.Flags = E_MEXPR;
+ k2 = 0;
}
labt = GetLocalLabel ();
ConsumeColon ();
g_jump (labt);
- /* Parse the third expression */
+ /* Jump here if the first expression was false */
g_defcodelabel (labf);
- k = expr (hie1, &lval3);
- type3 = lval3.Type;
- if (!IsTypeVoid (lval3.Type)) {
+
+ /* Parse second expression. Remember for later if it is a NULL pointer
+ * expression, then load it into the primary.
+ */
+ k3 = expr (hie1, &Expr3);
+ Expr3IsNULL = IsNullPtr (&Expr3);
+ if (!IsTypeVoid (Expr3.Type)) {
/* Load it into the primary */
- exprhs (CF_NONE, k, &lval3);
+ exprhs (CF_NONE, k3, &Expr3);
+ Expr3.Flags = E_MEXPR;
+ k3 = 0;
}
/* Check if any conversions are needed, if so, do them.
* type void.
* - all other cases are flagged by an error.
*/
- if (IsClassInt (type2) && IsClassInt (type3)) {
+ if (IsClassInt (Expr2.Type) && IsClassInt (Expr3.Type)) {
/* Get common type */
- rtype = promoteint (type2, type3);
+ ResultType = promoteint (Expr2.Type, Expr3.Type);
/* Convert the third expression to this type if needed */
- g_typecast (TypeOf (rtype), TypeOf (type3));
+ TypeConversion (&Expr3, k3, ResultType);
/* Setup a new label so that the expr3 code will jump around
* the type cast code for expr2.
*/
labf = GetLocalLabel (); /* Get new label */
- g_jump (labf); /* Jump around code */
+ g_jump (labf); /* Jump around code */
/* The jump for expr2 goes here */
g_defcodelabel (labt);
/* Create the typecast code for expr2 */
- g_typecast (TypeOf (rtype), TypeOf (type2));
+ TypeConversion (&Expr2, k2, ResultType);
/* Jump here around the typecase code. */
g_defcodelabel (labf);
- labt = 0; /* Mark other label as invalid */
+ labt = 0; /* Mark other label as invalid */
- } else if (IsClassPtr (type2) && IsClassPtr (type3)) {
+ } else if (IsClassPtr (Expr2.Type) && IsClassPtr (Expr3.Type)) {
/* Must point to same type */
- if (TypeCmp (Indirect (type2), Indirect (type3)) < TC_EQUAL) {
- Error ("Incompatible pointer types");
+ if (TypeCmp (Indirect (Expr2.Type), Indirect (Expr3.Type)) < TC_EQUAL) {
+ Error ("Incompatible pointer types");
}
/* Result has the common type */
- rtype = lval2.Type;
- } else if (IsClassPtr (type2) && IsNullPtr (&lval3)) {
+ ResultType = Expr2.Type;
+ } else if (IsClassPtr (Expr2.Type) && Expr3IsNULL) {
/* Result type is pointer, no cast needed */
- rtype = lval2.Type;
- } else if (IsNullPtr (&lval2) && IsClassPtr (type3)) {
+ ResultType = Expr2.Type;
+ } else if (Expr2IsNULL && IsClassPtr (Expr3.Type)) {
/* Result type is pointer, no cast needed */
- rtype = lval3.Type;
- } else if (IsTypeVoid (type2) && IsTypeVoid (type3)) {
+ ResultType = Expr3.Type;
+ } else if (IsTypeVoid (Expr2.Type) && IsTypeVoid (Expr3.Type)) {
/* Result type is void */
- rtype = lval3.Type;
- } else {
- Error ("Incompatible types");
- rtype = lval2.Type; /* Doesn't matter here */
- }
+ ResultType = Expr3.Type;
+ } else {
+ Error ("Incompatible types");
+ ResultType = Expr2.Type; /* Doesn't matter here */
+ }
- /* If we don't have the label defined until now, do it */
- if (labt) {
- g_defcodelabel (labt);
- }
+ /* If we don't have the label defined until now, do it */
+ if (labt) {
+ g_defcodelabel (labt);
+ }
- /* Setup the target expression */
+ /* Setup the target expression */
lval->Flags = E_MEXPR;
- lval->Type = rtype;
- k = 0;
+ lval->Type = ResultType;
+ k1 = 0;
}
- return k;
+ return k1;
}
ExprDesc lval2;
unsigned lflags;
unsigned rflags;
- int MustScale;
+ int MustScale;
/* We must have an lvalue */
rflags = 0;
/* Evaluate the rhs */
- if (evalexpr (CF_NONE, hie1, &lval2) == 0) {
+ k = hie1 (&lval2);
+ if (k == 0 && lval2.Flags == E_MCONST) {
/* The resulting value is a constant. */
if (MustScale) {
/* lhs is a pointer, scale rhs */
lval2.ConstVal *= CheckedSizeOf (lval->Type+1);
}
rflags |= CF_CONST;
- lflags |= CF_CONST;
+ lflags |= CF_CONST;
} else {
- /* rhs is not constant and already in the primary register */
+ /* Not constant, load into the primary */
+ exprhs (CF_NONE, k, &lval2);
if (MustScale) {
/* lhs is a pointer, scale rhs */
g_scale (TypeOf (lval2.Type), CheckedSizeOf (lval->Type+1));
lflags |= TypeOf (lval->Type) | CF_FORCECHAR;
rflags |= TypeOf (lval2.Type);
- /* Cast the rhs to the type of the lhs */
+ /* Convert the type of the lhs to that of the rhs */
g_typecast (lflags, rflags);
/* Output apropriate code */
projects / cc65 / blobdiff