bp->sym = sym; /* update the symbol pointer */
bp->level = level; /* update the nest level */
bp->block = block;
- strcpy (bp->name, sname); /* copy the name into place */
+ strncpyz (bp->name, sname, sizeof(bp->name)); /* copy the name into place */
/* if this is the first entry */
if (stab[i] == NULL)
sym = Safe_alloc ( sizeof (symbol));
- strcpy (sym->name, name); /* copy the name */
+ strncpyz (sym->name, name, sizeof(sym->name)); /* copy the name */
sym->level = scope; /* set the level */
sym->block = currBlockno;
sym->lineDef = yylineno; /* set the line number */
/* newLink - creates a new link (declarator,specifier) */
/*------------------------------------------------------------------*/
sym_link *
-newLink ()
+newLink (SYM_LINK_CLASS select)
{
sym_link *p;
p = Safe_alloc ( sizeof (sym_link));
+ p->class=select;
return p;
}
s = Safe_alloc ( sizeof (structdef));
- strcpy (s->tag, tag); /* copy the tag */
+ strncpyz (s->tag, tag, sizeof(s->tag)); /* copy the tag */
return s;
}
storage class of the type */
if (IS_SPEC (type))
{
- DCL_PTR_CONST (ptr) = SPEC_CONST (type);
- DCL_PTR_VOLATILE (ptr) = SPEC_VOLATILE (type);
switch (SPEC_SCLS (type))
{
case S_XDATA:
DCL_TYPE (ptr) = POINTER;
break;
case S_CODE:
- DCL_PTR_CONST (ptr) = port->mem.code_ro;
DCL_TYPE (ptr) = CPOINTER;
break;
case S_EEPROM:
break;
}
/* the storage class of type ends here */
- SPEC_SCLS (type) =
+ SPEC_SCLS (type) =
SPEC_CONST (type) =
SPEC_VOLATILE (type) = 0;
}
}
else
{
- head = tail = newLink ();
+ head = tail = newLink (DECLARATOR);
DCL_TYPE (head) = type;
}
}
/* if the type is an unknown pointer and has
- a tspec then take the storage class const & volatile
+ a tspec then take the const & volatile
attribute from the tspec & make it those of this
symbol */
+
if (p &&
- !IS_SPEC (p) &&
- //DCL_TYPE (p) == UPOINTER &&
+ IS_DECL (p) &&
+ DCL_TYPE (p) == UPOINTER &&
DCL_TSPEC (p))
{
+ // only for declarators
+ wassert (IS_DECL(sym->type));
+
if (!IS_SPEC (sym->etype))
{
- sym->etype = sym->etype->next = newLink ();
- sym->etype->class = SPECIFIER;
+ sym->etype = sym->etype->next = newLink (SPECIFIER);
}
+
SPEC_SCLS (sym->etype) = SPEC_SCLS (DCL_TSPEC (p));
- SPEC_CONST (sym->etype) = SPEC_CONST (DCL_TSPEC (p));
- SPEC_VOLATILE (sym->etype) = SPEC_VOLATILE (DCL_TSPEC (p));
+ DCL_PTR_CONST (sym->type) = SPEC_CONST (DCL_TSPEC (p));
+ DCL_PTR_VOLATILE (sym->type) = SPEC_VOLATILE (DCL_TSPEC (p));
DCL_TSPEC (p) = NULL;
}
noun=nounName(etype);
if (getenv("DEBUG_SANITY")) {
- fprintf (stderr, "checking sanity for %s %x\n", name, (int)etype);
+ fprintf (stderr, "checking sanity for %s %p\n", name, etype);
}
if ((SPEC_NOUN(etype)==V_CHAR ||
sym_link *
mergeSpec (sym_link * dest, sym_link * src, char *name)
{
- sym_link *symlink=dest;
-
if (!IS_SPEC(dest) || !IS_SPEC(src)) {
-#if 0
- werror (E_INTERNAL_ERROR, __FILE__, __LINE__, "cannot merge declarator");
- exit (1);
-#else
werror (E_SYNTAX_ERROR, yytext);
- // the show must go on
- return newIntLink();
-#endif
}
if (SPEC_NOUN(src)) {
/* copy all the specifications */
- // we really should do:
-#if 0
- if (SPEC_what(src)) {
- if (SPEC_what(dest)) {
- werror(W_DUPLICATE_SPEC, "what");
- }
- SPEC_what(dst)|=SPEC_what(src);
- }
-#endif
- // but there are more important thing right now
-
SPEC_LONG (dest) |= SPEC_LONG (src);
dest->select.s._short|=src->select.s._short;
SPEC_USIGN (dest) |= SPEC_USIGN (src);
FUNC_INTNO(dest) |= FUNC_INTNO(src);
FUNC_REGBANK(dest) |= FUNC_REGBANK(src);
- return symlink;
-}
-
-/*------------------------------------------------------------------*/
-/* cloneSpec - copies the entire spec and returns a new spec */
-/*------------------------------------------------------------------*/
-sym_link *
-cloneSpec (sym_link * src)
-{
- sym_link *spec;
-
- /* go thru chain till we find the specifier */
- while (src && src->class != SPECIFIER)
- src = src->next;
-
- spec = newLink ();
- memcpy (spec, src, sizeof (sym_link));
- return spec;
+ return dest;
}
/*------------------------------------------------------------------*/
static int gCount = 0;
static char gname[SDCC_NAME_MAX + 1];
- sprintf (gname, "__%04d%04d", level, gCount++);
+ SNPRINTF (gname, sizeof(gname), "__%04d%04d", level, gCount++);
return gname;
}
{
sym_link *p;
- p = newLink ();
- p->class = SPECIFIER;
+ p = newLink (SPECIFIER);
SPEC_NOUN (p) = V_CHAR;
return p;
{
sym_link *p;
- p = newLink ();
- p->class = SPECIFIER;
+ p = newLink (SPECIFIER);
SPEC_NOUN (p) = V_FLOAT;
return p;
{
sym_link *p;
- p = newLink ();
- p->class = SPECIFIER;
+ p = newLink (SPECIFIER);
SPEC_NOUN (p) = V_INT;
SPEC_LONG (p) = 1;
{
sym_link *p;
- p = newLink ();
- p->class = SPECIFIER;
+ p = newLink (SPECIFIER);
SPEC_NOUN (p) = V_INT;
return p;
werror (E_EXTERN_MISMATCH, csym->name);
continue;
}
- /* delete current entry */
- deleteSym (SymbolTab, csym, csym->name);
- deleteFromSeg(csym);
} else {
/* not extern */
- werror (E_DUPLICATE, sym->name);
- continue;
+ if (compareType (csym->type, sym->type) != 1) {
+ werror (E_DUPLICATE, sym->name);
+ continue;
+ }
}
+ /* delete current entry */
+ deleteSym (SymbolTab, csym, csym->name);
+ deleteFromSeg(csym);
}
/* add new entry */
while (loop) {
/* create the internal name for this variable */
- sprintf (loop->rname, "_%s", loop->name);
+ SNPRINTF (loop->rname, sizeof(loop->rname), "_%s", loop->name);
loop->offset = (su == UNION ? sum = 0 : sum);
SPEC_VOLATILE (loop->etype) |= (su == UNION ? 1 : 0);
/* if no other storage class specified */
if (sym->level == 0 &&
SPEC_CONST (sym->etype) &&
- SPEC_SCLS(sym->etype) == S_FIXED) {
+ SPEC_SCLS(sym->etype) == S_FIXED &&
+ !IS_FUNC(sym->type)) {
SPEC_SCLS (sym->etype) = S_CODE;
}
-
+
/* global variable in code space is a constant */
if (sym->level == 0 &&
SPEC_SCLS (sym->etype) == S_CODE &&
- port->mem.code_ro)
- SPEC_CONST (sym->etype) = 1;
-
+ port->mem.code_ro) {
+ if (IS_SPEC(sym->type)) {
+ SPEC_CONST (sym->type) = 1;
+ } else {
+ DCL_PTR_CONST (sym->type) = 1;
+ }
+ }
/* if bit variable then no storage class can be */
/* specified since bit is already a storage */
sym_link *head, *curr, *loop;
curr = p;
- head = loop = (curr ? newLink () : (void *) NULL);
+ head = loop = (curr ? newLink (p->class) : (void *) NULL);
while (curr)
{
memcpy (loop, curr, sizeof (sym_link)); /* copy it */
- loop->next = (curr->next ? newLink () : (void *) NULL);
+ loop->next = (curr->next ? newLink (curr->next->class) : (void *) NULL);
loop = loop->next;
curr = curr->next;
}
}
return compareType (dest->next, src->next);
}
+ if (IS_PTR (dest) && IS_GENPTR (src) && IS_VOID(src->next)) {
+ return 1;
+ }
if (IS_PTR (src) && IS_GENPTR (dest))
return -1;
if (IS_PTR (dest) && IS_ARRAY (src)) {
int res=compareType (dest, val->type);
Safe_free(val->type);
Safe_free(val);
- //return res ? -1 : 0;
return res;
}
if (IS_PTR (dest) && IS_FUNC (dest->next) && IS_FUNC (src))
sym_link *p = val->type;
werror (W_STRUCT_AS_ARG, val->name);
- val->type = newLink ();
+ val->type = newLink (DECLARATOR);
val->type->next = p;
}
if (SPEC_OCLS(val->etype)) {
DCL_TYPE(val->type)=PTR_TYPE(SPEC_OCLS(val->etype));
} else {
-#if 1
// this happens for (external) function parameters
DCL_TYPE (val->type) = port->unqualified_pointer;
-#else
- if (TARGET_IS_DS390) {
- /* The AUTO and REGISTER classes should probably
- * also become generic pointers, but I haven't yet
- * devised a test case for that.
- */
- DCL_TYPE (val->type) = port->unqualified_pointer;
- break;
- }
- if (options.model==MODEL_LARGE) {
- DCL_TYPE (val->type) = FPOINTER;
- break;
- }
-#endif
}
break;
case S_AUTO:
// this can happen for reentrant functions
werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
// the show must go on: synthesize a name and symbol
- sprintf (acargs->name, "_%s_PARM_%d", sym->name, argCnt);
+ SNPRINTF (acargs->name, sizeof(acargs->name), "_%s_PARM_%d", sym->name, argCnt);
acargs->sym = newSymbol (acargs->name, 1);
SPEC_OCLS (acargs->etype) = istack;
acargs->sym->type = copyLinkChain (acargs->type);
acargs->sym->etype = getSpec (acargs->sym->type);
acargs->sym->_isparm = 1;
- strcpy (acargs->sym->rname, acargs->name);
+ strncpyz (acargs->sym->rname, acargs->name, sizeof(acargs->sym->rname));
} else if (strcmp(acargs->sym->name, acargs->sym->rname)==0) {
// synthesized name
werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
/* synthesize a variable name */
if (!val->sym)
{
- sprintf (val->name, "_%s_PARM_%d", func->name, pNum++);
+ SNPRINTF (val->name, sizeof(val->name),
+ "_%s_PARM_%d", func->name, pNum++);
val->sym = newSymbol (val->name, 1);
SPEC_OCLS (val->etype) = port->mem.default_local_map;
val->sym->type = copyLinkChain (val->type);
val->sym->etype = getSpec (val->sym->type);
val->sym->_isparm = 1;
- strcpy (val->sym->rname, val->name);
- SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
- SPEC_STAT (func->etype);
+ strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
+ if (IS_SPEC(func->etype)) {
+ SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
+ SPEC_STAT (func->etype);
+ }
addSymChain (val->sym);
}
else /* symbol name given create synth name */
{
- sprintf (val->name, "_%s_PARM_%d", func->name, pNum++);
- strcpy (val->sym->rname, val->name);
+ SNPRINTF (val->name, sizeof(val->name), "_%s_PARM_%d", func->name, pNum++);
+ strncpyz (val->sym->rname, val->name, sizeof(val->sym->rname));
val->sym->_isparm = 1;
SPEC_OCLS (val->etype) = SPEC_OCLS (val->sym->etype) =
(options.model != MODEL_SMALL ? xdata : data);
- SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
- SPEC_STAT (func->etype);
+ if (IS_SPEC(func->etype)) {
+ SPEC_STAT (val->etype) = SPEC_STAT (val->sym->etype) =
+ SPEC_STAT (func->etype);
+ }
}
+ if (!isinSet(operKeyReset, val->sym)) {
+ addSet (&operKeyReset, val->sym);
+ applyToSet (operKeyReset, resetParmKey);
+ }
val = val->next;
}
}
{
int nlr = 0;
sym_link * type, * search;
+ STORAGE_CLASS scls;
if (!of)
{
return;
}
- /* print the chain as it is written in the source: */
- /* start with the last entry */
+ /* Print the chain as it is written in the source: */
+ /* start with the last entry. */
+ /* However, the storage class at the end of the */
+ /* chain reall applies to the first in the chain! */
+
for (type = start; type && type->next; type = type->next)
;
+ scls=SPEC_SCLS(type);
while (type)
{
+ if (type==start) {
+ switch (scls)
+ {
+ case S_DATA: fprintf (of, "data-"); break;
+ case S_XDATA: fprintf (of, "xdata-"); break;
+ case S_SFR: fprintf (of, "sfr-"); break;
+ case S_SBIT: fprintf (of, "sbit-"); break;
+ case S_CODE: fprintf (of, "code-"); break;
+ case S_IDATA: fprintf (of, "idata-"); break;
+ case S_PDATA: fprintf (of, "pdata-"); break;
+ case S_LITERAL: fprintf (of, "literal-"); break;
+ case S_STACK: fprintf (of, "stack-"); break;
+ case S_XSTACK: fprintf (of, "xstack-"); break;
+ case S_BIT: fprintf (of, "bit-"); break;
+ case S_EEPROM: fprintf (of, "eeprom-"); break;
+ default: break;
+ }
+ }
+
if (IS_DECL (type))
{
- if (DCL_PTR_VOLATILE (type)) {
- fprintf (of, "volatile ");
+ if (!IS_FUNC(type)) {
+ if (DCL_PTR_VOLATILE (type)) {
+ fprintf (of, "volatile-");
+ }
+ if (DCL_PTR_CONST (type)) {
+ fprintf (of, "const-");
+ }
}
switch (DCL_TYPE (type))
{
(IFFUNC_ISJAVANATIVE(type) ? "_JavaNative" : " "));
break;
case GPOINTER:
- if (DCL_PTR_CONST (type))
- fprintf (of, "const ");
- fprintf (of, "generic * ");
+ fprintf (of, "generic* ");
break;
case CPOINTER:
- if (DCL_PTR_CONST (type))
- fprintf (of, "const ");
- fprintf (of, "code * ");
+ fprintf (of, "code* ");
break;
case FPOINTER:
- if (DCL_PTR_CONST (type))
- fprintf (of, "const ");
- fprintf (of, "xdata * ");
+ fprintf (of, "xdata* ");
break;
case EEPPOINTER:
- if (DCL_PTR_CONST (type))
- fprintf (of, "const ");
- fprintf (of, "eeprom * ");
+ fprintf (of, "eeprom* ");
break;
-
case POINTER:
- if (DCL_PTR_CONST (type))
- fprintf (of, "const ");
- fprintf (of, "near *");
+ fprintf (of, "near* ");
break;
case IPOINTER:
- if (DCL_PTR_CONST (type))
- fprintf (of, "const ");
- fprintf (of, "idata * ");
+ fprintf (of, "idata* ");
break;
case PPOINTER:
- if (DCL_PTR_CONST (type))
- fprintf (of, "const ");
- fprintf (of, "pdata * ");
+ fprintf (of, "pdata* ");
break;
case UPOINTER:
- if (DCL_PTR_CONST (type))
- fprintf (of, "const ");
- fprintf (of, "unkown * ");
+ fprintf (of, "unkown* ");
break;
case ARRAY:
if (DCL_ELEM(type)) {
}
else
{
- switch (SPEC_SCLS(type))
- {
- case S_DATA: fprintf (of, "data "); break;
- case S_XDATA: fprintf (of, "xdata "); break;
- case S_SFR: fprintf (of, "sfr "); break;
- case S_SBIT: fprintf (of, "sbit "); break;
- case S_CODE: fprintf (of, "code "); break;
- case S_IDATA: fprintf (of, "idata "); break;
- case S_PDATA: fprintf (of, "pdata "); break;
- case S_LITERAL: fprintf (of, "literal "); break;
- case S_STACK: fprintf (of, "stack "); break;
- case S_XSTACK: fprintf (of, "xstack "); break;
- case S_BIT: fprintf (of, "bit "); break;
- case S_EEPROM: fprintf (of, "eeprom "); break;
- default: break;
- }
-
if (SPEC_VOLATILE (type))
- fprintf (of, "volatile ");
- if (SPEC_USIGN (type))
- fprintf (of, "unsigned ");
+ fprintf (of, "volatile-");
if (SPEC_CONST (type))
- fprintf (of, "const ");
+ fprintf (of, "const-");
+ if (SPEC_USIGN (type))
+ fprintf (of, "unsigned-");
switch (SPEC_NOUN (type))
{
case V_INT:
if (IS_LONG (type))
- fprintf (of, "long ");
+ fprintf (of, "long-");
fprintf (of, "int");
break;
break;
}
}
- /* search entry in list before "type" */
- for (search = start; search && search->next != type;)
- search = search->next;
- type = search;
- if (type)
- fputc (' ', of);
+ /* search entry in list before "type" */
+ for (search = start; search && search->next != type;)
+ search = search->next;
+ type = search;
+ if (type)
+ fputc (' ', of);
}
if (nlr)
fprintf (of, "\n");
/*-----------------------------------------------------------------*/
sym_link *typeFromStr (char *s)
{
- sym_link *r = newLink();
+ sym_link *r = newLink(DECLARATOR);
int usign = 0;
do {
case 'd':
case 'F':
assert(*(s+1)=='*');
- nr = newLink();
+ nr = newLink(DECLARATOR);
nr->next = r;
r = nr;
- r->class = DECLARATOR ;
switch (*s) {
case 'g':
DCL_TYPE(r) = GPOINTER;
break;
case 'F':
DCL_TYPE(r) = FUNCTION;
- nr = newLink();
+ nr = newLink(DECLARATOR);
nr->next = r;
r = nr;
- r->class = DECLARATOR ;
DCL_TYPE(r) = CPOINTER;
break;
}
{
if (tofrom)
{
- sprintf (buffer, "__fs2%s%s", ssu[su], sbwd[bwd]);
+ SNPRINTF (buffer, sizeof(buffer), "__fs2%s%s", ssu[su], sbwd[bwd]);
__conv[tofrom][bwd][su] = funcOfType (buffer, __multypes[bwd][su], floatType, 1, options.float_rent);
}
else
{
- sprintf (buffer, "__%s%s2fs", ssu[su], sbwd[bwd]);
+ SNPRINTF (buffer, sizeof(buffer), "__%s%s2fs", ssu[su], sbwd[bwd]);
__conv[tofrom][bwd][su] = funcOfType (buffer, floatType, __multypes[bwd][su], 1, options.float_rent);
}
}
{
for (su = 0; su < 2; su++)
{
- sprintf (buffer, "_%s%s%s",
+ SNPRINTF (buffer, sizeof(buffer),
+ "_%s%s%s",
smuldivmod[muldivmod],
ssu[su],
sbwd[bwd]);
{
for (su = 0; su < 2; su++)
{
- sprintf (buffer, "_%s%s%s",
+ SNPRINTF (buffer, sizeof(buffer),
+ "_%s%s%s",
srlrr[rlrr],
ssu[su],
sbwd[bwd]);
FUNC_ISREENT(sym->type) = 0; /* can never be reentrant */
}
}
+
+sym_link *validateLink(sym_link *l,
+ const char *macro,
+ const char *args,
+ const char select,
+ const char *file,
+ unsigned line)
+{
+ if (l && l->class==select)
+ {
+ return l;
+ }
+ fprintf(stderr,
+ "Internal error: validateLink failed in %s(%s) @ %s:%u:"
+ " expected %s, got %s\n",
+ macro, args, file, line,
+ DECLSPEC2TXT(select), l ? DECLSPEC2TXT(l->class) : "null-link");
+ exit(-1);
+ return l; // never reached, makes compiler happy.
+}