Fixed an error.

[cc65] / src / cc65 / locals.c

diff --git a/src/cc65/locals.c b/src/cc65/locals.c
index 44662577c70500affc4d1ca6d6834e30e44abaa9..af2c5a28be654efc4979fba55442d24466049eeb 100644 (file)
--- a/src/cc65/locals.c
+++ b/src/cc65/locals.c
@@ -46,7 +46,10 @@
 #include "expr.h"
 #include "function.h"
 #include "global.h"
+#include "loadexpr.h"
 #include "locals.h"
+#include "stackptr.h"
+#include "standard.h"
 #include "symtab.h"
 #include "typeconv.h"
 
@@ -117,7 +120,7 @@ static unsigned ParseRegisterDecl (Declaration* Decl, unsigned* SC, int Reg)
             TypeConversion (&Expr, Decl->Type);
 
             /* Load the value into the primary */
-            ExprLoad (CF_NONE, &Expr);
+            LoadExpr (CF_NONE, &Expr);
 
             /* Store the value into the variable */
             g_putstatic (CF_REGVAR | TypeOf (Decl->Type), Reg, 0);
@@ -214,16 +217,16 @@ static unsigned ParseAutoDecl (Declaration* Decl, unsigned* SC)
 
                 /* If the value is not const, load it into the primary.
                  * Otherwise pass the information to the code generator.
-                 */ 
+                 */
                 if (ED_IsConstAbsInt (&Expr)) {
                     Flags |= CF_CONST;
                 } else {
-                    ExprLoad (CF_NONE, &Expr);
+                    LoadExpr (CF_NONE, &Expr);
                     ED_MakeRVal (&Expr);
                 }
 
                 /* Push the value */
-                g_push (Flags | TypeOf (Decl->Type), Expr.Val);
+                g_push (Flags | TypeOf (Decl->Type), Expr.IVal);
 
             }
 
@@ -289,7 +292,7 @@ static unsigned ParseAutoDecl (Declaration* Decl, unsigned* SC)
                 TypeConversion (&Expr, Decl->Type);
 
                 /* Load the value into the primary */
-                ExprLoad (CF_NONE, &Expr);
+                LoadExpr (CF_NONE, &Expr);
 
                 /* Store the value into the variable */
                 g_putstatic (TypeOf (Decl->Type), SymData, 0);
@@ -377,7 +380,7 @@ static unsigned ParseStaticDecl (Declaration* Decl, unsigned* SC)
 static void ParseOneDecl (const DeclSpec* Spec)
 /* Parse one variable declaration */
 {
-    unsigned    SC;            /* Storage class for symbol */
+    unsigned    SC;            /* Storage class for symbol */
     unsigned    SymData = 0;    /* Symbol data (offset, label name, ...) */
     Declaration Decl;          /* Declaration data structure */
 
@@ -424,12 +427,25 @@ static void ParseOneDecl (const DeclSpec* Spec)
                } else if ((SC & SC_AUTO) == SC_AUTO) {
             /* Auto variable */
             SymData = ParseAutoDecl (&Decl, &SC);
+        } else if ((SC & SC_EXTERN) == SC_EXTERN) {
+            /* External identifier - may not get initialized */
+            if (CurTok.Tok == TOK_ASSIGN) {
+                Error ("Cannot initialize externals");
+            }
+            SymData = 0;
                } else if ((SC & SC_STATIC) == SC_STATIC) {
             /* Static variable */
             SymData = ParseStaticDecl (&Decl, &SC);
                } else {
             Internal ("Invalid storage class in ParseOneDecl: %04X", SC);
         }
+
+        /* If the standard was not set explicitly to C89, print a warning
+         * for variables with implicit int type.
+         */
+        if ((Spec->Flags & DS_DEF_TYPE) != 0 && IS_Get (&Standard) >= STD_C99) {
+            Warning ("Implicit `int' is an obsolete feature");
+        }
     }
 
     /* If the symbol is not marked as external, it will be defined now */
@@ -441,7 +457,7 @@ static void ParseOneDecl (const DeclSpec* Spec)
     AddLocalSym (Decl.Ident, Decl.Type, SC, SymData);
 }
 
-
+                        
 
 void DeclareLocals (void)
 /* Declare local variables and types. */
@@ -452,38 +468,38 @@ void DeclareLocals (void)
     /* Loop until we don't find any more variables */
     while (1) {
 
-       /* Check variable declarations. We need to distinguish between a
-        * default int type and the end of variable declarations. So we
-        * will do the following: If there is no explicit storage class
-        * specifier *and* no explicit type given, *and* no type qualifiers
+       /* Check variable declarations. We need to distinguish between a
+        * default int type and the end of variable declarations. So we
+        * will do the following: If there is no explicit storage class
+        * specifier *and* no explicit type given, *and* no type qualifiers
          * have been read, it is assumed that we have reached the end of
          * declarations.
-        */
-       DeclSpec Spec;
-       ParseDeclSpec (&Spec, SC_AUTO, T_INT);
+        */
+       DeclSpec Spec;
+       ParseDeclSpec (&Spec, SC_AUTO, T_INT);
                if ((Spec.Flags & DS_DEF_STORAGE) != 0 &&       /* No storage spec */
             (Spec.Flags & DS_DEF_TYPE) != 0    &&       /* No type given */
             GetQualifier (Spec.Type) == T_QUAL_NONE) {  /* No type qualifier */
-           break;
-       }
+           break;
+       }
 
-       /* Accept type only declarations */
-       if (CurTok.Tok == TOK_SEMI) {
-           /* Type declaration only */
-           CheckEmptyDecl (&Spec);
-           NextToken ();
-           continue;
-       }
+       /* Accept type only declarations */
+       if (CurTok.Tok == TOK_SEMI) {
+           /* Type declaration only */
+           CheckEmptyDecl (&Spec);
+           NextToken ();
+           continue;
+       }
 
        /* Parse a comma separated variable list */
        while (1) {
 
-           /* Parse one declaration */
-           ParseOneDecl (&Spec);
+           /* Parse one declaration */
+           ParseOneDecl (&Spec);
 
-           /* Check if there is more */
+           /* Check if there is more */
            if (CurTok.Tok == TOK_COMMA) {
-               /* More to come */
+               /* More to come */
                NextToken ();
            } else {
                /* Done */