Change the OptStackOps function so that it adjusts the instruction pointer

[cc65] / src / cc65 / expr.c

diff --git a/src/cc65/expr.c b/src/cc65/expr.c
index cf417577f5963837a3e87073ecd4055a499100c1..343ecdfed4eb048acab1813cef404fc9205623d1 100644 (file)
--- a/src/cc65/expr.c
+++ b/src/cc65/expr.c
@@ -486,6 +486,12 @@ static void FunctionCall (ExprDesc* Expr)
        }
 
     } else {
+        /* Check function attributes */
+        if (Expr->Sym && SymHasAttr (Expr->Sym, atNoReturn)) {
+            /* For now, handle as if a return statement was encountered */
+            F_ReturnFound (CurrentFunc);
+        }
+
         /* Check for known standard functions and inline them */
         if (Expr->Name != 0) {
             int StdFunc = FindStdFunc ((const char*) Expr->Name);
@@ -547,7 +553,7 @@ static void FunctionCall (ExprDesc* Expr)
 
        /* If we have a pointer on stack, remove it */
        if (PtrOnStack) {
-           g_space (- (int) sizeofarg (CF_PTR));
+           g_drop (SIZEOF_PTR);
            pop (CF_PTR);
        }
 
@@ -742,10 +748,11 @@ static void Primary (ExprDesc* E)
         case TOK_SCONST:
         case TOK_WCSCONST:
             /* String literal */
-            E->Type  = GetCharArrayType (GetLiteralPoolOffs () - CurTok.IVal);
+            E->LVal  = UseLiteral (CurTok.SVal);
+            E->Type  = GetCharArrayType (GetLiteralSize (CurTok.SVal));
             E->Flags = E_LOC_LITERAL | E_RTYPE_RVAL;
-            E->IVal  = CurTok.IVal;
-            E->Name  = LiteralPoolLabel;
+            E->IVal  = 0;
+            E->Name  = GetLiteralLabel (CurTok.SVal);
             NextToken ();
             break;
 
@@ -797,6 +804,7 @@ static void ArrayRef (ExprDesc* Expr)
     ExprDesc    Subscript;
     CodeMark    Mark1;
     CodeMark    Mark2;
+    TypeCode    Qualifiers;
     Type*       ElementType;
     Type*       tptr1;
 
@@ -838,12 +846,16 @@ static void ArrayRef (ExprDesc* Expr)
      * Since we do the necessary checking here, we can rely later on the
      * correct types.
      */
+    Qualifiers = T_QUAL_NONE;
     if (IsClassPtr (Expr->Type)) {
         if (!IsClassInt (Subscript.Type))  {
             Error ("Array subscript is not an integer");
             /* To avoid any compiler errors, make the expression a valid int */
             ED_MakeConstAbsInt (&Subscript, 0);
         }
+        if (IsTypeArray (Expr->Type)) {
+            Qualifiers = GetQualifier (Expr->Type);
+        }
         ElementType = Indirect (Expr->Type);
     } else if (IsClassInt (Expr->Type)) {
         if (!IsClassPtr (Subscript.Type)) {
@@ -852,6 +864,8 @@ static void ArrayRef (ExprDesc* Expr)
              * address 0.
              */
             ED_MakeConstAbs (&Subscript, 0, GetCharArrayType (1));
+        } else if (IsTypeArray (Subscript.Type)) {
+            Qualifiers = GetQualifier (Subscript.Type);
         }
         ElementType = Indirect (Subscript.Type);
     } else {
@@ -864,6 +878,14 @@ static void ArrayRef (ExprDesc* Expr)
         ElementType = Indirect (Expr->Type);
     }
 
+    /* The element type has the combined qualifiers from itself and the array,
+     * it is a member of (if any).
+     */
+    if (GetQualifier (ElementType) != (GetQualifier (ElementType) | Qualifiers)) {
+        ElementType = TypeDup (ElementType);
+        ElementType->C |= Qualifiers;
+    }
+
     /* If the subscript is a bit-field, load it and make it an rvalue */
     if (ED_IsBitField (&Subscript)) {
         LoadExpr (CF_NONE, &Subscript);
@@ -1076,7 +1098,8 @@ static void StructRef (ExprDesc* Expr)
     NextToken ();
     if (CurTok.Tok != TOK_IDENT) {
        Error ("Identifier expected");
-       Expr->Type = type_int;
+        /* Make the expression an integer at address zero */
+        ED_MakeConstAbs (Expr, 0, type_int);
         return;
     }
 
@@ -1086,7 +1109,8 @@ static void StructRef (ExprDesc* Expr)
     Field = FindStructField (Expr->Type, Ident);
     if (Field == 0) {
        Error ("Struct/union has no field named `%s'", Ident);
-               Expr->Type = type_int;
+        /* Make the expression an integer at address zero */
+        ED_MakeConstAbs (Expr, 0, type_int);
        return;
     }
 
@@ -1106,7 +1130,11 @@ static void StructRef (ExprDesc* Expr)
     Expr->IVal += Field->V.Offs;
 
     /* The type is the type of the field plus any qualifiers from the struct */
-    Q = GetQualifier (Expr->Type);
+    if (IsClassStruct (Expr->Type)) {
+        Q = GetQualifier (Expr->Type);
+    } else {
+        Q = GetQualifier (Indirect (Expr->Type));
+    }
     if (GetQualifier (Field->Type) == (GetQualifier (Field->Type) | Q)) {
         Expr->Type = Field->Type;
     } else {