/*****************************************************************************/
/* */
-/* compile.c */
+/* compile.c */
/* */
-/* Top level compiler subroutine */
+/* Top level compiler subroutine */
/* */
/* */
/* */
-/* (C) 2000-2012, Ullrich von Bassewitz */
+/* (C) 2000-2013, Ullrich von Bassewitz */
/* Roemerstrasse 52 */
/* D-70794 Filderstadt */
/* EMail: uz@cc65.org */
/*****************************************************************************/
-/* Code */
+/* Code */
/*****************************************************************************/
/* Parse until end of input */
while (CurTok.Tok != TOK_CEOF) {
- DeclSpec Spec;
+ DeclSpec Spec;
- /* Check for empty statements */
- if (CurTok.Tok == TOK_SEMI) {
- NextToken ();
- continue;
- }
+ /* Check for empty statements */
+ if (CurTok.Tok == TOK_SEMI) {
+ NextToken ();
+ continue;
+ }
- /* Disallow ASM statements on global level */
- if (CurTok.Tok == TOK_ASM) {
+ /* 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 ();
+ AsmStatement ();
+ ConsumeSemi ();
RemoveGlobalCode ();
- continue;
- }
+ continue;
+ }
- /* Check for a #pragma */
- if (CurTok.Tok == TOK_PRAGMA) {
- DoPragma ();
- continue;
- }
+ /* Check for a #pragma */
+ if (CurTok.Tok == TOK_PRAGMA) {
+ DoPragma ();
+ continue;
+ }
- /* Read variable defs and functions */
- ParseDeclSpec (&Spec, SC_EXTERN | SC_STATIC, T_INT);
+ /* Read variable defs and functions */
+ ParseDeclSpec (&Spec, SC_EXTERN | SC_STATIC, T_INT);
- /* Don't accept illegal storage classes */
+ /* Don't accept illegal storage classes */
if ((Spec.StorageClass & SC_TYPE) == 0) {
if ((Spec.StorageClass & SC_AUTO) != 0 ||
(Spec.StorageClass & SC_REGISTER) != 0) {
}
}
- /* Check if this is only a type declaration */
- if (CurTok.Tok == TOK_SEMI) {
- CheckEmptyDecl (&Spec);
- NextToken ();
- continue;
- }
+ /* Check if this is only a type declaration */
+ if (CurTok.Tok == TOK_SEMI) {
+ CheckEmptyDecl (&Spec);
+ NextToken ();
+ continue;
+ }
- /* Read declarations for this type */
- Entry = 0;
- comma = 0;
- while (1) {
+ /* Read declarations for this type */
+ Entry = 0;
+ comma = 0;
+ while (1) {
Declaration Decl;
- /* Read the next declaration */
- ParseDecl (&Spec, &Decl, DM_NEED_IDENT);
- if (Decl.Ident[0] == '\0') {
- NextToken ();
- break;
- }
+ /* Read the next declaration */
+ ParseDecl (&Spec, &Decl, DM_NEED_IDENT);
+ if (Decl.Ident[0] == '\0') {
+ NextToken ();
+ break;
+ }
/* 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")
- * - 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) != SC_FUNC &&
- (Decl.StorageClass & SC_TYPEDEF) != SC_TYPEDEF &&
+ **
+ ** - 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) != SC_FUNC &&
+ (Decl.StorageClass & SC_TYPEMASK) != 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;
- }
+ Decl.StorageClass |= SC_STORAGE;
+ }
/* 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.
- */
+ ** 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)) {
}
}
- /* Add an entry to the symbol table */
- Entry = AddGlobalSym (Decl.Ident, Decl.Type, Decl.StorageClass);
+ /* 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) {
-
- /* Get the size of the variable */
- unsigned Size = SizeOf (Decl.Type);
-
- /* Allow initialization */
- if (CurTok.Tok == TOK_ASSIGN) {
-
- /* We cannot initialize types of unknown size, or
- * void types in non ANSI mode.
- */
- if (Size == 0) {
- if (!IsTypeVoid (Decl.Type)) {
- if (!IsTypeArray (Decl.Type)) {
- /* Size is unknown and not an array */
- Error ("Variable `%s' has unknown size", Decl.Ident);
- }
- } else if (IS_Get (&Standard) != STD_CC65) {
- /* We cannot declare variables of type void */
- Error ("Illegal type for variable `%s'", Decl.Ident);
- }
- }
-
- /* Switch to the data or rodata segment. For arrays, check
- * the element qualifiers, since not the array but its
- * elements are const.
- */
- if (IsQualConst (GetBaseElementType (Decl.Type))) {
- g_userodata ();
- } else {
- g_usedata ();
- }
-
- /* Define a label */
- g_defgloblabel (Entry->Name);
-
- /* Skip the '=' */
- NextToken ();
-
- /* Parse the initialization */
- ParseInit (Entry->Type);
- } else {
-
- if (IsTypeVoid (Decl.Type)) {
- /* We cannot declare variables of type void */
- Error ("Illegal type for variable `%s'", Decl.Ident);
+ /* Reserve storage for the variable if we need to */
+ if (Decl.StorageClass & SC_STORAGE) {
+
+ /* Get the size of the variable */
+ unsigned Size = SizeOf (Decl.Type);
+
+ /* Allow initialization */
+ if (CurTok.Tok == TOK_ASSIGN) {
+
+ /* This is a definition */
+ if (SymIsDef (Entry)) {
+ Error ("Global variable `%s' has already been defined",
+ Entry->Name);
+ }
+ Entry->Flags |= SC_DEF;
+
+ /* We cannot initialize types of unknown size, or
+ ** void types in ISO modes.
+ */
+ if (Size == 0) {
+ if (!IsTypeVoid (Decl.Type)) {
+ if (!IsTypeArray (Decl.Type)) {
+ /* Size is unknown and not an array */
+ Error ("Variable `%s' has unknown size", Decl.Ident);
+ }
+ } else if (IS_Get (&Standard) != STD_CC65) {
+ /* We cannot declare variables of type void */
+ Error ("Illegal type for variable `%s'", Decl.Ident);
+ }
+ }
+
+ /* Switch to the data or rodata segment. For arrays, check
+ ** the element qualifiers, since not the array but its
+ ** elements are const.
+ */
+ if (IsQualConst (GetBaseElementType (Decl.Type))) {
+ g_userodata ();
+ } else {
+ g_usedata ();
+ }
+
+ /* Define a label */
+ g_defgloblabel (Entry->Name);
+
+ /* Skip the '=' */
+ NextToken ();
+
+ /* Parse the initialization */
+ ParseInit (Entry->Type);
+ } else {
+
+ if (IsTypeVoid (Decl.Type)) {
+ /* We cannot declare variables of type void */
+ Error ("Illegal type for variable `%s'", Decl.Ident);
Entry->Flags &= ~(SC_STORAGE | SC_DEF);
} else if (Size == 0) {
- /* Size is unknown. Is it an array? */
+ /* Size is unknown. Is it an array? */
if (!IsTypeArray (Decl.Type)) {
Error ("Variable `%s' has unknown size", Decl.Ident);
}
Entry->Flags &= ~(SC_STORAGE | SC_DEF);
- }
-
- /* Allocate storage if it is still needed */
- if (Entry->Flags & SC_STORAGE) {
-
- /* Switch to the BSS segment */
- g_usebss ();
-
- /* Define a label */
- g_defgloblabel (Entry->Name);
-
- /* Allocate space for uninitialized variable */
- g_res (Size);
+ } else {
+ /* A global (including static) uninitialized variable is
+ ** only a tentative definition. For example, this is valid:
+ ** int i;
+ ** int i;
+ ** static int j;
+ ** static int j = 42;
+ ** Code for them will be generated by FinishCompile().
+ ** For now, just save the BSS segment name
+ ** (can be set by #pragma bss-name).
+ */
+ const char* bssName = GetSegName (SEG_BSS);
+
+ if (Entry->V.BssName && strcmp (Entry->V.BssName, bssName) != 0) {
+ Error ("Global variable `%s' already was defined in the `%s' segment.",
+ Entry->Name, Entry->V.BssName);
+ }
+ Entry->V.BssName = xstrdup (bssName);
}
- }
+ }
- }
+ }
- /* Check for end of declaration list */
- if (CurTok.Tok == TOK_COMMA) {
- NextToken ();
- comma = 1;
- } else {
- break;
- }
- }
+ /* Check for end of declaration list */
+ if (CurTok.Tok == TOK_COMMA) {
+ NextToken ();
+ comma = 1;
+ } else {
+ break;
+ }
+ }
- /* Function declaration? */
- if (Entry && IsTypeFunc (Entry->Type)) {
+ /* Function declaration? */
+ if (Entry && IsTypeFunc (Entry->Type)) {
- /* Function */
- if (!comma) {
- if (CurTok.Tok == TOK_SEMI) {
- /* Prototype only */
- NextToken ();
- } else {
+ /* Function */
+ if (!comma) {
+ if (CurTok.Tok == TOK_SEMI) {
+ /* Prototype only */
+ NextToken ();
+ } else {
/* Function body. Check for duplicate function definitions */
if (SymIsDef (Entry)) {
/* Parse the function body */
NewFunc (Entry);
- }
- }
+ }
+ }
- } else {
+ } else {
- /* Must be followed by a semicolon */
- ConsumeSemi ();
+ /* Must be followed by a semicolon */
+ ConsumeSemi ();
- }
+ }
}
}
struct tm* TM;
/* Since strftime is locale dependent, we need the abbreviated month names
- * in english.
- */
+ ** in English.
+ */
static const char MonthNames[12][4] = {
"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
DefineNumericMacro ("__CC65_STD__", IS_Get (&Standard));
/* Optimization macros. Since no source code has been parsed for now, the
- * IS_Get functions access the values in effect now, regardless of any
- * changes using #pragma later.
- */
+ ** IS_Get functions access the values in effect now, regardless of any
+ ** changes using #pragma later.
+ */
if (IS_Get (&Optimize)) {
+ DefineNumericMacro ("__OPT__", 1);
+ }
+ {
long CodeSize = IS_Get (&CodeSizeFactor);
- DefineNumericMacro ("__OPT__", 1);
- if (CodeSize > 100) {
- DefineNumericMacro ("__OPT_i__", CodeSize);
- }
- if (IS_Get (&EnableRegVars)) {
- DefineNumericMacro ("__OPT_r__", 1);
- }
- if (IS_Get (&InlineStdFuncs)) {
- DefineNumericMacro ("__OPT_s__", 1);
- }
+ if (CodeSize > 100) {
+ DefineNumericMacro ("__OPT_i__", CodeSize);
+ }
+ }
+ if (IS_Get (&EnableRegVars)) {
+ DefineNumericMacro ("__OPT_r__", 1);
+ }
+ if (IS_Get (&InlineStdFuncs)) {
+ DefineNumericMacro ("__OPT_s__", 1);
+ }
+ if (IS_Get (&EagerlyInlineFuncs)) {
+ DefineNumericMacro ("__EAGERLY_INLINE_FUNCS__", 1);
}
/* __TIME__ and __DATE__ macros */
/* Are we supposed to compile or just preprocess the input? */
if (PreprocessOnly) {
- /* Open the file */
+ /* Open the file */
OpenOutputFile ();
/* Preprocess each line and write it to the output file */
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)) {
+ SymEntry* Entry;
+
+ /* Walk over all global symbols:
+ ** - for functions, do clean-up and optimizations
+ ** - generate code for uninitialized global variables
+ */
+ for (Entry = GetGlobalSymTab ()->SymHead; Entry; Entry = Entry->NextSym) {
+ if (SymIsOutputFunc (Entry)) {
/* 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);
+ MoveLiteralPool (Entry->V.F.LitPool);
+ CS_MergeLabels (Entry->V.F.Seg->Code);
+ RunOpt (Entry->V.F.Seg->Code);
+ } else if ((Entry->Flags & (SC_STORAGE | SC_DEF | SC_STATIC)) == (SC_STORAGE | SC_STATIC)) {
+ /* Assembly definition of uninitialized global variable */
+
+ /* Set the segment name only when it changes */
+ if (strcmp (GetSegName (SEG_BSS), Entry->V.BssName) != 0) {
+ SetSegName (SEG_BSS, Entry->V.BssName);
+ g_segname (SEG_BSS);
+ }
+ g_usebss ();
+ g_defgloblabel (Entry->Name);
+ g_res (SizeOf (Entry->Type));
+ /* Mark as defined; so that it will be exported, not imported */
+ Entry->Flags |= SC_DEF;
}
- Func = Func->NextSym;
}
/* Output the literal pool */
/* Leave the main lexical level */
LeaveGlobalLevel ();
}
-
-
-