Fixed two compiler warnings.

[cc65] / src / cc65 / compile.c

diff --git a/src/cc65/compile.c b/src/cc65/compile.c
index c51191885b665e8bc14b3eebad2bfc487f16b1de..d7167706b21de9ca4ec2e9ba05944fe201ee3c29 100644 (file)
--- a/src/cc65/compile.c
+++ b/src/cc65/compile.c
@@ -6,10 +6,10 @@
 /*                                                                           */
 /*                                                                           */
 /*                                                                           */
-/* (C) 2000-2009 Ullrich von Bassewitz                                       */
-/*               Roemerstrasse 52                                            */
-/*               D-70794 Filderstadt                                         */
-/* EMail:        uz@cc65.org                                                 */
+/* (C) 2000-2009, Ullrich von Bassewitz                                      */
+/*                Roemerstrasse 52                                           */
+/*                D-70794 Filderstadt                                        */
+/* EMail:         uz@cc65.org                                                */
 /*                                                                           */
 /*                                                                           */
 /* This software is provided 'as-is', without any expressed or implied       */
@@ -46,6 +46,7 @@
 #include "asmlabel.h"
 #include "asmstmt.h"
 #include "codegen.h"
+#include "codeopt.h"
 #include "compile.h"
 #include "declare.h"
 #include "error.h"
@@ -83,7 +84,6 @@ static void Parse (void)
     while (CurTok.Tok != TOK_CEOF) {
 
        DeclSpec        Spec;
-       Declaration     Decl;
 
        /* Check for empty statements */
        if (CurTok.Tok == TOK_SEMI) {
@@ -91,10 +91,13 @@ static void Parse (void)
            continue;
        }
 
-       /* Check for an ASM statement (which is allowed also on global level) */
+               /* Disallow ASM statements on global level */
        if (CurTok.Tok == TOK_ASM) {
+            Error ("__asm__ is not allowed here");                 
+            /* Parse and remove the statement for error recovery */
            AsmStatement ();
            ConsumeSemi ();
+            RemoveGlobalCode ();
            continue;
        }
 
@@ -128,6 +131,8 @@ static void Parse (void)
        comma = 0;
                while (1) {
 
+            Declaration         Decl;
+
            /* Read the next declaration */
            ParseDecl (&Spec, &Decl, DM_NEED_IDENT);
            if (Decl.Ident[0] == '\0') {
@@ -136,15 +141,20 @@ static void Parse (void)
            }
 
             /* Check if we must reserve storage for the variable. We do this,
-             * if it is not a typedef or function, if we don't had a storage
-             * class given ("int i") or if the storage class is explicitly
-             * specified as static. This means that "extern int i" will not
-             * get storage allocated.
+             *
+             *   - if it is not a typedef or function,
+             *   - if we don't had a storage class given ("int i")
+             *   - if the storage class is explicitly specified as static,
+             *   - or if there is an initialization.
+             *
+             * This means that "extern int i;" will not get storage allocated.
              */
-           if ((Decl.StorageClass & SC_FUNC) == 0      &&
-                (Decl.StorageClass & SC_TYPEDEF) == 0   &&
-                ((Spec.Flags & DS_DEF_STORAGE) != 0  ||
-                 (Decl.StorageClass & (SC_STATIC | SC_EXTERN)) == SC_STATIC)) {
+           if ((Decl.StorageClass & SC_FUNC) != SC_FUNC          &&
+                (Decl.StorageClass & SC_TYPEDEF) != SC_TYPEDEF    &&
+                ((Spec.Flags & DS_DEF_STORAGE) != 0         ||
+                 (Decl.StorageClass & (SC_EXTERN|SC_STATIC)) == SC_STATIC ||
+                 ((Decl.StorageClass & SC_EXTERN) != 0 &&
+                  CurTok.Tok == TOK_ASSIGN))) {
 
                 /* We will allocate storage */
                Decl.StorageClass |= SC_STORAGE | SC_DEF;
@@ -168,6 +178,9 @@ static void Parse (void)
            /* Add an entry to the symbol table */
            Entry = AddGlobalSym (Decl.Ident, Decl.Type, Decl.StorageClass);
 
+            /* Add declaration attributes */
+            SymUseAttr (Entry, &Decl);
+
            /* Reserve storage for the variable if we need to */
                    if (Decl.StorageClass & SC_STORAGE) {
 
@@ -300,7 +313,7 @@ void Compile (const char* FileName)
     };
 
     /* Add macros that are always defined */
-    DefineNumericMacro ("__CC65__", VERSION);
+    DefineNumericMacro ("__CC65__", GetVersionAsNumber ());
 
     /* Language standard that is supported */
     DefineNumericMacro ("__CC65_STD_C89__", STD_C89);
@@ -335,12 +348,19 @@ void Compile (const char* FileName)
     DefineTextMacro ("__DATE__", DateStr);
     DefineTextMacro ("__TIME__", TimeStr);
 
-    /* Initialize the literal pool */
-    InitLiteralPool ();
+    /* Other standard macros */
+    /* DefineNumericMacro ("__STDC__", 1);      <- not now */
+    DefineNumericMacro ("__STDC_HOSTED__", 1);
 
     /* Create the base lexical level */
     EnterGlobalLevel ();
 
+    /* Create the global code and data segments */
+    CreateGlobalSegments ();
+
+    /* Initialize the literal pool */
+    InitLiteralPool ();
+
     /* Generate the code generator preamble */
     g_preamble ();
 
@@ -356,41 +376,60 @@ void Compile (const char* FileName)
         /* Preprocess each line and write it to the output file */
         while (NextLine ()) {
             Preprocess ();
-            WriteOutput ("%.*s\n", SB_GetLen (Line), SB_GetConstBuf (Line));
+            WriteOutput ("%.*s\n", (int) SB_GetLen (Line), SB_GetConstBuf (Line));
         }
 
         /* Close the output file */
         CloseOutputFile ();
 
-        if (Debug) {
-            PrintMacroStats (stdout);
-        }
-
     } else {
 
         /* Ok, start the ball rolling... */
         Parse ();
 
-        /* Dump the literal pool. */
-        DumpLiteralPool ();
+    }
+
+    if (Debug) {
+        PrintMacroStats (stdout);
+    }
+
+    /* Print an error report */
+    ErrorReport ();
+}
 
-        /* Write imported/exported symbols */
-        EmitExternals ();
 
-        if (Debug) {
-            PrintLiteralPoolStats (stdout);
-            PrintMacroStats (stdout);
-        }
 
+void FinishCompile (void)
+/* Emit literals, externals, debug info, do cleanup and optimizations */
+{
+    SymTable* SymTab;
+    SymEntry* Func;
+
+    /* Walk over all functions, doing cleanup, optimizations ... */
+    SymTab = GetGlobalSymTab ();
+    Func   = SymTab->SymHead;
+    while (Func) {
+        if (SymIsOutputFunc (Func)) {
+            /* Function which is defined and referenced or extern */
+            MoveLiteralPool (Func->V.F.LitPool);
+            CS_MergeLabels (Func->V.F.Seg->Code);
+            RunOpt (Func->V.F.Seg->Code);
+        }
+        Func = Func->NextSym;
     }
 
+    /* Output the literal pool */
+    OutputLiteralPool ();
+
+    /* Emit debug infos if enabled */
+    EmitDebugInfo ();
+
+    /* Write imported/exported symbols */
+    EmitExternals ();
+
     /* Leave the main lexical level */
     LeaveGlobalLevel ();
-
-    /* Print an error report */
-    ErrorReport ();
 }
 
 
 
-