X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2FSDCCglue.c;h=f753441a01b4b846a60e6821771ccac47b8c472d;hb=fd94924a3d743c1c82f4b370d9401d7239172789;hp=acb2d34284eb95807086c4d0b5e9d1bbddc13be3;hpb=d2da99feec099aa224e1db53bc5a1ed42ed51ec9;p=fw%2Fsdcc diff --git a/src/SDCCglue.c b/src/SDCCglue.c index acb2d342..f753441a 100644 --- a/src/SDCCglue.c +++ b/src/SDCCglue.c @@ -23,11 +23,11 @@ -------------------------------------------------------------------------*/ #include "common.h" -#include "asm.h" #include #include "newalloc.h" #include #include +#include "dbuf_string.h" #ifdef _WIN32 #include @@ -37,100 +37,15 @@ symbol *interrupts[INTNO_MAX+1]; -void printIval (symbol *, sym_link *, initList *, FILE *); +void printIval (symbol *, sym_link *, initList *, struct dbuf_s *, bool check); set *publics = NULL; /* public variables */ set *externs = NULL; /* Variables that are declared as extern */ unsigned maxInterrupts = 0; int allocInfo = 1; symbol *mainf; -set *pipeSet = NULL; /* set of pipes */ -set *tmpfileSet = NULL; /* set of tmp file created by the compiler */ -set *tmpfileNameSet = NULL; /* All are unlinked at close. */ +int noInit = 0; /* no initialization */ -/*-----------------------------------------------------------------*/ -/* closePipes - closes all pipes created by the compiler */ -/*-----------------------------------------------------------------*/ -DEFSETFUNC (closePipes) -{ - FILE *pfile = item; - int ret; - - if (pfile) { - ret = pclose (pfile); - assert(ret != -1); - } - - return 0; -} - -/*-----------------------------------------------------------------*/ -/* closeTmpFiles - closes all tmp files created by the compiler */ -/* because of BRAIN DEAD MS/DOS & CYGNUS Libraries */ -/*-----------------------------------------------------------------*/ -DEFSETFUNC (closeTmpFiles) -{ - FILE *tfile = item; - int ret; - - if (tfile) { - ret = fclose (tfile); - assert(ret == 0); - } - - return 0; -} - -/*-----------------------------------------------------------------*/ -/* rmTmpFiles - unlinks all tmp files created by the compiler */ -/* because of BRAIN DEAD MS/DOS & CYGNUS Libraries */ -/*-----------------------------------------------------------------*/ -DEFSETFUNC (rmTmpFiles) -{ - char *name = item; - int ret; - - if (name) { - ret = unlink (name); - assert(ret == 0); - Safe_free (name); - } - - return 0; -} - -/*-----------------------------------------------------------------*/ -/* rm_tmpfiles - close and remove temporary files and delete sets */ -/*-----------------------------------------------------------------*/ -void -rm_tmpfiles (void) -{ - /* close temporary files */ - applyToSet (pipeSet, closePipes); - /* close temporary files */ - deleteSet (&pipeSet); - - applyToSet (tmpfileSet, closeTmpFiles); - /* remove temporary files */ - applyToSet (tmpfileNameSet, rmTmpFiles); - /* delete temorary file sets */ - deleteSet (&tmpfileSet); - deleteSet (&tmpfileNameSet); -} - -/*-----------------------------------------------------------------*/ -/* copyFile - copies source file to destination file */ -/*-----------------------------------------------------------------*/ -void -copyFile (FILE * dest, FILE * src) -{ - int ch; - - rewind (src); - while (!feof (src)) - if ((ch = fgetc (src)) != EOF) - fputc (ch, dest); -} char * aopLiteralLong (value * val, int offset, int size) @@ -143,22 +58,22 @@ aopLiteralLong (value * val, int offset, int size) if (!val) { // assuming we have been warned before - val=constVal("0"); + val = constCharVal (0); } /* if it is a float then it gets tricky */ /* otherwise it is fairly simple */ if (!IS_FLOAT (val->type)) { - unsigned long v = (unsigned long) floatFromVal (val); + unsigned long v = ulFromVal (val); v >>= (offset * 8); switch (size) { case 1: - tsprintf (buffer, sizeof(buffer), + tsprintf (buffer, sizeof(buffer), "!immedbyte", (unsigned int) v & 0xff); break; case 2: - tsprintf (buffer, sizeof(buffer), + tsprintf (buffer, sizeof(buffer), "!immedword", (unsigned int) v & 0xffff); break; default: @@ -174,10 +89,10 @@ aopLiteralLong (value * val, int offset, int size) /* it is type float */ fl.f = (float) floatFromVal (val); #ifdef WORDS_BIGENDIAN - tsprintf (buffer, sizeof(buffer), + tsprintf (buffer, sizeof(buffer), "!immedbyte", fl.c[3 - offset]); #else - tsprintf (buffer, sizeof(buffer), + tsprintf (buffer, sizeof(buffer), "!immedbyte", fl.c[offset]); #endif return Safe_strdup (buffer); @@ -195,7 +110,7 @@ aopLiteral (value * val, int offset) /*-----------------------------------------------------------------*/ /* emitRegularMap - emit code for maps with no special cases */ /*-----------------------------------------------------------------*/ -static void +static void emitRegularMap (memmap * map, bool addPublics, bool arFlag) { symbol *sym; @@ -208,19 +123,18 @@ emitRegularMap (memmap * map, bool addPublics, bool arFlag) { /* PENDING: special case here - should remove */ if (!strcmp (map->sname, CODE_NAME)) - tfprintf (map->oFile, "\t!areacode\n", map->sname); + dbuf_tprintf (&map->oBuf, "\t!areacode\n", map->sname); else if (!strcmp (map->sname, DATA_NAME)) - tfprintf (map->oFile, "\t!areadata\n", map->sname); + dbuf_tprintf (&map->oBuf, "\t!areadata\n", map->sname); else if (!strcmp (map->sname, HOME_NAME)) - tfprintf (map->oFile, "\t!areahome\n", map->sname); + dbuf_tprintf (&map->oBuf, "\t!areahome\n", map->sname); else - tfprintf (map->oFile, "\t!area\n", map->sname); + dbuf_tprintf (&map->oBuf, "\t!area\n", map->sname); } - - for (sym = setFirstItem (map->syms); sym; - sym = setNextItem (map->syms)) + + for (sym = setFirstItem (map->syms); sym; sym = setNextItem (map->syms)) { - symbol *newSym=NULL; + symbol *newSym = NULL; /* if extern then add it into the extern list */ if (IS_EXTERN (sym->etype)) @@ -239,10 +153,11 @@ emitRegularMap (memmap * map, bool addPublics, bool arFlag) continue; /* for bitvar locals and parameters */ - if (!arFlag && !sym->allocreq && sym->level - && !SPEC_ABSA (sym->etype)) { - continue; - } + if (!arFlag && !sym->allocreq && sym->level + && !SPEC_ABSA (sym->etype)) + { + continue; + } /* if global variable & not static or extern and addPublics allowed then add it to the public set */ @@ -250,7 +165,7 @@ emitRegularMap (memmap * map, bool addPublics, bool arFlag) (sym->_isparm && !IS_REGPARM (sym->etype))) && addPublics && !IS_STATIC (sym->etype) && - (IS_FUNC(sym->type) ? (sym->used || IFFUNC_HASBODY(sym->type)) : 1)) + (IS_FUNC (sym->type) ? (sym->used || IFFUNC_HASBODY (sym->type)) : 1)) { addSetHead (&publics, sym); } @@ -266,116 +181,135 @@ emitRegularMap (memmap * map, bool addPublics, bool arFlag) if (!sym->level) /* global */ { if (IS_STATIC (sym->etype)) - fprintf (map->oFile, "F%s$", moduleName); /* scope is file */ + dbuf_printf (&map->oBuf, "F%s$", moduleName); /* scope is file */ else - fprintf (map->oFile, "G$"); /* scope is global */ + dbuf_printf (&map->oBuf, "G$"); /* scope is global */ } else { /* symbol is local */ - fprintf (map->oFile, "L%s$", (sym->localof ? sym->localof->name : "-null-")); + dbuf_printf (&map->oBuf, "L%s$", (sym->localof ? sym->localof->name : "-null-")); } - fprintf (map->oFile, "%s$%d$%d", sym->name, sym->level, sym->block); + dbuf_printf (&map->oBuf, "%s$%d$%d", sym->name, sym->level, sym->block); } - + /* if it has an initial value then do it only if it is a global variable */ - if (sym->ival && sym->level == 0) { - if (SPEC_OCLS(sym->etype)==xidata) { - /* create a new "XINIT (CODE)" symbol, that will be emitted later - in the static seg */ - newSym=copySymbol (sym); - SPEC_OCLS(newSym->etype)=xinit; - SNPRINTF (newSym->name, sizeof(newSym->name), "__xinit_%s", sym->name); - SNPRINTF (newSym->rname, sizeof(newSym->rname), "__xinit_%s", sym->rname); - if (IS_SPEC (newSym->type)) - SPEC_CONST (newSym->type) = 1; - else - DCL_PTR_CONST (newSym->type) = 1; - SPEC_STAT(newSym->etype)=1; - resolveIvalSym(newSym->ival, newSym->type); - - // add it to the "XINIT (CODE)" segment - addSet(&xinit->syms, newSym); - - if (!SPEC_ABSA (sym->etype)) + if (sym->ival && sym->level == 0) + { + if ((SPEC_OCLS (sym->etype) == xidata) && !SPEC_ABSA (sym->etype)) { - FILE *tmpFile = tempfile (); - addSetHead (&tmpfileSet, tmpFile); - // before allocation we must parse the sym->ival tree - // but without actually generating initialization code - noAlloc++; - resolveIvalSym (sym->ival, sym->type); - printIval (sym, sym->type, sym->ival, tmpFile); - noAlloc--; - } - - sym->ival=NULL; - } else { - if (IS_AGGREGATE (sym->type)) { - ival = initAggregates (sym, sym->ival, NULL); - } else { - if (getNelements(sym->type, sym->ival)>1) { - werrorfl (sym->fileDef, sym->lineDef, W_EXCESS_INITIALIZERS, "scalar", - sym->name); + /* create a new "XINIT (CODE)" symbol, that will be emitted later + in the static seg */ + newSym=copySymbol (sym); + SPEC_OCLS(newSym->etype)=xinit; + SNPRINTF (newSym->name, sizeof(newSym->name), "__xinit_%s", sym->name); + SNPRINTF (newSym->rname, sizeof(newSym->rname), "__xinit_%s", sym->rname); + if (IS_SPEC (newSym->type)) + SPEC_CONST (newSym->type) = 1; + else + DCL_PTR_CONST (newSym->type) = 1; + SPEC_STAT(newSym->etype)=1; + resolveIvalSym(newSym->ival, newSym->type); + + // add it to the "XINIT (CODE)" segment + addSet(&xinit->syms, newSym); + + if (!SPEC_ABSA (sym->etype)) + { + struct dbuf_s tmpBuf; + + dbuf_init(&tmpBuf, 4096); + // before allocation we must parse the sym->ival tree + // but without actually generating initialization code + ++noAlloc; + resolveIvalSym (sym->ival, sym->type); + ++noInit; + printIval (sym, sym->type, sym->ival, &tmpBuf, TRUE); + --noInit; + --noAlloc; + dbuf_destroy(&tmpBuf); + } } - ival = newNode ('=', newAst_VALUE (symbolVal (sym)), - decorateType (resolveSymbols (list2expr (sym->ival)), RESULT_TYPE_NONE)); - } - codeOutFile = statsg->oFile; - - if (ival) { - // set ival's lineno to where the symbol was defined - setAstLineno (ival, lineno=sym->lineDef); - // check if this is not a constant expression - if (!constExprTree(ival)) { - werror (E_CONST_EXPECTED, "found expression"); - // but try to do it anyway + else + { + if (IS_AGGREGATE (sym->type)) + { + ival = initAggregates (sym, sym->ival, NULL); + } + else + { + if (getNelements (sym->type, sym->ival)>1) + { + werrorfl (sym->fileDef, sym->lineDef, W_EXCESS_INITIALIZERS, "scalar", sym->name); + } + ival = newNode ('=', newAst_VALUE (symbolVal (sym)), + decorateType (resolveSymbols (list2expr (sym->ival)), RESULT_TYPE_NONE)); + } + codeOutBuf = &statsg->oBuf; + + if (ival) + { + // set ival's lineno to where the symbol was defined + setAstFileLine (ival, filename = sym->fileDef, lineno = sym->lineDef); + // check if this is not a constant expression + if (!constExprTree (ival)) + { + werror (E_CONST_EXPECTED, "found expression"); + // but try to do it anyway + } + allocInfo = 0; + if (!astErrors (ival)) + eBBlockFromiCode (iCodeFromAst (ival)); + allocInfo = 1; + } } - allocInfo = 0; - if (!astErrors(ival)) - eBBlockFromiCode (iCodeFromAst (ival)); - allocInfo = 1; - } - } - sym->ival = NULL; - } + } /* if it has an absolute address then generate an equate for this no need to allocate space */ - if (SPEC_ABSA (sym->etype)) + if (SPEC_ABSA (sym->etype) && !sym->ival) { - char *equ="="; + char *equ = "="; if (options.debug) { - fprintf (map->oFile, " == 0x%04x\n", SPEC_ADDR (sym->etype)); + dbuf_printf (&map->oBuf, " == 0x%04x\n", SPEC_ADDR (sym->etype)); } - if (TARGET_IS_XA51) { - if (map==sfr) { - equ="sfr"; - } else if (map==bit || map==sfrbit) { - equ="bit"; + if (TARGET_IS_XA51) + { + if (map == sfr) + { + equ = "sfr"; + } + else if (map == bit || map == sfrbit) + { + equ="bit"; + } } - } - fprintf (map->oFile, "%s\t%s\t0x%04x\n", - sym->rname, equ, - SPEC_ADDR (sym->etype)); - } - else { - int size = getAllocSize (sym->type); - if (size==0) { - werrorfl (sym->fileDef, sym->lineDef, E_UNKNOWN_SIZE, sym->name); + dbuf_printf (&map->oBuf, "%s\t%s\t0x%04x\n", sym->rname, equ, SPEC_ADDR (sym->etype)); } - /* allocate space */ - if (options.debug) { - fprintf (map->oFile, "==.\n"); + else + { + int size = getSize (sym->type) + sym->flexArrayLength; + if (size == 0) + { + werrorfl (sym->fileDef, sym->lineDef, E_UNKNOWN_SIZE, sym->name); + } + /* allocate space */ + if (options.debug) + { + dbuf_printf (&map->oBuf, "==.\n"); + } + if (SPEC_ABSA (sym->etype)) + { + dbuf_tprintf (&map->oBuf, "\t!org\n", SPEC_ADDR (sym->etype)); + } + if (IS_STATIC (sym->etype) || sym->level) + dbuf_tprintf (&map->oBuf, "!slabeldef\n", sym->rname); + else + dbuf_tprintf (&map->oBuf, "!labeldef\n", sym->rname); + dbuf_tprintf (&map->oBuf, "\t!ds\n", (unsigned int) size & 0xffff); } - if (IS_STATIC (sym->etype)) - tfprintf (map->oFile, "!slabeldef\n", sym->rname); - else - tfprintf (map->oFile, "!labeldef\n", sym->rname); - tfprintf (map->oFile, "\t!ds\n", - (unsigned int) size & 0xffff); - } + sym->ival = NULL; } } @@ -393,14 +327,14 @@ initPointer (initList * ilist, sym_link *toType) } expr = list2expr (ilist); - + if (!expr) goto wrong; - + /* try it the old way first */ if ((val = constExprValue (expr, FALSE))) return val; - + /* ( ptr + constant ) */ if (IS_AST_OP (expr) && (expr->opval.op == '+' || expr->opval.op == '-') && @@ -412,7 +346,7 @@ initPointer (initList * ilist, sym_link *toType) expr->right, expr->opval.op); } - + /* (char *)&a */ if (IS_AST_OP(expr) && expr->opval.op==CAST && IS_AST_OP(expr->right) && expr->right->opval.op=='&') { @@ -430,12 +364,14 @@ initPointer (initList * ilist, sym_link *toType) if (IS_AST_OP (expr) && expr->opval.op == '&') { /* address of symbol */ if (IS_AST_SYM_VALUE (expr->left)) { - val = copyValue (AST_VALUE (expr->left)); + val = AST_VALUE (expr->left); val->type = newLink (DECLARATOR); if (SPEC_SCLS (expr->left->etype) == S_CODE) { DCL_TYPE (val->type) = CPOINTER; DCL_PTR_CONST (val->type) = port->mem.code_ro; } + else if (SPEC_SCLS (expr->left->etype) == S_PDATA) + DCL_TYPE (val->type) = PPOINTER; else if (SPEC_SCLS (expr->left->etype) == S_XDATA) DCL_TYPE (val->type) = FPOINTER; else if (SPEC_SCLS (expr->left->etype) == S_XSTACK) @@ -495,6 +431,8 @@ initPointer (initList * ilist, sym_link *toType) DCL_TYPE (val->type) = CPOINTER; DCL_PTR_CONST (val->type) = port->mem.code_ro; } + else if (SPEC_SCLS (expr->right->etype) == S_PDATA) + DCL_TYPE (val->type) = PPOINTER; else if (SPEC_SCLS (expr->right->etype) == S_XDATA) DCL_TYPE (val->type) = FPOINTER; else if (SPEC_SCLS (expr->right->etype) == S_XSTACK) @@ -521,8 +459,8 @@ initPointer (initList * ilist, sym_link *toType) /*-----------------------------------------------------------------*/ /* printChar - formats and prints a characater string with DB */ /*-----------------------------------------------------------------*/ -void -printChar (FILE * ofile, char *s, int plen) +void +printChar (struct dbuf_s * oBuf, char *s, int plen) { int i; int len = plen; @@ -539,8 +477,8 @@ printChar (FILE * ofile, char *s, int plen) { *p = '\0'; if (p != buf) - tfprintf (ofile, "\t!ascii\n", buf); - tfprintf (ofile, "\t!db !constbyte\n", (unsigned char)*s); + dbuf_tprintf (oBuf, "\t!ascii\n", buf); + dbuf_tprintf (oBuf, "\t!db !constbyte\n", (unsigned char)*s); p = buf; } else @@ -555,7 +493,7 @@ printChar (FILE * ofile, char *s, int plen) if (p != buf) { *p = '\0'; - tfprintf (ofile, "\t!ascii\n", buf); + dbuf_tprintf (oBuf, "\t!ascii\n", buf); p = buf; } @@ -566,7 +504,7 @@ printChar (FILE * ofile, char *s, int plen) } while (pplen < plen) { - tfprintf (ofile, "\t!db !constbyte\n", 0); + dbuf_tprintf (oBuf, "\t!db !constbyte\n", 0); pplen++; } } @@ -574,7 +512,7 @@ printChar (FILE * ofile, char *s, int plen) /*-----------------------------------------------------------------*/ /* return the generic pointer high byte for a given pointer type. */ /*-----------------------------------------------------------------*/ -int +int pointerTypeToGPByte (const int p_type, const char *iname, const char *oname) { switch (p_type) @@ -583,8 +521,8 @@ pointerTypeToGPByte (const int p_type, const char *iname, const char *oname) case POINTER: return GPTYPE_NEAR; case GPOINTER: - werror (E_CANNOT_USE_GENERIC_POINTER, - iname ? iname : "", + werror (E_CANNOT_USE_GENERIC_POINTER, + iname ? iname : "", oname ? oname : ""); exit (1); case FPOINTER: @@ -605,51 +543,51 @@ pointerTypeToGPByte (const int p_type, const char *iname, const char *oname) /*-----------------------------------------------------------------*/ /* printPointerType - generates ival for pointer type */ /*-----------------------------------------------------------------*/ -void -_printPointerType (FILE * oFile, const char *name) +void +_printPointerType (struct dbuf_s * oBuf, const char *name) { if (options.model == MODEL_FLAT24) { if (port->little_endian) - fprintf (oFile, "\t.byte %s,(%s >> 8),(%s >> 16)", name, name, name); + dbuf_printf (oBuf, "\t.byte %s,(%s >> 8),(%s >> 16)", name, name, name); else - fprintf (oFile, "\t.byte (%s >> 16),(%s >> 8),%s", name, name, name); + dbuf_printf (oBuf, "\t.byte (%s >> 16),(%s >> 8),%s", name, name, name); } else { if (port->little_endian) - fprintf (oFile, "\t.byte %s,(%s >> 8)", name, name); + dbuf_printf (oBuf, "\t.byte %s,(%s >> 8)", name, name); else - fprintf (oFile, "\t.byte (%s >> 8),%s", name, name); + dbuf_printf (oBuf, "\t.byte (%s >> 8),%s", name, name); } } /*-----------------------------------------------------------------*/ /* printPointerType - generates ival for pointer type */ /*-----------------------------------------------------------------*/ -void -printPointerType (FILE * oFile, const char *name) +void +printPointerType (struct dbuf_s * oBuf, const char *name) { - _printPointerType (oFile, name); - fprintf (oFile, "\n"); + _printPointerType (oBuf, name); + dbuf_printf (oBuf, "\n"); } /*-----------------------------------------------------------------*/ /* printGPointerType - generates ival for generic pointer type */ /*-----------------------------------------------------------------*/ -void -printGPointerType (FILE * oFile, const char *iname, const char *oname, +void +printGPointerType (struct dbuf_s * oBuf, const char *iname, const char *oname, const unsigned int type) { - _printPointerType (oFile, iname); - fprintf (oFile, ",#0x%02x\n", pointerTypeToGPByte (type, iname, oname)); + _printPointerType (oBuf, iname); + dbuf_printf (oBuf, ",#0x%02x\n", pointerTypeToGPByte (type, iname, oname)); } /*-----------------------------------------------------------------*/ /* printIvalType - generates ival for int/char */ /*-----------------------------------------------------------------*/ -void -printIvalType (symbol *sym, sym_link * type, initList * ilist, FILE * oFile) +void +printIvalType (symbol *sym, sym_link * type, initList * ilist, struct dbuf_s * oBuf) { value *val; @@ -659,42 +597,49 @@ printIvalType (symbol *sym, sym_link * type, initList * ilist, FILE * oFile) if (!(val = list2val (ilist))) { // assuming a warning has been thrown - val=constVal("0"); + val = constCharVal (0); } + /* check if the literal value is within bounds */ + if (checkConstantRange (type, val->etype, '=', FALSE) == CCR_OVL && + !options.lessPedantic) + { + werror (W_LIT_OVERFLOW); + } + if (val->type != type) { val = valCastLiteral(type, floatFromVal(val)); } - + switch (getSize (type)) { case 1: if (!val) - tfprintf (oFile, "\t!db !constbyte\n", 0); + dbuf_tprintf (oBuf, "\t!db !constbyte\n", 0); else - tfprintf (oFile, "\t!dbs\n", + dbuf_tprintf (oBuf, "\t!dbs\n", aopLiteral (val, 0)); break; case 2: if (port->use_dw_for_init) - tfprintf (oFile, "\t!dws\n", aopLiteralLong (val, 0, 2)); + dbuf_tprintf (oBuf, "\t!dws\n", aopLiteralLong (val, 0, 2)); else if (port->little_endian) - fprintf (oFile, "\t.byte %s,%s\n", aopLiteral (val, 0), aopLiteral (val, 1)); + dbuf_printf (oBuf, "\t.byte %s,%s\n", aopLiteral (val, 0), aopLiteral (val, 1)); else - fprintf (oFile, "\t.byte %s,%s\n", aopLiteral (val, 1), aopLiteral (val, 0)); + dbuf_printf (oBuf, "\t.byte %s,%s\n", aopLiteral (val, 1), aopLiteral (val, 0)); break; case 4: if (!val) { - tfprintf (oFile, "\t!dw !constword\n", 0); - tfprintf (oFile, "\t!dw !constword\n", 0); + dbuf_tprintf (oBuf, "\t!dw !constword\n", 0); + dbuf_tprintf (oBuf, "\t!dw !constword\n", 0); } else if (port->little_endian) { - fprintf (oFile, "\t.byte %s,%s,%s,%s\n", + dbuf_printf (oBuf, "\t.byte %s,%s,%s,%s\n", aopLiteral (val, 0), aopLiteral (val, 1), aopLiteral (val, 2), aopLiteral (val, 3)); } else { - fprintf (oFile, "\t.byte %s,%s,%s,%s\n", + dbuf_printf (oBuf, "\t.byte %s,%s,%s,%s\n", aopLiteral (val, 3), aopLiteral (val, 2), aopLiteral (val, 1), aopLiteral (val, 0)); } @@ -705,49 +650,66 @@ printIvalType (symbol *sym, sym_link * type, initList * ilist, FILE * oFile) /*-----------------------------------------------------------------*/ /* printIvalBitFields - generate initializer for bitfields */ /*-----------------------------------------------------------------*/ -void printIvalBitFields(symbol **sym, initList **ilist, FILE * oFile) +static void +printIvalBitFields (symbol **sym, initList **ilist, struct dbuf_s * oBuf) { - value *val ; symbol *lsym = *sym; - initList *lilist = *ilist ; + initList *lilist = *ilist; unsigned long ival = 0; - int size =0; - - - do { - unsigned long i; - val = list2val(lilist); - if (size) { - if (SPEC_BLEN(lsym->etype) > 8) { - size += ((SPEC_BLEN (lsym->etype) / 8) + - (SPEC_BLEN (lsym->etype) % 8 ? 1 : 0)); - } - } else { - size = ((SPEC_BLEN (lsym->etype) / 8) + - (SPEC_BLEN (lsym->etype) % 8 ? 1 : 0)); - } - i = (unsigned long)floatFromVal(val); - i <<= SPEC_BSTR (lsym->etype); - ival |= i; - if (! ( lsym->next && - (IS_BITFIELD(lsym->next->type)) && - (SPEC_BSTR(lsym->next->etype)))) break; - lsym = lsym->next; - lilist = lilist->next; - } while (1); - switch (size) { - case 1: - tfprintf (oFile, "\t!db !constbyte\n",ival); - break; + int size = 0; - case 2: - tfprintf (oFile, "\t!dw !constword\n",ival); - break; - case 4: /* EEP: why is this db and not dw? */ - tfprintf (oFile, "\t!db !constword,!constword\n", - (ival >> 8) & 0xffff, (ival & 0xffff)); - break; - } + while (lsym) + { + + if (0 == SPEC_BLEN (lsym->etype)) + { + /* bit-field structure member with a width of 0 */ + lsym = lsym->next; + break; + } + else if (!SPEC_BUNNAMED (lsym->etype)) + { + /* not an unnamed bit-field structure member */ + value *val = list2val (lilist); + int bit_length = SPEC_BLEN (lsym->etype); + + if (size) + { + if (bit_length > 8) + size += (bit_length + 7) / 8; + } + else + size = (bit_length + 7) / 8; + + /* check if the literal value is within bounds */ + if (val && + checkConstantRange (lsym->etype, val->etype, '=', FALSE) == CCR_OVL && + !options.lessPedantic) + { + werror (W_LIT_OVERFLOW); + } + + ival |= (ulFromVal (val) & ((1ul << bit_length) - 1ul)) << SPEC_BSTR (lsym->etype); + lilist = lilist ? lilist->next : NULL; + } + lsym = lsym->next; + } + + switch (size) + { + case 1: + dbuf_tprintf (oBuf, "\t!db !constbyte\n", ival); + break; + + case 2: + dbuf_tprintf (oBuf, "\t!dw !constword\n", ival); + break; + + case 4: + dbuf_tprintf (oBuf, "\t!dw !constword,!constword\n", + (ival >> 16) & 0xffff, (ival & 0xffff)); + break; + } *sym = lsym; *ilist = lilist; } @@ -755,56 +717,80 @@ void printIvalBitFields(symbol **sym, initList **ilist, FILE * oFile) /*-----------------------------------------------------------------*/ /* printIvalStruct - generates initial value for structures */ /*-----------------------------------------------------------------*/ -void +static void printIvalStruct (symbol * sym, sym_link * type, - initList * ilist, FILE * oFile) + initList * ilist, struct dbuf_s * oBuf) { symbol *sflds; initList *iloop = NULL; sflds = SPEC_STRUCT (type)->fields; - if (ilist) { - if (ilist->type != INIT_DEEP) { - werrorfl (sym->fileDef, sym->lineDef, E_INIT_STRUCT, sym->name); - return; - } + if (ilist) + { + if (ilist->type != INIT_DEEP) + { + werrorfl (sym->fileDef, sym->lineDef, E_INIT_STRUCT, sym->name); + return; + } - iloop = ilist->init.deep; - } + iloop = ilist->init.deep; + } - for (; sflds; sflds = sflds->next, iloop = (iloop ? iloop->next : NULL)) { - if (IS_BITFIELD(sflds->type)) { - printIvalBitFields(&sflds,&iloop,oFile); - } else { - printIval (sym, sflds->type, iloop, oFile); + if (SPEC_STRUCT (type)->type == UNION) + { + printIval (sym, sflds->type, iloop, oBuf, 1); + iloop = iloop ? iloop->next : NULL; } - } - if (iloop) { + else + { + while (sflds) + { + if (IS_BITFIELD (sflds->type)) + printIvalBitFields(&sflds, &iloop, oBuf); + else + { + printIval (sym, sflds->type, iloop, oBuf, 1); + sflds = sflds->next; + iloop = iloop ? iloop->next : NULL; + } + } + } + + if (iloop) werrorfl (sym->fileDef, sym->lineDef, W_EXCESS_INITIALIZERS, "struct", sym->name); - } - return; } /*-----------------------------------------------------------------*/ /* printIvalChar - generates initital value for character array */ /*-----------------------------------------------------------------*/ -int -printIvalChar (sym_link * type, initList * ilist, FILE * oFile, char *s) +int +printIvalChar (symbol * sym, sym_link * type, initList * ilist, struct dbuf_s * oBuf, char *s, bool check) { value *val; + unsigned int size = DCL_ELEM (type); if (!s) { - val = list2val (ilist); /* if the value is a character string */ if (IS_ARRAY (val->type) && IS_CHAR (val->etype)) { - if (!DCL_ELEM (type)) - DCL_ELEM (type) = strlen (SPEC_CVAL (val->etype).v_char) + 1; + if (!size) + { + /* we have not been given a size, but now we know it */ + size = strlen (SPEC_CVAL (val->etype).v_char) + 1; + /* but first check, if it's a flexible array */ + if (sym && IS_STRUCT (sym->type)) + sym->flexArrayLength = size; + else + DCL_ELEM (type) = size; + } - printChar (oFile, SPEC_CVAL (val->etype).v_char, DCL_ELEM (type)); + if (check && DCL_ELEM (val->type) > size) + werror (W_EXCESS_INITIALIZERS, "array of chars", sym->name, sym->lineDef); + + printChar (oBuf, SPEC_CVAL (val->etype).v_char, size); return 1; } @@ -812,7 +798,7 @@ printIvalChar (sym_link * type, initList * ilist, FILE * oFile, char *s) return 0; } else - printChar (oFile, s, strlen (s) + 1); + printChar (oBuf, s, strlen (s) + 1); return 1; } @@ -821,8 +807,9 @@ printIvalChar (sym_link * type, initList * ilist, FILE * oFile, char *s) /*-----------------------------------------------------------------*/ void printIvalArray (symbol * sym, sym_link * type, initList * ilist, - FILE * oFile) + struct dbuf_s * oBuf, bool check) { + value *val; initList *iloop; unsigned int size = 0; @@ -831,13 +818,18 @@ printIvalArray (symbol * sym, sym_link * type, initList * ilist, /* array of characters can be init */ /* by a string */ if (IS_CHAR (type->next)) { - if (!IS_LITERAL(list2val(ilist)->etype)) { + val = list2val(ilist); + if (!val) { + werrorfl (ilist->filename, ilist->lineno, E_INIT_STRUCT, sym->name); + return; + } + if (!IS_LITERAL(val->etype)) { werrorfl (ilist->filename, ilist->lineno, E_CONST_EXPECTED); return; } - if (printIvalChar (type, + if (printIvalChar (sym, type, (ilist->type == INIT_DEEP ? ilist->init.deep : ilist), - oFile, SPEC_CVAL (sym->etype).v_char)) + oBuf, SPEC_CVAL (sym->etype).v_char, check)) return; } /* not the special case */ @@ -851,21 +843,25 @@ printIvalArray (symbol * sym, sym_link * type, initList * ilist, werrorfl (sym->fileDef, sym->lineDef, W_EXCESS_INITIALIZERS, "array", sym->name); break; } - printIval (sym, type->next, iloop, oFile); + printIval (sym, type->next, iloop, oBuf, TRUE); } } - + if (DCL_ELEM(type)) { // pad with zeros if needed if (sizenext); while (size--) { - tfprintf (oFile, "\t!db !constbyte\n", 0); + dbuf_tprintf (oBuf, "\t!db !constbyte\n", 0); } } } else { - // we have not been given a size, but we now know it - DCL_ELEM (type) = size; + /* we have not been given a size, but now we know it */ + /* but first check, if it's a flexible array */ + if (IS_STRUCT (sym->type)) + sym->flexArrayLength = size * getSize (type->next); + else + DCL_ELEM (type) = size; } return; @@ -874,8 +870,8 @@ printIvalArray (symbol * sym, sym_link * type, initList * ilist, /*-----------------------------------------------------------------*/ /* printIvalFuncPtr - generate initial value for function pointers */ /*-----------------------------------------------------------------*/ -void -printIvalFuncPtr (sym_link * type, initList * ilist, FILE * oFile) +void +printIvalFuncPtr (sym_link * type, initList * ilist, struct dbuf_s * oBuf) { value *val; int dLvl = 0; @@ -887,7 +883,7 @@ printIvalFuncPtr (sym_link * type, initList * ilist, FILE * oFile) if (!val) { // an error has been thrown already - val=constVal("0"); + val = constCharVal (0); } if (IS_LITERAL(val->etype)) { @@ -895,14 +891,14 @@ printIvalFuncPtr (sym_link * type, initList * ilist, FILE * oFile) werrorfl (ilist->filename, ilist->lineno, E_INCOMPAT_TYPES); printFromToType (val->type, type); } - printIvalCharPtr (NULL, type, val, oFile); + printIvalCharPtr (NULL, type, val, oBuf); return; } /* check the types */ if ((dLvl = compareType (val->type, type->next)) <= 0) { - tfprintf (oFile, "\t!dw !constword\n", 0); + dbuf_tprintf (oBuf, "\t!dw !constword\n", 0); return; } @@ -911,20 +907,20 @@ printIvalFuncPtr (sym_link * type, initList * ilist, FILE * oFile) { if (port->use_dw_for_init) { - tfprintf (oFile, "\t!dws\n", val->name); + dbuf_tprintf (oBuf, "\t!dws\n", val->name); } else { - printPointerType (oFile, val->name); + printPointerType (oBuf, val->name); } } else if (port->use_dw_for_init) { - tfprintf (oFile, "\t!dws\n", val->sym->rname); + dbuf_tprintf (oBuf, "\t!dws\n", val->sym->rname); } else { - printPointerType (oFile, val->sym->rname); + printPointerType (oBuf, val->sym->rname); } return; @@ -933,14 +929,14 @@ printIvalFuncPtr (sym_link * type, initList * ilist, FILE * oFile) /*-----------------------------------------------------------------*/ /* printIvalCharPtr - generates initial values for character pointers */ /*-----------------------------------------------------------------*/ -int -printIvalCharPtr (symbol * sym, sym_link * type, value * val, FILE * oFile) +int +printIvalCharPtr (symbol * sym, sym_link * type, value * val, struct dbuf_s * oBuf) { int size = 0; /* PENDING: this is _very_ mcs51 specific, including a magic number... - It's also endin specific. + It's also endian specific. */ size = getSize (type); @@ -948,18 +944,18 @@ printIvalCharPtr (symbol * sym, sym_link * type, value * val, FILE * oFile) { if (size == 1) /* This appears to be Z80 specific?? */ { - tfprintf (oFile, + dbuf_tprintf (oBuf, "\t!dbs\n", val->name); } else if (size == FPTRSIZE) { if (port->use_dw_for_init) { - tfprintf (oFile, "\t!dws\n", val->name); + dbuf_tprintf (oBuf, "\t!dws\n", val->name); } else { - printPointerType (oFile, val->name); + printPointerType (oBuf, val->name); } } else if (size == GPTRSIZE) @@ -974,7 +970,7 @@ printIvalCharPtr (symbol * sym, sym_link * type, value * val, FILE * oFile) // this is a literal string type=CPOINTER; } - printGPointerType (oFile, val->name, sym->name, type); + printGPointerType (oBuf, val->name, sym->name, type); } else { @@ -988,16 +984,16 @@ printIvalCharPtr (symbol * sym, sym_link * type, value * val, FILE * oFile) switch (size) { case 1: - tfprintf (oFile, "\t!dbs\n", aopLiteral (val, 0)); + dbuf_tprintf (oBuf, "\t!dbs\n", aopLiteral (val, 0)); break; case 2: if (port->use_dw_for_init) - tfprintf (oFile, "\t!dws\n", aopLiteralLong (val, 0, size)); + dbuf_tprintf (oBuf, "\t!dws\n", aopLiteralLong (val, 0, size)); else if (port->little_endian) - tfprintf (oFile, "\t.byte %s,%s\n", + dbuf_tprintf (oBuf, "\t.byte %s,%s\n", aopLiteral (val, 0), aopLiteral (val, 1)); else - tfprintf (oFile, "\t.byte %s,%s\n", + dbuf_tprintf (oBuf, "\t.byte %s,%s\n", aopLiteral (val, 1), aopLiteral (val, 0)); break; case 3: @@ -1006,13 +1002,13 @@ printIvalCharPtr (symbol * sym, sym_link * type, value * val, FILE * oFile) werrorfl (sym->fileDef, sym->lineDef, E_LITERAL_GENERIC); } if (port->little_endian) { - fprintf (oFile, "\t.byte %s,%s,%s\n", - aopLiteral (val, 0), + dbuf_printf (oBuf, "\t.byte %s,%s,%s\n", + aopLiteral (val, 0), aopLiteral (val, 1), aopLiteral (val, 2)); } else { - fprintf (oFile, "\t.byte %s,%s,%s\n", - aopLiteral (val, 2), + dbuf_printf (oBuf, "\t.byte %s,%s,%s\n", + aopLiteral (val, 2), aopLiteral (val, 1), aopLiteral (val, 0)); } @@ -1023,15 +1019,15 @@ printIvalCharPtr (symbol * sym, sym_link * type, value * val, FILE * oFile) werrorfl (sym->fileDef, sym->lineDef, E_LITERAL_GENERIC); } if (port->little_endian) { - fprintf (oFile, "\t.byte %s,%s,%s,%s\n", - aopLiteral (val, 0), - aopLiteral (val, 1), + dbuf_printf (oBuf, "\t.byte %s,%s,%s,%s\n", + aopLiteral (val, 0), + aopLiteral (val, 1), aopLiteral (val, 2), aopLiteral (val, 3)); } else { - fprintf (oFile, "\t.byte %s,%s,%s,%s\n", - aopLiteral (val, 3), - aopLiteral (val, 2), + dbuf_printf (oBuf, "\t.byte %s,%s,%s,%s\n", + aopLiteral (val, 3), + aopLiteral (val, 2), aopLiteral (val, 1), aopLiteral (val, 0)); } @@ -1041,7 +1037,7 @@ printIvalCharPtr (symbol * sym, sym_link * type, value * val, FILE * oFile) } } - if (val->sym && val->sym->isstrlit && !isinSet(statsg->syms, val->sym)) { + if (!noInit && val->sym && val->sym->isstrlit && !isinSet(statsg->syms, val->sym)) { addSet (&statsg->syms, val->sym); } @@ -1051,8 +1047,8 @@ printIvalCharPtr (symbol * sym, sym_link * type, value * val, FILE * oFile) /*-----------------------------------------------------------------*/ /* printIvalPtr - generates initial value for pointers */ /*-----------------------------------------------------------------*/ -void -printIvalPtr (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) +void +printIvalPtr (symbol * sym, sym_link * type, initList * ilist, struct dbuf_s * oBuf) { value *val; int size; @@ -1064,7 +1060,7 @@ printIvalPtr (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) /* function pointer */ if (IS_FUNC (type->next)) { - printIvalFuncPtr (type, ilist, oFile); + printIvalFuncPtr (type, ilist, oBuf); return; } @@ -1073,7 +1069,7 @@ printIvalPtr (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) /* if character pointer */ if (IS_CHAR (type->next)) - if (printIvalCharPtr (sym, type, val, oFile)) + if (printIvalCharPtr (sym, type, val, oBuf)) return; /* check the type */ @@ -1088,34 +1084,34 @@ printIvalPtr (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) switch (getSize (type)) { case 1: - tfprintf (oFile, "\t!db !constbyte\n", (unsigned int) floatFromVal (val) & 0xff); + dbuf_tprintf (oBuf, "\t!db !constbyte\n", (unsigned int) ulFromVal (val) & 0xff); break; case 2: if (port->use_dw_for_init) - tfprintf (oFile, "\t!dws\n", aopLiteralLong (val, 0, 2)); + dbuf_tprintf (oBuf, "\t!dws\n", aopLiteralLong (val, 0, 2)); else if (port->little_endian) - tfprintf (oFile, "\t.byte %s,%s\n", aopLiteral (val, 0), aopLiteral (val, 1)); + dbuf_tprintf (oBuf, "\t.byte %s,%s\n", aopLiteral (val, 0), aopLiteral (val, 1)); else - tfprintf (oFile, "\t.byte %s,%s\n", aopLiteral (val, 1), aopLiteral (val, 0)); + dbuf_tprintf (oBuf, "\t.byte %s,%s\n", aopLiteral (val, 1), aopLiteral (val, 0)); break; case 3: // how about '390?? - fprintf (oFile, "; generic printIvalPtr\n"); + dbuf_printf (oBuf, "; generic printIvalPtr\n"); if (port->little_endian) { - fprintf (oFile, "\t.byte %s,%s", + dbuf_printf (oBuf, "\t.byte %s,%s", aopLiteral (val, 0), aopLiteral (val, 1)); } else { - fprintf (oFile, "\t.byte %s,%s", + dbuf_printf (oBuf, "\t.byte %s,%s", aopLiteral (val, 1), aopLiteral (val, 0)); } if (IS_GENPTR (val->type)) - fprintf (oFile, ",%s\n", aopLiteral (val, 2)); + dbuf_printf (oBuf, ",%s\n", aopLiteral (val, 2)); else if (IS_PTR (val->type)) - fprintf (oFile, ",#%x\n", pointerTypeToGPByte (DCL_TYPE (val->type), NULL, NULL)); + dbuf_printf (oBuf, ",#%x\n", pointerTypeToGPByte (DCL_TYPE (val->type), NULL, NULL)); else - fprintf (oFile, ",%s\n", aopLiteral (val, 2)); + dbuf_printf (oBuf, ",%s\n", aopLiteral (val, 2)); } return; } @@ -1125,19 +1121,19 @@ printIvalPtr (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) if (size == 1) /* Z80 specific?? */ { - tfprintf (oFile, "\t!dbs\n", val->name); + dbuf_tprintf (oBuf, "\t!dbs\n", val->name); } else if (size == FPTRSIZE) { if (port->use_dw_for_init) { - tfprintf (oFile, "\t!dws\n", val->name); + dbuf_tprintf (oBuf, "\t!dws\n", val->name); } else { - printPointerType (oFile, val->name); + printPointerType (oBuf, val->name); } } else if (size == GPTRSIZE) { - printGPointerType (oFile, val->name, sym->name, + printGPointerType (oBuf, val->name, sym->name, (IS_PTR (val->type) ? DCL_TYPE (val->type) : PTR_TYPE (SPEC_OCLS (val->etype)))); } @@ -1147,22 +1143,22 @@ printIvalPtr (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) /*-----------------------------------------------------------------*/ /* printIval - generates code for initial value */ /*-----------------------------------------------------------------*/ -void -printIval (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) +void +printIval (symbol * sym, sym_link * type, initList * ilist, struct dbuf_s * oBuf, bool check) { sym_link *itype; - + /* if structure then */ if (IS_STRUCT (type)) { - printIvalStruct (sym, type, ilist, oFile); + printIvalStruct (sym, type, ilist, oBuf); return; } /* if this is an array */ if (IS_ARRAY (type)) { - printIvalArray (sym, type, ilist, oFile); + printIvalArray (sym, type, ilist, oBuf, check); return; } @@ -1172,7 +1168,7 @@ printIval (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) if (ilist->type!=INIT_NODE) { // or a 1-element list if (ilist->init.deep->next) { - werrorfl (sym->fileDef, sym->lineDef, W_EXCESS_INITIALIZERS, "scalar", + werrorfl (sym->fileDef, sym->lineDef, W_EXCESS_INITIALIZERS, "scalar", sym->name); } else { ilist=ilist->init.deep; @@ -1198,14 +1194,14 @@ printIval (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) /* if this is a pointer */ if (IS_PTR (type)) { - printIvalPtr (sym, type, ilist, oFile); + printIvalPtr (sym, type, ilist, oBuf); return; } /* if type is SPECIFIER */ if (IS_SPEC (type)) { - printIvalType (sym, type, ilist, oFile); + printIvalType (sym, type, ilist, oBuf); return; } } @@ -1213,8 +1209,8 @@ printIval (symbol * sym, sym_link * type, initList * ilist, FILE * oFile) /*-----------------------------------------------------------------*/ /* emitStaticSeg - emitcode for the static segment */ /*-----------------------------------------------------------------*/ -void -emitStaticSeg (memmap * map, FILE * out) +void +emitStaticSeg (memmap * map, struct dbuf_s * oBuf) { symbol *sym; @@ -1229,54 +1225,59 @@ emitStaticSeg (memmap * map, FILE * out) if (IS_EXTERN (sym->etype)) continue; - /* if it is not static add it to the public - table */ + /* if it is not static add it to the public table */ if (!IS_STATIC (sym->etype)) { addSetHead (&publics, sym); } /* print extra debug info if required */ - if (options.debug) { - - if (!sym->level) - { /* global */ - if (IS_STATIC (sym->etype)) - fprintf (out, "F%s$", moduleName); /* scope is file */ - else - fprintf (out, "G$"); /* scope is global */ - } - else - /* symbol is local */ - fprintf (out, "L%s$", - (sym->localof ? sym->localof->name : "-null-")); - fprintf (out, "%s$%d$%d", sym->name, sym->level, sym->block); - } - - /* if it has an absolute address */ - if (SPEC_ABSA (sym->etype)) + if (options.debug) + { + if (!sym->level) + { /* global */ + if (IS_STATIC (sym->etype)) + dbuf_printf (oBuf, "F%s$", moduleName); /* scope is file */ + else + dbuf_printf (oBuf, "G$"); /* scope is global */ + } + else + { + /* symbol is local */ + dbuf_printf (oBuf, "L%s$", + (sym->localof ? sym->localof->name : "-null-")); + } + dbuf_printf (oBuf, "%s$%d$%d", sym->name, sym->level, sym->block); + } + + /* if it has an absolute address and no initializer */ + if (SPEC_ABSA (sym->etype) && !sym->ival) { if (options.debug) - fprintf (out, " == 0x%04x\n", SPEC_ADDR (sym->etype)); - - fprintf (out, "%s\t=\t0x%04x\n", + dbuf_printf (oBuf, " == 0x%04x\n", SPEC_ADDR (sym->etype)); + + dbuf_printf (oBuf, "%s\t=\t0x%04x\n", sym->rname, SPEC_ADDR (sym->etype)); } else { if (options.debug) - fprintf (out, " == .\n"); - + dbuf_printf (oBuf, " == .\n"); + /* if it has an initial value */ if (sym->ival) { - fprintf (out, "%s:\n", sym->rname); - noAlloc++; + if (SPEC_ABSA (sym->etype)) + { + dbuf_tprintf (oBuf, "\t!org\n", SPEC_ADDR (sym->etype)); + } + dbuf_printf (oBuf, "%s:\n", sym->rname); + ++noAlloc; resolveIvalSym (sym->ival, sym->type); - printIval (sym, sym->type, sym->ival, out); - noAlloc--; - /* if sym is a simple string and sym->ival is a string, + printIval (sym, sym->type, sym->ival, oBuf, map != xinit); + --noAlloc; + /* if sym is a simple string and sym->ival is a string, WE don't need it anymore */ if (IS_ARRAY(sym->type) && IS_CHAR(sym->type->next) && IS_AST_SYM_VALUE(list2expr(sym->ival)) && @@ -1287,19 +1288,19 @@ emitStaticSeg (memmap * map, FILE * out) else { /* allocate space */ int size = getSize (sym->type); - + if (size==0) { werrorfl (sym->fileDef, sym->lineDef, E_UNKNOWN_SIZE,sym->name); } - fprintf (out, "%s:\n", sym->rname); + dbuf_printf (oBuf, "%s:\n", sym->rname); /* special case for character strings */ if (IS_ARRAY (sym->type) && IS_CHAR (sym->type->next) && SPEC_CVAL (sym->etype).v_char) - printChar (out, + printChar (oBuf, SPEC_CVAL (sym->etype).v_char, size); else - tfprintf (out, "\t!ds\n", (unsigned int) size & 0xffff); + dbuf_tprintf (oBuf, "\t!ds\n", (unsigned int) size & 0xffff); } } } @@ -1308,20 +1309,23 @@ emitStaticSeg (memmap * map, FILE * out) /*-----------------------------------------------------------------*/ /* emitMaps - emits the code for the data portion the code */ /*-----------------------------------------------------------------*/ -void +void emitMaps (void) { int publicsfr = TARGET_IS_MCS51; /* Ideally, this should be true for all */ /* ports but let's be conservative - EEP */ - + inInitMode++; /* no special considerations for the following data, idata & bit & xdata */ emitRegularMap (data, TRUE, TRUE); emitRegularMap (idata, TRUE, TRUE); - emitRegularMap (bit, TRUE, FALSE); + emitRegularMap (d_abs, TRUE, TRUE); + emitRegularMap (i_abs, TRUE, TRUE); + emitRegularMap (bit, TRUE, TRUE); emitRegularMap (pdata, TRUE, TRUE); emitRegularMap (xdata, TRUE, TRUE); + emitRegularMap (x_abs, TRUE, TRUE); if (port->genXINIT) { emitRegularMap (xidata, TRUE, TRUE); } @@ -1330,11 +1334,16 @@ emitMaps (void) emitRegularMap (home, TRUE, FALSE); emitRegularMap (code, TRUE, FALSE); - emitStaticSeg (statsg, code->oFile); + if (options.const_seg) { + dbuf_tprintf (&code->oBuf, "\t!area\n", options.const_seg); + } + emitStaticSeg (statsg, &code->oBuf); if (port->genXINIT) { - tfprintf (code->oFile, "\t!area\n", xinit->sname); - emitStaticSeg (xinit, code->oFile); + dbuf_tprintf (&code->oBuf, "\t!area\n", xinit->sname); + emitStaticSeg (xinit, &code->oBuf); } + dbuf_tprintf (&code->oBuf, "\t!area\n", c_abs->sname); + emitStaticSeg (c_abs, &code->oBuf); inInitMode--; } @@ -1342,18 +1351,18 @@ emitMaps (void) /* flushStatics - flush all currently defined statics out to file */ /* and delete. Temporary function */ /*-----------------------------------------------------------------*/ -void +void flushStatics (void) { - emitStaticSeg (statsg, codeOutFile); + emitStaticSeg (statsg, codeOutBuf); statsg->syms = NULL; } /*-----------------------------------------------------------------*/ /* createInterruptVect - creates the interrupt vector */ /*-----------------------------------------------------------------*/ -void -createInterruptVect (FILE * vFile) +void +createInterruptVect (struct dbuf_s *vBuf) { mainf = newSymbol ("main", 0); mainf->block = 0; @@ -1375,11 +1384,11 @@ createInterruptVect (FILE * vFile) return; } - tfprintf (vFile, "\t!areacode\n", CODE_NAME); - fprintf (vFile, "__interrupt_vect:\n"); + dbuf_tprintf (vBuf, "\t!areacode\n", HOME_NAME); + dbuf_printf (vBuf, "__interrupt_vect:\n"); - if (!port->genIVT || !(port->genIVT (vFile, interrupts, maxInterrupts))) + if (!port->genIVT || !(port->genIVT (vBuf, interrupts, maxInterrupts))) { /* There's no such thing as a "generic" interrupt table header. */ wassert(0); @@ -1389,7 +1398,7 @@ createInterruptVect (FILE * vFile) char *iComments1 = { ";--------------------------------------------------------\n" - "; File Created by SDCC : FreeWare ANSI-C Compiler\n"}; + "; File Created by SDCC : free open source ANSI-C Compiler\n"}; char *iComments2 = { @@ -1399,21 +1408,22 @@ char *iComments2 = /*-----------------------------------------------------------------*/ /* initialComments - puts in some initial comments */ /*-----------------------------------------------------------------*/ -void +void initialComments (FILE * afile) { time_t t; time (&t); fprintf (afile, "%s", iComments1); - fprintf (afile, "; Version " SDCC_VERSION_STR " #%s (%s)\n", getBuildNumber(), __DATE__); - fprintf (afile, "; This file generated %s", asctime (localtime (&t))); + fprintf (afile, "; Version " SDCC_VERSION_STR " #%s (%s) (%s)\n", + getBuildNumber(), getBuildDate(), getBuildEnvironment()); + fprintf (afile, "; This file was generated %s", asctime (localtime (&t))); fprintf (afile, "%s", iComments2); } /*-----------------------------------------------------------------*/ /* printPublics - generates .global for publics */ /*-----------------------------------------------------------------*/ -void +void printPublics (FILE * afile) { symbol *sym; @@ -1430,7 +1440,7 @@ printPublics (FILE * afile) /*-----------------------------------------------------------------*/ /* printExterns - generates .global for externs */ /*-----------------------------------------------------------------*/ -void +void printExterns (FILE * afile) { symbol *sym; @@ -1447,13 +1457,13 @@ printExterns (FILE * afile) /*-----------------------------------------------------------------*/ /* emitOverlay - will emit code for the overlay stuff */ /*-----------------------------------------------------------------*/ -static void -emitOverlay (FILE * afile) +static void +emitOverlay (struct dbuf_s * aBuf) { set *ovrset; if (!elementsInSet (ovrSetSets)) - tfprintf (afile, "\t!area\n", port->mem.overlay_name); + dbuf_tprintf (aBuf, "\t!area\n", port->mem.overlay_name); /* for each of the sets in the overlay segment do */ for (ovrset = setFirstItem (ovrSetSets); ovrset; @@ -1465,7 +1475,7 @@ emitOverlay (FILE * afile) if (elementsInSet (ovrset)) { /* output the area informtion */ - fprintf (afile, "\t.area\t%s\n", port->mem.overlay_name); /* MOF */ + dbuf_printf (aBuf, "\t.area\t%s\n", port->mem.overlay_name); /* MOF */ } for (sym = setFirstItem (ovrset); sym; @@ -1502,15 +1512,15 @@ emitOverlay (FILE * afile) if (!sym->level) { /* global */ if (IS_STATIC (sym->etype)) - fprintf (afile, "F%s$", moduleName); /* scope is file */ + dbuf_printf (aBuf, "F%s$", moduleName); /* scope is file */ else - fprintf (afile, "G$"); /* scope is global */ + dbuf_printf (aBuf, "G$"); /* scope is global */ } else /* symbol is local */ - fprintf (afile, "L%s$", + dbuf_printf (aBuf, "L%s$", (sym->localof ? sym->localof->name : "-null-")); - fprintf (afile, "%s$%d$%d", sym->name, sym->level, sym->block); + dbuf_printf (aBuf, "%s$%d$%d", sym->name, sym->level, sym->block); } /* if is has an absolute address then generate @@ -1519,97 +1529,65 @@ emitOverlay (FILE * afile) { if (options.debug) - fprintf (afile, " == 0x%04x\n", SPEC_ADDR (sym->etype)); + dbuf_printf (aBuf, " == 0x%04x\n", SPEC_ADDR (sym->etype)); - fprintf (afile, "%s\t=\t0x%04x\n", + dbuf_printf (aBuf, "%s\t=\t0x%04x\n", sym->rname, SPEC_ADDR (sym->etype)); } - else { + else + { int size = getSize(sym->type); if (size==0) { werrorfl (sym->fileDef, sym->lineDef, E_UNKNOWN_SIZE); - } + } if (options.debug) - fprintf (afile, "==.\n"); - + dbuf_printf (aBuf, "==.\n"); + /* allocate space */ - tfprintf (afile, "!labeldef\n", sym->rname); - tfprintf (afile, "\t!ds\n", (unsigned int) getSize (sym->type) & 0xffff); + dbuf_tprintf (aBuf, "!labeldef\n", sym->rname); + dbuf_tprintf (aBuf, "\t!ds\n", (unsigned int) getSize (sym->type) & 0xffff); } - + } } } - -/*-----------------------------------------------------------------*/ -/* spacesToUnderscores - replace spaces with underscores */ -/*-----------------------------------------------------------------*/ -static char * -spacesToUnderscores (char *dest, const char *src, size_t len) -{ - unsigned int i; - char *p; - - assert(dest != NULL); - assert(src != NULL); - assert(len > 0); - - --len; - for (p = dest, i = 0; *src != '\0' && i < len; ++src, ++i) { - *p++ = isspace(*src) ? '_' : *src; - } - *p = '\0'; - - return dest; -} - - /*-----------------------------------------------------------------*/ /* glue - the final glue that hold the whole thing together */ /*-----------------------------------------------------------------*/ -void +void glue (void) { - FILE *vFile; + struct dbuf_s vBuf; + struct dbuf_s ovrBuf; FILE *asmFile; - FILE *ovrFile = tempfile (); - char moduleBuf[PATH_MAX]; int mcs51_like; - if(port->general.glue_up_main && - (TARGET_IS_MCS51 || TARGET_IS_DS390 || TARGET_IS_XA51 || TARGET_IS_DS400)) - { - mcs51_like=1; /*So it has bits, sfr, sbits, data, idata, etc...*/ - } - else - { - mcs51_like=0; - } + dbuf_init (&vBuf, 4096); + dbuf_init (&ovrBuf, 4096); + + mcs51_like = (port->general.glue_up_main && + (TARGET_IS_MCS51 || TARGET_IS_DS390 || TARGET_IS_XA51 || TARGET_IS_DS400)); - addSetHead (&tmpfileSet, ovrFile); /* print the global struct definitions */ if (options.debug) cdbStructBlock (0); - vFile = tempfile (); - /* PENDING: this isnt the best place but it will do */ + /* PENDING: this isn't the best place but it will do */ if (port->general.glue_up_main) { /* create the interrupt vector table */ - createInterruptVect (vFile); + createInterruptVect (&vBuf); } - addSetHead (&tmpfileSet, vFile); - /* emit code for the all the variables declared */ emitMaps (); /* do the overlay segments */ - emitOverlay (ovrFile); + emitOverlay (&ovrBuf); - outputDebugSymbols(); + outputDebugSymbols (); /* now put it all together into the assembler file */ /* create the assembler file name */ @@ -1628,21 +1606,20 @@ glue (void) if (!(asmFile = fopen (scratchFileName, "w"))) { werror (E_FILE_OPEN_ERR, scratchFileName); - exit (1); + exit (EXIT_FAILURE); } /* initial comments */ initialComments (asmFile); /* print module name */ - tfprintf (asmFile, "\t!module\n", - spacesToUnderscores (moduleBuf, moduleName, sizeof moduleBuf)); - if(mcs51_like) - { - fprintf (asmFile, "\t.optsdcc -m%s", port->target); - - switch(options.model) + tfprintf (asmFile, "\t!module\n", moduleName); + if (mcs51_like) { + fprintf (asmFile, "\t.optsdcc -m%s", port->target); + + switch(options.model) + { case MODEL_SMALL: fprintf (asmFile, " --model-small"); break; case MODEL_COMPACT: fprintf (asmFile, " --model-compact"); break; case MODEL_MEDIUM: fprintf (asmFile, " --model-medium"); break; @@ -1650,19 +1627,19 @@ glue (void) case MODEL_FLAT24: fprintf (asmFile, " --model-flat24"); break; case MODEL_PAGE0: fprintf (asmFile, " --model-page0"); break; default: break; + } + /*if(options.stackAuto) fprintf (asmFile, " --stack-auto");*/ + if(options.useXstack) fprintf (asmFile, " --xstack"); + /*if(options.intlong_rent) fprintf (asmFile, " --int-long-rent");*/ + /*if(options.float_rent) fprintf (asmFile, " --float-rent");*/ + if(options.noRegParams) fprintf (asmFile, " --no-reg-params"); + if(options.parms_in_bank1) fprintf (asmFile, " --parms-in-bank1"); + fprintf (asmFile, "\n"); + } + else if (TARGET_Z80_LIKE || TARGET_IS_HC08) + { + fprintf (asmFile, "\t.optsdcc -m%s\n", port->target); } - /*if(options.stackAuto) fprintf (asmFile, " --stack-auto");*/ - if(options.useXstack) fprintf (asmFile, " --xstack"); - /*if(options.intlong_rent) fprintf (asmFile, " --int-long-rent");*/ - /*if(options.float_rent) fprintf (asmFile, " --float-rent");*/ - if(options.noRegParams) fprintf (asmFile, " --no-reg-params"); - if(options.parms_in_bank1) fprintf (asmFile, " --parms-in-bank1"); - fprintf (asmFile, "\n"); - } - else if(TARGET_IS_Z80 || TARGET_IS_GBZ80 || TARGET_IS_HC08) - { - fprintf (asmFile, "\t.optsdcc -m%s\n", port->target); - } tfprintf (asmFile, "\t!fileprelude\n"); @@ -1677,58 +1654,75 @@ glue (void) if (port->assembler.externGlobal) printExterns (asmFile); - if(( mcs51_like ) - ||( TARGET_IS_Z80 )) /*.p.t.20030924 need to output SFR table for Z80 as well */ - { + if (( mcs51_like ) + ||( TARGET_IS_Z80 )) /*.p.t.20030924 need to output SFR table for Z80 as well */ + { /* copy the sfr segment */ fprintf (asmFile, "%s", iComments2); fprintf (asmFile, "; special function registers\n"); fprintf (asmFile, "%s", iComments2); - copyFile (asmFile, sfr->oFile); - } - - if(mcs51_like) + dbuf_write_and_destroy (&sfr->oBuf, asmFile); + } + + if (mcs51_like) { /* copy the sbit segment */ fprintf (asmFile, "%s", iComments2); - fprintf (asmFile, "; special function bits \n"); + fprintf (asmFile, "; special function bits\n"); fprintf (asmFile, "%s", iComments2); - copyFile (asmFile, sfrbit->oFile); - + dbuf_write_and_destroy (&sfrbit->oBuf, asmFile); + /*JCF: Create the areas for the register banks*/ - if(RegBankUsed[0]||RegBankUsed[1]||RegBankUsed[2]||RegBankUsed[3]) - { - fprintf (asmFile, "%s", iComments2); - fprintf (asmFile, "; overlayable register banks \n"); - fprintf (asmFile, "%s", iComments2); - if(RegBankUsed[0]) + if (RegBankUsed[0] || RegBankUsed[1] || RegBankUsed[2] || RegBankUsed[3]) + { + fprintf (asmFile, "%s", iComments2); + fprintf (asmFile, "; overlayable register banks\n"); + fprintf (asmFile, "%s", iComments2); + if (RegBankUsed[0]) fprintf (asmFile, "\t.area REG_BANK_0\t(REL,OVR,DATA)\n\t.ds 8\n"); - if(RegBankUsed[1]||options.parms_in_bank1) + if (RegBankUsed[1] || options.parms_in_bank1) fprintf (asmFile, "\t.area REG_BANK_1\t(REL,OVR,DATA)\n\t.ds 8\n"); - if(RegBankUsed[2]) + if (RegBankUsed[2]) fprintf (asmFile, "\t.area REG_BANK_2\t(REL,OVR,DATA)\n\t.ds 8\n"); - if(RegBankUsed[3]) + if (RegBankUsed[3]) fprintf (asmFile, "\t.area REG_BANK_3\t(REL,OVR,DATA)\n\t.ds 8\n"); - } + } + if (BitBankUsed) + { + fprintf (asmFile, "%s", iComments2); + fprintf (asmFile, "; overlayable bit register bank\n"); + fprintf (asmFile, "%s", iComments2); + fprintf (asmFile, "\t.area BIT_BANK\t(REL,OVR,DATA)\n"); + fprintf (asmFile, "bits:\n\t.ds 1\n"); + fprintf (asmFile, "\tb0 = bits[0]\n"); + fprintf (asmFile, "\tb1 = bits[1]\n"); + fprintf (asmFile, "\tb2 = bits[2]\n"); + fprintf (asmFile, "\tb3 = bits[3]\n"); + fprintf (asmFile, "\tb4 = bits[4]\n"); + fprintf (asmFile, "\tb5 = bits[5]\n"); + fprintf (asmFile, "\tb6 = bits[6]\n"); + fprintf (asmFile, "\tb7 = bits[7]\n"); + } } /* copy the data segment */ fprintf (asmFile, "%s", iComments2); fprintf (asmFile, "; %s ram data\n", mcs51_like?"internal":""); fprintf (asmFile, "%s", iComments2); - copyFile (asmFile, data->oFile); + dbuf_write_and_destroy (&data->oBuf, asmFile); /* create the overlay segments */ - if (overlay) { - fprintf (asmFile, "%s", iComments2); - fprintf (asmFile, "; overlayable items in %s ram \n", mcs51_like?"internal":""); - fprintf (asmFile, "%s", iComments2); - copyFile (asmFile, ovrFile); - } + if (overlay) + { + fprintf (asmFile, "%s", iComments2); + fprintf (asmFile, "; overlayable items in %s ram \n", mcs51_like?"internal":""); + fprintf (asmFile, "%s", iComments2); + dbuf_write_and_destroy (&ovrBuf, asmFile); + } /* create the stack segment MOF */ - if (mainf && IFFUNC_HASBODY(mainf->type)) + if (mainf && IFFUNC_HASBODY (mainf->type)) { fprintf (asmFile, "%s", iComments2); fprintf (asmFile, "; Stack segment in internal ram \n"); @@ -1738,20 +1732,32 @@ glue (void) } /* create the idata segment */ - if ( (idata) && (mcs51_like) ) { - fprintf (asmFile, "%s", iComments2); - fprintf (asmFile, "; indirectly addressable internal ram data\n"); - fprintf (asmFile, "%s", iComments2); - copyFile (asmFile, idata->oFile); - } + if ((idata) && (mcs51_like)) + { + fprintf (asmFile, "%s", iComments2); + fprintf (asmFile, "; indirectly addressable internal ram data\n"); + fprintf (asmFile, "%s", iComments2); + dbuf_write_and_destroy (&idata->oBuf, asmFile); + } + + /* create the absolute idata/data segment */ + if ((i_abs) && (mcs51_like)) + { + fprintf (asmFile, "%s", iComments2); + fprintf (asmFile, "; absolute internal ram data\n"); + fprintf (asmFile, "%s", iComments2); + dbuf_write_and_destroy (&d_abs->oBuf, asmFile); + dbuf_write_and_destroy (&i_abs->oBuf, asmFile); + } /* copy the bit segment */ - if (mcs51_like) { - fprintf (asmFile, "%s", iComments2); - fprintf (asmFile, "; bit data\n"); - fprintf (asmFile, "%s", iComments2); - copyFile (asmFile, bit->oFile); - } + if (mcs51_like) + { + fprintf (asmFile, "%s", iComments2); + fprintf (asmFile, "; bit data\n"); + fprintf (asmFile, "%s", iComments2); + dbuf_write_and_destroy (&bit->oBuf, asmFile); + } /* copy paged external ram data */ if (mcs51_like) @@ -1759,11 +1765,11 @@ glue (void) fprintf (asmFile, "%s", iComments2); fprintf (asmFile, "; paged external ram data\n"); fprintf (asmFile, "%s", iComments2); - copyFile (asmFile, pdata->oFile); + dbuf_write_and_destroy (&pdata->oBuf, asmFile); } /* if external stack then reserve space for it */ - if (mainf && IFFUNC_HASBODY(mainf->type) && options.useXstack) + if (mainf && IFFUNC_HASBODY (mainf->type) && options.useXstack) { fprintf (asmFile, "%s", iComments2); fprintf (asmFile, "; external stack \n"); @@ -1773,33 +1779,43 @@ glue (void) } /* copy external ram data */ - if (mcs51_like) { - fprintf (asmFile, "%s", iComments2); - fprintf (asmFile, "; external ram data\n"); - fprintf (asmFile, "%s", iComments2); - copyFile (asmFile, xdata->oFile); - } + if (mcs51_like) + { + fprintf (asmFile, "%s", iComments2); + fprintf (asmFile, "; external ram data\n"); + fprintf (asmFile, "%s", iComments2); + dbuf_write_and_destroy (&xdata->oBuf, asmFile); + } + + /* create the absolute xdata segment */ + if (mcs51_like || TARGET_IS_HC08) + { + fprintf (asmFile, "%s", iComments2); + fprintf (asmFile, "; absolute external ram data\n"); + fprintf (asmFile, "%s", iComments2); + dbuf_write_and_destroy (&x_abs->oBuf, asmFile); + } /* copy external initialized ram data */ fprintf (asmFile, "%s", iComments2); fprintf (asmFile, "; external initialized ram data\n"); fprintf (asmFile, "%s", iComments2); - copyFile (asmFile, xidata->oFile); + dbuf_write_and_destroy (&xidata->oBuf, asmFile); /* If the port wants to generate any extra areas, let it do so. */ if (port->extraAreas.genExtraAreaDeclaration) - { - port->extraAreas.genExtraAreaDeclaration(asmFile, + { + port->extraAreas.genExtraAreaDeclaration(asmFile, mainf && IFFUNC_HASBODY(mainf->type)); - } - + } + /* copy the interrupt vector table */ - if (mainf && IFFUNC_HASBODY(mainf->type)) + if (mainf && IFFUNC_HASBODY (mainf->type)) { fprintf (asmFile, "%s", iComments2); fprintf (asmFile, "; interrupt vector \n"); fprintf (asmFile, "%s", iComments2); - copyFile (asmFile, vFile); + dbuf_write_and_destroy (&vBuf, asmFile); } /* copy global & static initialisations */ @@ -1813,18 +1829,20 @@ glue (void) * the post_static_name area will immediately follow the static_name * area. */ + tfprintf (asmFile, "\t!area\n", port->mem.home_name); tfprintf (asmFile, "\t!area\n", port->mem.static_name); /* MOF */ tfprintf (asmFile, "\t!area\n", port->mem.post_static_name); tfprintf (asmFile, "\t!area\n", port->mem.static_name); - if (mainf && IFFUNC_HASBODY(mainf->type)) + if (mainf && IFFUNC_HASBODY (mainf->type)) { if (port->genInitStartup) { - port->genInitStartup(asmFile); + port->genInitStartup (asmFile); } else { + assert (mcs51_like); fprintf (asmFile, "__sdcc_gsinit_startup:\n"); /* if external stack is specified then the higher order byte of the xdatalocation is @@ -1847,30 +1865,29 @@ glue (void) fprintf (asmFile, "\tmov\tsp,#__start__stack - 1\n"); /* MOF */ } - fprintf (asmFile, "\tlcall\t__sdcc_external_startup\n"); + fprintf (asmFile, "\t%ccall\t__sdcc_external_startup\n", options.acall_ajmp?'a':'l'); fprintf (asmFile, "\tmov\ta,dpl\n"); fprintf (asmFile, "\tjz\t__sdcc_init_data\n"); - fprintf (asmFile, "\tljmp\t__sdcc_program_startup\n"); + fprintf (asmFile, "\t%cjmp\t__sdcc_program_startup\n", options.acall_ajmp?'a':'l'); fprintf (asmFile, "__sdcc_init_data:\n"); // if the port can copy the XINIT segment to XISEG if (port->genXINIT) { - port->genXINIT(asmFile); + port->genXINIT (asmFile); } } - } - copyFile (asmFile, statsg->oFile); + dbuf_write_and_destroy (&statsg->oBuf, asmFile); - if (port->general.glue_up_main && mainf && IFFUNC_HASBODY(mainf->type)) + if (port->general.glue_up_main && mainf && IFFUNC_HASBODY (mainf->type)) { /* This code is generated in the post-static area. * This area is guaranteed to follow the static area * by the ugly shucking and jiving about 20 lines ago. */ tfprintf (asmFile, "\t!area\n", port->mem.post_static_name); - fprintf (asmFile, "\tljmp\t__sdcc_program_startup\n"); + fprintf (asmFile, "\t%cjmp\t__sdcc_program_startup\n", options.acall_ajmp?'a':'l'); } fprintf (asmFile, @@ -1878,198 +1895,36 @@ glue (void) "; Home\n" "%s", iComments2, iComments2); tfprintf (asmFile, "\t!areahome\n", HOME_NAME); - copyFile (asmFile, home->oFile); + dbuf_write_and_destroy (&home->oBuf, asmFile); - /* copy over code */ - fprintf (asmFile, "%s", iComments2); - fprintf (asmFile, "; code\n"); - fprintf (asmFile, "%s", iComments2); - tfprintf (asmFile, "\t!areacode\n", CODE_NAME); - if (mainf && IFFUNC_HASBODY(mainf->type)) + if (mainf && IFFUNC_HASBODY (mainf->type)) { - - /* entry point @ start of CSEG */ + /* entry point @ start of HOME */ fprintf (asmFile, "__sdcc_program_startup:\n"); /* put in jump or call to main */ if (options.mainreturn) { - fprintf (asmFile, "\tljmp\t_main\n"); /* needed? */ + fprintf (asmFile, "\t%cjmp\t_main\n", options.acall_ajmp?'a':'l'); /* needed? */ fprintf (asmFile, ";\treturn from main will return to caller\n"); } else { - fprintf (asmFile, "\tlcall\t_main\n"); + fprintf (asmFile, "\t%ccall\t_main\n", options.acall_ajmp?'a':'l'); fprintf (asmFile, ";\treturn from main will lock up\n"); fprintf (asmFile, "\tsjmp .\n"); } } - copyFile (asmFile, code->oFile); - - if (port->genAssemblerEnd) { - port->genAssemblerEnd(asmFile); - } - fclose (asmFile); - - rm_tmpfiles (); -} - - -/** Creates a temporary file with unique file name - Scans, in order: - - TMP, TEMP, TMPDIR env. variables - - if Un*x system: /usr/tmp and /tmp - - root directory using mkstemp() if available - - default location using tempnam() -*/ -static int -tempfileandname(char *fname, size_t len) -{ -#define TEMPLATE "sdccXXXXXX" -#define TEMPLATE_LEN ((sizeof TEMPLATE) - 1) - - const char *tmpdir = NULL; - int fd; - - if ((tmpdir = getenv ("TMP")) == NULL) - if ((tmpdir = getenv ("TEMP")) == NULL) - tmpdir = getenv ("TMPDIR"); - -#if defined(_WIN32) - { - static int warning_emitted; - - if (tmpdir == NULL) - { - tmpdir = "c:\\"; - if (!warning_emitted) - { - fprintf (stderr, "TMP not defined in environment, using %s for temporary files\n.", tmpdir); - warning_emitted = 1; - } - } - } -#else - { - /* try with /usr/tmp and /tmp on Un*x systems */ - struct stat statbuf; - - if (tmpdir == NULL) { - if (stat("/usr/tmp", &statbuf) != -1) - tmpdir = "/usr/tmp"; - else if (stat("/tmp", &statbuf) != -1) - tmpdir = "/tmp"; - } - } -#endif - -#ifdef HAVE_MKSTEMP - { - char fnamebuf[PATH_MAX]; - size_t name_len; - - if (fname == NULL || len == 0) { - fname = fnamebuf; - len = sizeof fnamebuf; - } - - if (tmpdir) { - name_len = strlen(tmpdir) + 1 + TEMPLATE_LEN; - - assert(name_len < len); - if (!(name_len < len)) /* in NDEBUG is defined */ - return -1; /* buffer too small, temporary file can not be created */ - - sprintf(fname, "%s" DIR_SEPARATOR_STRING TEMPLATE, tmpdir); - } - else { - name_len = TEMPLATE_LEN; - - assert(name_len < len); - if (!(name_len < len)) /* in NDEBUG is defined */ - return -1; /* buffer too small, temporary file can not be created */ - - strcpy(fname, TEMPLATE); - } - - fd = mkstemp(fname); - } -#else - { - char *name = tempnam(tmpdir, "sdcc"); + /* copy over code */ + fprintf (asmFile, "%s", iComments2); + fprintf (asmFile, "; code\n"); + fprintf (asmFile, "%s", iComments2); + tfprintf (asmFile, "\t!areacode\n", options.code_seg); + dbuf_write_and_destroy (&code->oBuf, asmFile); - if (name == NULL) { - perror("Can't create temporary file name"); - exit(1); + if (port->genAssemblerEnd) + { + port->genAssemblerEnd (asmFile); } - - assert(strlen(name) < len); - if (!(strlen(name) < len)) /* in NDEBUG is defined */ - return -1; /* buffer too small, temporary file can not be created */ - - strcpy(fname, name); -#ifdef _WIN32 - fd = open(name, O_CREAT | O_EXCL | O_RDWR, S_IREAD | S_IWRITE); -#else - fd = open(name, O_CREAT | O_EXCL | O_RDWR, S_IRUSR | S_IWUSR); -#endif - } -#endif - - if (fd == -1) { - perror("Can't create temporary file"); - exit(1); - } - - return fd; -} - - -/** Create a temporary file name -*/ -char * -tempfilename(void) -{ - int fd; - static char fnamebuf[PATH_MAX]; - - if ((fd = tempfileandname(fnamebuf, sizeof fnamebuf)) == -1) { - fprintf(stderr, "Can't create temporary file name!"); - exit(1); - } - - fd = close(fd); - assert(fd != -1); - - return fnamebuf; -} - - -/** Create a temporary file and add it to tmpfileNameSet, - so that it is removed explicitly by rm_tmpfiles() - or implicitly at program extit. -*/ -FILE * -tempfile(void) -{ - int fd; - char *tmp; - FILE *fp; - char fnamebuf[PATH_MAX]; - - if ((fd = tempfileandname(fnamebuf, sizeof fnamebuf)) == -1) { - fprintf(stderr, "Can't create temporary file!"); - exit(1); - } - - tmp = Safe_strdup(fnamebuf); - if (tmp) - addSetHead(&tmpfileNameSet, tmp); - - if ((fp = fdopen(fd, "w+b")) == NULL) { - perror("Can't create temporary file!"); - exit(1); - } - - return fp; + fclose (asmFile); }