X-Git-Url: https://git.gag.com/?a=blobdiff_plain;ds=sidebyside;f=src%2FSDCCsymt.c;h=c085bc09f2766a2cd5e15c16c2ac64ca71dbbe55;hb=017de88e377891f9ee18b831bd93a77343064bcb;hp=0f8822bad70f93d868bb5eca91482f1fc023bf1e;hpb=74cc47c04fa325773b214f28ff1d0ecfe4d5205d;p=fw%2Fsdcc

diff --git a/src/SDCCsymt.c b/src/SDCCsymt.c
index 0f8822ba..c085bc09 100644
--- a/src/SDCCsymt.c
+++ b/src/SDCCsymt.c
@@ -138,7 +138,7 @@ addSym (bucket ** stab,
   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)
@@ -287,10 +287,10 @@ newSymbol (char *name, int scope)
 
   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 */
+  sym->lineDef = mylineno;	/* set the line number */
   return sym;
 }
 
@@ -298,11 +298,12 @@ newSymbol (char *name, int scope)
 /* 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;
 }
@@ -317,7 +318,7 @@ newStruct (char *tag)
 
   s = Safe_alloc ( sizeof (structdef));
 
-  strcpy (s->tag, tag);		/* copy the tag            */
+  strncpyz (s->tag, tag, sizeof(s->tag));		/* copy the tag */
   return s;
 }
 
@@ -375,7 +376,7 @@ pointerTypes (sym_link * ptr, sym_link * type)
 	  break;
 	}
       /* the storage class of type ends here */
-      SPEC_SCLS (type) =
+      SPEC_SCLS (type) = 
 	SPEC_CONST (type) =
 	SPEC_VOLATILE (type) = 0;
     }
@@ -422,7 +423,7 @@ addDecl (symbol * sym, int type, sym_link * p)
     }
   else
     {
-      head = tail = newLink ();
+      head = tail = newLink (DECLARATOR);
       DCL_TYPE (head) = type;
     }
 
@@ -467,8 +468,7 @@ addDecl (symbol * sym, int type, sym_link * p)
     {
       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));
@@ -508,7 +508,7 @@ void checkTypeSanity(sym_link *etype, char *name) {
   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 || 
@@ -557,8 +557,6 @@ void checkTypeSanity(sym_link *etype, char *name) {
 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");
@@ -622,7 +620,9 @@ mergeSpec (sym_link * dest, sym_link * src, char *name)
   SPEC_BSTR (dest) |= SPEC_BSTR (src);
   SPEC_TYPEDEF (dest) |= SPEC_TYPEDEF (src);
   SPEC_ENUM (dest) |= SPEC_ENUM (src);
-
+  if (SPEC_ARGREG(src) && !SPEC_ARGREG(dest))
+      SPEC_ARGREG(dest) = SPEC_ARGREG(src);
+  
   if (IS_STRUCT (dest) && SPEC_STRUCT (dest) == NULL)
     SPEC_STRUCT (dest) = SPEC_STRUCT (src);
 
@@ -640,24 +640,7 @@ mergeSpec (sym_link * dest, sym_link * src, char *name)
   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;
 }
 
 /*------------------------------------------------------------------*/
@@ -669,7 +652,7 @@ genSymName (int level)
   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;
 }
 
