/* */
/* 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 */
/* */
#include "input.h"
#include "litpool.h"
#include "macrotab.h"
+#include "output.h"
#include "pragma.h"
#include "preproc.h"
#include "standard.h"
DeclSpec Spec;
Declaration Decl;
- int NeedStorage;
/* Check for empty statements */
if (CurTok.Tok == TOK_SEMI) {
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') {
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);
}
}
- /* 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 ();
}
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);
}
}
void Compile (const char* FileName)
/* Top level compile routine. Will setup things and call the parser. */
{
- char Buf[20];
- char DateStr[20];
- char TimeStr[20];
+ char DateStr[32];
+ char TimeStr[32];
time_t Time;
struct tm* TM;
*/
if (IS_Get (&Optimize)) {
long CodeSize = IS_Get (&CodeSizeFactor);
- DefineNumericMacro ("__OPT__", 1);
+ DefineNumericMacro ("__OPT__", 1);
if (CodeSize > 100) {
- DefineNumericMacro ("__OPT_i__", CodeSize);
- }
- if (IS_Get (&EnableRegVars)) {
- DefineNumericMacro ("__OPT_r__", 1);
- }
+ DefineNumericMacro ("__OPT_i__", CodeSize);
+ }
+ if (IS_Get (&EnableRegVars)) {
+ DefineNumericMacro ("__OPT_r__", 1);
+ }
if (IS_Get (&InlineStdFuncs)) {
- DefineNumericMacro ("__OPT_s__", 1);
- }
+ DefineNumericMacro ("__OPT_s__", 1);
+ }
}
/* __TIME__ and __DATE__ macros */
Time = time (0);
TM = localtime (&Time);
- strftime (Buf, sizeof (Buf), "%e %Y", TM);
- xsprintf (DateStr, sizeof (DateStr), "\"%s %s\"", MonthNames[TM->tm_mon], Buf);
+ xsprintf (DateStr, sizeof (DateStr), "\"%s %2d %d\"",
+ MonthNames[TM->tm_mon], TM->tm_mday, TM->tm_year + 1900);
strftime (TimeStr, sizeof (TimeStr), "\"%H:%M:%S\"", TM);
DefineTextMacro ("__DATE__", DateStr);
DefineTextMacro ("__TIME__", TimeStr);
/* 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);
}