X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2FSDCCsymt.c;h=2b7824644c61c79ece879999ea9da461ca92333b;hb=2de847a479c5a08a4e0dc8205a340809be8815f4;hp=9d45864c5814029c7fda074b8fe012ac59b3c25e;hpb=e62b6792afc55ee7aff91f187d53d4ebc64bc816;p=fw%2Fsdcc

diff --git a/src/SDCCsymt.c b/src/SDCCsymt.c
index 9d45864c..2b782464 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,7 +287,7 @@ 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 */
@@ -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;
 }
 
@@ -371,11 +372,11 @@ pointerTypes (sym_link * ptr, sym_link * type)
 	  DCL_TYPE (ptr) = EEPPOINTER;
 	  break;
 	default:
-	  DCL_TYPE (ptr) = GPOINTER;
+	  DCL_TYPE (ptr) = port->unqualified_pointer;
 	  break;
 	}
       /* the storage class of type ends here */
-      SPEC_SCLS (type) =
+      SPEC_SCLS (type) = 
 	SPEC_CONST (type) =
 	SPEC_VOLATILE (type) = 0;
     }
@@ -385,7 +386,7 @@ pointerTypes (sym_link * ptr, sym_link * type)
   while (ptr)
     {
       if (!IS_SPEC (ptr) && DCL_TYPE (ptr) == UPOINTER)
-	DCL_TYPE (ptr) = GPOINTER;
+	DCL_TYPE (ptr) = port->unqualified_pointer;
       ptr = ptr->next;
     }
 
@@ -394,7 +395,7 @@ pointerTypes (sym_link * ptr, sym_link * type)
   while (type)
     {
       if (!IS_SPEC (type) && DCL_TYPE (type) == UPOINTER)
-	DCL_TYPE (type) = GPOINTER;
+	DCL_TYPE (type) = port->unqualified_pointer;
       type = type->next;
     }
 
@@ -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);
 
@@ -634,27 +634,13 @@ mergeSpec (sym_link * dest, sym_link * src, char *name)
   FUNC_ISREENT(dest) |= FUNC_ISREENT(src);
   FUNC_ISNAKED(dest) |= FUNC_ISNAKED(src);
   FUNC_ISISR(dest) |= FUNC_ISISR(src);
+  FUNC_ISJAVANATIVE(dest) |= FUNC_ISJAVANATIVE(src);
+  FUNC_ISBUILTIN(dest) |= FUNC_ISBUILTIN(src);
+  FUNC_ISOVERLAY(dest) |= FUNC_ISOVERLAY(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;
 }
 
 /*------------------------------------------------------------------*/
@@ -666,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;
 }
 
@@ -693,8 +679,7 @@ newCharLink ()
 {
   sym_link *p;
 
-  p = newLink ();
-  p->class = SPECIFIER;
+  p = newLink (SPECIFIER);
   SPEC_NOUN (p) = V_CHAR;
 
   return p;
@@ -708,8 +693,7 @@ newFloatLink ()
 {
   sym_link *p;
 
-  p = newLink ();
-  p->class = SPECIFIER;
+  p = newLink (SPECIFIER);
   SPEC_NOUN (p) = V_FLOAT;
 
   return p;
@@ -723,8 +707,7 @@ newLongLink ()
 {
   sym_link *p;
 
-  p = newLink ();
-  p->class = SPECIFIER;
+  p = newLink (SPECIFIER);
   SPEC_NOUN (p) = V_INT;
   SPEC_LONG (p) = 1;
 
@@ -739,8 +722,7 @@ newIntLink ()
 {
   sym_link *p;
 
-  p = newLink ();
-  p->class = SPECIFIER;
+  p = newLink (SPECIFIER);
   SPEC_NOUN (p) = V_INT;
 
   return p;
@@ -787,8 +769,8 @@ getSize (sym_link * p)
       if (DCL_ELEM(p)) {
 	return DCL_ELEM (p) * getSize (p->next);
       } else {
-	werror (E_INTERNAL_ERROR, __FILE__, __LINE__, 
-		"can not tell the size of an array[]");
+	  //	werror (E_INTERNAL_ERROR, __FILE__, __LINE__, 
+	  //	"can not tell the size of an array[]");
 	return 0;
       }
     case IPOINTER:
@@ -985,13 +967,16 @@ addSymChain (symbol * symHead)
 	    werror (E_EXTERN_MISMATCH, csym->name);
 	    continue;
 	  }
-	  /* delete current entry */
-	  deleteSym (SymbolTab, csym, csym->name);
 	} 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 */
@@ -1025,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();
 }
 
 /*------------------------------------------------------------------*/
@@ -1078,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);
 