@@ -696,8 +679,7 @@ newCharLink ()
 {
   sym_link *p;
 
-  p = newLink ();
-  p->class = SPECIFIER;
+  p = newLink (SPECIFIER);
   SPEC_NOUN (p) = V_CHAR;
 
   return p;
@@ -711,8 +693,7 @@ newFloatLink ()
 {
   sym_link *p;
 
-  p = newLink ();
-  p->class = SPECIFIER;
+  p = newLink (SPECIFIER);
   SPEC_NOUN (p) = V_FLOAT;
 
   return p;
@@ -726,8 +707,7 @@ newLongLink ()
 {
   sym_link *p;
 
-  p = newLink ();
-  p->class = SPECIFIER;
+  p = newLink (SPECIFIER);
   SPEC_NOUN (p) = V_INT;
   SPEC_LONG (p) = 1;
 
@@ -742,8 +722,7 @@ newIntLink ()
 {
   sym_link *p;
 
-  p = newLink ();
-  p->class = SPECIFIER;
+  p = newLink (SPECIFIER);
   SPEC_NOUN (p) = V_INT;
 
   return p;
@@ -988,14 +967,16 @@ addSymChain (symbol * symHead)
 	    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 */
@@ -1029,25 +1010,27 @@ structElemType (sym_link * stype, value * id)
   sym_link *type, *etype;
   sym_link *petype = getSpec (stype);
 
-  if (!fields || !id)
-    return NULL;
+  if (fields && id) {
+    
+    /* look for the id */
+    while (fields)
+      {
+	if (strcmp (fields->rname, id->name) == 0)
+	  {
+	    type = copyLinkChain (fields->type);
+	    etype = getSpec (type);
+	    SPEC_SCLS (etype) = (SPEC_SCLS (petype) == S_REGISTER ?
+				 SPEC_SCLS (etype) : SPEC_SCLS (petype));
+	    return type;
+	  }
+	fields = fields->next;
+      }
+  }
 
-  /* look for the id */
-  while (fields)
-    {
-      if (strcmp (fields->rname, id->name) == 0)
-	{
-	  type = copyLinkChain (fields->type);
-	  etype = getSpec (type);
-	  SPEC_SCLS (etype) = (SPEC_SCLS (petype) == S_REGISTER ?
-			       SPEC_SCLS (etype) : SPEC_SCLS (petype));
-	  return type;
-	}
-      fields = fields->next;
-    }
   werror (E_NOT_MEMBER, id->name);
-
-  return NULL;
+    
+  // the show must go on
+  return newIntLink();
 }
 
 /*------------------------------------------------------------------*/
@@ -1082,7 +1065,7 @@ compStructSize (int su, structdef * sdef)
     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);
 
@@ -1151,42 +1134,44 @@ checkSClass (symbol * sym, int isProto)
   if (SPEC_SCLS (sym->etype) == S_LITERAL && !SPEC_ENUM (sym->etype))
     SPEC_SCLS (sym->etype) = S_AUTO;
   
-  /* if sfr or sbit then must also be */
-  /* volatile the initial value will be xlated */
-  /* to an absolute address */
+  /* if sfr or sbit then must also be volatile */
   if (SPEC_SCLS (sym->etype) == S_SBIT ||
       SPEC_SCLS (sym->etype) == S_SFR)
     {
       SPEC_VOLATILE (sym->etype) = 1;
-      /* if initial value given */
-      if (sym->ival)
-	{
-	  SPEC_ABSA (sym->etype) = 1;
-	  SPEC_ADDR (sym->etype) =
-	    (int) list2int (sym->ival);
-	  sym->ival = NULL;
-	}
     }
   
   /* if absolute address given then it mark it as
-     volatile */
-  if (IS_ABSOLUTE (sym->etype))
-    SPEC_VOLATILE (sym->etype) = 1;
+     volatile -- except in the PIC port */
+
+#if !OPT_DISABLE_PIC || !OPT_DISABLE_PIC16
+  /* The PIC port uses a different peep hole optimizer based on "pCode" */
+  if (!TARGET_IS_PIC && !TARGET_IS_PIC16)
+#endif
+
+    if (IS_ABSOLUTE (sym->etype))
+      SPEC_VOLATILE (sym->etype) = 1;
   
+
   /* global variables declared const put into code */
   /* 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 */
@@ -1277,7 +1262,8 @@ checkSClass (symbol * sym, int isProto)
 	   * control this allcoation, but the code was originally that way, and
 	   * changing it for non-390 ports breaks the compiler badly.
 	   */
-	  bool useXdata = TARGET_IS_DS390 ? 1 : options.useXstack;
+	  bool useXdata = (TARGET_IS_DS390 || TARGET_IS_DS400) ? 
+		1 : options.useXstack;
 	  SPEC_SCLS (sym->etype) = (useXdata ?
 				    S_XDATA : S_FIXED);
 	}
@@ -1332,11 +1318,11 @@ copyLinkChain (sym_link * p)
   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;
     }
@@ -1470,6 +1456,9 @@ compareType (sym_link * dest, sym_link * src)
 	    }
 	    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)) {
@@ -1477,7 +1466,6 @@ compareType (sym_link * dest, sym_link * 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))
@@ -1542,17 +1530,18 @@ compareType (sym_link * dest, sym_link * src)
 /*------------------------------------------------------------------*/
 /* inCalleeSaveList - return 1 if found in callee save list          */
 /*------------------------------------------------------------------*/
-bool 
-inCalleeSaveList (char *s)
+static int
+calleeCmp(void *p1, void *p2)
 {
-  int i;
-
-  if (options.all_callee_saves) return 1;
-  for (i = 0; options.calleeSaves[i]; i++)
-    if (strcmp (options.calleeSaves[i], s) == 0)
-      return 1;
+  return (strcmp((char *)p1, (char *)(p2)) == 0);
+}
 
