1 /*****************************************************************************/
5 /* Top level compiler subroutine */
9 /* (C) 2000-2013, Ullrich von Bassewitz */
10 /* Roemerstrasse 52 */
11 /* D-70794 Filderstadt */
12 /* EMail: uz@cc65.org */
15 /* This software is provided 'as-is', without any expressed or implied */
16 /* warranty. In no event will the authors be held liable for any damages */
17 /* arising from the use of this software. */
19 /* Permission is granted to anyone to use this software for any purpose, */
20 /* including commercial applications, and to alter it and redistribute it */
21 /* freely, subject to the following restrictions: */
23 /* 1. The origin of this software must not be misrepresented; you must not */
24 /* claim that you wrote the original software. If you use this software */
25 /* in a product, an acknowledgment in the product documentation would be */
26 /* appreciated but is not required. */
27 /* 2. Altered source versions must be plainly marked as such, and must not */
28 /* be misrepresented as being the original software. */
29 /* 3. This notice may not be removed or altered from any source */
32 /*****************************************************************************/
40 #include "debugflag.h"
67 /*****************************************************************************/
69 /*****************************************************************************/
73 static void Parse (void)
74 /* Top level parser routine. */
83 /* Parse until end of input */
84 while (CurTok.Tok != TOK_CEOF) {
88 /* Check for empty statements */
89 if (CurTok.Tok == TOK_SEMI) {
94 /* Disallow ASM statements on global level */
95 if (CurTok.Tok == TOK_ASM) {
96 Error ("__asm__ is not allowed here");
97 /* Parse and remove the statement for error recovery */
104 /* Check for a #pragma */
105 if (CurTok.Tok == TOK_PRAGMA) {
110 /* Read variable defs and functions */
111 ParseDeclSpec (&Spec, SC_EXTERN | SC_STATIC, T_INT);
113 /* Don't accept illegal storage classes */
114 if ((Spec.StorageClass & SC_TYPE) == 0) {
115 if ((Spec.StorageClass & SC_AUTO) != 0 ||
116 (Spec.StorageClass & SC_REGISTER) != 0) {
117 Error ("Illegal storage class");
118 Spec.StorageClass = SC_EXTERN | SC_STATIC;
122 /* Check if this is only a type declaration */
123 if (CurTok.Tok == TOK_SEMI) {
124 CheckEmptyDecl (&Spec);
129 /* Read declarations for this type */
136 /* Read the next declaration */
137 ParseDecl (&Spec, &Decl, DM_NEED_IDENT);
138 if (Decl.Ident[0] == '\0') {
143 /* Check if we must reserve storage for the variable. We do this,
145 ** - if it is not a typedef or function,
146 ** - if we don't had a storage class given ("int i")
147 ** - if the storage class is explicitly specified as static,
148 ** - or if there is an initialization.
150 ** This means that "extern int i;" will not get storage allocated.
152 if ((Decl.StorageClass & SC_FUNC) != SC_FUNC &&
153 (Decl.StorageClass & SC_TYPEMASK) != SC_TYPEDEF &&
154 ((Spec.Flags & DS_DEF_STORAGE) != 0 ||
155 (Decl.StorageClass & (SC_EXTERN|SC_STATIC)) == SC_STATIC ||
156 ((Decl.StorageClass & SC_EXTERN) != 0 &&
157 CurTok.Tok == TOK_ASSIGN))) {
159 /* We will allocate storage */
160 Decl.StorageClass |= SC_STORAGE;
163 /* If this is a function declarator that is not followed by a comma
164 ** or semicolon, it must be followed by a function body. If this is
165 ** the case, convert an empty parameter list into one accepting no
166 ** parameters (same as void) as required by the standard.
168 if ((Decl.StorageClass & SC_FUNC) != 0 &&
169 (CurTok.Tok != TOK_COMMA) &&
170 (CurTok.Tok != TOK_SEMI)) {
172 FuncDesc* D = GetFuncDesc (Decl.Type);
173 if (D->Flags & FD_EMPTY) {
174 D->Flags = (D->Flags & ~(FD_EMPTY | FD_VARIADIC)) | FD_VOID_PARAM;
178 /* Add an entry to the symbol table */
179 Entry = AddGlobalSym (Decl.Ident, Decl.Type, Decl.StorageClass);
181 /* Add declaration attributes */
182 SymUseAttr (Entry, &Decl);
184 /* Reserve storage for the variable if we need to */
185 if (Decl.StorageClass & SC_STORAGE) {
187 /* Get the size of the variable */
188 unsigned Size = SizeOf (Decl.Type);
190 /* Allow initialization */
191 if (CurTok.Tok == TOK_ASSIGN) {
193 /* This is a definition */
194 if (SymIsDef (Entry)) {
195 Error ("Global variable '%s' has already been defined",
198 Entry->Flags |= SC_DEF;
200 /* We cannot initialize types of unknown size, or
201 ** void types in ISO modes.
204 if (!IsTypeVoid (Decl.Type)) {
205 if (!IsTypeArray (Decl.Type)) {
206 /* Size is unknown and not an array */
207 Error ("Variable '%s' has unknown size", Decl.Ident);
209 } else if (IS_Get (&Standard) != STD_CC65) {
210 /* We cannot declare variables of type void */
211 Error ("Illegal type for variable '%s'", Decl.Ident);
215 /* Switch to the data or rodata segment. For arrays, check
216 ** the element qualifiers, since not the array but its
217 ** elements are const.
219 if (IsQualConst (GetBaseElementType (Decl.Type))) {
226 g_defgloblabel (Entry->Name);
231 /* Parse the initialization */
232 ParseInit (Entry->Type);
235 if (IsTypeVoid (Decl.Type)) {
236 /* We cannot declare variables of type void */
237 Error ("Illegal type for variable '%s'", Decl.Ident);
238 Entry->Flags &= ~(SC_STORAGE | SC_DEF);
239 } else if (Size == 0) {
240 /* Size is unknown. Is it an array? */
241 if (!IsTypeArray (Decl.Type)) {
242 Error ("Variable '%s' has unknown size", Decl.Ident);
244 Entry->Flags &= ~(SC_STORAGE | SC_DEF);
246 /* A global (including static) uninitialized variable is
247 ** only a tentative definition. For example, this is valid:
251 ** static int j = 42;
252 ** Code for them will be generated by FinishCompile().
253 ** For now, just save the BSS segment name
254 ** (can be set by #pragma bss-name).
256 const char* bssName = GetSegName (SEG_BSS);
258 if (Entry->V.BssName && strcmp (Entry->V.BssName, bssName) != 0) {
259 Error ("Global variable '%s' already was defined in the '%s' segment.",
260 Entry->Name, Entry->V.BssName);
262 Entry->V.BssName = xstrdup (bssName);
268 /* Check for end of declaration list */
269 if (CurTok.Tok == TOK_COMMA) {
277 /* Function declaration? */
278 if (Entry && IsTypeFunc (Entry->Type)) {
282 if (CurTok.Tok == TOK_SEMI) {
287 /* Function body. Check for duplicate function definitions */
288 if (SymIsDef (Entry)) {
289 Error ("Body for function '%s' has already been defined",
293 /* Parse the function body */
300 /* Must be followed by a semicolon */
309 void Compile (const char* FileName)
310 /* Top level compile routine. Will setup things and call the parser. */
317 /* Since strftime is locale dependent, we need the abbreviated month names
320 static const char MonthNames[12][4] = {
321 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
322 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
325 /* Add macros that are always defined */
326 DefineNumericMacro ("__CC65__", GetVersionAsNumber ());
328 /* Language standard that is supported */
329 DefineNumericMacro ("__CC65_STD_C89__", STD_C89);
330 DefineNumericMacro ("__CC65_STD_C99__", STD_C99);
331 DefineNumericMacro ("__CC65_STD_CC65__", STD_CC65);
332 DefineNumericMacro ("__CC65_STD__", IS_Get (&Standard));
334 /* Optimization macros. Since no source code has been parsed for now, the
335 ** IS_Get functions access the values in effect now, regardless of any
336 ** changes using #pragma later.
338 if (IS_Get (&Optimize)) {
339 DefineNumericMacro ("__OPT__", 1);
342 long CodeSize = IS_Get (&CodeSizeFactor);
343 if (CodeSize > 100) {
344 DefineNumericMacro ("__OPT_i__", CodeSize);
347 if (IS_Get (&EnableRegVars)) {
348 DefineNumericMacro ("__OPT_r__", 1);
350 if (IS_Get (&InlineStdFuncs)) {
351 DefineNumericMacro ("__OPT_s__", 1);
353 if (IS_Get (&EagerlyInlineFuncs)) {
354 DefineNumericMacro ("__EAGERLY_INLINE_FUNCS__", 1);
357 /* __TIME__ and __DATE__ macros */
359 TM = localtime (&Time);
360 xsprintf (DateStr, sizeof (DateStr), "\"%s %2d %d\"",
361 MonthNames[TM->tm_mon], TM->tm_mday, TM->tm_year + 1900);
362 strftime (TimeStr, sizeof (TimeStr), "\"%H:%M:%S\"", TM);
363 DefineTextMacro ("__DATE__", DateStr);
364 DefineTextMacro ("__TIME__", TimeStr);
366 /* Other standard macros */
367 /* DefineNumericMacro ("__STDC__", 1); <- not now */
368 DefineNumericMacro ("__STDC_HOSTED__", 1);
370 /* Create the base lexical level */
373 /* Create the global code and data segments */
374 CreateGlobalSegments ();
376 /* Initialize the literal pool */
379 /* Generate the code generator preamble */
382 /* Open the input file */
383 OpenMainFile (FileName);
385 /* Are we supposed to compile or just preprocess the input? */
386 if (PreprocessOnly) {
391 /* Preprocess each line and write it to the output file */
392 while (NextLine ()) {
394 WriteOutput ("%.*s\n", (int) SB_GetLen (Line), SB_GetConstBuf (Line));
397 /* Close the output file */
402 /* Ok, start the ball rolling... */
408 PrintMacroStats (stdout);
411 /* Print an error report */
417 void FinishCompile (void)
418 /* Emit literals, externals, debug info, do cleanup and optimizations */
422 /* Walk over all global symbols:
423 ** - for functions, do clean-up and optimizations
424 ** - generate code for uninitialized global variables
426 for (Entry = GetGlobalSymTab ()->SymHead; Entry; Entry = Entry->NextSym) {
427 if (SymIsOutputFunc (Entry)) {
428 /* Function which is defined and referenced or extern */
429 MoveLiteralPool (Entry->V.F.LitPool);
430 CS_MergeLabels (Entry->V.F.Seg->Code);
431 RunOpt (Entry->V.F.Seg->Code);
432 } else if ((Entry->Flags & (SC_STORAGE | SC_DEF | SC_STATIC)) == (SC_STORAGE | SC_STATIC)) {
433 /* Assembly definition of uninitialized global variable */
435 /* Set the segment name only when it changes */
436 if (strcmp (GetSegName (SEG_BSS), Entry->V.BssName) != 0) {
437 SetSegName (SEG_BSS, Entry->V.BssName);
441 g_defgloblabel (Entry->Name);
442 g_res (SizeOf (Entry->Type));
443 /* Mark as defined; so that it will be exported, not imported */
444 Entry->Flags |= SC_DEF;
448 /* Output the literal pool */
449 OutputLiteralPool ();
451 /* Emit debug infos if enabled */
454 /* Write imported/exported symbols */
457 /* Leave the main lexical level */