@@ -1113,13 +1100,6 @@ compStructSize (int su, structdef * sdef)
 	    sum += getSize (loop->type);
 	}
 
-#if 0 // jwk: this is done now in addDecl()
-	/* if function then do the arguments for it */
-	if (funcInChain (loop->type)) {
-	    processFuncArgs (loop);
-	}
-#endif
-
 	loop = loop->next;
 
 	/* if this is not a bitfield but the */
@@ -1154,40 +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
+  /* The PIC port uses a different peep hole optimizer based on "pCode" */
+  if (!TARGET_IS_PIC)
+#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_CONST (sym->etype) &&
+      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 */
@@ -1300,7 +1284,7 @@ changePointer (symbol * sym)
   for (p = sym->type; p; p = p->next)
     {
       if (!IS_SPEC (p) && DCL_TYPE (p) == UPOINTER)
-	DCL_TYPE (p) = GPOINTER;
+	DCL_TYPE (p) = port->unqualified_pointer;
       if (IS_PTR (p) && IS_FUNC (p->next))
 	DCL_TYPE (p) = CPOINTER;
     }
@@ -1333,11 +1317,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;
     }
@@ -1471,6 +1455,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)) {
@@ -1478,7 +1465,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))
@@ -1573,7 +1559,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;
 	}
 
@@ -1591,23 +1577,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) = GPOINTER;
-#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) = GPOINTER;
-	      break;
-	    }
-	    if (options.model==MODEL_LARGE) {
-	      DCL_TYPE (val->type) = FPOINTER;
-	      break;
-	    }
-#endif
+	    DCL_TYPE (val->type) = port->unqualified_pointer;
 	  }
 	  break;
 	case S_AUTO:
@@ -1625,7 +1596,7 @@ aggregateToPointer (value * val)
 	  DCL_TYPE (val->type) = EEPPOINTER;
 	  break;
 	default:
-	  DCL_TYPE (val->type) = GPOINTER;
+	  DCL_TYPE (val->type) = port->unqualified_pointer;
 	}
       
       /* is there is a symbol associated then */
@@ -1679,7 +1650,7 @@ checkFunction (symbol * sym, symbol *csym)
 
   /* check if this function is defined as calleeSaves
      then mark it as such */
-    FUNC_CALLEESAVES(sym->type) = inCalleeSaveList (sym->name);
+  FUNC_CALLEESAVES(sym->type) = inCalleeSaveList (sym->name);
 
   /* if interrupt service routine  */
   /* then it cannot have arguments */
@@ -1691,6 +1662,26 @@ checkFunction (symbol * sym, symbol *csym)
       }
     }
 
+  for (argCnt=1, acargs = FUNC_ARGS(sym->type); 
+       acargs; 
+       acargs=acargs->next, argCnt++) {
+    if (!acargs->sym) { 
+      // this can happen for reentrant functions
+      werror(E_PARAM_NAME_OMITTED, sym->name, argCnt);
+      // the show must go on: synthesize a name and symbol
+      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;
+      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);
+    }
+  }
+
   if (!csym && !(csym = findSym (SymbolTab, sym, sym->name)))
     return 1;			/* not defined nothing more to check  */
 
@@ -1769,6 +1760,7 @@ checkFunction (symbol * sym, symbol *csym)
   /* replace with this defition */
   sym->cdef = csym->cdef;
   deleteSym (SymbolTab, csym, csym->name);
+  deleteFromSeg(csym);
   addSym (SymbolTab, sym, sym->name, sym->level, sym->block, 1);
   if (IS_EXTERN (csym->etype) && !
       IS_EXTERN (sym->etype))