-  return 0;
+bool
+inCalleeSaveList(char *s)
+{
+  if (options.all_callee_saves)
+    return 1;
+  return isinSetWith(options.calleeSavesSet, s, calleeCmp);
 }
 
 /*-----------------------------------------------------------------*/
@@ -1572,7 +1561,7 @@ aggregateToPointer (value * val)
 	  sym_link *p = val->type;
 
 	  werror (W_STRUCT_AS_ARG, val->name);
-	  val->type = newLink ();
+	  val->type = newLink (DECLARATOR);
 	  val->type->next = p;
 	}
 
@@ -1590,23 +1579,8 @@ aggregateToPointer (value * val)
 	  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:
@@ -1697,13 +1671,13 @@ checkFunction (symbol * sym, symbol *csym)
       // 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);
@@ -1798,6 +1772,29 @@ checkFunction (symbol * sym, symbol *csym)
   return 1;
 }
 
+/*------------------------------------------------------------------*/
+/* cdbStructBlock - calls struct printing for a blcks               */
+/*------------------------------------------------------------------*/
+void cdbStructBlock (int block)
+{
+  int i;
+  bucket **table = StructTab;
+  bucket *chain;
+
+  /* go thru the entire  table  */
+  for (i = 0; i < 256; i++)
+    {
+      for (chain = table[i]; chain; chain = chain->next)
+	{
+	  if (chain->block >= block)
+	    {
+	      if(debugFile)
+		debugFile->writeType((structdef *)chain->sym, chain->block, 0, NULL);
+	    }
+	}
+    }
+}
+
 /*-----------------------------------------------------------------*/
 /* processFuncArgs - does some processing with function args       */
 /*-----------------------------------------------------------------*/
@@ -1841,13 +1838,15 @@ processFuncArgs (symbol * func)
   /* change it to pointer to the same type */
   while (val)
     {
+	int argreg = 0;
       /* mark it as a register parameter if
          the function does not have VA_ARG
          and as port dictates */
       if (!IFFUNC_HASVARARGS(funcType) &&
-	  (*port->reg_parm) (val->type))
+	  (argreg = (*port->reg_parm) (val->type)))
 	{
 	  SPEC_REGPARM (val->etype) = 1;
+	  SPEC_ARGREG(val->etype) = argreg;
 	} else if (IFFUNC_ISREENT(funcType)) {
 	    FUNC_HASSTACKPARM(funcType) = 1;
 	}
