/* */
/* compile.c */
/* */
-/* Top level compiler subroutine */
+/* Top level compiler subroutine */
/* */
/* */
/* */
-/* (C) 2000-2008 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 */
#include "asmlabel.h"
#include "asmstmt.h"
#include "codegen.h"
+#include "codeopt.h"
#include "compile.h"
#include "declare.h"
#include "error.h"
#include "input.h"
#include "litpool.h"
#include "macrotab.h"
+#include "output.h"
#include "pragma.h"
#include "preproc.h"
#include "standard.h"
while (CurTok.Tok != TOK_CEOF) {
DeclSpec Spec;
- Declaration Decl;
/* Check for empty statements */
if (CurTok.Tok == TOK_SEMI) {
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;
}
comma = 0;
while (1) {
+ Declaration Decl;
+
/* Read the next declaration */
ParseDecl (&Spec, &Decl, DM_NEED_IDENT);
if (Decl.Ident[0] == '\0') {
}
/* 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;
}
+ /* 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);
+ /* Add declaration attributes */
+ SymUseAttr (Entry, &Decl);
+
/* Reserve storage for the variable if we need to */
if (Decl.StorageClass & SC_STORAGE) {
}
}
- /* 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 ();
}
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);
}
};
/* Add macros that are always defined */
- DefineNumericMacro ("__CC65__", VERSION);
+ DefineNumericMacro ("__CC65__", GetVersionAsNumber ());
/* Language standard that is supported */
DefineNumericMacro ("__CC65_STD_C89__", STD_C89);
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 ();
/* 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", (int) SB_GetLen (Line), SB_GetConstBuf (Line));
}
- if (Debug) {
- PrintMacroStats (stdout);
- }
+ /* Close the output file */
+ CloseOutputFile ();
} else {
/* Ok, start the ball rolling... */
Parse ();
- /* Dump the literal pool. */
- DumpLiteralPool ();
+ }
- /* Write imported/exported symbols */
- EmitExternals ();
+ if (Debug) {
+ PrintMacroStats (stdout);
+ }
+
+ /* Print an error report */
+ ErrorReport ();
+}
- 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 ();
}
-
projects / cc65 / blobdiff