@@ -1778,6 +1770,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       */
 /*-----------------------------------------------------------------*/
@@ -1798,7 +1813,7 @@ processFuncArgs (symbol * func)
 
   /* if this function has variable argument list */
   /* then make the function a reentrant one    */
-  if (IFFUNC_HASVARARGS(funcType))
+  if (IFFUNC_HASVARARGS(funcType) || (options.stackAuto && !func->cdef))
     FUNC_ISREENT(funcType)=1;
 
   /* check if this function is defined as calleeSaves
@@ -1821,13 +1836,17 @@ 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;
 	}
 
       if (IS_AGGREGATE (val->type))
@@ -1862,30 +1881,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;
     }
 }
@@ -1924,6 +1951,7 @@ printTypeChain (sym_link * start, FILE * of)
 {
   int nlr = 0;
   sym_link * type, * search;
+  STORAGE_CLASS scls;
 
   if (!of)
     {
@@ -1936,99 +1964,98 @@ 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))
 	    {
 	    case FUNCTION:
-	      fprintf (of, "function %s", (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "));
+	      fprintf (of, "function %s %s", 
+		       (IFFUNC_ISBUILTIN(type) ? "__builtin__" : " "),
+		       (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;
 
@@ -2065,217 +2092,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 */
@@ -2348,13 +2175,14 @@ _mangleFunctionName(char *in)
 /*                      'x' - xdata                                */
 /*                      'p' - code                                 */
 /*                      'd' - data                                 */                     
+/*                      'F' - function                             */                     
 /* examples : "ig*" - generic int *				   */
 /*            "cx*" - char xdata *                                 */
 /*            "ui" -  unsigned int                                 */
 /*-----------------------------------------------------------------*/
 sym_link *typeFromStr (char *s)
 {
-    sym_link *r = newLink();
+    sym_link *r = newLink(DECLARATOR);
     int usign = 0;
 
     do {
@@ -2388,17 +2216,17 @@ sym_link *typeFromStr (char *s)
 	    SPEC_NOUN(r) = V_VOID;
 	    break;
 	case '*':
-	    DCL_TYPE(r) = GPOINTER;
+	    DCL_TYPE(r) = port->unqualified_pointer;
 	    break;
 	case 'g':
 	case 'x':
 	case 'p':
 	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;
@@ -2412,11 +2240,19 @@ sym_link *typeFromStr (char *s)
 	    case 'd':
 		DCL_TYPE(r) = POINTER;
 		break;
+	    case 'F':
+		DCL_TYPE(r) = FUNCTION;
+		nr = newLink(DECLARATOR);
+		nr->next = r;
+		r = nr;
+		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) {
@@ -2462,7 +2298,7 @@ initCSupport ()
 
   for (bwd = 0; bwd < 3; bwd++)
     {
-      sym_link *l;
+      sym_link *l = NULL;
       switch (bwd)
 	{
 	case 0:
@@ -2501,13 +2337,13 @@ 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);
 		}
 	    }
 	}
@@ -2519,7 +2355,8 @@ initCSupport ()
 	{
 	  for (su = 0; su < 2; su++)
 	    {
-	      sprintf (buffer, "_%s%s%s",
+	      SNPRINTF (buffer, sizeof(buffer), 
+			"_%s%s%s",
 		       smuldivmod[muldivmod],
 		       ssu[su],
 		       sbwd[bwd]);
@@ -2535,7 +2372,8 @@ initCSupport ()
 	{
 	  for (su = 0; su < 2; su++)
 	    {
-	      sprintf (buffer, "_%s%s%s",
+	      SNPRINTF (buffer, sizeof(buffer), 
+			"_%s%s%s",
 		       srlrr[rlrr],
 		       ssu[su],
 		       sbwd[bwd]);
@@ -2560,5 +2398,26 @@ void initBuiltIns()
 	sym = funcOfTypeVarg(port->builtintable[i].name,port->builtintable[i].rtype,
 			     port->builtintable[i].nParms,port->builtintable[i].parm_types);
 	FUNC_ISBUILTIN(sym->type) = 1;
+	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.
+}