@@ -1884,29 +1883,38 @@ processFuncArgs (symbol * func)
       /* 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;
     }
 }
@@ -1945,6 +1953,7 @@ printTypeChain (sym_link * start, FILE * of)
 {
   int nlr = 0;
   sym_link * type, * search;
+  STORAGE_CLASS scls;
 
   if (!of)
     {
@@ -1957,16 +1966,44 @@ printTypeChain (sym_link * start, FILE * 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))
 	    {
@@ -1976,82 +2013,51 @@ printTypeChain (sym_link * start, FILE * of)
 		       (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:
-	      fprintf (of, "[] ");
+	      if (DCL_ELEM(type)) {
+		fprintf (of, "[%d] ", DCL_ELEM(type));
+	      } else {
+		fprintf (of, "[] ");
+	      }
 	      break;
 	    }
 	}
       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;
 
@@ -2088,217 +2094,17 @@ printTypeChain (sym_link * start, FILE * of)
 	      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");
 }
 
-/*-----------------------------------------------------------------*/
-/* cdbTypeInfo - print the type information for debugger           */
-/*-----------------------------------------------------------------*/
-void
-cdbTypeInfo (sym_link * type, FILE * of)
-{
-  fprintf (of, "{%d}", getSize (type));
-  while (type)
-    {
-      if (IS_DECL (type))
-	{
-	  switch (DCL_TYPE (type))
-	    {
-	    case FUNCTION:
-	      fprintf (of, "DF,");
-	      break;
-	    case GPOINTER:
-	      fprintf (of, "DG,");
-	      break;
-	    case CPOINTER:
-	      fprintf (of, "DC,");
-	      break;
-	    case FPOINTER:
-	      fprintf (of, "DX,");
-	      break;
-	    case POINTER:
-	      fprintf (of, "DD,");
-	      break;
-	    case IPOINTER:
-	      fprintf (of, "DI,");
-	      break;
-	    case PPOINTER:
-	      fprintf (of, "DP,");
-	      break;
-	    case EEPPOINTER:
-	      fprintf (of, "DA,");
-	      break;
-	    case ARRAY:
-	      fprintf (of, "DA%d,", DCL_ELEM (type));
-	      break;
-	    default:
-	      break;
-	    }
-	}
-      else
-	{
-	  switch (SPEC_NOUN (type))
-	    {
-	    case V_INT:
-	      if (IS_LONG (type))
-		fprintf (of, "SL");
-	      else
-		fprintf (of, "SI");
-	      break;
-
-	    case V_CHAR:
-	      fprintf (of, "SC");
-	      break;
-
-	    case V_VOID:
-	      fprintf (of, "SV");
-	      break;
-
-	    case V_FLOAT:
-	      fprintf (of, "SF");
-	      break;
-
-	    case V_STRUCT:
-	      fprintf (of, "ST%s", SPEC_STRUCT (type)->tag);
-	      break;
-
-	    case V_SBIT:
-	      fprintf (of, "SX");
-	      break;
-
-	    case V_BIT:
-	      fprintf (of, "SB%d$%d", SPEC_BSTR (type), SPEC_BLEN (type));
-	      break;
-
-	    default:
-	      break;
-	    }
-	  fputs (":", of);
-	  if (SPEC_USIGN (type))
-	    fputs ("U", of);
-	  else
-	    fputs ("S", of);
-	}
-      type = type->next;
-    }
-}
-/*-----------------------------------------------------------------*/
-/* cdbSymbol - prints a symbol & its type information for debugger */
-/*-----------------------------------------------------------------*/
-void 
-cdbSymbol (symbol * sym, FILE * of, int isStructSym, int isFunc)
-{
-  memmap *map;
-
-  if (!sym)
-    return;
-  if (!of)
-    of = stdout;
-
-  if (isFunc)
-    fprintf (of, "F:");
-  else
-    fprintf (of, "S:");		/* symbol record */
-  /* if this is not a structure symbol then
-     we need to figure out the scope information */
-  if (!isStructSym)
-    {
-      if (!sym->level)
-	{
-	  /* global */
-	  if (IS_STATIC (sym->etype))
-	    fprintf (of, "F%s$", moduleName);	/* scope is file */
-	  else
-	    fprintf (of, "G$");	/* scope is global */
-	}
-      else
-	/* symbol is local */
-	fprintf (of, "L%s$", (sym->localof ? sym->localof->name : "-null-"));
-    }
-  else
-    fprintf (of, "S$");		/* scope is structure */
-
-  /* print the name, & mangled name */
-  fprintf (of, "%s$%d$%d(", sym->name,
-	   sym->level, sym->block);
-
-  cdbTypeInfo (sym->type, of);
-  fprintf (of, "),");
-
-  /* print the address space */
-  map = SPEC_OCLS (sym->etype);
-  fprintf (of, "%c,%d,%d",
-	   (map ? map->dbName : 'Z'), sym->onStack, SPEC_STAK (sym->etype));
-
-  /* if assigned to registers then output register names */
-  /* if this is a function then print
-     if is it an interrupt routine & interrupt number
-     and the register bank it is using */
-  if (isFunc)
-    fprintf (of, ",%d,%d,%d", FUNC_ISISR (sym->type),
-	     FUNC_INTNO (sym->type), FUNC_REGBANK (sym->type));
-  /* alternate location to find this symbol @ : eg registers
-     or spillication */
-
-  if (!isStructSym)
-    fprintf (of, "\n");
-}
-
-/*-----------------------------------------------------------------*/
-/* cdbStruct - print a structure for debugger                      */
-/*-----------------------------------------------------------------*/
-void 
-cdbStruct (structdef * sdef, int block, FILE * of,
-	   int inStruct, char *tag)
-{
-  symbol *sym;
-
-  fprintf (of, "T:");
-  /* if block # then must have function scope */
-  fprintf (of, "F%s$", moduleName);
-  fprintf (of, "%s[", (tag ? tag : sdef->tag));
-  for (sym = sdef->fields; sym; sym = sym->next)
-    {
-      fprintf (of, "({%d}", sym->offset);
-      cdbSymbol (sym, of, TRUE, FALSE);
-      fprintf (of, ")");
-    }
-  fprintf (of, "]");
-  if (!inStruct)
-    fprintf (of, "\n");
-}
-
-/*------------------------------------------------------------------*/
-/* cdbStructBlock - calls struct printing for a blcks               */
-/*------------------------------------------------------------------*/
-void 
-cdbStructBlock (int block, FILE * of)
-{
-  int i;
-  bucket **table = StructTab;
-  bucket *chain;
-  wassert (of);
-
-  /* go thru the entire  table  */
-  for (i = 0; i < 256; i++)
-    {
-      for (chain = table[i]; chain; chain = chain->next)
-	{
-	  if (chain->block >= block)
-	    {
-	      cdbStruct ((structdef *) chain->sym, chain->block, of, 0, NULL);
-	    }
-	}
-    }
-}
 
 /*-----------------------------------------------------------------*/
 /* powof2 - returns power of two for the number if number is pow 2 */
