#include "asm.h"
#include <time.h>
+#if !defined(__BORLANDC__) && !defined(_MSC_VER)
+#if 0 /* This should no longer be necessary. */
+// This is a bit messy because we define link ourself
+#define link NoLiNk
+#include <unistd.h>
+#undef link
+#else
+
+#include <unistd.h>
+#endif
+#else
+// No unistd.h in Borland C++
+#endif
+
symbol *interrupts[256];
-/*extern char *aopLiteral (value *, int);*//* drdani Jan 30 2000 */
-void printIval (symbol *, link *, initList *, FILE *);
-extern int noAlloc;
+
+void printIval (symbol *, sym_link *, initList *, FILE *);
set *publics = NULL; /* public variables */
set *externs = NULL; /* Varibles that are declared as extern */
/* TODO: this should be configurable (DS803C90 uses more than 6) */
int maxInterrupts = 6;
int allocInfo = 1;
-extern int maxRegBank ;
symbol *mainf;
extern char *VersionString;
-extern FILE *codeOutFile;
set *tmpfileSet = NULL; /* set of tmp file created by the compiler */
set *tmpfileNameSet = NULL; /* All are unlinked at close. */
+
/*-----------------------------------------------------------------*/
/* closeTmpFiles - closes all tmp files created by the compiler */
/* because of BRAIN DEAD MS/DOS & CYGNUS Libraries */
if ((sym->level == 0 ||
(sym->_isparm && !IS_REGPARM(sym->etype))) &&
addPublics &&
- !IS_STATIC (sym->etype))
+ !IS_STATIC (sym->etype) &&
+ (sym->used || sym->fbody)) {
addSetHead (&publics, sym);
+ }
/* if extern then do nothing or is a function
then do nothing */
tfprintf(map->oFile, "\t!ds\n", (unsigned int)getSize (sym->type) & 0xffff);
}
- /* if it has a initial value then do it only if
+ /* if it has an initial value then do it only if
it is a global variable */
if (sym->ival && sym->level == 0) {
ast *ival = NULL;
if (IS_AGGREGATE (sym->type))
ival = initAggregates (sym, sym->ival, NULL);
else
- ival = newNode ('=', newAst (EX_VALUE, symbolVal (sym)),
+ ival = newNode ('=', newAst_VALUE(symbolVal (sym)),
decorateType (resolveSymbols (list2expr (sym->ival))));
codeOutFile = statsg->oFile;
allocInfo = 0;
}
}
-
/*-----------------------------------------------------------------*/
/* initPointer - pointer initialization code massaging */
/*-----------------------------------------------------------------*/
tfprintf(ofile, "\t!db !constbyte\n", 0);
}
+/*-----------------------------------------------------------------*/
+/* return the generic pointer high byte for a given pointer type. */
+/*-----------------------------------------------------------------*/
+int pointerTypeToGPByte(const int p_type)
+{
+ switch (p_type)
+ {
+ case IPOINTER:
+ case POINTER:
+ return 0;
+ case GPOINTER:
+ /* hack - if we get a generic pointer, we just assume
+ * it's an FPOINTER (i.e. in XDATA space).
+ */
+ case FPOINTER:
+ return 1;
+ case CPOINTER:
+ return 2;
+ case PPOINTER:
+ return 3;
+ default:
+ fprintf(stderr, "*** internal error: unknown pointer type %d in GPByte.\n",
+ p_type);
+ break;
+ }
+ return -1;
+}
+
+
+/*-----------------------------------------------------------------*/
+/* printPointerType - generates ival for pointer type */
+/*-----------------------------------------------------------------*/
+void _printPointerType(FILE *oFile, const char *name)
+{
+ if (IS_DS390_PORT)
+ {
+ fprintf(oFile, "\t.byte %s,(%s >> 8),(%s >> 16)",name,name,name);
+ }
+ else
+ {
+ fprintf(oFile, "\t.byte %s,(%s >> 8)",name,name);
+ }
+}
+
+/*-----------------------------------------------------------------*/
+/* printPointerType - generates ival for pointer type */
+/*-----------------------------------------------------------------*/
+void printPointerType(FILE *oFile, const char *name)
+{
+ _printPointerType(oFile, name);
+ fprintf(oFile, "\n");
+}
+
+/*-----------------------------------------------------------------*/
+/* printGPointerType - generates ival for generic pointer type */
+/*-----------------------------------------------------------------*/
+void printGPointerType(FILE *oFile, const char *name,
+ const unsigned int type)
+{
+ _printPointerType(oFile,name);
+ fprintf(oFile, ",#0x%02x\n", pointerTypeToGPByte(type));
+}
+
/*-----------------------------------------------------------------*/
/* printIvalType - generates ival for int/char */
/*-----------------------------------------------------------------*/
-void printIvalType (link * type, initList * ilist, FILE * oFile)
+void printIvalType (sym_link * type, initList * ilist, FILE * oFile)
{
value *val;
/*-----------------------------------------------------------------*/
/* printIvalStruct - generates initial value for structures */
/*-----------------------------------------------------------------*/
-void printIvalStruct (symbol * sym,link * type,
+void printIvalStruct (symbol * sym,sym_link * type,
initList * ilist, FILE * oFile)
{
symbol *sflds;
/*-----------------------------------------------------------------*/
/* printIvalChar - generates initital value for character array */
/*-----------------------------------------------------------------*/
-int printIvalChar (link * type, initList * ilist, FILE * oFile, char *s)
+int printIvalChar (sym_link * type, initList * ilist, FILE * oFile, char *s)
{
value *val;
int remain;
/*-----------------------------------------------------------------*/
/* printIvalArray - generates code for array initialization */
/*-----------------------------------------------------------------*/
-void printIvalArray (symbol * sym, link * type, initList * ilist,
+void printIvalArray (symbol * sym, sym_link * type, initList * ilist,
FILE * oFile)
{
initList *iloop;
/*-----------------------------------------------------------------*/
/* printIvalFuncPtr - generate initial value for function pointers */
/*-----------------------------------------------------------------*/
-void printIvalFuncPtr (link * type, initList * ilist, FILE * oFile)
+void printIvalFuncPtr (sym_link * type, initList * ilist, FILE * oFile)
{
value *val;
int dLvl = 0;
/* now generate the name */
if (!val->sym) {
if (port->use_dw_for_init)
+ {
tfprintf(oFile, "\t!dws\n", val->name);
+ }
else
- fprintf(oFile, "\t.byte %s,(%s >> 8)\n", val->name,val->name);
+ {
+ printPointerType(oFile, val->name);
+ }
}
else
if (port->use_dw_for_init)
+ {
tfprintf(oFile, "\t!dws\n", val->sym->rname);
- else
- fprintf(oFile, "\t.byte %s,(%s >> 8)\n", val->sym->rname,val->sym->rname);
+ }
+ else
+ {
+ printPointerType(oFile, val->sym->rname);
+ }
return;
}
/*-----------------------------------------------------------------*/
/* printIvalCharPtr - generates initial values for character pointers */
/*-----------------------------------------------------------------*/
-int printIvalCharPtr (symbol * sym, link * type, value * val, FILE * oFile)
+int printIvalCharPtr (symbol * sym, sym_link * type, value * val, FILE * oFile)
{
int size = 0;
size = getSize (type);
if (val->name && strlen(val->name)) {
- switch (size) {
- case 1:
+ if (size == 1) /* This appears to be Z80 specific?? */
+ {
tfprintf(oFile,
- "\t!dbs\n", val->name) ;
- break;
- case 2:
+ "\t!dbs\n", val->name);
+ }
+ else if (size == FPTRSIZE)
+ {
if (port->use_dw_for_init)
+ {
tfprintf(oFile, "\t!dws\n", val->name);
+ }
else
- fprintf(oFile, "\t.byte %s,(%s >> 8)\n", val->name, val->name);
- break;
- /* PENDING: probably just 3 */
- default:
+ {
+ printPointerType(oFile, val->name);
+ }
+ }
+ else if (size == GPTRSIZE)
+ {
/* PENDING: 0x02 or 0x%02x, CDATA? */
- fprintf (oFile,
- "\t.byte %s,(%s >> 8),#0x%02x\n",
- val->name, val->name, (IS_PTR(val->type) ? DCL_TYPE(val->type) :
- PTR_TYPE(SPEC_OCLS(val->etype))));
+ printGPointerType(oFile, val->name,
+ (IS_PTR(val->type) ? DCL_TYPE(val->type) :
+ PTR_TYPE(SPEC_OCLS(val->etype))));
+ }
+ else
+ {
+ fprintf(stderr, "*** internal error: unknown size in "
+ "printIvalCharPtr.\n");
}
}
else {
+ /* What is this case? Are these pointers? */
switch (size) {
case 1:
tfprintf(oFile, "\t!dbs\n", aopLiteral(val, 0));
/*-----------------------------------------------------------------*/
/* printIvalPtr - generates initial value for pointers */
/*-----------------------------------------------------------------*/
-void printIvalPtr (symbol * sym, link * type, initList * ilist, FILE * oFile)
+void printIvalPtr (symbol * sym, sym_link * type, initList * ilist, FILE * oFile)
{
value *val;
+ int size;
/* if deep then */
if (ilist->type == INIT_DEEP)
}
- switch (getSize (type)) {
- case 1:
+ size = getSize (type);
+
+ if (size == 1) /* Z80 specific?? */
+ {
tfprintf (oFile, "\t!dbs\n", val->name);
- break;
- case 2:
+ }
+ else if (size == FPTRSIZE)
+ {
tfprintf (oFile, "\t!dws\n", val->name);
- break;
-
- case 3:
- fprintf (oFile, "\t.byte %s,(%s >> 8),#0x%02x\n",
- val->name, val->name,(IS_PTR(val->type) ? DCL_TYPE(val->type) :
- PTR_TYPE(SPEC_OCLS(val->etype))));
+ }
+ else if (size == GPTRSIZE)
+ {
+ printGPointerType(oFile, val->name,
+ (IS_PTR(val->type) ? DCL_TYPE(val->type) :
+ PTR_TYPE(SPEC_OCLS(val->etype))));
}
return;
}
/*-----------------------------------------------------------------*/
/* printIval - generates code for initial value */
/*-----------------------------------------------------------------*/
-void printIval (symbol * sym, link * type, initList * ilist, FILE * oFile)
+void printIval (symbol * sym, sym_link * type, initList * ilist, FILE * oFile)
{
if (!ilist)
return;
/*-----------------------------------------------------------------*/
/* emitStaticSeg - emitcode for the static segment */
/*-----------------------------------------------------------------*/
-void emitStaticSeg (memmap * map)
+void emitStaticSeg(memmap * map, FILE *out)
{
symbol *sym;
/* fprintf(map->oFile,"\t.area\t%s\n",map->sname); */
-
- if (!codeOutFile)
- codeOutFile = code->oFile;
+ if (!out)
+ out = code->oFile;
/* for all variables in this segment do */
for (sym = setFirstItem (map->syms); sym;
if (!sym->level) { /* global */
if (IS_STATIC(sym->etype))
- fprintf(codeOutFile,"F%s$",moduleName); /* scope is file */
+ fprintf(out,"F%s$",moduleName); /* scope is file */
else
- fprintf(codeOutFile,"G$"); /* scope is global */
+ fprintf(out,"G$"); /* scope is global */
}
else
/* symbol is local */
- fprintf(codeOutFile,"L%s$",
+ fprintf(out,"L%s$",
(sym->localof ? sym->localof->name : "-null-"));
- fprintf(codeOutFile,"%s$%d$%d",sym->name,sym->level,sym->block);
+ 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 || sym->level == 0) && !options.nodebug)
- fprintf(codeOutFile," == 0x%04x\n", SPEC_ADDR (sym->etype));
+ fprintf(out," == 0x%04x\n", SPEC_ADDR (sym->etype));
- fprintf (codeOutFile, "%s\t=\t0x%04x\n",
+ fprintf (out, "%s\t=\t0x%04x\n",
sym->rname,
SPEC_ADDR (sym->etype));
}
else {
if ((options.debug || sym->level == 0) && !options.nodebug)
- fprintf(codeOutFile," == .\n");
+ fprintf(out," == .\n");
/* if it has an initial value */
if (sym->ival) {
- fprintf (codeOutFile, "%s:\n", sym->rname);
+ fprintf (out, "%s:\n", sym->rname);
noAlloc++;
resolveIvalSym (sym->ival);
- printIval (sym, sym->type, sym->ival, codeOutFile);
+ printIval (sym, sym->type, sym->ival, out);
noAlloc--;
}
else {
/* allocate space */
- fprintf (codeOutFile, "%s:\n", sym->rname);
+ fprintf (out, "%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 (codeOutFile,
+ printChar (out,
SPEC_CVAL (sym->etype).v_char,
strlen(SPEC_CVAL (sym->etype).v_char)+1);
else
- tfprintf(codeOutFile, "\t!ds\n", (unsigned int)getSize (sym->type)& 0xffff);
+ tfprintf(out, "\t!ds\n", (unsigned int)getSize (sym->type)& 0xffff);
}
}
}
emitRegularMap (sfrbit, FALSE,FALSE);
emitRegularMap (home, TRUE,FALSE);
emitRegularMap (code, TRUE,FALSE);
- emitStaticSeg (statsg);
+
+ emitStaticSeg (statsg, code->oFile);
}
/*-----------------------------------------------------------------*/
/*-----------------------------------------------------------------*/
void flushStatics(void)
{
- emitStaticSeg(statsg);
+ emitStaticSeg(statsg, codeOutFile);
statsg->syms = NULL;
}
addSetHead(&tmpfileSet,ovrFile);
/* print the global struct definitions */
- if (options.debug)
+ if (options.debug && !options.nodebug)
cdbStructBlock (0,cdbFile);
vFile = tempfile();
if (name) {
FILE *fp = fopen(name, "w+b");
if (fp)
+ {
addSetHead(&tmpfileNameSet, name);
+ }
return fp;
}
return NULL;
projects / fw / sdcc / blobdiff