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 2157a748e83bf56baf6b6e92e594c1b28d58cdfb..befb1e9c682a35d95d9da15ffa98e866aca26169 100644 (file)
--- a/src/cc65/compile.c
+++ b/src/cc65/compile.c
@@ -2,11 +2,11 @@
 /*                                                                           */
 /*                                compile.c                                 */
 /*                                                                           */
-/*                      Top level compiler subroutine                       */
+/*                      Top level compiler subroutine                       */
 /*                                                                           */
 /*                                                                           */
 /*                                                                           */
-/* (C) 2000-2008 Ullrich von Bassewitz                                       */
+/* (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"
@@ -140,8 +141,8 @@ static void Parse (void)
              * specified as static. This means that "extern int i" will not
              * get storage allocated.
              */
-           if ((Decl.StorageClass & SC_FUNC) == 0      &&
-                (Decl.StorageClass & SC_TYPEDEF) == 0   &&
+           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)) {
 
@@ -149,6 +150,21 @@ static void Parse (void)
                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, Decl.StorageClass);
 
@@ -176,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 ();
                    }
@@ -240,25 +261,12 @@ static void Parse (void)
                    NextToken ();
                } else {
 
-                    FuncDesc* D;
-
                     /* Function body. Check for duplicate function definitions */
                     if (SymIsDef (Entry)) {
                         Error ("Body for function `%s' has already been defined",
                                Entry->Name);
                     }
 
-                    /* An empty parameter list in a function definition means
-                     * that the function doesn't take any parameters. The same
-                     * in a declarator means that the function can take any
-                     * number of parameters. This seems weird but is necessary
-                     * to support old K&R style programs.
-                     */
-                    D = Entry->V.F.Func;
-                    if (D->Flags & FD_EMPTY) {
-                        D->Flags = (D->Flags & ~(FD_EMPTY | FD_VARIADIC)) | FD_VOID_PARAM;
-                    }
-
                     /* Parse the function body */
                     NewFunc (Entry);
                }
@@ -342,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);
         }