@@ -2378,7 +2184,7 @@ _mangleFunctionName(char *in)
 /*-----------------------------------------------------------------*/
 sym_link *typeFromStr (char *s)
 {
-    sym_link *r = newLink();
+    sym_link *r = newLink(DECLARATOR);
     int usign = 0;
 
     do {
@@ -2420,10 +2226,9 @@ sym_link *typeFromStr (char *s)
 	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;
@@ -2439,17 +2244,17 @@ sym_link *typeFromStr (char *s)
 		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;
 	    }
 	    s++;
 	    break;
 	default:
-	    werror(E_INTERNAL_ERROR,"typeFromStr");
+	    werror(E_INTERNAL_ERROR, __FILE__, __LINE__, 
+		   "typeFromStr: unknown type");
 	    break;
 	}
 	if (IS_SPEC(r) && usign) {
@@ -2495,7 +2300,7 @@ initCSupport ()
 
   for (bwd = 0; bwd < 3; bwd++)
     {
-      sym_link *l;
+      sym_link *l = NULL;
       switch (bwd)
 	{
 	case 0:
@@ -2534,25 +2339,27 @@ initCSupport ()
 	    {
 	      if (tofrom)
 		{
-		  sprintf (buffer, "__fs2%s%s", ssu[su], sbwd[bwd]);
-		  __conv[tofrom][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], floatType, 1, options.float_rent);
+		  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]);
-		  __conv[tofrom][bwd][su] = funcOfType (_mangleFunctionName(buffer), floatType, __multypes[bwd][su], 1, options.float_rent);
+		  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 (muldivmod = 0; muldivmod < 3; muldivmod++)
     {
       for (bwd = 0; bwd < 3; bwd++)
 	{
 	  for (su = 0; su < 2; su++)
 	    {
-	      sprintf (buffer, "_%s%s%s",
+	      SNPRINTF (buffer, sizeof(buffer),
+			"_%s%s%s",
 		       smuldivmod[muldivmod],
 		       ssu[su],
 		       sbwd[bwd]);
@@ -2562,13 +2369,67 @@ initCSupport ()
 	}
     }
 
+  muluint() and mulsint() resp. mululong() and mulslong() return the same result.
+  Therefore they've been merged into mulint() and mullong().
+*/
+
+  for (bwd = 0; bwd < 3; bwd++)
+    {
+      for (su = 0; su < 2; su++)
+	{
+	  for (muldivmod = 1; muldivmod < 3; muldivmod++)
+	    {
+	      /* div and mod */
+	      SNPRINTF (buffer, sizeof(buffer),
+			"_%s%s%s",
+		       smuldivmod[muldivmod],
+		       ssu[su],
+		       sbwd[bwd]);
+	      __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
+	      FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
+	    }
+	}
+    }
+  /* mul only */
+  muldivmod = 0;
+  /* byte */
+  bwd = 0;
+  for (su = 0; su < 2; su++)
+    {
+      /* muluchar and mulschar are still separate functions, because e.g. the z80
+         port is sign/zero-extending to int before calling mulint() */
+      SNPRINTF (buffer, sizeof(buffer),
+		"_%s%s%s",
+		smuldivmod[muldivmod],
+		ssu[su],
+		sbwd[bwd]);
+      __muldiv[muldivmod][bwd][su] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
+      FUNC_NONBANKED (__muldiv[muldivmod][bwd][su]->type) = 1;
+    }
+  /* signed only */
+  su = 0;
+  /* word and doubleword */
+  for (bwd = 1; bwd < 3; bwd++)
+    {
+      /* mul, int/long */
+      SNPRINTF (buffer, sizeof(buffer),
+		"_%s%s",
+		smuldivmod[muldivmod],
+		sbwd[bwd]);
+      __muldiv[muldivmod][bwd][0] = funcOfType (_mangleFunctionName(buffer), __multypes[bwd][su], __multypes[bwd][su], 2, options.intlong_rent);
+      FUNC_NONBANKED (__muldiv[muldivmod][bwd][0]->type) = 1;
+      /* signed = unsigned */
+      __muldiv[muldivmod][bwd][1] = __muldiv[muldivmod][bwd][0];
+    }
+
   for (rlrr = 0; rlrr < 2; rlrr++)
     {
       for (bwd = 0; bwd < 3; 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]);
@@ -2596,3 +2457,23 @@ void initBuiltIns()
 	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.
+}