Since we have now builtin search paths, we need to be able to forget them,

[cc65] / src / cc65 / compile.c

diff --git a/src/cc65/compile.c b/src/cc65/compile.c
index bfec3eda5ef566454a5d8171b07745b32369b8c8..befb1e9c682a35d95d9da15ffa98e866aca26169 100644 (file)
--- a/src/cc65/compile.c
+++ b/src/cc65/compile.c
@@ -2,12 +2,12 @@
 /*                                                                           */
 /*                                compile.c                                 */
 /*                                                                           */
-/*                      Top level compiler subroutine                       */
+/*                      Top level compiler subroutine                       */
 /*                                                                           */
 /*                                                                           */
 /*                                                                           */
-/* (C) 2000-2004 Ullrich von Bassewitz                                       */
-/*               Römerstrasse 52                                             */
+/* (C) 2000-2009 Ullrich von Bassewitz                                       */
+/*               Roemerstrasse 52                                            */
 /*               D-70794 Filderstadt                                         */
 /* EMail:        uz@cc65.org                                                 */
 /*                                                                           */
@@ -55,6 +55,7 @@
 #include "input.h"
 #include "litpool.h"
 #include "macrotab.h"
+#include "output.h"
 #include "pragma.h"
 #include "preproc.h"
 #include "standard.h"
@@ -83,7 +84,6 @@ static void Parse (void)
 
        DeclSpec        Spec;
        Declaration     Decl;
-       int             NeedStorage;
 
        /* Check for empty statements */
        if (CurTok.Tok == TOK_SEMI) {
@@ -123,23 +123,11 @@ static void Parse (void)
            continue;
        }
 
-               /* Check if we must reserve storage for the variable. We do
-        * this 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.
-        */
-       NeedStorage = (Spec.StorageClass & SC_TYPEDEF) == 0 &&
-                     ((Spec.Flags & DS_DEF_STORAGE) != 0  ||
-                     (Spec.StorageClass & (SC_STATIC | SC_EXTERN)) == SC_STATIC);
-
        /* Read declarations for this type */
        Entry = 0;
        comma = 0;
                while (1) {
 
-           unsigned SymFlags;
-
            /* Read the next declaration */
            ParseDecl (&Spec, &Decl, DM_NEED_IDENT);
            if (Decl.Ident[0] == '\0') {
@@ -147,22 +135,41 @@ static void Parse (void)
                break;
            }
 
-           /* Get the symbol flags */
-           SymFlags = Spec.StorageClass;
-           if (IsTypeFunc (Decl.Type)) {
-               SymFlags |= SC_FUNC;
-           } else {
-               if (NeedStorage) {
-                   /* We will allocate storage, variable is defined */
-                   SymFlags |= SC_STORAGE | SC_DEF;
-               }
+            /* 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 ((Decl.StorageClass & SC_FUNC) != SC_FUNC          &&
+                (Decl.StorageClass & SC_TYPEDEF) != SC_TYPEDEF    &&
+                ((Spec.Flags & DS_DEF_STORAGE) != 0  ||
+                 (Decl.StorageClass & (SC_STATIC | SC_EXTERN)) == SC_STATIC)) {
+
+                /* We will allocate storage */
+               Decl.StorageClass |= SC_STORAGE | SC_DEF;
            }
 
+            /* If this is a function declarator that is not followed by a comma
+             * or semicolon, it must be followed by a function body. If this is
+             * the case, convert an empty parameter list into one accepting no
+             * parameters (same as void) as required by the standard.
+             */
+            if ((Decl.StorageClass & SC_FUNC) != 0 &&
+                (CurTok.Tok != TOK_COMMA)          &&
+                (CurTok.Tok != TOK_SEMI)) {
+
+                FuncDesc* D = GetFuncDesc (Decl.Type);
+                if (D->Flags & FD_EMPTY) {
+                    D->Flags = (D->Flags & ~(FD_EMPTY | FD_VARIADIC)) | FD_VOID_PARAM;
+                }
+            }
+
            /* Add an entry to the symbol table */
-           Entry = AddGlobalSym (Decl.Ident, Decl.Type, SymFlags);
+           Entry = AddGlobalSym (Decl.Ident, Decl.Type, Decl.StorageClass);
 
            /* Reserve storage for the variable if we need to */
-                   if (SymFlags & SC_STORAGE) {
+                   if (Decl.StorageClass & SC_STORAGE) {
 
                /* Get the size of the variable */
                unsigned Size = SizeOf (Decl.Type);
@@ -185,9 +192,14 @@ static void Parse (void)
                        }
                    }
 
-                   /* Switch to the data or rodata segment */
-                   if (IsQualConst (Decl.Type)) {
-                       g_userodata ();
+                   /* Switch to the data or rodata segment. For arrays, check
+                      * the element qualifiers, since not the array but its
+                      * elements are const.
+                      */
+                   if (IsQualConst (Decl.Type) ||
+                        (IsTypeArray (Decl.Type) &&
+                         IsQualConst (GetElementType (Decl.Type)))) {
+                       g_userodata ();
                    } else {
                        g_usedata ();
                    }
@@ -247,12 +259,15 @@ static void Parse (void)
                if (CurTok.Tok == TOK_SEMI) {
                    /* Prototype only */
                    NextToken ();
-               } else if (Entry) {
-                    /* Function body definition */
+               } else {
+
+                    /* Function body. Check for duplicate function definitions */
                     if (SymIsDef (Entry)) {
                         Error ("Body for function `%s' has already been defined",
                                Entry->Name);
                     }
+
+                    /* Parse the function body */
                     NewFunc (Entry);
                }
            }
@@ -335,11 +350,18 @@ void Compile (const char* FileName)
     /* Are we supposed to compile or just preprocess the input? */
     if (PreprocessOnly) {
 
+       /* Open the file */
+        OpenOutputFile ();
+
+        /* Preprocess each line and write it to the output file */
         while (NextLine ()) {
             Preprocess ();
-            printf ("%.*s\n", SB_GetLen (Line), SB_GetConstBuf (Line));
+            WriteOutput ("%.*s\n", SB_GetLen (Line), SB_GetConstBuf (Line));
         }
 
+        /* Close the output file */
+        CloseOutputFile ();
+
         if (Debug) {
             PrintMacroStats (stdout);
         }