From 9fc71c5e93f7e8270dd6f8fc3810b7b731bf1259 Mon Sep 17 00:00:00 2001 From: cuz Date: Sun, 6 Jun 2004 14:48:59 +0000 Subject: [PATCH] Renamed ExprDesc.Val to ExprDesc.IVal. Added an FVal field for a floating point constant. git-svn-id: svn://svn.cc65.org/cc65/trunk@3107 b7a2c559-68d2-44c3-8de9-860c34a00d81 --- src/cc65/asmstmt.c | 24 +++--- src/cc65/declare.c | 28 +++--- src/cc65/expr.c | 204 ++++++++++++++++++++++---------------------- src/cc65/exprdesc.c | 24 ++++-- src/cc65/exprdesc.h | 5 +- src/cc65/locals.c | 2 +- src/cc65/preproc.c | 8 +- src/cc65/stdfunc.c | 108 +++++++++++------------ src/cc65/swstmt.c | 2 +- src/cc65/testexpr.c | 6 +- src/cc65/typeconv.c | 8 +- 11 files changed, 213 insertions(+), 206 deletions(-) diff --git a/src/cc65/asmstmt.c b/src/cc65/asmstmt.c index 774d5ffa4..30176add9 100644 --- a/src/cc65/asmstmt.c +++ b/src/cc65/asmstmt.c @@ -137,19 +137,19 @@ static void ParseByteArg (StrBuf* T, unsigned Arg) /* Check the range but allow negative values if the type is signed */ if (IsSignUnsigned (Expr.Type)) { - if (Expr.Val < 0 || Expr.Val > 0xFF) { + if (Expr.IVal < 0 || Expr.IVal > 0xFF) { AsmRangeError (Arg); - Expr.Val = 0; + Expr.IVal = 0; } } else { - if (Expr.Val < -128 || Expr.Val > 127) { + if (Expr.IVal < -128 || Expr.IVal > 127) { AsmRangeError (Arg); - Expr.Val = 0; + Expr.IVal = 0; } } /* Convert into a hex number */ - xsprintf (Buf, sizeof (Buf), "$%02lX", Expr.Val & 0xFF); + xsprintf (Buf, sizeof (Buf), "$%02lX", Expr.IVal & 0xFF); /* Add the number to the target buffer */ SB_AppendStr (T, Buf); @@ -171,19 +171,19 @@ static void ParseWordArg (StrBuf* T, unsigned Arg) /* Check the range but allow negative values if the type is signed */ if (IsSignUnsigned (Expr.Type)) { - if (Expr.Val < 0 || Expr.Val > 0xFFFF) { + if (Expr.IVal < 0 || Expr.IVal > 0xFFFF) { AsmRangeError (Arg); - Expr.Val = 0; + Expr.IVal = 0; } } else { - if (Expr.Val < -32768 || Expr.Val > 32767) { + if (Expr.IVal < -32768 || Expr.IVal > 32767) { AsmRangeError (Arg); - Expr.Val = 0; + Expr.IVal = 0; } } /* Convert into a hex number */ - xsprintf (Buf, sizeof (Buf), "$%04lX", Expr.Val & 0xFFFF); + xsprintf (Buf, sizeof (Buf), "$%04lX", Expr.IVal & 0xFFFF); /* Add the number to the target buffer */ SB_AppendStr (T, Buf); @@ -204,7 +204,7 @@ static void ParseLongArg (StrBuf* T, unsigned Arg attribute ((unused))) ConstAbsIntExpr (hie1, &Expr); /* Convert into a hex number */ - xsprintf (Buf, sizeof (Buf), "$%08lX", Expr.Val & 0xFFFFFFFF); + xsprintf (Buf, sizeof (Buf), "$%08lX", Expr.IVal & 0xFFFFFFFF); /* Add the number to the target buffer */ SB_AppendStr (T, Buf); @@ -302,7 +302,7 @@ static void ParseStrArg (StrBuf* T, unsigned Arg attribute ((unused))) default: ConstAbsIntExpr (hie1, &Expr); - xsprintf (Buf, sizeof (Buf), "%ld", Expr.Val); + xsprintf (Buf, sizeof (Buf), "%ld", Expr.IVal); SB_AppendStr (T, Buf); break; } diff --git a/src/cc65/declare.c b/src/cc65/declare.c index b22d7b04f..c536e4c7e 100644 --- a/src/cc65/declare.c +++ b/src/cc65/declare.c @@ -191,7 +191,7 @@ static void AddEncodeToDeclaration (Declaration* D, type T, unsigned long Val) D->Index += DECODE_SIZE; } - + static void ParseStorageClass (DeclSpec* D, unsigned DefStorage) /* Parse a storage class */ @@ -267,10 +267,10 @@ static void ParseEnumDecl (void) /* Check for an assigned value */ if (CurTok.Tok == TOK_ASSIGN) { - ExprDesc lval; + ExprDesc Expr; NextToken (); - ConstAbsIntExpr (hie1, &lval); - EnumVal = lval.Val; + ConstAbsIntExpr (hie1, &Expr); + EnumVal = Expr.IVal; } /* Add an entry to the symbol table */ @@ -281,7 +281,7 @@ static void ParseEnumDecl (void) break; NextToken (); } - ConsumeRCurly (); + ConsumeRCurly (); } @@ -1045,17 +1045,17 @@ static void Decl (const DeclSpec* Spec, Declaration* D, unsigned Mode) NextToken (); /* Read the size if it is given */ if (CurTok.Tok != TOK_RBRACK) { - ExprDesc lval; - ConstAbsIntExpr (hie1, &lval); - if (lval.Val <= 0) { + ExprDesc Expr; + ConstAbsIntExpr (hie1, &Expr); + if (Expr.IVal <= 0) { if (D->Ident[0] != '\0') { Error ("Size of array `%s' is invalid", D->Ident); } else { Error ("Size of array is invalid"); } - lval.Val = 1; + Expr.IVal = 1; } - Size = lval.Val; + Size = Expr.IVal; } ConsumeRBrack (); @@ -1431,7 +1431,7 @@ static unsigned ParseVoidInit (void) case T_UCHAR: if (ED_IsConstAbsInt (&Expr)) { /* Make it byte sized */ - Expr.Val &= 0xFF; + Expr.IVal &= 0xFF; } DefineData (&Expr); Size += SIZEOF_CHAR; @@ -1445,7 +1445,7 @@ static unsigned ParseVoidInit (void) case T_ARRAY: if (ED_IsConstAbsInt (&Expr)) { /* Make it word sized */ - Expr.Val &= 0xFFFF; + Expr.IVal &= 0xFFFF; } DefineData (&Expr); Size += SIZEOF_INT; @@ -1455,7 +1455,7 @@ static unsigned ParseVoidInit (void) case T_ULONG: if (ED_IsConstAbsInt (&Expr)) { /* Make it dword sized */ - Expr.Val &= 0xFFFFFFFF; + Expr.IVal &= 0xFFFFFFFF; } DefineData (&Expr); Size += SIZEOF_LONG; @@ -1527,7 +1527,7 @@ static unsigned ParseInitInternal (type* T, int AllowFlexibleMembers) unsigned ParseInit (type* T) /* Parse initialization of variables. Return the number of data bytes. */ { - /* Parse the initialization */ + /* Parse the initialization */ unsigned Size = ParseInitInternal (T, !ANSI); /* The initialization may not generate code on global level, because code diff --git a/src/cc65/expr.c b/src/cc65/expr.c index c6fb1092a..7a3aacde0 100644 --- a/src/cc65/expr.c +++ b/src/cc65/expr.c @@ -195,18 +195,18 @@ void DefineData (ExprDesc* Expr) case E_LOC_ABS: /* Absolute: numeric address or const */ - g_defdata (TypeOf (Expr->Type) | CF_CONST, Expr->Val, 0); + g_defdata (TypeOf (Expr->Type) | CF_CONST, Expr->IVal, 0); break; case E_LOC_GLOBAL: /* Global variable */ - g_defdata (CF_EXTERNAL, Expr->Name, Expr->Val); + g_defdata (CF_EXTERNAL, Expr->Name, Expr->IVal); break; case E_LOC_STATIC: case E_LOC_LITERAL: /* Static variable or literal in the literal pool */ - g_defdata (CF_STATIC, Expr->Name, Expr->Val); + g_defdata (CF_STATIC, Expr->Name, Expr->IVal); break; case E_LOC_REGISTER: @@ -216,7 +216,7 @@ void DefineData (ExprDesc* Expr) if (IS_Get (&AllowRegVarAddr) == 0) { Error ("Cannot take the address of a register variable"); } - g_defdata (CF_REGVAR, Expr->Name, Expr->Val); + g_defdata (CF_REGVAR, Expr->Name, Expr->IVal); break; default: @@ -233,18 +233,18 @@ static void LoadConstant (unsigned Flags, ExprDesc* Expr) case E_LOC_ABS: /* Number constant */ - g_getimmed (Flags | TypeOf (Expr->Type) | CF_CONST, Expr->Val, 0); + g_getimmed (Flags | TypeOf (Expr->Type) | CF_CONST, Expr->IVal, 0); break; case E_LOC_GLOBAL: /* Global symbol, load address */ - g_getimmed ((Flags | CF_EXTERNAL) & ~CF_CONST, Expr->Name, Expr->Val); + g_getimmed ((Flags | CF_EXTERNAL) & ~CF_CONST, Expr->Name, Expr->IVal); break; case E_LOC_STATIC: case E_LOC_LITERAL: /* Static symbol or literal, load address */ - g_getimmed ((Flags | CF_STATIC) & ~CF_CONST, Expr->Name, Expr->Val); + g_getimmed ((Flags | CF_STATIC) & ~CF_CONST, Expr->Name, Expr->IVal); break; case E_LOC_REGISTER: @@ -254,10 +254,10 @@ static void LoadConstant (unsigned Flags, ExprDesc* Expr) if (IS_Get (&AllowRegVarAddr) == 0) { Error ("Cannot take the address of a register variable"); } - g_getimmed ((Flags | CF_REGVAR) & ~CF_CONST, Expr->Name, Expr->Val); + g_getimmed ((Flags | CF_REGVAR) & ~CF_CONST, Expr->Name, Expr->IVal); case E_LOC_STACK: - g_leasp (Expr->Val); + g_leasp (Expr->IVal); break; default: @@ -392,28 +392,28 @@ void ExprLoad (unsigned Flags, ExprDesc* Expr) case E_LOC_ABS: /* Absolute: numeric address or const */ - g_getstatic (Flags | CF_ABSOLUTE, Expr->Val, 0); + g_getstatic (Flags | CF_ABSOLUTE, Expr->IVal, 0); break; case E_LOC_GLOBAL: /* Global variable */ - g_getstatic (Flags | CF_EXTERNAL, Expr->Name, Expr->Val); + g_getstatic (Flags | CF_EXTERNAL, Expr->Name, Expr->IVal); break; case E_LOC_STATIC: case E_LOC_LITERAL: /* Static variable or literal in the literal pool */ - g_getstatic (Flags | CF_STATIC, Expr->Name, Expr->Val); + g_getstatic (Flags | CF_STATIC, Expr->Name, Expr->IVal); break; case E_LOC_REGISTER: /* Register variable */ - g_getstatic (Flags | CF_REGVAR, Expr->Name, Expr->Val); + g_getstatic (Flags | CF_REGVAR, Expr->Name, Expr->IVal); break; case E_LOC_STACK: /* Value on the stack */ - g_getlocal (Flags, Expr->Val); + g_getlocal (Flags, Expr->IVal); break; case E_LOC_PRIMARY: @@ -425,7 +425,7 @@ void ExprLoad (unsigned Flags, ExprDesc* Expr) case E_LOC_EXPR: /* Reference to address in primary with offset in Expr */ - g_getind (Flags, Expr->Val); + g_getind (Flags, Expr->IVal); break; default: @@ -438,12 +438,12 @@ void ExprLoad (unsigned Flags, ExprDesc* Expr) } else { /* An rvalue */ if (ED_IsLocExpr (Expr)) { - if (Expr->Val != 0) { + if (Expr->IVal != 0) { /* We have an expression in the primary plus a constant * offset. Adjust the value in the primary accordingly. */ Flags |= TypeOf (Expr->Type); - g_inc (Flags | CF_CONST, Expr->Val); + g_inc (Flags | CF_CONST, Expr->IVal); } } else { /* Constant of some sort, load it into the primary */ @@ -593,10 +593,10 @@ static unsigned FunctionParamList (FuncDesc* Func) } FrameOffs -= ArgSize; /* Store */ - g_putlocal (Flags | CF_NOKEEP, FrameOffs, Expr.Val); + g_putlocal (Flags | CF_NOKEEP, FrameOffs, Expr.IVal); } else { /* Push the argument */ - g_push (Flags, Expr.Val); + g_push (Flags, Expr.IVal); } /* Calculate total parameter size */ @@ -768,7 +768,7 @@ static void Primary (ExprDesc* E) if (CurTok.Tok == TOK_ICONST || CurTok.Tok == TOK_CCONST) { E->Flags = E_LOC_ABS | E_RTYPE_RVAL; E->Type = CurTok.Type; - E->Val = CurTok.IVal; + E->IVal = CurTok.IVal; NextToken (); return; } @@ -834,7 +834,7 @@ static void Primary (ExprDesc* E) if ((Sym->Flags & SC_CONST) == SC_CONST) { /* Enum or some other numeric constant */ E->Flags = E_LOC_ABS | E_RTYPE_RVAL; - E->Val = Sym->V.ConstVal; + E->IVal = Sym->V.ConstVal; } else if ((Sym->Flags & SC_FUNC) == SC_FUNC) { /* Function */ E->Flags = E_LOC_GLOBAL | E_RTYPE_LVAL; @@ -851,7 +851,7 @@ static void Primary (ExprDesc* E) } else { /* Normal parameter */ E->Flags = E_LOC_STACK | E_RTYPE_LVAL; - E->Val = Sym->V.Offs; + E->IVal = Sym->V.Offs; } } else if ((Sym->Flags & SC_REGISTER) == SC_REGISTER) { /* Register variable, zero page based */ @@ -915,7 +915,7 @@ static void Primary (ExprDesc* E) /* String literal */ E->Type = GetCharArrayType (GetLiteralPoolOffs () - CurTok.IVal); E->Flags = E_LOC_LITERAL | E_RTYPE_RVAL; - E->Val = CurTok.IVal; + E->IVal = CurTok.IVal; E->Name = LiteralPoolLabel; NextToken (); break; @@ -1052,7 +1052,7 @@ static void ArrayRef (ExprDesc* Expr) /* Lhs is pointer/array. Scale the subscript value according to * the element size. */ - SubScript.Val *= CheckedSizeOf (ElementType); + SubScript.IVal *= CheckedSizeOf (ElementType); /* Remove the address load code */ RemoveCode (Mark1); @@ -1064,7 +1064,7 @@ static void ArrayRef (ExprDesc* Expr) if (IsTypeArray (Expr->Type)) { /* Adjust the offset */ - Expr->Val += SubScript.Val; + Expr->IVal += SubScript.IVal; } else { @@ -1077,7 +1077,7 @@ static void ArrayRef (ExprDesc* Expr) } /* Use the offset */ - Expr->Val = SubScript.Val; + Expr->IVal = SubScript.IVal; } } else { @@ -1089,7 +1089,7 @@ static void ArrayRef (ExprDesc* Expr) * we will ignore the true type of the subscript here and * use always an int. #### Use offset but beware of ExprLoad! */ - g_inc (CF_INT | CF_CONST, SubScript.Val); + g_inc (CF_INT | CF_CONST, SubScript.IVal); } @@ -1170,29 +1170,29 @@ static void ArrayRef (ExprDesc* Expr) /* Add the variable */ if (ED_IsLocStack (&SubScript)) { - g_addlocal (Flags, SubScript.Val); + g_addlocal (Flags, SubScript.IVal); } else { Flags |= GlobalModeFlags (SubScript.Flags); - g_addstatic (Flags, SubScript.Name, SubScript.Val); + g_addstatic (Flags, SubScript.Name, SubScript.IVal); } } else { if (ED_IsLocAbs (Expr)) { /* Constant numeric address. Just add it */ - g_inc (CF_INT, Expr->Val); + g_inc (CF_INT, Expr->IVal); } else if (ED_IsLocStack (Expr)) { /* Base address is a local variable address */ if (IsTypeArray (Expr->Type)) { - g_addaddr_local (CF_INT, Expr->Val); + g_addaddr_local (CF_INT, Expr->IVal); } else { - g_addlocal (CF_PTR, Expr->Val); + g_addlocal (CF_PTR, Expr->IVal); } } else { /* Base address is a static variable address */ unsigned Flags = CF_INT | GlobalModeFlags (Expr->Flags); if (IsTypeArray (Expr->Type)) { - g_addaddr_static (Flags, Expr->Name, Expr->Val); + g_addaddr_static (Flags, Expr->Name, Expr->IVal); } else { - g_addstatic (Flags, Expr->Name, Expr->Val); + g_addstatic (Flags, Expr->Name, Expr->IVal); } } } @@ -1262,7 +1262,7 @@ static void StructRef (ExprDesc* Expr) } /* Set the struct field offset */ - Expr->Val += Field->V.Offs; + Expr->IVal += Field->V.Offs; /* The type is now the type of the field */ Expr->Type = Field->Type; @@ -1362,28 +1362,28 @@ void Store (ExprDesc* Expr, const type* StoreType) case E_LOC_ABS: /* Absolute: numeric address or const */ - g_putstatic (Flags | CF_ABSOLUTE, Expr->Val, 0); + g_putstatic (Flags | CF_ABSOLUTE, Expr->IVal, 0); break; case E_LOC_GLOBAL: /* Global variable */ - g_putstatic (Flags | CF_EXTERNAL, Expr->Name, Expr->Val); + g_putstatic (Flags | CF_EXTERNAL, Expr->Name, Expr->IVal); break; case E_LOC_STATIC: case E_LOC_LITERAL: /* Static variable or literal in the literal pool */ - g_putstatic (Flags | CF_STATIC, Expr->Name, Expr->Val); + g_putstatic (Flags | CF_STATIC, Expr->Name, Expr->IVal); break; case E_LOC_REGISTER: /* Register variable */ - g_putstatic (Flags | CF_REGVAR, Expr->Name, Expr->Val); + g_putstatic (Flags | CF_REGVAR, Expr->Name, Expr->IVal); break; case E_LOC_STACK: /* Value on the stack */ - g_putlocal (Flags, Expr->Val, 0); + g_putlocal (Flags, Expr->IVal, 0); break; case E_LOC_PRIMARY: @@ -1393,7 +1393,7 @@ void Store (ExprDesc* Expr, const type* StoreType) case E_LOC_EXPR: /* An expression in the primary register */ - g_putind (Flags, Expr->Val); + g_putind (Flags, Expr->IVal); break; default: @@ -1433,28 +1433,28 @@ static void PreInc (ExprDesc* Expr) case E_LOC_ABS: /* Absolute: numeric address or const */ - g_addeqstatic (Flags | CF_ABSOLUTE, Expr->Val, 0, Val); + g_addeqstatic (Flags | CF_ABSOLUTE, Expr->IVal, 0, Val); break; case E_LOC_GLOBAL: /* Global variable */ - g_addeqstatic (Flags | CF_EXTERNAL, Expr->Name, Expr->Val, Val); + g_addeqstatic (Flags | CF_EXTERNAL, Expr->Name, Expr->IVal, Val); break; case E_LOC_STATIC: case E_LOC_LITERAL: /* Static variable or literal in the literal pool */ - g_addeqstatic (Flags | CF_STATIC, Expr->Name, Expr->Val, Val); + g_addeqstatic (Flags | CF_STATIC, Expr->Name, Expr->IVal, Val); break; case E_LOC_REGISTER: /* Register variable */ - g_addeqstatic (Flags | CF_REGVAR, Expr->Name, Expr->Val, Val); + g_addeqstatic (Flags | CF_REGVAR, Expr->Name, Expr->IVal, Val); break; case E_LOC_STACK: /* Value on the stack */ - g_addeqlocal (Flags, Expr->Val, Val); + g_addeqlocal (Flags, Expr->IVal, Val); break; case E_LOC_PRIMARY: @@ -1464,7 +1464,7 @@ static void PreInc (ExprDesc* Expr) case E_LOC_EXPR: /* An expression in the primary register */ - g_addeqind (Flags, Expr->Val, Val); + g_addeqind (Flags, Expr->IVal, Val); break; default: @@ -1475,7 +1475,7 @@ static void PreInc (ExprDesc* Expr) ED_MakeRValExpr (Expr); } - + static void PreDec (ExprDesc* Expr) /* Handle the predecrement operators */ @@ -1504,28 +1504,28 @@ static void PreDec (ExprDesc* Expr) case E_LOC_ABS: /* Absolute: numeric address or const */ - g_subeqstatic (Flags | CF_ABSOLUTE, Expr->Val, 0, Val); + g_subeqstatic (Flags | CF_ABSOLUTE, Expr->IVal, 0, Val); break; case E_LOC_GLOBAL: /* Global variable */ - g_subeqstatic (Flags | CF_EXTERNAL, Expr->Name, Expr->Val, Val); + g_subeqstatic (Flags | CF_EXTERNAL, Expr->Name, Expr->IVal, Val); break; case E_LOC_STATIC: case E_LOC_LITERAL: /* Static variable or literal in the literal pool */ - g_subeqstatic (Flags | CF_STATIC, Expr->Name, Expr->Val, Val); + g_subeqstatic (Flags | CF_STATIC, Expr->Name, Expr->IVal, Val); break; case E_LOC_REGISTER: /* Register variable */ - g_subeqstatic (Flags | CF_REGVAR, Expr->Name, Expr->Val, Val); + g_subeqstatic (Flags | CF_REGVAR, Expr->Name, Expr->IVal, Val); break; case E_LOC_STACK: /* Value on the stack */ - g_subeqlocal (Flags, Expr->Val, Val); + g_subeqlocal (Flags, Expr->IVal, Val); break; case E_LOC_PRIMARY: @@ -1535,7 +1535,7 @@ static void PreDec (ExprDesc* Expr) case E_LOC_EXPR: /* An expression in the primary register */ - g_subeqind (Flags, Expr->Val, Val); + g_subeqind (Flags, Expr->IVal, Val); break; default: @@ -1547,7 +1547,7 @@ static void PreDec (ExprDesc* Expr) } - + static void PostIncDec (ExprDesc* Expr, void (*inc) (unsigned, unsigned long)) /* Handle i-- and i++ */ { @@ -1612,9 +1612,9 @@ static void UnaryOp (ExprDesc* Expr) if (ED_IsConstAbs (Expr)) { /* Value is constant */ switch (Tok) { - case TOK_MINUS: Expr->Val = -Expr->Val; break; - case TOK_PLUS: break; - case TOK_COMP: Expr->Val = ~Expr->Val; break; + case TOK_MINUS: Expr->IVal = -Expr->IVal; break; + case TOK_PLUS: break; + case TOK_COMP: Expr->IVal = ~Expr->IVal; break; default: Internal ("Unexpected token: %d", Tok); } } else { @@ -1664,7 +1664,7 @@ void hie10 (ExprDesc* Expr) NextToken (); if (evalexpr (CF_NONE, hie10, Expr) == 0) { /* Constant expression */ - Expr->Val = !Expr->Val; + Expr->IVal = !Expr->IVal; } else { g_bneg (TypeOf (Expr->Type)); ED_MakeRValExpr (Expr); @@ -1797,7 +1797,7 @@ static void hie_internal (const GenDesc* Ops, /* List of generators */ if (ED_IsConstAbs (Expr)) { /* Constant value */ Mark2 = GetCodePos (); - g_push (ltype | CF_CONST, Expr->Val); + g_push (ltype | CF_CONST, Expr->IVal); } else { /* Value not constant */ ExprLoad (CF_NONE, Expr); @@ -1821,7 +1821,7 @@ static void hie_internal (const GenDesc* Ops, /* List of generators */ pop (ltype); /* Evaluate the result */ - Expr->Val = kcalc (Tok, Expr->Val, Expr2.Val); + Expr->IVal = kcalc (Tok, Expr->IVal, Expr2.IVal); /* Get the type of the result */ Expr->Type = promoteint (Expr->Type, Expr2.Type); @@ -1838,9 +1838,9 @@ static void hie_internal (const GenDesc* Ops, /* List of generators */ /* Second value is constant - check for div */ type |= CF_CONST; rtype |= CF_CONST; - if (Tok == TOK_DIV && Expr2.Val == 0) { + if (Tok == TOK_DIV && Expr2.IVal == 0) { Error ("Division by zero"); - } else if (Tok == TOK_MOD && Expr2.Val == 0) { + } else if (Tok == TOK_MOD && Expr2.IVal == 0) { Error ("Modulo operation with zero"); } if ((Gen->Flags & GEN_NOPUSH) != 0) { @@ -1855,7 +1855,7 @@ static void hie_internal (const GenDesc* Ops, /* List of generators */ Expr->Type = promoteint (Expr->Type, Expr2.Type); /* Generate code */ - Gen->Func (type, Expr2.Val); + Gen->Func (type, Expr2.IVal); /* We have a rvalue in the primary now */ ED_MakeRValExpr (Expr); @@ -1893,7 +1893,7 @@ static void hie_compare (const GenDesc* Ops, /* List of generators */ if (ED_IsConstAbs (Expr)) { /* Constant value */ Mark2 = GetCodePos (); - g_push (ltype | CF_CONST, Expr->Val); + g_push (ltype | CF_CONST, Expr->IVal); } else { /* Value not constant */ ExprLoad (CF_NONE, Expr); @@ -1933,7 +1933,7 @@ static void hie_compare (const GenDesc* Ops, /* List of generators */ pop (ltype); /* Evaluate the result */ - Expr->Val = kcalc (tok, Expr->Val, Expr2.Val); + Expr->IVal = kcalc (tok, Expr->IVal, Expr2.IVal); } else { @@ -1971,7 +1971,7 @@ static void hie_compare (const GenDesc* Ops, /* List of generators */ } /* Generate code */ - Gen->Func (flags, Expr2.Val); + Gen->Func (flags, Expr2.IVal); /* The result is an rvalue in the primary */ ED_MakeRValExpr (Expr); @@ -2036,16 +2036,16 @@ static void parseadd (ExprDesc* Expr) /* Both expressions are constants. Check for pointer arithmetic */ if (IsClassPtr (lhst) && IsClassInt (rhst)) { /* Left is pointer, right is int, must scale rhs */ - Expr->Val += Expr2.Val * CheckedPSizeOf (lhst); + Expr->IVal += Expr2.IVal * CheckedPSizeOf (lhst); /* Result type is a pointer */ } else if (IsClassInt (lhst) && IsClassPtr (rhst)) { /* Left is int, right is pointer, must scale lhs */ - Expr->Val = Expr->Val * CheckedPSizeOf (rhst) + Expr2.Val; + Expr->IVal = Expr->IVal * CheckedPSizeOf (rhst) + Expr2.IVal; /* Result type is a pointer */ Expr->Type = Expr2.Type; } else if (IsClassInt (lhst) && IsClassInt (rhst)) { /* Integer addition */ - Expr->Val += Expr2.Val; + Expr->IVal += Expr2.IVal; typeadjust (Expr, &Expr2, 1); } else { /* OOPS */ @@ -2085,10 +2085,10 @@ static void parseadd (ExprDesc* Expr) /* Generate the code for the add */ if (ED_GetLoc (Expr) == E_LOC_ABS) { /* Numeric constant */ - g_inc (flags, Expr->Val); + g_inc (flags, Expr->IVal); } else { /* Constant address */ - g_addaddr_static (flags, Expr->Name, Expr->Val); + g_addaddr_static (flags, Expr->Name, Expr->IVal); } } else if (IsClassInt (lhst) && IsClassPtr (rhst)) { @@ -2105,16 +2105,16 @@ static void parseadd (ExprDesc* Expr) */ if (ED_IsLocAbs (Expr)) { /* Numeric constant, scale lhs */ - Expr->Val *= ScaleFactor; + Expr->IVal *= ScaleFactor; /* Generate the code for the add */ - g_inc (flags, Expr->Val); + g_inc (flags, Expr->IVal); } else if (ScaleFactor == 1) { /* Constant address but no need to scale */ - g_addaddr_static (flags, Expr->Name, Expr->Val); + g_addaddr_static (flags, Expr->Name, Expr->IVal); } else { /* Constant address that must be scaled */ g_push (TypeOf (Expr2.Type), 0); /* rhs --> stack */ - g_getimmed (flags, Expr->Name, Expr->Val); + g_getimmed (flags, Expr->Name, Expr->IVal); g_scale (CF_PTR, ScaleFactor); g_add (CF_PTR, 0); } @@ -2124,10 +2124,10 @@ static void parseadd (ExprDesc* Expr) /* Generate the code for the add */ if (ED_IsLocAbs (Expr)) { /* Numeric constant */ - g_inc (flags, Expr->Val); + g_inc (flags, Expr->IVal); } else { /* Constant address */ - g_addaddr_static (flags, Expr->Name, Expr->Val); + g_addaddr_static (flags, Expr->Name, Expr->IVal); } } else { /* OOPS */ @@ -2158,7 +2158,7 @@ static void parseadd (ExprDesc* Expr) /* Check for pointer arithmetic */ if (IsClassPtr (lhst) && IsClassInt (rhst)) { /* Left is pointer, right is int, must scale rhs */ - Expr2.Val *= CheckedPSizeOf (lhst); + Expr2.IVal *= CheckedPSizeOf (lhst); /* Operate on pointers, result type is a pointer */ flags = CF_PTR; } else if (IsClassInt (lhst) && IsClassPtr (rhst)) { @@ -2176,7 +2176,7 @@ static void parseadd (ExprDesc* Expr) } /* Generate code for the add */ - g_inc (flags | CF_CONST, Expr2.Val); + g_inc (flags | CF_CONST, Expr2.IVal); } else { @@ -2274,14 +2274,14 @@ static void parsesub (ExprDesc* Expr) /* Check for pointer arithmetic */ if (IsClassPtr (lhst) && IsClassInt (rhst)) { /* Left is pointer, right is int, must scale rhs */ - Expr->Val -= Expr2.Val * CheckedPSizeOf (lhst); + Expr->IVal -= Expr2.IVal * CheckedPSizeOf (lhst); /* Operate on pointers, result type is a pointer */ } else if (IsClassPtr (lhst) && IsClassPtr (rhst)) { /* Left is pointer, right is pointer, must scale result */ if (TypeCmp (Indirect (lhst), Indirect (rhst)) < TC_QUAL_DIFF) { Error ("Incompatible pointer types"); } else { - Expr->Val = (Expr->Val - Expr2.Val) / + Expr->IVal = (Expr->IVal - Expr2.IVal) / CheckedPSizeOf (lhst); } /* Operate on pointers, result type is an integer */ @@ -2289,7 +2289,7 @@ static void parsesub (ExprDesc* Expr) } else if (IsClassInt (lhst) && IsClassInt (rhst)) { /* Integer subtraction */ typeadjust (Expr, &Expr2, 1); - Expr->Val -= Expr2.Val; + Expr->IVal -= Expr2.IVal; } else { /* OOPS */ Error ("Invalid operands for binary operator `-'"); @@ -2308,7 +2308,7 @@ static void parsesub (ExprDesc* Expr) if (IsClassPtr (lhst) && IsClassInt (rhst)) { /* Left is pointer, right is int, must scale rhs */ - Expr2.Val *= CheckedPSizeOf (lhst); + Expr2.IVal *= CheckedPSizeOf (lhst); /* Operate on pointers, result type is a pointer */ flags = CF_PTR; } else if (IsClassPtr (lhst) && IsClassPtr (rhst)) { @@ -2330,7 +2330,7 @@ static void parsesub (ExprDesc* Expr) } /* Do the subtraction */ - g_dec (flags | CF_CONST, Expr2.Val); + g_dec (flags | CF_CONST, Expr2.IVal); /* If this was a pointer subtraction, we must scale the result */ if (rscale != 1) { @@ -2512,7 +2512,7 @@ static void hieAndPP (ExprDesc* Expr) ConstAbsIntExpr (hie2, &Expr2); /* Combine the two */ - Expr->Val = (Expr->Val && Expr2.Val); + Expr->IVal = (Expr->IVal && Expr2.IVal); } } @@ -2535,7 +2535,7 @@ static void hieOrPP (ExprDesc *Expr) ConstAbsIntExpr (hieAndPP, &Expr2); /* Combine the two */ - Expr->Val = (Expr->Val || Expr2.Val); + Expr->IVal = (Expr->IVal || Expr2.IVal); } } @@ -2852,7 +2852,7 @@ static void opeq (const GenDesc* Gen, ExprDesc* Expr) } if (MustScale) { /* lhs is a pointer, scale rhs */ - Expr2.Val *= CheckedSizeOf (Expr->Type+1); + Expr2.IVal *= CheckedSizeOf (Expr->Type+1); } /* If the lhs is character sized, the operation may be later done @@ -2864,11 +2864,11 @@ static void opeq (const GenDesc* Gen, ExprDesc* Expr) /* Special handling for add and sub - some sort of a hack, but short code */ if (Gen->Func == g_add) { - g_inc (flags | CF_CONST, Expr2.Val); + g_inc (flags | CF_CONST, Expr2.IVal); } else if (Gen->Func == g_sub) { - g_dec (flags | CF_CONST, Expr2.Val); + g_dec (flags | CF_CONST, Expr2.IVal); } else { - Gen->Func (flags | CF_CONST, Expr2.Val); + Gen->Func (flags | CF_CONST, Expr2.IVal); } } else { /* rhs is not constant and already in the primary register */ @@ -2938,7 +2938,7 @@ static void addsubeq (const GenDesc* Gen, ExprDesc *Expr) if (ED_IsConstAbs (&Expr2)) { /* The resulting value is a constant. Scale it. */ if (MustScale) { - Expr2.Val *= CheckedSizeOf (Indirect (Expr->Type)); + Expr2.IVal *= CheckedSizeOf (Indirect (Expr->Type)); } rflags |= CF_CONST; lflags |= CF_CONST; @@ -2965,9 +2965,9 @@ static void addsubeq (const GenDesc* Gen, ExprDesc *Expr) /* Absolute: numeric address or const */ lflags |= CF_ABSOLUTE; if (Gen->Tok == TOK_PLUS_ASSIGN) { - g_addeqstatic (lflags, Expr->Name, Expr->Val, Expr2.Val); + g_addeqstatic (lflags, Expr->Name, Expr->IVal, Expr2.IVal); } else { - g_subeqstatic (lflags, Expr->Name, Expr->Val, Expr2.Val); + g_subeqstatic (lflags, Expr->Name, Expr->IVal, Expr2.IVal); } break; @@ -2975,9 +2975,9 @@ static void addsubeq (const GenDesc* Gen, ExprDesc *Expr) /* Global variable */ lflags |= CF_EXTERNAL; if (Gen->Tok == TOK_PLUS_ASSIGN) { - g_addeqstatic (lflags, Expr->Name, Expr->Val, Expr2.Val); + g_addeqstatic (lflags, Expr->Name, Expr->IVal, Expr2.IVal); } else { - g_subeqstatic (lflags, Expr->Name, Expr->Val, Expr2.Val); + g_subeqstatic (lflags, Expr->Name, Expr->IVal, Expr2.IVal); } break; @@ -2986,9 +2986,9 @@ static void addsubeq (const GenDesc* Gen, ExprDesc *Expr) /* Static variable or literal in the literal pool */ lflags |= CF_STATIC; if (Gen->Tok == TOK_PLUS_ASSIGN) { - g_addeqstatic (lflags, Expr->Name, Expr->Val, Expr2.Val); + g_addeqstatic (lflags, Expr->Name, Expr->IVal, Expr2.IVal); } else { - g_subeqstatic (lflags, Expr->Name, Expr->Val, Expr2.Val); + g_subeqstatic (lflags, Expr->Name, Expr->IVal, Expr2.IVal); } break; @@ -2996,18 +2996,18 @@ static void addsubeq (const GenDesc* Gen, ExprDesc *Expr) /* Register variable */ lflags |= CF_REGVAR; if (Gen->Tok == TOK_PLUS_ASSIGN) { - g_addeqstatic (lflags, Expr->Name, Expr->Val, Expr2.Val); + g_addeqstatic (lflags, Expr->Name, Expr->IVal, Expr2.IVal); } else { - g_subeqstatic (lflags, Expr->Name, Expr->Val, Expr2.Val); + g_subeqstatic (lflags, Expr->Name, Expr->IVal, Expr2.IVal); } break; case E_LOC_STACK: /* Value on the stack */ if (Gen->Tok == TOK_PLUS_ASSIGN) { - g_addeqlocal (lflags, Expr->Val, Expr2.Val); + g_addeqlocal (lflags, Expr->IVal, Expr2.IVal); } else { - g_subeqlocal (lflags, Expr->Val, Expr2.Val); + g_subeqlocal (lflags, Expr->IVal, Expr2.IVal); } break; diff --git a/src/cc65/exprdesc.c b/src/cc65/exprdesc.c index 470c0e10e..9b9a0a6fb 100644 --- a/src/cc65/exprdesc.c +++ b/src/cc65/exprdesc.c @@ -58,9 +58,10 @@ ExprDesc* ED_Init (ExprDesc* Expr) { Expr->Sym = 0; Expr->Type = 0; - Expr->Val = 0; Expr->Flags = 0; Expr->Name = 0; + Expr->IVal = 0; + Expr->FVal = 0.0; return Expr; } @@ -75,7 +76,7 @@ const char* ED_GetLabelName (const ExprDesc* Expr, long Offs) static char Buf[256]; /* Expr may have it's own offset, adjust Offs accordingly */ - Offs += Expr->Val; + Offs += Expr->IVal; /* Generate a label depending on the location */ switch (ED_GetLoc (Expr)) { @@ -130,7 +131,7 @@ int ED_GetStackOffs (const ExprDesc* Expr, int Offs) */ { PRECONDITION (ED_IsLocStack (Expr)); - Offs += ((int) Expr->Val) - StackPtr; + Offs += ((int) Expr->IVal) - StackPtr; CHECK (Offs >= 0); /* Cannot handle negative stack offsets */ return Offs; } @@ -142,9 +143,10 @@ ExprDesc* ED_MakeConstAbs (ExprDesc* Expr, long Value, type* Type) { Expr->Sym = 0; Expr->Type = Type; - Expr->Val = Value; Expr->Flags = E_LOC_ABS | E_RTYPE_RVAL; Expr->Name = 0; + Expr->IVal = Value; + Expr->FVal = 0.0; return Expr; } @@ -155,9 +157,10 @@ ExprDesc* ED_MakeConstAbsInt (ExprDesc* Expr, long Value) { Expr->Sym = 0; Expr->Type = type_int; - Expr->Val = Value; Expr->Flags = E_LOC_ABS | E_RTYPE_RVAL; Expr->Name = 0; + Expr->IVal = Value; + Expr->FVal = 0.0; return Expr; } @@ -169,10 +172,11 @@ ExprDesc* ED_MakeRValExpr (ExprDesc* Expr) */ { Expr->Sym = 0; - Expr->Val = 0; /* No offset */ Expr->Flags &= ~(E_MASK_LOC | E_MASK_RTYPE | E_NEED_TEST | E_CC_SET); Expr->Flags |= (E_LOC_EXPR | E_RTYPE_RVAL); Expr->Name = 0; + Expr->IVal = 0; /* No offset */ + Expr->FVal = 0.0; return Expr; } @@ -184,10 +188,11 @@ ExprDesc* ED_MakeLValExpr (ExprDesc* Expr) */ { Expr->Sym = 0; - Expr->Val = 0; /* No offset */ Expr->Flags &= ~(E_MASK_LOC | E_MASK_RTYPE | E_NEED_TEST | E_CC_SET); Expr->Flags |= (E_LOC_EXPR | E_RTYPE_LVAL); Expr->Name = 0; + Expr->IVal = 0; /* No offset */ + Expr->FVal = 0.0; return Expr; } @@ -227,7 +232,7 @@ int ED_IsNullPtr (const ExprDesc* Expr) /* Return true if the given expression is a NULL pointer constant */ { return (Expr->Flags & (E_MASK_LOC|E_MASK_RTYPE)) == (E_LOC_ABS|E_RTYPE_RVAL) && - Expr->Val == 0 && + Expr->IVal == 0 && IsClassInt (Expr->Type); } @@ -262,7 +267,8 @@ void PrintExprDesc (FILE* F, ExprDesc* E) fprintf (F, "Type: (unknown)\n" "Raw type: (unknown)\n"); } - fprintf (F, "Value: 0x%08lX\n", E->Val); + fprintf (F, "IVal: 0x%08lX\n", E->IVal); + fprintf (F, "FVal: %f\n", E->FVal); Flags = E->Flags; Sep = '('; diff --git a/src/cc65/exprdesc.h b/src/cc65/exprdesc.h index 06225ccb1..97f87b162 100644 --- a/src/cc65/exprdesc.h +++ b/src/cc65/exprdesc.h @@ -86,9 +86,10 @@ typedef struct ExprDesc ExprDesc; struct ExprDesc { struct SymEntry* Sym; /* Symbol table entry if known */ type* Type; /* Type array of expression */ - long Val; /* Value if expression constant */ - unsigned short Flags; + unsigned Flags; unsigned long Name; /* Name or label number */ + long IVal; /* Integer value if expression constant */ + float FVal; /* Floating point value */ }; diff --git a/src/cc65/locals.c b/src/cc65/locals.c index 6805424fb..14f804e09 100644 --- a/src/cc65/locals.c +++ b/src/cc65/locals.c @@ -224,7 +224,7 @@ static unsigned ParseAutoDecl (Declaration* Decl, unsigned* SC) } /* Push the value */ - g_push (Flags | TypeOf (Decl->Type), Expr.Val); + g_push (Flags | TypeOf (Decl->Type), Expr.IVal); } diff --git a/src/cc65/preproc.c b/src/cc65/preproc.c index 87eec2ae1..6efdff5eb 100644 --- a/src/cc65/preproc.c +++ b/src/cc65/preproc.c @@ -755,8 +755,8 @@ static int PushIf (int Skip, int Invert, int Cond) static int DoIf (int Skip) /* Process #if directive */ -{ - ExprDesc lval; +{ + ExprDesc Expr; char* S; /* We're about to abuse the compiler expression parser to evaluate the @@ -804,7 +804,7 @@ static int DoIf (int Skip) NextToken (); /* Call the expression parser */ - ConstExpr (hie1, &lval); + ConstExpr (hie1, &Expr); /* End preprocessing mode */ Preprocessing = 0; @@ -814,7 +814,7 @@ static int DoIf (int Skip) NextTok = sv2; /* Set the #if condition according to the expression result */ - return PushIf (Skip, 1, lval.Val != 0); + return PushIf (Skip, 1, Expr.IVal != 0); } diff --git a/src/cc65/stdfunc.c b/src/cc65/stdfunc.c index 820f4d75c..5be226ec0 100644 --- a/src/cc65/stdfunc.c +++ b/src/cc65/stdfunc.c @@ -205,14 +205,14 @@ static void StdFunc_memcpy (FuncDesc* F attribute ((unused)), ExprDesc* Expr) /* Argument #1 */ ParseArg (&Arg1, Arg1Type); - g_push (Arg1.Flags, Arg1.Expr.Val); + g_push (Arg1.Flags, Arg1.Expr.IVal); Arg1.End = GetCodePos (); ParamSize += SizeOf (Arg1Type); ConsumeComma (); /* Argument #2 */ ParseArg (&Arg2, Arg2Type); - g_push (Arg2.Flags, Arg2.Expr.Val); + g_push (Arg2.Flags, Arg2.Expr.IVal); Arg2.End = GetCodePos (); ParamSize += SizeOf (Arg2Type); ConsumeComma (); @@ -230,7 +230,7 @@ static void StdFunc_memcpy (FuncDesc* F attribute ((unused)), ExprDesc* Expr) /* Emit the actual function call. This will also cleanup the stack. */ g_call (CF_FIXARGC, Func_memcpy, ParamSize); - if (ED_IsConstAbsInt (&Arg3.Expr) && Arg3.Expr.Val == 0) { + if (ED_IsConstAbsInt (&Arg3.Expr) && Arg3.Expr.IVal == 0) { /* memcpy has been called with a count argument of zero */ Warning ("Call to memcpy has no effect"); @@ -252,7 +252,7 @@ static void StdFunc_memcpy (FuncDesc* F attribute ((unused)), ExprDesc* Expr) * be generated. If such a situation is detected, throw away the * generated, and emit better code. */ - if (ED_IsConstAbsInt (&Arg3.Expr) && Arg3.Expr.Val <= 256 && + if (ED_IsConstAbsInt (&Arg3.Expr) && Arg3.Expr.IVal <= 256 && ((ED_IsRVal (&Arg2.Expr) && ED_IsLocConst (&Arg2.Expr)) || (ED_IsLVal (&Arg2.Expr) && ED_IsLocRegister (&Arg2.Expr))) && ((ED_IsRVal (&Arg1.Expr) && ED_IsLocConst (&Arg1.Expr)) || @@ -268,10 +268,10 @@ static void StdFunc_memcpy (FuncDesc* F attribute ((unused)), ExprDesc* Expr) Label = GetLocalLabel (); /* Generate memcpy code */ - if (Arg3.Expr.Val <= 127) { + if (Arg3.Expr.IVal <= 127) { - AddCodeLine ("ldy #$%02X", (unsigned char) (Arg3.Expr.Val-1)); - AddCodeLine ("lda #$%02X", (unsigned char) Arg2.Expr.Val); + AddCodeLine ("ldy #$%02X", (unsigned char) (Arg3.Expr.IVal-1)); + AddCodeLine ("lda #$%02X", (unsigned char) Arg2.Expr.IVal); g_defcodelabel (Label); if (Reg2) { AddCodeLine ("lda (%s),y", ED_GetLabelName (&Arg2.Expr, 0)); @@ -289,7 +289,7 @@ static void StdFunc_memcpy (FuncDesc* F attribute ((unused)), ExprDesc* Expr) } else { AddCodeLine ("ldy #$00"); - AddCodeLine ("lda #$%02X", (unsigned char) Arg2.Expr.Val); + AddCodeLine ("lda #$%02X", (unsigned char) Arg2.Expr.IVal); g_defcodelabel (Label); if (Reg2) { AddCodeLine ("lda (%s),y", ED_GetLabelName (&Arg2.Expr, 0)); @@ -302,7 +302,7 @@ static void StdFunc_memcpy (FuncDesc* F attribute ((unused)), ExprDesc* Expr) AddCodeLine ("sta %s,y", ED_GetLabelName (&Arg1.Expr, 0)); } AddCodeLine ("iny"); - AddCodeLine ("cpy #$%02X", (unsigned char) Arg3.Expr.Val); + AddCodeLine ("cpy #$%02X", (unsigned char) Arg3.Expr.IVal); AddCodeLine ("bne %s", LocalLabelName (Label)); } @@ -312,10 +312,10 @@ static void StdFunc_memcpy (FuncDesc* F attribute ((unused)), ExprDesc* Expr) */ *Expr = Arg1.Expr; - } else if (ED_IsConstAbsInt (&Arg3.Expr) && Arg3.Expr.Val <= 256 && + } else if (ED_IsConstAbsInt (&Arg3.Expr) && Arg3.Expr.IVal <= 256 && ED_IsRVal (&Arg2.Expr) && ED_IsLocConst (&Arg2.Expr) && ED_IsRVal (&Arg1.Expr) && ED_IsLocStack (&Arg1.Expr) && - (Arg1.Expr.Val - StackPtr) + Arg3.Expr.Val < 256) { + (Arg1.Expr.IVal - StackPtr) + Arg3.Expr.IVal < 256) { /* It is possible to just use one index register even if the stack * offset is not zero, by adjusting the offset to the constant @@ -325,7 +325,7 @@ static void StdFunc_memcpy (FuncDesc* F attribute ((unused)), ExprDesc* Expr) * address calculation could overflow in the linker. */ int AllowOneIndex = !ED_IsLocRegister (&Arg2.Expr) && - !(ED_IsLocAbs (&Arg2.Expr) && Arg2.Expr.Val < 256); + !(ED_IsLocAbs (&Arg2.Expr) && Arg2.Expr.IVal < 256); /* Calculate the real stack offset */ int Offs = ED_GetStackOffs (&Arg1.Expr, 0); @@ -337,18 +337,18 @@ static void StdFunc_memcpy (FuncDesc* F attribute ((unused)), ExprDesc* Expr) Label = GetLocalLabel (); /* Generate memcpy code */ - if (Arg3.Expr.Val <= 127) { + if (Arg3.Expr.IVal <= 127) { if (Offs == 0 || AllowOneIndex) { - AddCodeLine ("ldy #$%02X", (unsigned char) (Offs + Arg3.Expr.Val - 1)); + AddCodeLine ("ldy #$%02X", (unsigned char) (Offs + Arg3.Expr.IVal - 1)); g_defcodelabel (Label); AddCodeLine ("lda %s,y", ED_GetLabelName (&Arg2.Expr, -Offs)); AddCodeLine ("sta (sp),y"); AddCodeLine ("dey"); AddCodeLine ("bpl %s", LocalLabelName (Label)); } else { - AddCodeLine ("ldx #$%02X", (unsigned char) (Arg3.Expr.Val-1)); - AddCodeLine ("ldy #$%02X", (unsigned char) (Offs + Arg3.Expr.Val - 1)); + AddCodeLine ("ldx #$%02X", (unsigned char) (Arg3.Expr.IVal-1)); + AddCodeLine ("ldy #$%02X", (unsigned char) (Offs + Arg3.Expr.IVal - 1)); g_defcodelabel (Label); AddCodeLine ("lda %s,x", ED_GetLabelName (&Arg2.Expr, 0)); AddCodeLine ("sta (sp),y"); @@ -365,7 +365,7 @@ static void StdFunc_memcpy (FuncDesc* F attribute ((unused)), ExprDesc* Expr) AddCodeLine ("lda %s,y", ED_GetLabelName (&Arg2.Expr, -Offs)); AddCodeLine ("sta (sp),y"); AddCodeLine ("iny"); - AddCodeLine ("cpy #$%02X", (unsigned char) (Offs + Arg3.Expr.Val)); + AddCodeLine ("cpy #$%02X", (unsigned char) (Offs + Arg3.Expr.IVal)); AddCodeLine ("bne %s", LocalLabelName (Label)); } else { AddCodeLine ("ldx #$00"); @@ -375,7 +375,7 @@ static void StdFunc_memcpy (FuncDesc* F attribute ((unused)), ExprDesc* Expr) AddCodeLine ("sta (sp),y"); AddCodeLine ("iny"); AddCodeLine ("inx"); - AddCodeLine ("cpx #$%02X", (unsigned char) Arg3.Expr.Val); + AddCodeLine ("cpx #$%02X", (unsigned char) Arg3.Expr.IVal); AddCodeLine ("bne %s", LocalLabelName (Label)); } @@ -386,9 +386,9 @@ static void StdFunc_memcpy (FuncDesc* F attribute ((unused)), ExprDesc* Expr) */ *Expr = Arg1.Expr; - } else if (ED_IsConstAbsInt (&Arg3.Expr) && Arg3.Expr.Val <= 256 && + } else if (ED_IsConstAbsInt (&Arg3.Expr) && Arg3.Expr.IVal <= 256 && ED_IsRVal (&Arg2.Expr) && ED_IsLocStack (&Arg2.Expr) && - (Arg2.Expr.Val - StackPtr) + Arg3.Expr.Val < 256 && + (Arg2.Expr.IVal - StackPtr) + Arg3.Expr.IVal < 256 && ED_IsRVal (&Arg1.Expr) && ED_IsLocConst (&Arg1.Expr)) { /* It is possible to just use one index register even if the stack @@ -399,7 +399,7 @@ static void StdFunc_memcpy (FuncDesc* F attribute ((unused)), ExprDesc* Expr) * address calculation could overflow in the linker. */ int AllowOneIndex = !ED_IsLocRegister (&Arg1.Expr) && - !(ED_IsLocAbs (&Arg1.Expr) && Arg1.Expr.Val < 256); + !(ED_IsLocAbs (&Arg1.Expr) && Arg1.Expr.IVal < 256); /* Calculate the real stack offset */ int Offs = ED_GetStackOffs (&Arg2.Expr, 0); @@ -411,18 +411,18 @@ static void StdFunc_memcpy (FuncDesc* F attribute ((unused)), ExprDesc* Expr) Label = GetLocalLabel (); /* Generate memcpy code */ - if (Arg3.Expr.Val <= 127) { + if (Arg3.Expr.IVal <= 127) { if (Offs == 0 || AllowOneIndex) { - AddCodeLine ("ldy #$%02X", (unsigned char) (Offs + Arg3.Expr.Val - 1)); + AddCodeLine ("ldy #$%02X", (unsigned char) (Offs + Arg3.Expr.IVal - 1)); g_defcodelabel (Label); AddCodeLine ("lda (sp),y"); AddCodeLine ("sta %s,y", ED_GetLabelName (&Arg1.Expr, -Offs)); AddCodeLine ("dey"); AddCodeLine ("bpl %s", LocalLabelName (Label)); } else { - AddCodeLine ("ldx #$%02X", (unsigned char) (Arg3.Expr.Val-1)); - AddCodeLine ("ldy #$%02X", (unsigned char) (Offs + Arg3.Expr.Val - 1)); + AddCodeLine ("ldx #$%02X", (unsigned char) (Arg3.Expr.IVal-1)); + AddCodeLine ("ldy #$%02X", (unsigned char) (Offs + Arg3.Expr.IVal - 1)); g_defcodelabel (Label); AddCodeLine ("lda (sp),y"); AddCodeLine ("sta %s,x", ED_GetLabelName (&Arg1.Expr, 0)); @@ -439,7 +439,7 @@ static void StdFunc_memcpy (FuncDesc* F attribute ((unused)), ExprDesc* Expr) AddCodeLine ("lda (sp),y"); AddCodeLine ("sta %s,y", ED_GetLabelName (&Arg1.Expr, -Offs)); AddCodeLine ("iny"); - AddCodeLine ("cpy #$%02X", (unsigned char) (Offs + Arg3.Expr.Val)); + AddCodeLine ("cpy #$%02X", (unsigned char) (Offs + Arg3.Expr.IVal)); AddCodeLine ("bne %s", LocalLabelName (Label)); } else { AddCodeLine ("ldx #$00"); @@ -449,7 +449,7 @@ static void StdFunc_memcpy (FuncDesc* F attribute ((unused)), ExprDesc* Expr) AddCodeLine ("sta %s,x", ED_GetLabelName (&Arg1.Expr, 0)); AddCodeLine ("iny"); AddCodeLine ("inx"); - AddCodeLine ("cpx #$%02X", (unsigned char) Arg3.Expr.Val); + AddCodeLine ("cpx #$%02X", (unsigned char) Arg3.Expr.IVal); AddCodeLine ("bne %s", LocalLabelName (Label)); } @@ -500,7 +500,7 @@ static void StdFunc_memset (FuncDesc* F attribute ((unused)), ExprDesc* Expr) /* Argument #1 */ ParseArg (&Arg1, Arg1Type); - g_push (Arg1.Flags, Arg1.Expr.Val); + g_push (Arg1.Flags, Arg1.Expr.IVal); Arg1.End = GetCodePos (); ParamSize += SizeOf (Arg1Type); ConsumeComma (); @@ -509,12 +509,12 @@ static void StdFunc_memset (FuncDesc* F attribute ((unused)), ExprDesc* Expr) * function if it is a constant zero. */ ParseArg (&Arg2, Arg2Type); - if ((Arg2.Flags & CF_CONST) != 0 && Arg2.Expr.Val == 0) { + if ((Arg2.Flags & CF_CONST) != 0 && Arg2.Expr.IVal == 0) { /* Don't call memset, call bzero instead */ MemSet = 0; } else { /* Push the argument */ - g_push (Arg2.Flags, Arg2.Expr.Val); + g_push (Arg2.Flags, Arg2.Expr.IVal); Arg2.End = GetCodePos (); ParamSize += SizeOf (Arg2Type); } @@ -533,7 +533,7 @@ static void StdFunc_memset (FuncDesc* F attribute ((unused)), ExprDesc* Expr) /* Emit the actual function call. This will also cleanup the stack. */ g_call (CF_FIXARGC, MemSet? Func_memset : Func__bzero, ParamSize); - if (ED_IsConstAbsInt (&Arg3.Expr) && Arg3.Expr.Val == 0) { + if (ED_IsConstAbsInt (&Arg3.Expr) && Arg3.Expr.IVal == 0) { /* memset has been called with a count argument of zero */ Warning ("Call to memset has no effect"); @@ -559,7 +559,7 @@ static void StdFunc_memset (FuncDesc* F attribute ((unused)), ExprDesc* Expr) * being constant numerical values. Some checks have shown that this * covers nearly 90% of all memset calls. */ - if (ED_IsConstAbsInt (&Arg3.Expr) && Arg3.Expr.Val <= 256 && + if (ED_IsConstAbsInt (&Arg3.Expr) && Arg3.Expr.IVal <= 256 && ED_IsConstAbsInt (&Arg2.Expr) && ((ED_IsRVal (&Arg1.Expr) && ED_IsLocConst (&Arg1.Expr)) || (ED_IsLVal (&Arg1.Expr) && ED_IsLocRegister (&Arg1.Expr)))) { @@ -573,10 +573,10 @@ static void StdFunc_memset (FuncDesc* F attribute ((unused)), ExprDesc* Expr) Label = GetLocalLabel (); /* Generate memset code */ - if (Arg3.Expr.Val <= 127) { + if (Arg3.Expr.IVal <= 127) { - AddCodeLine ("ldy #$%02X", (unsigned char) (Arg3.Expr.Val-1)); - AddCodeLine ("lda #$%02X", (unsigned char) Arg2.Expr.Val); + AddCodeLine ("ldy #$%02X", (unsigned char) (Arg3.Expr.IVal-1)); + AddCodeLine ("lda #$%02X", (unsigned char) Arg2.Expr.IVal); g_defcodelabel (Label); if (Reg) { AddCodeLine ("sta (%s),y", ED_GetLabelName (&Arg1.Expr, 0)); @@ -589,7 +589,7 @@ static void StdFunc_memset (FuncDesc* F attribute ((unused)), ExprDesc* Expr) } else { AddCodeLine ("ldy #$00"); - AddCodeLine ("lda #$%02X", (unsigned char) Arg2.Expr.Val); + AddCodeLine ("lda #$%02X", (unsigned char) Arg2.Expr.IVal); g_defcodelabel (Label); if (Reg) { AddCodeLine ("sta (%s),y", ED_GetLabelName (&Arg1.Expr, 0)); @@ -597,7 +597,7 @@ static void StdFunc_memset (FuncDesc* F attribute ((unused)), ExprDesc* Expr) AddCodeLine ("sta %s,y", ED_GetLabelName (&Arg1.Expr, 0)); } AddCodeLine ("iny"); - AddCodeLine ("cpy #$%02X", (unsigned char) Arg3.Expr.Val); + AddCodeLine ("cpy #$%02X", (unsigned char) Arg3.Expr.IVal); AddCodeLine ("bne %s", LocalLabelName (Label)); } @@ -607,10 +607,10 @@ static void StdFunc_memset (FuncDesc* F attribute ((unused)), ExprDesc* Expr) */ *Expr = Arg1.Expr; - } else if (ED_IsConstAbsInt (&Arg3.Expr) && Arg3.Expr.Val <= 256 && + } else if (ED_IsConstAbsInt (&Arg3.Expr) && Arg3.Expr.IVal <= 256 && ED_IsConstAbsInt (&Arg2.Expr) && ED_IsRVal (&Arg1.Expr) && ED_IsLocStack (&Arg1.Expr) && - (Arg1.Expr.Val - StackPtr) + Arg3.Expr.Val < 256) { + (Arg1.Expr.IVal - StackPtr) + Arg3.Expr.IVal < 256) { /* Calculate the real stack offset */ int Offs = ED_GetStackOffs (&Arg1.Expr, 0); @@ -623,11 +623,11 @@ static void StdFunc_memset (FuncDesc* F attribute ((unused)), ExprDesc* Expr) /* Generate memset code */ AddCodeLine ("ldy #$%02X", (unsigned char) Offs); - AddCodeLine ("lda #$%02X", (unsigned char) Arg2.Expr.Val); + AddCodeLine ("lda #$%02X", (unsigned char) Arg2.Expr.IVal); g_defcodelabel (Label); AddCodeLine ("sta (sp),y"); AddCodeLine ("iny"); - AddCodeLine ("cpy #$%02X", (unsigned char) (Offs + Arg3.Expr.Val)); + AddCodeLine ("cpy #$%02X", (unsigned char) (Offs + Arg3.Expr.IVal)); AddCodeLine ("bne %s", LocalLabelName (Label)); /* memset returns the address, so the result is actually identical @@ -635,9 +635,9 @@ static void StdFunc_memset (FuncDesc* F attribute ((unused)), ExprDesc* Expr) */ *Expr = Arg1.Expr; - } else if (ED_IsConstAbsInt (&Arg3.Expr) && Arg3.Expr.Val <= 256 && + } else if (ED_IsConstAbsInt (&Arg3.Expr) && Arg3.Expr.IVal <= 256 && ED_IsConstAbsInt (&Arg2.Expr) && - (Arg2.Expr.Val != 0 || CodeSizeFactor > 200)) { + (Arg2.Expr.IVal != 0 || CodeSizeFactor > 200)) { /* Remove all of the generated code but the load of the first * argument. @@ -650,20 +650,20 @@ static void StdFunc_memset (FuncDesc* F attribute ((unused)), ExprDesc* Expr) /* Generate code */ AddCodeLine ("sta ptr1"); AddCodeLine ("stx ptr1+1"); - if (Arg3.Expr.Val <= 127) { - AddCodeLine ("ldy #$%02X", (unsigned char) (Arg3.Expr.Val-1)); - AddCodeLine ("lda #$%02X", (unsigned char) Arg2.Expr.Val); + if (Arg3.Expr.IVal <= 127) { + AddCodeLine ("ldy #$%02X", (unsigned char) (Arg3.Expr.IVal-1)); + AddCodeLine ("lda #$%02X", (unsigned char) Arg2.Expr.IVal); g_defcodelabel (Label); AddCodeLine ("sta (ptr1),y"); AddCodeLine ("dey"); AddCodeLine ("bpl %s", LocalLabelName (Label)); } else { AddCodeLine ("ldy #$00"); - AddCodeLine ("lda #$%02X", (unsigned char) Arg2.Expr.Val); + AddCodeLine ("lda #$%02X", (unsigned char) Arg2.Expr.IVal); g_defcodelabel (Label); AddCodeLine ("sta (ptr1),y"); AddCodeLine ("iny"); - AddCodeLine ("cpy #$%02X", (unsigned char) Arg3.Expr.Val); + AddCodeLine ("cpy #$%02X", (unsigned char) Arg3.Expr.IVal); AddCodeLine ("bne %s", LocalLabelName (Label)); } @@ -719,7 +719,7 @@ static void StdFunc_strcpy (FuncDesc* F attribute ((unused)), ExprDesc* Expr) /* Argument #1 */ ParseArg (&Arg1, Arg1Type); - g_push (Arg1.Flags, Arg1.Expr.Val); + g_push (Arg1.Flags, Arg1.Expr.IVal); Arg1.End = GetCodePos (); ParamSize += SizeOf (Arg1Type); ConsumeComma (); @@ -794,7 +794,7 @@ static void StdFunc_strcpy (FuncDesc* F attribute ((unused)), ExprDesc* Expr) * address calculation could overflow in the linker. */ int AllowOneIndex = !ED_IsLocRegister (&Arg1.Expr) && - !(ED_IsLocAbs (&Arg1.Expr) && Arg1.Expr.Val < 256); + !(ED_IsLocAbs (&Arg1.Expr) && Arg1.Expr.IVal < 256); /* Calculate the real stack offset */ int Offs = ED_GetStackOffs (&Arg2.Expr, 0); @@ -837,7 +837,7 @@ static void StdFunc_strcpy (FuncDesc* F attribute ((unused)), ExprDesc* Expr) * address calculation could overflow in the linker. */ int AllowOneIndex = !ED_IsLocRegister (&Arg2.Expr) && - !(ED_IsLocAbs (&Arg2.Expr) && Arg2.Expr.Val < 256); + !(ED_IsLocAbs (&Arg2.Expr) && Arg2.Expr.IVal < 256); /* Calculate the real stack offset */ int Offs = ED_GetStackOffs (&Arg1.Expr, 0); @@ -940,8 +940,8 @@ static void StdFunc_strlen (FuncDesc* F attribute ((unused)), ExprDesc* Expr) if (ED_IsLocLiteral (&Arg) && IS_Get (&WritableStrings) == 0) { /* Constant string literal */ - ED_MakeConstAbs (Expr, strlen (GetLiteral (Arg.Val)), type_size_t); - ResetLiteralPoolOffs (Arg.Val); + ED_MakeConstAbs (Expr, strlen (GetLiteral (Arg.IVal)), type_size_t); + ResetLiteralPoolOffs (Arg.IVal); /* We will inline strlen for arrays with constant addresses, if either the * inlining was forced on the command line, or the array is smaller than @@ -968,7 +968,7 @@ static void StdFunc_strlen (FuncDesc* F attribute ((unused)), ExprDesc* Expr) * completely within the reach of a byte sized index register. */ } else if (ED_IsLocStack (&Arg) && IsArray && IsByteIndex && - (Arg.Val - StackPtr) + ECount < 256) { + (Arg.IVal - StackPtr) + ECount < 256) { /* Calculate the true stack offset */ int Offs = ED_GetStackOffs (&Arg, 0); diff --git a/src/cc65/swstmt.c b/src/cc65/swstmt.c index 25c82c430..ab073e15b 100644 --- a/src/cc65/swstmt.c +++ b/src/cc65/swstmt.c @@ -148,7 +148,7 @@ void SwitchStatement (void) ConstAbsIntExpr (hie1, &CaseExpr); /* Check the range of the expression */ - Val = CaseExpr.Val; + Val = CaseExpr.IVal; switch (SwitchExprType) { case T_SCHAR: diff --git a/src/cc65/testexpr.c b/src/cc65/testexpr.c index a9702c6b4..370f52e03 100644 --- a/src/cc65/testexpr.c +++ b/src/cc65/testexpr.c @@ -63,13 +63,13 @@ unsigned Test (unsigned Label, int Invert) if (ED_IsConstAbs (&Expr)) { /* Result is constant, so we know the outcome */ - Result = (Expr.Val != 0); + Result = (Expr.IVal != 0); /* Constant rvalue */ - if (!Invert && Expr.Val == 0) { + if (!Invert && Expr.IVal == 0) { g_jump (Label); Warning ("Unreachable code"); - } else if (Invert && Expr.Val != 0) { + } else if (Invert && Expr.IVal != 0) { g_jump (Label); } diff --git a/src/cc65/typeconv.c b/src/cc65/typeconv.c index c97ee4d67..f39aac96f 100644 --- a/src/cc65/typeconv.c +++ b/src/cc65/typeconv.c @@ -138,13 +138,13 @@ static void DoConversion (ExprDesc* Expr, const type* NewType) if (NewBits <= OldBits) { /* Cut the value to the new size */ - Expr->Val &= (0xFFFFFFFFUL >> (32 - NewBits)); + Expr->IVal &= (0xFFFFFFFFUL >> (32 - NewBits)); /* If the new type is signed, sign extend the value */ if (!IsSignUnsigned (NewType)) { - if (Expr->Val & (0x01UL << (NewBits-1))) { + if (Expr->IVal & (0x01UL << (NewBits-1))) { /* Beware: Use the safe shift routine here. */ - Expr->Val |= shl_l (~0UL, NewBits); + Expr->IVal |= shl_l (~0UL, NewBits); } } } @@ -233,7 +233,7 @@ void TypeConversion (ExprDesc* Expr, type* NewType) } } else if (IsClassInt (Expr->Type)) { /* Int to pointer assignment is valid only for constant zero */ - if (!ED_IsConstAbsInt (Expr) || Expr->Val != 0) { + if (!ED_IsConstAbsInt (Expr) || Expr->IVal != 0) { Warning ("Converting integer to pointer without a cast"); } } else if (IsTypeFuncPtr (NewType) && IsTypeFunc(Expr->Type)) { -- 2.39.5