* device/include/pic16/pic18f*.h: add bit aliases in INTCONbits_t
[fw/sdcc] / src / SDCCglue.c
index 448034e8ea3775cc329cf45b471780cdefd3b431..19c452ea17571170913290e4404f3bea74cee696 100644 (file)
 /*-------------------------------------------------------------------------
 
 /*-------------------------------------------------------------------------
 
-  SDCCglue.c - glues everything we have done together into one file.                 
+  SDCCglue.c - glues everything we have done together into one file.
                 Written By -  Sandeep Dutta . sandeep.dutta@usa.net (1998)
                 Written By -  Sandeep Dutta . sandeep.dutta@usa.net (1998)
-               
+
    This program is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by the
    Free Software Foundation; either version 2, or (at your option) any
    later version.
    This program is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by the
    Free Software Foundation; either version 2, or (at your option) any
    later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-   
+
    In other words, you are welcome to use, share and improve this program.
    You are forbidden to forbid anyone else to use, share and improve
    In other words, you are welcome to use, share and improve this program.
    You are forbidden to forbid anyone else to use, share and improve
-   what you give them.   Help stamp out software-hoarding!  
+   what you give them.   Help stamp out software-hoarding!
 -------------------------------------------------------------------------*/
 
 #include "common.h"
 -------------------------------------------------------------------------*/
 
 #include "common.h"
-#include "asm.h"
 #include <time.h>
 #include <time.h>
+#include "newalloc.h"
+#include <fcntl.h>
+#include <sys/stat.h>
+#include "dbuf_string.h"
 
 
-symbol *interrupts[256];
-/*extern char *aopLiteral (value *, int);*//* drdani Jan 30 2000 */
-void printIval (symbol *, link *, initList *, FILE *);
-extern int noAlloc;
-set *publics = NULL;           /* public variables */
-set *externs = NULL;           /* Varibles that are declared as extern */
+#ifdef _WIN32
+#include <io.h>
+#else
+#include <unistd.h>
+#endif
+
+symbol *interrupts[INTNO_MAX+1];
 
 
-/* TODO: this should be configurable (DS803C90 uses more than 6) */
-int maxInterrupts = 6;
+void printIval (symbol *, sym_link *, initList *, struct dbuf_s *, bool check);
+set *publics = NULL;            /* public variables */
+set *externs = NULL;            /* Variables that are declared as extern */
+
+unsigned maxInterrupts = 0;
 int allocInfo = 1;
 int allocInfo = 1;
-extern int maxRegBank ;
 symbol *mainf;
 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. */
+int noInit = 0;                 /* no initialization */
+
+
+char *
+aopLiteralLong (value * val, int offset, int size)
+{
+  union {
+    float f;
+    unsigned char c[4];
+  }
+  fl;
+
+  if (!val) {
+    // assuming we have been warned before
+    val = constCharVal (0);
+  }
+
+  /* if it is a float then it gets tricky */
+  /* otherwise it is fairly simple */
+  if (!IS_FLOAT (val->type)) {
+    unsigned long v = ulFromVal (val);
+
+    v >>= (offset * 8);
+    switch (size) {
+    case 1:
+      tsprintf (buffer, sizeof(buffer),
+          "!immedbyte", (unsigned int) v & 0xff);
+      break;
+    case 2:
+      tsprintf (buffer, sizeof(buffer),
+          "!immedword", (unsigned int) v & 0xffff);
+      break;
+    default:
+      /* Hmm.  Too big for now. */
+      assert (0);
+    }
+    return Safe_strdup (buffer);
+  }
+
+  /* PENDING: For now size must be 1 */
+  assert (size == 1);
+
+  /* it is type float */
+  fl.f = (float) floatFromVal (val);
+#ifdef WORDS_BIGENDIAN
+  tsprintf (buffer, sizeof(buffer),
+      "!immedbyte", fl.c[3 - offset]);
+#else
+  tsprintf (buffer, sizeof(buffer),
+      "!immedbyte", fl.c[offset]);
+#endif
+  return Safe_strdup (buffer);
+}
 
 /*-----------------------------------------------------------------*/
 
 /*-----------------------------------------------------------------*/
-/* closeTmpFiles - closes all tmp files created by the compiler    */
-/*                 because of BRAIN DEAD MS/DOS & CYGNUS Libraries */
+/* aopLiteral - string from a literal value                        */
 /*-----------------------------------------------------------------*/
 /*-----------------------------------------------------------------*/
-DEFSETFUNC(closeTmpFiles)
+char *
+aopLiteral (value * val, int offset)
 {
 {
-    FILE *tfile = item;
-
-    if (tfile)
-       fclose(tfile);
-    
-    return 0;
+  return aopLiteralLong (val, offset, 1);
 }
 
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/
-/* rmTmpFiles - closes all tmp files created by the compiler    */
-/*                 because of BRAIN DEAD MS/DOS & CYGNUS Libraries */
+/* emitRegularMap - emit code for maps with no special cases       */
 /*-----------------------------------------------------------------*/
 /*-----------------------------------------------------------------*/
-DEFSETFUNC(rmTmpFiles)
+static void
+emitRegularMap (memmap * map, bool addPublics, bool arFlag)
 {
 {
-    char *name = item;
+  symbol *sym;
+  ast *ival = NULL;
+
+  if (!map)
+    return;
+
+  if (addPublics)
+    {
+      /* PENDING: special case here - should remove */
+      if (!strcmp (map->sname, CODE_NAME))
+        dbuf_tprintf (&map->oBuf, "\t!areacode\n", map->sname);
+      else if (!strcmp (map->sname, DATA_NAME))
+        dbuf_tprintf (&map->oBuf, "\t!areadata\n", map->sname);
+      else if (!strcmp (map->sname, HOME_NAME))
+        dbuf_tprintf (&map->oBuf, "\t!areahome\n", map->sname);
+      else
+        dbuf_tprintf (&map->oBuf, "\t!area\n", map->sname);
+    }
 
 
-    if (name) {
-       unlink(name);
-       free(name);
+  for (sym = setFirstItem (map->syms); sym; sym = setNextItem (map->syms))
+    {
+      symbol *newSym = NULL;
+
+      /* if extern then add it into the extern list */
+      if (IS_EXTERN (sym->etype))
+        {
+          addSetHead (&externs, sym);
+          continue;
+        }
+
+      /* if allocation required check is needed
+         then check if the symbol really requires
+         allocation only for local variables */
+
+      if (arFlag && !IS_AGGREGATE (sym->type) &&
+          !(sym->_isparm && !IS_REGPARM (sym->etype)) &&
+          !sym->allocreq && sym->level)
+        continue;
+
+      /* for bitvar locals and parameters */
+      if (!arFlag && !sym->allocreq && sym->level
+          && !SPEC_ABSA (sym->etype))
+        {
+          continue;
+        }
+
+      /* if global variable & not static or extern
+         and addPublics allowed then add it to the public set */
+      if ((sym->level == 0 ||
+           (sym->_isparm && !IS_REGPARM (sym->etype))) &&
+          addPublics &&
+          !IS_STATIC (sym->etype) &&
+          (IS_FUNC (sym->type) ? (sym->used || IFFUNC_HASBODY (sym->type)) : 1))
+        {
+          addSetHead (&publics, sym);
+        }
+
+      /* if extern then do nothing or is a function
+         then do nothing */
+      if (IS_FUNC (sym->type) && !(sym->isitmp))
+        continue;
+
+      /* print extra debug info if required */
+      if (options.debug)
+        {
+          if (!sym->level) /* global */
+            {
+              if (IS_STATIC (sym->etype))
+                dbuf_printf (&map->oBuf, "F%s$", moduleName); /* scope is file */
+              else
+                dbuf_printf (&map->oBuf, "G$");     /* scope is global */
+            }
+          else
+            {
+              /* symbol is local */
+              dbuf_printf (&map->oBuf, "L%s$", (sym->localof ? sym->localof->name : "-null-"));
+            }
+          dbuf_printf (&map->oBuf, "%s$%d$%d", sym->name, sym->level, sym->block);
+        }
+
+      /* if it has an initial value then do it only if
+         it is a global variable */
+      if (sym->ival && sym->level == 0)
+        {
+          if ((SPEC_OCLS (sym->etype) == xidata) && !SPEC_ABSA (sym->etype))
+            {
+              /* create a new "XINIT (CODE)" symbol, that will be emitted later
+                 in the static seg */
+              newSym=copySymbol (sym);
+              SPEC_OCLS(newSym->etype)=xinit;
+              SNPRINTF (newSym->name, sizeof(newSym->name), "__xinit_%s", sym->name);
+              SNPRINTF (newSym->rname, sizeof(newSym->rname), "__xinit_%s", sym->rname);
+              if (IS_SPEC (newSym->type))
+                SPEC_CONST (newSym->type) = 1;
+              else
+                DCL_PTR_CONST (newSym->type) = 1;
+              SPEC_STAT(newSym->etype)=1;
+              resolveIvalSym(newSym->ival, newSym->type);
+
+              // add it to the "XINIT (CODE)" segment
+              addSet(&xinit->syms, newSym);
+
+              if (!SPEC_ABSA (sym->etype))
+                {
+                  struct dbuf_s tmpBuf;
+
+                  dbuf_init(&tmpBuf, 4096);
+                  // before allocation we must parse the sym->ival tree
+                  // but without actually generating initialization code
+                  ++noAlloc;
+                  resolveIvalSym (sym->ival, sym->type);
+                  ++noInit;
+                  printIval (sym, sym->type, sym->ival, &tmpBuf, TRUE);
+                  --noInit;
+                  --noAlloc;
+                  dbuf_destroy(&tmpBuf);
+                }
+            }
+          else
+            {
+              if (IS_AGGREGATE (sym->type))
+                {
+                  ival = initAggregates (sym, sym->ival, NULL);
+                }
+              else
+                {
+                  if (getNelements (sym->type, sym->ival)>1)
+                    {
+                      werrorfl (sym->fileDef, sym->lineDef, W_EXCESS_INITIALIZERS, "scalar", sym->name);
+                    }
+                  ival = newNode ('=', newAst_VALUE (symbolVal (sym)),
+                                  decorateType (resolveSymbols (list2expr (sym->ival)), RESULT_TYPE_NONE));
+                }
+              codeOutBuf = &statsg->oBuf;
+
+              if (ival)
+                {
+                  // set ival's lineno to where the symbol was defined
+                  setAstFileLine (ival, filename = sym->fileDef, lineno = sym->lineDef);
+                  // check if this is not a constant expression
+                  if (!constExprTree (ival))
+                    {
+                      werror (E_CONST_EXPECTED, "found expression");
+                    // but try to do it anyway
+                    }
+                  allocInfo = 0;
+                  if (!astErrors (ival))
+                    eBBlockFromiCode (iCodeFromAst (ival));
+                  allocInfo = 1;
+                }
+            }
+        }
+
+      /* if it has an absolute address then generate
+         an equate for this no need to allocate space */
+      if (SPEC_ABSA (sym->etype) && !sym->ival)
+        {
+          char *equ = "=";
+          if (options.debug) {
+            dbuf_printf (&map->oBuf, " == 0x%04x\n", SPEC_ADDR (sym->etype));
+          }
+          if (TARGET_IS_XA51)
+            {
+              if (map == sfr)
+                {
+                  equ = "sfr";
+                }
+              else if (map == bit || map == sfrbit)
+                {
+                  equ="bit";
+                }
+            }
+          dbuf_printf (&map->oBuf, "%s\t%s\t0x%04x\n", sym->rname, equ, SPEC_ADDR (sym->etype));
+        }
+      else
+        {
+          int size = getSize (sym->type) + sym->flexArrayLength;
+          if (size == 0)
+            {
+              werrorfl (sym->fileDef, sym->lineDef, E_UNKNOWN_SIZE, sym->name);
+            }
+          /* allocate space */
+          if (options.debug)
+            {
+              dbuf_printf (&map->oBuf, "==.\n");
+            }
+          if (SPEC_ABSA (sym->etype))
+            {
+              dbuf_tprintf (&map->oBuf, "\t!org\n", SPEC_ADDR (sym->etype));
+            }
+          if (IS_STATIC (sym->etype) || sym->level)
+            dbuf_tprintf (&map->oBuf, "!slabeldef\n", sym->rname);
+          else
+            dbuf_tprintf (&map->oBuf, "!labeldef\n", sym->rname);
+          dbuf_tprintf (&map->oBuf, "\t!ds\n", (unsigned int) size & 0xffff);
+        }
+      sym->ival = NULL;
     }
     }
-    return 0;
 }
 
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/
-/* copyFile - copies source file to destination file               */
+/* initPointer - pointer initialization code massaging             */
 /*-----------------------------------------------------------------*/
 /*-----------------------------------------------------------------*/
-void copyFile (FILE * dest, FILE * src)
+value *
+initPointer (initList * ilist, sym_link *toType)
 {
 {
-    int ch;
-    
-    rewind (src);
-    while (!feof (src))
-       if ((ch = fgetc (src)) != EOF)
-           fputc (ch, dest);
+  value *val;
+  ast *expr;
+
+  if (!ilist) {
+      return valCastLiteral(toType, 0.0);
+  }
+
+  expr = list2expr (ilist);
+
+  if (!expr)
+    goto wrong;
+
+  /* try it the old way first */
+  if ((val = constExprValue (expr, FALSE)))
+    return val;
+
+  /* ( ptr + constant ) */
+  if (IS_AST_OP (expr) &&
+      (expr->opval.op == '+' || expr->opval.op == '-') &&
+      IS_AST_SYM_VALUE (expr->left) &&
+      (IS_ARRAY(expr->left->ftype) || IS_PTR(expr->left->ftype)) &&
+      compareType(toType, expr->left->ftype) &&
+      IS_AST_LIT_VALUE (expr->right)) {
+    return valForCastAggr (expr->left, expr->left->ftype,
+                           expr->right,
+                           expr->opval.op);
+  }
+
+  /* (char *)&a */
+  if (IS_AST_OP(expr) && expr->opval.op==CAST &&
+      IS_AST_OP(expr->right) && expr->right->opval.op=='&') {
+    if (compareType(toType, expr->left->ftype)!=1) {
+      werror (W_INIT_WRONG);
+      printFromToType(expr->left->ftype, toType);
+    }
+    // skip the cast ???
+    expr=expr->right;
+  }
+
+  /* no then we have to do these cludgy checks */
+  /* pointers can be initialized with address of
+     a variable or address of an array element */
+  if (IS_AST_OP (expr) && expr->opval.op == '&') {
+    /* address of symbol */
+    if (IS_AST_SYM_VALUE (expr->left)) {
+      val = AST_VALUE (expr->left);
+      val->type = newLink (DECLARATOR);
+      if (SPEC_SCLS (expr->left->etype) == S_CODE) {
+        DCL_TYPE (val->type) = CPOINTER;
+        DCL_PTR_CONST (val->type) = port->mem.code_ro;
+      }
+      else if (SPEC_SCLS (expr->left->etype) == S_XDATA)
+        DCL_TYPE (val->type) = FPOINTER;
+      else if (SPEC_SCLS (expr->left->etype) == S_XSTACK)
+        DCL_TYPE (val->type) = PPOINTER;
+      else if (SPEC_SCLS (expr->left->etype) == S_IDATA)
+        DCL_TYPE (val->type) = IPOINTER;
+      else if (SPEC_SCLS (expr->left->etype) == S_EEPROM)
+        DCL_TYPE (val->type) = EEPPOINTER;
+      else
+        DCL_TYPE (val->type) = POINTER;
+      val->type->next = expr->left->ftype;
+      val->etype = getSpec (val->type);
+      return val;
+    }
+
+    /* if address of indexed array */
+    if (IS_AST_OP (expr->left) && expr->left->opval.op == '[')
+      return valForArray (expr->left);
+
+    /* if address of structure element then
+       case 1. a.b ; */
+    if (IS_AST_OP (expr->left) &&
+        expr->left->opval.op == '.') {
+      return valForStructElem (expr->left->left,
+                               expr->left->right);
+    }
+
+    /* case 2. (&a)->b ;
+       (&some_struct)->element */
+    if (IS_AST_OP (expr->left) &&
+        expr->left->opval.op == PTR_OP &&
+        IS_ADDRESS_OF_OP (expr->left->left)) {
+      return valForStructElem (expr->left->left->left,
+                               expr->left->right);
+    }
+  }
+  /* case 3. (((char *) &a) +/- constant) */
+  if (IS_AST_OP (expr) &&
+      (expr->opval.op == '+' || expr->opval.op == '-') &&
+      IS_AST_OP (expr->left) && expr->left->opval.op == CAST &&
+      IS_AST_OP (expr->left->right) &&
+      expr->left->right->opval.op == '&' &&
+      IS_AST_LIT_VALUE (expr->right)) {
+
+    return valForCastAggr (expr->left->right->left,
+                           expr->left->left->opval.lnk,
+                           expr->right, expr->opval.op);
+
+  }
+  /* case 4. (char *)(array type) */
+  if (IS_CAST_OP(expr) && IS_AST_SYM_VALUE (expr->right) &&
+      IS_ARRAY(expr->right->ftype)) {
+
+    val = copyValue (AST_VALUE (expr->right));
+    val->type = newLink (DECLARATOR);
+    if (SPEC_SCLS (expr->right->etype) == S_CODE) {
+      DCL_TYPE (val->type) = CPOINTER;
+      DCL_PTR_CONST (val->type) = port->mem.code_ro;
+    }
+    else if (SPEC_SCLS (expr->right->etype) == S_XDATA)
+      DCL_TYPE (val->type) = FPOINTER;
+    else if (SPEC_SCLS (expr->right->etype) == S_XSTACK)
+      DCL_TYPE (val->type) = PPOINTER;
+    else if (SPEC_SCLS (expr->right->etype) == S_IDATA)
+      DCL_TYPE (val->type) = IPOINTER;
+    else if (SPEC_SCLS (expr->right->etype) == S_EEPROM)
+      DCL_TYPE (val->type) = EEPPOINTER;
+    else
+      DCL_TYPE (val->type) = POINTER;
+    val->type->next = expr->right->ftype->next;
+    val->etype = getSpec (val->type);
+    return val;
+  }
+ wrong:
+  if (expr)
+    werrorfl (expr->filename, expr->lineno, E_INCOMPAT_PTYPES);
+  else
+    werror (E_INCOMPAT_PTYPES);
+  return NULL;
+
 }
 
 }
 
-char *aopLiteralLong(value *val, int offset, int size)
+/*-----------------------------------------------------------------*/
+/* printChar - formats and prints a characater string with DB      */
+/*-----------------------------------------------------------------*/
+void
+printChar (struct dbuf_s * oBuf, char *s, int plen)
 {
 {
-    char *rs;
-    union {
-        float f;
-        unsigned char c[4];
-    } fl;
-
-    /* if it is a float then it gets tricky */
-    /* otherwise it is fairly simple */
-    if (!IS_FLOAT(val->type)) {
-        unsigned long v = floatFromVal(val);
-
-        v >>= (offset * 8);
-       switch (size) {
-       case 1:
-           tsprintf(buffer, "!immedbyte", (unsigned int)v & 0xff);
-           break;
-       case 2:
-           tsprintf(buffer, "!immedword", (unsigned int)v & 0xffff);
-           break;
-       default:
-           /* Hmm.  Too big for now. */
-           assert(0);
-       }
-        ALLOC_ATOMIC(rs,strlen(buffer)+1);
-        return strcpy (rs,buffer);
-    }
-
-    /* PENDING: For now size must be 1 */
-    assert(size == 1);
-
-    /* it is type float */
-    fl.f = (float) floatFromVal(val);
-#ifdef _BIG_ENDIAN
-    tsprintf(buffer, "!immedbyte", fl.c[3-offset]);
-#else
-    tsprintf(buffer, "!immedbyte", fl.c[offset]);
-#endif
-    ALLOC_ATOMIC(rs,strlen(buffer)+1);
-    return strcpy (rs,buffer);
+  int i;
+  int len = plen;
+  int pplen = 0;
+  char buf[100];
+  char *p = buf;
+
+  while (len && pplen < plen)
+    {
+      i = 60;
+      while (i && pplen < plen)
+        {
+          if (*s < ' ' || *s == '\"' || *s=='\\')
+            {
+              *p = '\0';
+              if (p != buf)
+                dbuf_tprintf (oBuf, "\t!ascii\n", buf);
+              dbuf_tprintf (oBuf, "\t!db !constbyte\n", (unsigned char)*s);
+              p = buf;
+            }
+          else
+            {
+              *p = *s;
+              p++;
+            }
+          s++;
+          pplen++;
+          i--;
+        }
+      if (p != buf)
+        {
+          *p = '\0';
+          dbuf_tprintf (oBuf, "\t!ascii\n", buf);
+          p = buf;
+        }
+
+      if (len > 60)
+        len -= 60;
+      else
+        len = 0;
+    }
+  while (pplen < plen)
+    {
+      dbuf_tprintf (oBuf, "\t!db !constbyte\n", 0);
+      pplen++;
+    }
 }
 
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/
-/* aopLiteral - string from a literal value                        */
+/* return the generic pointer high byte for a given pointer type.  */
 /*-----------------------------------------------------------------*/
 /*-----------------------------------------------------------------*/
-char *aopLiteral (value *val, int offset)
+int
+pointerTypeToGPByte (const int p_type, const char *iname, const char *oname)
 {
 {
-    return aopLiteralLong(val, offset, 1);
+  switch (p_type)
+    {
+    case IPOINTER:
+    case POINTER:
+      return GPTYPE_NEAR;
+    case GPOINTER:
+      werror (E_CANNOT_USE_GENERIC_POINTER,
+              iname ? iname : "<null>",
+              oname ? oname : "<null>");
+      exit (1);
+    case FPOINTER:
+      return GPTYPE_FAR;
+    case CPOINTER:
+      return GPTYPE_CODE;
+    case PPOINTER:
+      return GPTYPE_XSTACK;
+    default:
+      fprintf (stderr, "*** internal error: unknown pointer type %d in GPByte.\n",
+               p_type);
+      break;
+    }
+  return -1;
 }
 
 }
 
+
 /*-----------------------------------------------------------------*/
 /*-----------------------------------------------------------------*/
-/* emitRegularMap - emit code for maps with no special cases       */
+/* printPointerType - generates ival for pointer type              */
 /*-----------------------------------------------------------------*/
 /*-----------------------------------------------------------------*/
-static void emitRegularMap (memmap * map, bool addPublics, bool arFlag)
+void
+_printPointerType (struct dbuf_s * oBuf, const char *name)
 {
 {
-    symbol *sym;
-    
-    if (addPublics) {
-       /* PENDING: special case here - should remove */
-       if (!strcmp(map->sname, CODE_NAME))
-           tfprintf(map->oFile, "\t!areacode\n", map->sname);
-       else if (!strcmp(map->sname, DATA_NAME)) 
-           tfprintf(map->oFile, "\t!areadata\n", map->sname);
-       else if (!strcmp(map->sname, HOME_NAME)) 
-           tfprintf(map->oFile, "\t!areahome\n", map->sname);
-       else
-           tfprintf(map->oFile, "\t!area\n", map->sname);
-    }
-    
-    /* print the area name */
-    for (sym = setFirstItem (map->syms); sym;
-        sym = setNextItem (map->syms))  {
-       
-       /* if extern then add it into the extern list */
-       if (IS_EXTERN (sym->etype)) {
-           addSetHead (&externs, sym);
-           continue;
-       }
-       
-       /* if allocation required check is needed
-          then check if the symbol really requires
-          allocation only for local variables */
-       if (arFlag && !IS_AGGREGATE(sym->type) &&
-           !(sym->_isparm && !IS_REGPARM(sym->etype)) && 
-             !sym->allocreq && sym->level)
-           continue ;
-       
-       /* if global variable & not static or extern 
-          and addPublics allowed then add it to the public set */
-       if ((sym->level == 0 || 
-            (sym->_isparm && !IS_REGPARM(sym->etype))) &&
-           addPublics &&
-           !IS_STATIC (sym->etype) &&
-           (sym->used || sym->fbody)) {
-           addSetHead (&publics, sym);
-       }
-       
-       /* if extern then do nothing or is a function 
-          then do nothing */
-       if (IS_FUNC (sym->type))
-           continue;
-       
-       /* print extra debug info if required */
-       if ((options.debug || sym->level == 0) && !options.nodebug) {
-
-           cdbSymbol(sym,cdbFile,FALSE,FALSE);
-
-           if (!sym->level) /* global */
-               if (IS_STATIC(sym->etype))
-                   fprintf(map->oFile,"F%s$",moduleName); /* scope is file */
-               else
-                   fprintf(map->oFile,"G$"); /* scope is global */
-           else
-               /* symbol is local */
-               fprintf(map->oFile,"L%s$",(sym->localof ? sym->localof->name : "-null-"));
-           fprintf(map->oFile,"%s$%d$%d",sym->name,sym->level,sym->block);
-       }
-
-       /* if is has an absolute address then generate
-          an equate for this no need to allocate space */
-       if (SPEC_ABSA (sym->etype)) {
-           if ((options.debug || sym->level == 0) && !options.nodebug)
-               fprintf (map->oFile," == 0x%04x\n",SPEC_ADDR (sym->etype));         
-
-           fprintf (map->oFile, "%s\t=\t0x%04x\n",
-                    sym->rname,
-                    SPEC_ADDR (sym->etype));
-       }
-       else {
-           /* allocate space */
-           if ((options.debug || sym->level == 0) && !options.nodebug)
-               fprintf(map->oFile,"==.\n");
-           if (IS_STATIC(sym->etype))
-               tfprintf(map->oFile, "!slabeldef\n", sym->rname);
-           else
-               tfprintf(map->oFile, "!labeldef\n", sym->rname);
-           tfprintf(map->oFile, "\t!ds\n", (unsigned int)getSize (sym->type) & 0xffff);
-       }
-       
-       /* if it has a 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)),
-                               decorateType (resolveSymbols (list2expr (sym->ival))));
-           codeOutFile = statsg->oFile;
-           allocInfo = 0;
-           eBBlockFromiCode (iCodeFromAst (ival));
-           allocInfo = 1;
-           sym->ival = NULL;
-       }
+  if (options.model == MODEL_FLAT24)
+    {
+      if (port->little_endian)
+        dbuf_printf (oBuf, "\t.byte %s,(%s >> 8),(%s >> 16)", name, name, name);
+      else
+        dbuf_printf (oBuf, "\t.byte (%s >> 16),(%s >> 8),%s", name, name, name);
+    }
+  else
+    {
+      if (port->little_endian)
+        dbuf_printf (oBuf, "\t.byte %s,(%s >> 8)", name, name);
+      else
+        dbuf_printf (oBuf, "\t.byte (%s >> 8),%s", name, name);
     }
 }
 
 /*-----------------------------------------------------------------*/
     }
 }
 
 /*-----------------------------------------------------------------*/
-/* initPointer - pointer initialization code massaging             */
+/* printPointerType - generates ival for pointer type              */
 /*-----------------------------------------------------------------*/
 /*-----------------------------------------------------------------*/
-value *initPointer (initList *ilist)
+void
+printPointerType (struct dbuf_s * oBuf, const char *name)
 {
 {
-    value *val;
-    ast *expr = list2expr(ilist);
-
-    if (!expr) 
-       goto wrong;             
-       
-    /* try it the oldway first */
-    if ((val = constExprValue(expr,FALSE)))
-       return val;
-
-    /* no then we have to do these cludgy checks */
-    /* pointers can be initialized with address of
-       a variable or address of an array element */
-    if (IS_AST_OP(expr) && expr->opval.op == '&') {
-       /* address of symbol */
-       if (IS_AST_SYM_VALUE(expr->left)) {
-           val = copyValue(AST_VALUE(expr->left));
-           val->type = newLink();
-           if (SPEC_SCLS(expr->left->etype) == S_CODE) {
-               DCL_TYPE(val->type) = CPOINTER ;
-               DCL_PTR_CONST(val->type) = port->mem.code_ro;
-           }
-           else
-               if (SPEC_SCLS(expr->left->etype) == S_XDATA)
-                   DCL_TYPE(val->type) = FPOINTER;
-               else
-                   if (SPEC_SCLS(expr->left->etype) == S_XSTACK )
-                       DCL_TYPE(val->type) = PPOINTER ;
-                   else
-                       if (SPEC_SCLS(expr->left->etype) == S_IDATA)
-                           DCL_TYPE(val->type) = IPOINTER ;
-                       else
-                           if (SPEC_SCLS(expr->left->etype) == S_EEPROM)
-                               DCL_TYPE(val->type) = EEPPOINTER ;
-                           else
-                               DCL_TYPE(val->type) = POINTER ;
-           val->type->next = expr->left->ftype;
-           val->etype = getSpec(val->type);
-           return val;
-       }
-
-       /* if address of indexed array */
-       if (IS_AST_OP(expr->left) && expr->left->opval.op == '[')
-           return valForArray(expr->left);     
-
-       /* if address of structure element then 
-          case 1. a.b ; */
-       if (IS_AST_OP(expr->left) && 
-           expr->left->opval.op == '.' ) {
-               return valForStructElem(expr->left->left,
-                                       expr->left->right);
-       }
-
-       /* case 2. (&a)->b ; 
-          (&some_struct)->element */
-       if (IS_AST_OP(expr->left) &&
-           expr->left->opval.op == PTR_OP &&
-           IS_ADDRESS_OF_OP(expr->left->left))
-               return valForStructElem(expr->left->left->left,
-                                       expr->left->right);
-
-    }
-    /* case 3. (((char *) &a) +/- constant) */
-    if (IS_AST_OP(expr) && 
-       (expr->opval.op == '+' || expr->opval.op == '-') &&
-       IS_AST_OP(expr->left) && expr->left->opval.op == CAST &&
-       IS_AST_OP(expr->left->right) && 
-       expr->left->right->opval.op == '&' &&
-       IS_AST_LIT_VALUE(expr->right)) {
-       
-       return valForCastAggr(expr->left->right->left,
-                             expr->left->left->opval.lnk,
-                             expr->right,expr->opval.op);
-       
-    }
-
- wrong:    
-    werror(E_INIT_WRONG);
-    return NULL;
-    
+  _printPointerType (oBuf, name);
+  dbuf_printf (oBuf, "\n");
 }
 
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/
-/* printChar - formats and prints a characater string with DB      */
+/* printGPointerType - generates ival for generic pointer type     */
 /*-----------------------------------------------------------------*/
 /*-----------------------------------------------------------------*/
-void printChar (FILE * ofile, char *s, int plen)
+void
+printGPointerType (struct dbuf_s * oBuf, const char *iname, const char *oname,
+                   const unsigned int type)
 {
 {
-    int i;
-    int len = strlen (s);
-    int pplen = 0;
-    char buf[100];
-    char *p = buf;
-
-    while (len && pplen < plen) {
-       i = 60;
-       while (i && *s && pplen < plen) {
-           if (*s < ' ' || *s == '\"') {
-               *p = '\0';
-               if (p != buf) 
-                   tfprintf(ofile, "\t!ascii\n", buf);
-               tfprintf(ofile, "\t!db !constbyte\n", *s);
-               p = buf;
-           }
-           else {
-               *p = *s;
-               p++;
-           }
-           s++;
-           pplen++;
-           i--;
-       }
-       if (p != buf) {
-           *p = '\0';
-           tfprintf(ofile, "\t!ascii\n", buf);
-           p = buf;
-       }
-       
-       if (len > 60)
-           len -= 60;
-       else
-           len = 0;
-    }
-    tfprintf(ofile, "\t!db !constbyte\n", 0);
+  _printPointerType (oBuf, iname);
+  dbuf_printf (oBuf, ",#0x%02x\n", pointerTypeToGPByte (type, iname, oname));
 }
 
 /*-----------------------------------------------------------------*/
 /* printIvalType - generates ival for int/char                     */
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/
 /* printIvalType - generates ival for int/char                     */
 /*-----------------------------------------------------------------*/
-void printIvalType (link * type, initList * ilist, FILE * oFile)
+void
+printIvalType (symbol *sym, sym_link * type, initList * ilist, struct dbuf_s * oBuf)
 {
 {
-    value *val;
-    
-    /* if initList is deep */
-    if (ilist->type == INIT_DEEP)
-       ilist = ilist->init.deep;
-    
-    val = list2val (ilist);
-    switch (getSize (type)) {
+  value *val;
+
+  /* if initList is deep */
+  if (ilist && (ilist->type == INIT_DEEP))
+    ilist = ilist->init.deep;
+
+  if (!(val = list2val (ilist))) {
+    // assuming a warning has been thrown
+    val = constCharVal (0);
+  }
+
+  /* check if the literal value is within bounds */
+  if (checkConstantRange (type, val->etype, '=', FALSE) == CCR_OVL &&
+      !options.lessPedantic)
+    {
+      werror (W_LIT_OVERFLOW);
+    }
+
+  if (val->type != type) {
+    val = valCastLiteral(type, floatFromVal(val));
+  }
+
+  switch (getSize (type)) {
+  case 1:
+    if (!val)
+      dbuf_tprintf (oBuf, "\t!db !constbyte\n", 0);
+    else
+      dbuf_tprintf (oBuf, "\t!dbs\n",
+                aopLiteral (val, 0));
+    break;
+
+  case 2:
+    if (port->use_dw_for_init)
+      dbuf_tprintf (oBuf, "\t!dws\n", aopLiteralLong (val, 0, 2));
+    else if (port->little_endian)
+      dbuf_printf (oBuf, "\t.byte %s,%s\n", aopLiteral (val, 0), aopLiteral (val, 1));
+    else
+      dbuf_printf (oBuf, "\t.byte %s,%s\n", aopLiteral (val, 1), aopLiteral (val, 0));
+    break;
+  case 4:
+    if (!val) {
+      dbuf_tprintf (oBuf, "\t!dw !constword\n", 0);
+      dbuf_tprintf (oBuf, "\t!dw !constword\n", 0);
+    }
+    else if (port->little_endian) {
+      dbuf_printf (oBuf, "\t.byte %s,%s,%s,%s\n",
+               aopLiteral (val, 0), aopLiteral (val, 1),
+               aopLiteral (val, 2), aopLiteral (val, 3));
+    }
+    else {
+      dbuf_printf (oBuf, "\t.byte %s,%s,%s,%s\n",
+               aopLiteral (val, 3), aopLiteral (val, 2),
+               aopLiteral (val, 1), aopLiteral (val, 0));
+    }
+    break;
+  }
+}
+
+/*-----------------------------------------------------------------*/
+/* printIvalBitFields - generate initializer for bitfields         */
+/*-----------------------------------------------------------------*/
+static void
+printIvalBitFields (symbol **sym, initList **ilist, struct dbuf_s * oBuf)
+{
+  symbol *lsym = *sym;
+  initList *lilist = *ilist;
+  unsigned long ival = 0;
+  int size = 0;
+
+  while (lsym)
+    {
+
+      if (0 == SPEC_BLEN (lsym->etype))
+        {
+          /* bit-field structure member with a width of 0 */
+          lsym = lsym->next;
+          break;
+        }
+      else if (!SPEC_BUNNAMED (lsym->etype))
+        {
+          /* not an unnamed bit-field structure member */
+          value *val = list2val (lilist);
+          int bit_length = SPEC_BLEN (lsym->etype);
+
+          if (size)
+            {
+              if (bit_length > 8)
+                size += (bit_length + 7) / 8;
+            }
+          else
+            size = (bit_length + 7) / 8;
+
+          /* check if the literal value is within bounds */
+          if (val &&
+            checkConstantRange (lsym->etype, val->etype, '=', FALSE) == CCR_OVL &&
+            !options.lessPedantic)
+            {
+              werror (W_LIT_OVERFLOW);
+            }
+
+          ival |= (ulFromVal (val) & ((1ul << bit_length) - 1ul)) << SPEC_BSTR (lsym->etype);
+          lilist = lilist ? lilist->next : NULL;
+        }
+      lsym = lsym->next;
+    }
+
+  switch (size)
+    {
     case 1:
     case 1:
-       if (!val)
-           tfprintf(oFile, "\t!db !constbyte\n", 0);
-       else
-           tfprintf(oFile, "\t!dbs\n",
-                    aopLiteral (val, 0));
-       break;
+      dbuf_tprintf (oBuf, "\t!db !constbyte\n", ival);
+      break;
 
     case 2:
 
     case 2:
-       if (port->use_dw_for_init)
-           tfprintf(oFile, "\t!dws\n", aopLiteralLong(val, 0, 2));
-       else
-           fprintf(oFile, "\t.byte %s,%s\n", aopLiteral(val, 0),aopLiteral(val, 1));
-       break;
+      dbuf_tprintf (oBuf, "\t!dw !constword\n", ival);
+      break;
+
     case 4:
     case 4:
-       if (!val) {
-           tfprintf (oFile, "\t!dw !constword\n", 0);
-           tfprintf (oFile, "\t!dw !constword\n", 0);
-       }
-       else {
-           fprintf (oFile, "\t.byte %s,%s,%s,%s\n",
-                    aopLiteral (val, 0), aopLiteral (val, 1),
-                    aopLiteral (val, 2), aopLiteral (val, 3));
-       }
-       break;
+      dbuf_tprintf (oBuf, "\t!dw  !constword,!constword\n",
+        (ival >> 16) & 0xffff, (ival & 0xffff));
+      break;
     }
     }
+  *sym = lsym;
+  *ilist = lilist;
 }
 
 /*-----------------------------------------------------------------*/
 /* printIvalStruct - generates initial value for structures        */
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/
 /* printIvalStruct - generates initial value for structures        */
 /*-----------------------------------------------------------------*/
-void printIvalStruct (symbol * sym,link * type,
-                     initList * ilist, FILE * oFile)
+static void
+printIvalStruct (symbol * sym, sym_link * type,
+                 initList * ilist, struct dbuf_s * oBuf)
 {
 {
-    symbol *sflds;
-    initList *iloop;
-    
-    sflds = SPEC_STRUCT (type)->fields;
-    if (ilist->type != INIT_DEEP) {
-       werror (E_INIT_STRUCT, sym->name);
-       return;
-    }
-    
-    iloop = ilist->init.deep;
-    
-    for (; sflds; sflds = sflds->next, iloop = (iloop ? iloop->next : NULL))
-       printIval (sflds, sflds->type, iloop, oFile);
-    
-    return;
+  symbol *sflds;
+  initList *iloop = NULL;
+
+  sflds = SPEC_STRUCT (type)->fields;
+
+  if (ilist)
+    {
+      if (ilist->type != INIT_DEEP)
+        {
+          werrorfl (sym->fileDef, sym->lineDef, E_INIT_STRUCT, sym->name);
+          return;
+        }
+
+      iloop = ilist->init.deep;
+    }
+
+  if (SPEC_STRUCT (type)->type == UNION)
+    {
+      printIval (sym, sflds->type, iloop, oBuf, 1);
+      iloop = iloop ? iloop->next : NULL;
+    }
+  else
+    {
+      while (sflds)
+        {
+          if (IS_BITFIELD (sflds->type))
+            printIvalBitFields(&sflds, &iloop, oBuf);
+          else
+            {
+              printIval (sym, sflds->type, iloop, oBuf, 1);
+              sflds = sflds->next;
+              iloop = iloop ? iloop->next : NULL;
+            }
+        }
+    }
+
+  if (iloop)
+    werrorfl (sym->fileDef, sym->lineDef, W_EXCESS_INITIALIZERS, "struct", sym->name);
 }
 
 /*-----------------------------------------------------------------*/
 /* printIvalChar - generates initital value for character array    */
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/
 /* printIvalChar - generates initital value for character array    */
 /*-----------------------------------------------------------------*/
-int printIvalChar (link * type, initList * ilist, FILE * oFile, char *s)
+int
+printIvalChar (symbol * sym, sym_link * type, initList * ilist, struct dbuf_s * oBuf, char *s, bool check)
 {
 {
-    value *val;
-    int remain;
-    
-    if (!s) {
-       
-       val = list2val (ilist);
-       /* if the value is a character string  */
-       if (IS_ARRAY (val->type) && IS_CHAR (val->etype)) {
-           if (!DCL_ELEM (type))
-               DCL_ELEM (type) = strlen (SPEC_CVAL (val->etype).v_char) + 1;
-           
-           /* if size mismatch  */
-/*         if (DCL_ELEM (type) < ((int) strlen (SPEC_CVAL (val->etype).v_char) + 1)) */
-/*             werror (E_ARRAY_BOUND); */
-           
-           printChar (oFile, SPEC_CVAL (val->etype).v_char,DCL_ELEM(type));
-           
-           if ((remain = (DCL_ELEM (type) - strlen (SPEC_CVAL (val->etype).v_char) -1))>0)
-               while (remain--)
-                   tfprintf (oFile, "\t!db !constbyte\n", 0);
-           
-           return 1;
-       }
-       else
-           return 0;
+  value *val;
+  unsigned int size = DCL_ELEM (type);
+
+  if (!s)
+    {
+      val = list2val (ilist);
+      /* if the value is a character string  */
+      if (IS_ARRAY (val->type) && IS_CHAR (val->etype))
+        {
+          if (!size)
+            {
+              /* we have not been given a size, but now we know it */
+              size = strlen (SPEC_CVAL (val->etype).v_char) + 1;
+              /* but first check, if it's a flexible array */
+              if (sym && IS_STRUCT (sym->type))
+                sym->flexArrayLength = size;
+              else
+                DCL_ELEM (type) = size;
+            }
+
+          if (check && DCL_ELEM (val->type) > size)
+            werror (W_EXCESS_INITIALIZERS, "array of chars", sym->name, sym->lineDef);
+
+          printChar (oBuf, SPEC_CVAL (val->etype).v_char, size);
+
+          return 1;
+        }
+      else
+        return 0;
     }
     }
-    else
-       printChar (oFile, s,strlen(s)+1);
-    return 1;
+  else
+    printChar (oBuf, s, strlen (s) + 1);
+  return 1;
 }
 
 /*-----------------------------------------------------------------*/
 /* printIvalArray - generates code for array initialization        */
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/
 /* printIvalArray - generates code for array initialization        */
 /*-----------------------------------------------------------------*/
-void printIvalArray (symbol * sym, link * type, initList * ilist,
-                    FILE * oFile)
+void
+printIvalArray (symbol * sym, sym_link * type, initList * ilist,
+                struct dbuf_s * oBuf, bool check)
 {
 {
-    initList *iloop;
-    int lcnt = 0, size = 0;
-    
+  value *val;
+  initList *iloop;
+  unsigned int size = 0;
+
+  if (ilist) {
     /* take care of the special   case  */
     /* array of characters can be init  */
     /* by a string                      */
     /* take care of the special   case  */
     /* array of characters can be init  */
     /* by a string                      */
-    if (IS_CHAR (type->next))
-       if (printIvalChar (type,
-                          (ilist->type == INIT_DEEP ? ilist->init.deep : ilist),
-                          oFile, SPEC_CVAL (sym->etype).v_char))
-           return;
-    
+    if (IS_CHAR (type->next)) {
+      val = list2val(ilist);
+      if (!val) {
+        werrorfl (ilist->filename, ilist->lineno, E_INIT_STRUCT, sym->name);
+        return;
+      }
+      if (!IS_LITERAL(val->etype)) {
+        werrorfl (ilist->filename, ilist->lineno, E_CONST_EXPECTED);
+        return;
+      }
+      if (printIvalChar (sym, type,
+                         (ilist->type == INIT_DEEP ? ilist->init.deep : ilist),
+                         oBuf, SPEC_CVAL (sym->etype).v_char, check))
+        return;
+    }
     /* not the special case             */
     if (ilist->type != INIT_DEEP) {
     /* not the special case             */
     if (ilist->type != INIT_DEEP) {
-       werror (E_INIT_STRUCT, sym->name);
-       return;
-    }
-    
-    iloop = ilist->init.deep;
-    lcnt = DCL_ELEM (type);
-    
-    for (;;) {
-       size++;
-       printIval (sym, type->next, iloop, oFile);
-       iloop = (iloop ? iloop->next : NULL);
-       
-       
-       /* if not array limits given & we */
-       /* are out of initialisers then   */
-       if (!DCL_ELEM (type) && !iloop)
-           break;
-       
-       /* no of elements given and we    */
-       /* have generated for all of them */
-       if (!--lcnt)
-           break;
-    }
-    
-    /* if we have not been given a size  */
-    if (!DCL_ELEM (type))
-       DCL_ELEM (type) = size;
-    
-    return;
+      werrorfl (ilist->filename, ilist->lineno, E_INIT_STRUCT, sym->name);
+      return;
+    }
+
+    for (iloop=ilist->init.deep; iloop; iloop=iloop->next) {
+      if ((++size > DCL_ELEM(type)) && DCL_ELEM(type)) {
+        werrorfl (sym->fileDef, sym->lineDef, W_EXCESS_INITIALIZERS, "array", sym->name);
+        break;
+      }
+      printIval (sym, type->next, iloop, oBuf, TRUE);
+    }
+  }
+
+  if (DCL_ELEM(type)) {
+    // pad with zeros if needed
+    if (size<DCL_ELEM(type)) {
+      size = (DCL_ELEM(type) - size) * getSize(type->next);
+      while (size--) {
+        dbuf_tprintf (oBuf, "\t!db !constbyte\n", 0);
+      }
+    }
+  } else {
+    /* we have not been given a size, but now we know it */
+    /* but first check, if it's a flexible array */
+    if (IS_STRUCT (sym->type))
+      sym->flexArrayLength = size * getSize (type->next);
+    else
+      DCL_ELEM (type) = size;
+  }
+
+  return;
 }
 
 /*-----------------------------------------------------------------*/
 /* printIvalFuncPtr - generate initial value for function pointers */
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/
 /* printIvalFuncPtr - generate initial value for function pointers */
 /*-----------------------------------------------------------------*/
-void printIvalFuncPtr (link * type, initList * ilist, FILE * oFile)
+void
+printIvalFuncPtr (sym_link * type, initList * ilist, struct dbuf_s * oBuf)
 {
 {
-    value *val;
-    int dLvl = 0;
-    
+  value *val;
+  int dLvl = 0;
+
+  if (ilist)
     val = list2val (ilist);
     val = list2val (ilist);
-    /* check the types   */
-    if ((dLvl = checkType (val->type, type->next)) <= 0) {
-       tfprintf(oFile, "\t!dw !constword\n", 0);
-       return;
-    }
-    
-    /* 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);
+  else
+    val = valCastLiteral(type, 0.0);
+
+  if (!val) {
+    // an error has been thrown already
+    val = constCharVal (0);
+  }
+
+  if (IS_LITERAL(val->etype)) {
+    if (compareType(type, val->etype) == 0) {
+      werrorfl (ilist->filename, ilist->lineno, E_INCOMPAT_TYPES);
+      printFromToType (val->type, type);
     }
     }
-    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);
-    
+    printIvalCharPtr (NULL, type, val, oBuf);
     return;
     return;
+  }
+
+  /* check the types   */
+  if ((dLvl = compareType (val->type, type->next)) <= 0)
+    {
+      dbuf_tprintf (oBuf, "\t!dw !constword\n", 0);
+      return;
+    }
+
+  /* now generate the name */
+  if (!val->sym)
+    {
+      if (port->use_dw_for_init)
+        {
+          dbuf_tprintf (oBuf, "\t!dws\n", val->name);
+        }
+      else
+        {
+          printPointerType (oBuf, val->name);
+        }
+    }
+  else if (port->use_dw_for_init)
+    {
+      dbuf_tprintf (oBuf, "\t!dws\n", val->sym->rname);
+    }
+  else
+    {
+      printPointerType (oBuf, val->sym->rname);
+    }
+
+  return;
 }
 
 /*-----------------------------------------------------------------*/
 /* printIvalCharPtr - generates initial values for character pointers */
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/
 /* 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, struct dbuf_s * oBuf)
 {
 {
-    int size = 0;
-    
-    /* PENDING: this is _very_ mcs51 specific, including a magic
-       number... 
-       It's also endin specific.
-    */
-    size = getSize (type);
-
-    if (val->name && strlen(val->name)) {
-       switch (size) {
-       case 1:
-           tfprintf(oFile,
-                   "\t!dbs\n", val->name) ;
-           break;
-       case 2:
-           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:
-           /* 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))));
-       }
+  int size = 0;
+
+  /* PENDING: this is _very_ mcs51 specific, including a magic
+     number...
+     It's also endian specific.
+   */
+  size = getSize (type);
+
+  if (val->name && strlen (val->name))
+    {
+      if (size == 1)            /* This appears to be Z80 specific?? */
+        {
+          dbuf_tprintf (oBuf,
+                    "\t!dbs\n", val->name);
+        }
+      else if (size == FPTRSIZE)
+        {
+          if (port->use_dw_for_init)
+            {
+              dbuf_tprintf (oBuf, "\t!dws\n", val->name);
+            }
+          else
+            {
+              printPointerType (oBuf, val->name);
+            }
+        }
+      else if (size == GPTRSIZE)
+        {
+          int type;
+          if (IS_PTR (val->type)) {
+            type = DCL_TYPE (val->type);
+          } else {
+            type = PTR_TYPE (SPEC_OCLS (val->etype));
+          }
+          if (val->sym && val->sym->isstrlit) {
+            // this is a literal string
+            type=CPOINTER;
+          }
+          printGPointerType (oBuf, val->name, sym->name, type);
+        }
+      else
+        {
+          fprintf (stderr, "*** internal error: unknown size in "
+                   "printIvalCharPtr.\n");
+        }
     }
     }
-    else {
-       switch (size) {
-       case 1:
-           tfprintf(oFile, "\t!dbs\n", aopLiteral(val, 0));
-           break;
-       case 2:
-           if (port->use_dw_for_init)
-               tfprintf(oFile, "\t!dws\n", aopLiteralLong(val, 0, size));
-           else 
-               tfprintf(oFile, "\t.byte %s,%s\n", 
-                        aopLiteral(val, 0),aopLiteral(val, 1));
-           break;
-       case 3:
-           /* PENDING: 0x02 or 0x%02x, CDATA? */
-           fprintf(oFile, "\t.byte %s,%s,#0x02\n",
-                   aopLiteral (val, 0), aopLiteral (val, 1));
-           break;
-       default:
-           assert(0);
-       }
-    }
-
-
-    if (val->sym && val->sym->isstrlit)
-       addSet (&statsg->syms, val->sym);
-    
-    return 1;
+  else
+    {
+      // these are literals assigned to pointers
+      switch (size)
+        {
+        case 1:
+          dbuf_tprintf (oBuf, "\t!dbs\n", aopLiteral (val, 0));
+          break;
+        case 2:
+          if (port->use_dw_for_init)
+            dbuf_tprintf (oBuf, "\t!dws\n", aopLiteralLong (val, 0, size));
+          else if (port->little_endian)
+            dbuf_tprintf (oBuf, "\t.byte %s,%s\n",
+                      aopLiteral (val, 0), aopLiteral (val, 1));
+          else
+            dbuf_tprintf (oBuf, "\t.byte %s,%s\n",
+                      aopLiteral (val, 1), aopLiteral (val, 0));
+          break;
+        case 3:
+          if (IS_GENPTR(type) && floatFromVal(val)!=0) {
+            // non-zero mcs51 generic pointer
+            werrorfl (sym->fileDef, sym->lineDef, E_LITERAL_GENERIC);
+          }
+          if (port->little_endian) {
+            dbuf_printf (oBuf, "\t.byte %s,%s,%s\n",
+                     aopLiteral (val, 0),
+                     aopLiteral (val, 1),
+                     aopLiteral (val, 2));
+          } else {
+            dbuf_printf (oBuf, "\t.byte %s,%s,%s\n",
+                     aopLiteral (val, 2),
+                     aopLiteral (val, 1),
+                     aopLiteral (val, 0));
+          }
+          break;
+        case 4:
+          if (IS_GENPTR(type) && floatFromVal(val)!=0) {
+            // non-zero ds390 generic pointer
+            werrorfl (sym->fileDef, sym->lineDef, E_LITERAL_GENERIC);
+          }
+          if (port->little_endian) {
+            dbuf_printf (oBuf, "\t.byte %s,%s,%s,%s\n",
+                     aopLiteral (val, 0),
+                     aopLiteral (val, 1),
+                     aopLiteral (val, 2),
+                     aopLiteral (val, 3));
+          } else {
+            dbuf_printf (oBuf, "\t.byte %s,%s,%s,%s\n",
+                     aopLiteral (val, 3),
+                     aopLiteral (val, 2),
+                     aopLiteral (val, 1),
+                     aopLiteral (val, 0));
+          }
+          break;
+        default:
+          assert (0);
+        }
+    }
+
+  if (!noInit && val->sym && val->sym->isstrlit && !isinSet(statsg->syms, val->sym)) {
+    addSet (&statsg->syms, val->sym);
+  }
+
+  return 1;
 }
 
 /*-----------------------------------------------------------------*/
 /* printIvalPtr - generates initial value for pointers             */
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/
 /* 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, struct dbuf_s * oBuf)
 {
 {
-    value *val;
-    
-    /* if deep then   */
-    if (ilist->type == INIT_DEEP)
-       ilist = ilist->init.deep;
-    
-    /* function pointer     */
-    if (IS_FUNC (type->next)) {
-       printIvalFuncPtr (type, ilist, oFile);
-       return;
-    }
-    
-    if (!(val = initPointer (ilist)))
-       return ;
-
-    /* if character pointer */
-    if (IS_CHAR (type->next))
-       if (printIvalCharPtr (sym, type, val, oFile))
-           return;
-    
-    /* check the type      */
-    if (checkType (type, val->type) != 1)
-       werror (E_INIT_WRONG);
-    
-    /* if val is literal */
-    if (IS_LITERAL (val->etype)) {
-       switch (getSize (type)) {
-       case 1:
-           tfprintf(oFile, "\t!db !constbyte\n", (unsigned int)floatFromVal(val) & 0xff);
-           break;
-       case 2:
-           if (port->use_dw_for_init)
-               tfprintf(oFile, "\t!dws\n", aopLiteralLong(val, 0, 2));
-           else
-               tfprintf (oFile, "\t.byte %s,%s\n", aopLiteral(val, 0),aopLiteral(val, 1));
-           break;
-       case 3:
-           fprintf (oFile, "\t.byte %s,%s,#0x02\n",
-                    aopLiteral (val, 0), aopLiteral (val, 1));
-       }
-       return;
-    }
-    
-    
-    switch (getSize (type)) {
-    case 1:
-       tfprintf (oFile, "\t!dbs\n", val->name);
-       break;
-    case 2:
-       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))));
+  value *val;
+  int size;
+
+  /* if deep then   */
+  if (ilist && (ilist->type == INIT_DEEP))
+    ilist = ilist->init.deep;
+
+  /* function pointer     */
+  if (IS_FUNC (type->next))
+    {
+      printIvalFuncPtr (type, ilist, oBuf);
+      return;
     }
     }
+
+  if (!(val = initPointer (ilist, type)))
     return;
     return;
+
+  /* if character pointer */
+  if (IS_CHAR (type->next))
+    if (printIvalCharPtr (sym, type, val, oBuf))
+      return;
+
+  /* check the type      */
+  if (compareType (type, val->type) == 0) {
+    werrorfl (ilist->filename, ilist->lineno, W_INIT_WRONG);
+    printFromToType (val->type, type);
+  }
+
+  /* if val is literal */
+  if (IS_LITERAL (val->etype))
+    {
+      switch (getSize (type))
+        {
+        case 1:
+          dbuf_tprintf (oBuf, "\t!db !constbyte\n", (unsigned int) ulFromVal (val) & 0xff);
+          break;
+        case 2:
+          if (port->use_dw_for_init)
+            dbuf_tprintf (oBuf, "\t!dws\n", aopLiteralLong (val, 0, 2));
+          else if (port->little_endian)
+            dbuf_tprintf (oBuf, "\t.byte %s,%s\n", aopLiteral (val, 0), aopLiteral (val, 1));
+          else
+            dbuf_tprintf (oBuf, "\t.byte %s,%s\n", aopLiteral (val, 1), aopLiteral (val, 0));
+          break;
+        case 3: // how about '390??
+          dbuf_printf (oBuf, "; generic printIvalPtr\n");
+          if (port->little_endian)
+            {
+              dbuf_printf (oBuf, "\t.byte %s,%s",
+                       aopLiteral (val, 0), aopLiteral (val, 1));
+            }
+          else
+            {
+              dbuf_printf (oBuf, "\t.byte %s,%s",
+                       aopLiteral (val, 1), aopLiteral (val, 0));
+            }
+          if (IS_GENPTR (val->type))
+            dbuf_printf (oBuf, ",%s\n", aopLiteral (val, 2));
+          else if (IS_PTR (val->type))
+            dbuf_printf (oBuf, ",#%x\n", pointerTypeToGPByte (DCL_TYPE (val->type), NULL, NULL));
+          else
+            dbuf_printf (oBuf, ",%s\n", aopLiteral (val, 2));
+        }
+      return;
+    }
+
+
+  size = getSize (type);
+
+  if (size == 1)                /* Z80 specific?? */
+    {
+      dbuf_tprintf (oBuf, "\t!dbs\n", val->name);
+    }
+  else if (size == FPTRSIZE)
+    {
+      if (port->use_dw_for_init) {
+        dbuf_tprintf (oBuf, "\t!dws\n", val->name);
+      } else {
+        printPointerType (oBuf, val->name);
+      }
+    }
+  else if (size == GPTRSIZE)
+    {
+      printGPointerType (oBuf, val->name, sym->name,
+                         (IS_PTR (val->type) ? DCL_TYPE (val->type) :
+                          PTR_TYPE (SPEC_OCLS (val->etype))));
+    }
+  return;
 }
 
 /*-----------------------------------------------------------------*/
 /* printIval - generates code for initial value                    */
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/
 /* 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, struct dbuf_s * oBuf, bool check)
 {
 {
-    if (!ilist)
-       return;    
-    
-    /* if structure then    */
-    if (IS_STRUCT (type)) {
-       printIvalStruct (sym, type, ilist, oFile);
-       return;
-    }
-    
-    /* if this is a pointer */
-    if (IS_PTR (type)) {
-       printIvalPtr (sym, type, ilist, oFile);
-       return;
-    }
-    
-    /* if this is an array   */
-    if (IS_ARRAY (type)) {
-       printIvalArray (sym, type, ilist, oFile);
-       return;
-    }
-    
-    /* if type is SPECIFIER */
-    if (IS_SPEC (type)) {
-       printIvalType (type, ilist, oFile);
-       return;
+  sym_link *itype;
+
+  /* if structure then    */
+  if (IS_STRUCT (type))
+    {
+      printIvalStruct (sym, type, ilist, oBuf);
+      return;
+    }
+
+  /* if this is an array   */
+  if (IS_ARRAY (type))
+    {
+      printIvalArray (sym, type, ilist, oBuf, check);
+      return;
+    }
+
+  if (ilist)
+    {
+      // not an aggregate, ilist must be a node
+      if (ilist->type!=INIT_NODE) {
+          // or a 1-element list
+        if (ilist->init.deep->next) {
+          werrorfl (sym->fileDef, sym->lineDef, W_EXCESS_INITIALIZERS, "scalar",
+                  sym->name);
+        } else {
+          ilist=ilist->init.deep;
+        }
+      }
+
+      // and the type must match
+      itype=ilist->init.node->ftype;
+
+      if (compareType(type, itype)==0) {
+        // special case for literal strings
+        if (IS_ARRAY (itype) && IS_CHAR (getSpec(itype)) &&
+            // which are really code pointers
+            IS_PTR(type) && DCL_TYPE(type)==CPOINTER) {
+          // no sweat
+        } else {
+          werrorfl (ilist->filename, ilist->lineno, E_TYPE_MISMATCH, "assignment", " ");
+          printFromToType(itype, type);
+        }
+      }
+    }
+
+  /* if this is a pointer */
+  if (IS_PTR (type))
+    {
+      printIvalPtr (sym, type, ilist, oBuf);
+      return;
+    }
+
+  /* if type is SPECIFIER */
+  if (IS_SPEC (type))
+    {
+      printIvalType (sym, type, ilist, oBuf);
+      return;
     }
 }
 
 /*-----------------------------------------------------------------*/
 /* emitStaticSeg - emitcode for the static segment                 */
 /*-----------------------------------------------------------------*/
     }
 }
 
 /*-----------------------------------------------------------------*/
 /* emitStaticSeg - emitcode for the static segment                 */
 /*-----------------------------------------------------------------*/
-void emitStaticSeg(memmap * map, FILE *out)
+void
+emitStaticSeg (memmap * map, struct dbuf_s * oBuf)
 {
 {
-    symbol *sym;
-    
-    /*     fprintf(map->oFile,"\t.area\t%s\n",map->sname); */
-    if (!out)
-       out = code->oFile;
-
-    /* for all variables in this segment do */
-    for (sym = setFirstItem (map->syms); sym;
-        sym = setNextItem (map->syms)) {
-       
-       /* if it is "extern" then do nothing */
-       if (IS_EXTERN (sym->etype))
-           continue;
-       
-       /* if it is not static add it to the public
-          table */
-       if (!IS_STATIC (sym->etype))
-           addSetHead (&publics, sym);
-
-       /* print extra debug info if required */
-       if ((options.debug || sym->level == 0) && !options.nodebug) {
-
-           cdbSymbol(sym,cdbFile,FALSE,FALSE);
-
-           if (!sym->level) { /* global */
-               if (IS_STATIC(sym->etype))
-                   fprintf(out,"F%s$",moduleName); /* scope is file */
-               else
-                   fprintf(out,"G$"); /* scope is global */
-           }
-           else
-               /* symbol is local */
-               fprintf(out,"L%s$",
-                       (sym->localof ? sym->localof->name : "-null-"));
-           fprintf(out,"%s$%d$%d",sym->name,sym->level,sym->block);
-       }
-       
-       /* if it has an absolute address */
-       if (SPEC_ABSA (sym->etype)) {
-           if ((options.debug || sym->level == 0) && !options.nodebug)
-               fprintf(out," == 0x%04x\n", SPEC_ADDR (sym->etype));
-
-           fprintf (out, "%s\t=\t0x%04x\n",
-                    sym->rname,
-                    SPEC_ADDR (sym->etype));
-       }
-       else {
-           if ((options.debug || sym->level == 0) && !options.nodebug)
-               fprintf(out," == .\n"); 
-
-           /* if it has an initial value */
-           if (sym->ival) {
-               fprintf (out, "%s:\n", sym->rname);
-               noAlloc++;
-               resolveIvalSym (sym->ival);
-               printIval (sym, sym->type, sym->ival, out);
-               noAlloc--;
-           }
-           else {
-               /* allocate space */
-               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 (out,
-                              SPEC_CVAL (sym->etype).v_char,
-                              strlen(SPEC_CVAL (sym->etype).v_char)+1);
-               else 
-                   tfprintf(out, "\t!ds\n", (unsigned int)getSize (sym->type)& 0xffff);
-           }
-       }
+  symbol *sym;
+
+  /* fprintf(out, "\t.area\t%s\n", map->sname); */
+
+  /* for all variables in this segment do */
+  for (sym = setFirstItem (map->syms); sym;
+       sym = setNextItem (map->syms))
+    {
+
+      /* if it is "extern" then do nothing */
+      if (IS_EXTERN (sym->etype))
+        continue;
+
+      /* if it is not static add it to the public table */
+      if (!IS_STATIC (sym->etype))
+        {
+          addSetHead (&publics, sym);
+        }
+
+      /* print extra debug info if required */
+      if (options.debug)
+        {
+          if (!sym->level)
+            {                     /* global */
+              if (IS_STATIC (sym->etype))
+                dbuf_printf (oBuf, "F%s$", moduleName);        /* scope is file */
+              else
+                dbuf_printf (oBuf, "G$");      /* scope is global */
+            }
+          else
+            {
+              /* symbol is local */
+              dbuf_printf (oBuf, "L%s$",
+                           (sym->localof ? sym->localof->name : "-null-"));
+            }
+          dbuf_printf (oBuf, "%s$%d$%d", sym->name, sym->level, sym->block);
+        }
+
+      /* if it has an absolute address and no initializer */
+      if (SPEC_ABSA (sym->etype) && !sym->ival)
+        {
+          if (options.debug)
+            dbuf_printf (oBuf, " == 0x%04x\n", SPEC_ADDR (sym->etype));
+
+          dbuf_printf (oBuf, "%s\t=\t0x%04x\n",
+                   sym->rname,
+                   SPEC_ADDR (sym->etype));
+        }
+      else
+        {
+          if (options.debug)
+            dbuf_printf (oBuf, " == .\n");
+
+          /* if it has an initial value */
+          if (sym->ival)
+            {
+              if (SPEC_ABSA (sym->etype))
+                {
+                  dbuf_tprintf (oBuf, "\t!org\n", SPEC_ADDR (sym->etype));
+                }
+              dbuf_printf (oBuf, "%s:\n", sym->rname);
+              ++noAlloc;
+              resolveIvalSym (sym->ival, sym->type);
+              printIval (sym, sym->type, sym->ival, oBuf, map != xinit);
+              --noAlloc;
+              /* if sym is a simple string and sym->ival is a string,
+                 WE don't need it anymore */
+              if (IS_ARRAY(sym->type) && IS_CHAR(sym->type->next) &&
+                  IS_AST_SYM_VALUE(list2expr(sym->ival)) &&
+                  list2val(sym->ival)->sym->isstrlit) {
+                freeStringSymbol(list2val(sym->ival)->sym);
+              }
+            }
+          else {
+              /* allocate space */
+              int size = getSize (sym->type);
+
+              if (size==0) {
+                  werrorfl (sym->fileDef, sym->lineDef, E_UNKNOWN_SIZE,sym->name);
+              }
+              dbuf_printf (oBuf, "%s:\n", sym->rname);
+              /* special case for character strings */
+              if (IS_ARRAY (sym->type) && IS_CHAR (sym->type->next) &&
+                  SPEC_CVAL (sym->etype).v_char)
+                  printChar (oBuf,
+                             SPEC_CVAL (sym->etype).v_char,
+                             size);
+              else
+                  dbuf_tprintf (oBuf, "\t!ds\n", (unsigned int) size & 0xffff);
+            }
+        }
     }
 }
 
 /*-----------------------------------------------------------------*/
 /* emitMaps - emits the code for the data portion the code         */
 /*-----------------------------------------------------------------*/
     }
 }
 
 /*-----------------------------------------------------------------*/
 /* emitMaps - emits the code for the data portion the code         */
 /*-----------------------------------------------------------------*/
-void emitMaps ()
+void
+emitMaps (void)
 {
 {
-    /* no special considerations for the following
-       data, idata & bit & xdata */
-    emitRegularMap (data, TRUE, TRUE);
-    emitRegularMap (idata, TRUE,TRUE);
-    emitRegularMap (bit, TRUE,FALSE);
-    emitRegularMap (xdata, TRUE,TRUE);
-    emitRegularMap (sfr, FALSE,FALSE);
-    emitRegularMap (sfrbit, FALSE,FALSE);
-    emitRegularMap (home, TRUE,FALSE);
-    emitRegularMap (code, TRUE,FALSE);
-
-    emitStaticSeg (statsg, code->oFile);
+  int publicsfr = TARGET_IS_MCS51; /* Ideally, this should be true for all  */
+                                   /* ports but let's be conservative - EEP */
+
+  inInitMode++;
+  /* no special considerations for the following
+     data, idata & bit & xdata */
+  emitRegularMap (data, TRUE, TRUE);
+  emitRegularMap (idata, TRUE, TRUE);
+  emitRegularMap (d_abs, TRUE, TRUE);
+  emitRegularMap (i_abs, TRUE, TRUE);
+  emitRegularMap (bit, TRUE, TRUE);
+  emitRegularMap (pdata, TRUE, TRUE);
+  emitRegularMap (xdata, TRUE, TRUE);
+  emitRegularMap (x_abs, TRUE, TRUE);
+  if (port->genXINIT) {
+    emitRegularMap (xidata, TRUE, TRUE);
+  }
+  emitRegularMap (sfr, publicsfr, FALSE);
+  emitRegularMap (sfrbit, publicsfr, FALSE);
+  emitRegularMap (home, TRUE, FALSE);
+  emitRegularMap (code, TRUE, FALSE);
+
+  if (options.const_seg) {
+    dbuf_tprintf (&code->oBuf, "\t!area\n", options.const_seg);
+  }
+  emitStaticSeg (statsg, &code->oBuf);
+  if (port->genXINIT) {
+    dbuf_tprintf (&code->oBuf, "\t!area\n", xinit->sname);
+    emitStaticSeg (xinit, &code->oBuf);
+  }
+  dbuf_tprintf (&code->oBuf, "\t!area\n", c_abs->sname);
+  emitStaticSeg (c_abs, &code->oBuf);
+  inInitMode--;
 }
 
 /*-----------------------------------------------------------------*/
 /* flushStatics - flush all currently defined statics out to file  */
 /*  and delete.  Temporary function                                */
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/
 /* flushStatics - flush all currently defined statics out to file  */
 /*  and delete.  Temporary function                                */
 /*-----------------------------------------------------------------*/
-void flushStatics(void)
+void
+flushStatics (void)
 {
 {
-    emitStaticSeg(statsg, codeOutFile);
-    statsg->syms = NULL;
+  emitStaticSeg (statsg, codeOutBuf);
+  statsg->syms = NULL;
 }
 
 /*-----------------------------------------------------------------*/
 /* createInterruptVect - creates the interrupt vector              */
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/
 /* createInterruptVect - creates the interrupt vector              */
 /*-----------------------------------------------------------------*/
-void createInterruptVect (FILE * vFile)
+void
+createInterruptVect (struct dbuf_s *vBuf)
 {
 {
-    int i = 0;
-    mainf = newSymbol ("main", 0);
-    mainf->block = 0;
-    
-    /* only if the main function exists */
-    if (!(mainf = findSymWithLevel (SymbolTab, mainf))) {
-       if (!options.cc_only)
-           werror(E_NO_MAIN);
-       return;
-    }
-    
-    /* if the main is only a prototype ie. no body then do nothing */
-    if (!mainf->fbody) {
-       /* if ! compile only then main function should be present */
-       if (!options.cc_only)
-           werror(E_NO_MAIN);
-       return;
-    }
-    
-    tfprintf(vFile, "\t!areacode\n", CODE_NAME);
-    fprintf (vFile, "__interrupt_vect:\n");
-
-    
-    if (!port->genIVT || ! (port->genIVT(vFile, interrupts, maxInterrupts)))
+  mainf = newSymbol ("main", 0);
+  mainf->block = 0;
+
+  /* only if the main function exists */
+  if (!(mainf = findSymWithLevel (SymbolTab, mainf)))
     {
     {
-        /* "generic" interrupt table header (if port doesn't specify one).
-         *
-         * Look suspiciously like 8051 code to me...
-         */
-    
-       fprintf (vFile, "\tljmp\t__sdcc_gsinit_startup\n");
-    
-    
-       /* now for the other interrupts */
-       for (; i < maxInterrupts; i++) {
-               if (interrupts[i])
-                       fprintf (vFile, "\tljmp\t%s\n\t.ds\t5\n", interrupts[i]->rname);
-               else
-                       fprintf (vFile, "\treti\n\t.ds\t7\n");
-       }
+      if (!options.cc_only && !noAssemble && !options.c1mode)
+        werror (E_NO_MAIN);
+      return;
+    }
+
+  /* if the main is only a prototype ie. no body then do nothing */
+  if (!IFFUNC_HASBODY(mainf->type))
+    {
+      /* if ! compile only then main function should be present */
+      if (!options.cc_only && !noAssemble)
+        werror (E_NO_MAIN);
+      return;
+    }
+
+  dbuf_tprintf (vBuf, "\t!areacode\n", HOME_NAME);
+  dbuf_printf (vBuf, "__interrupt_vect:\n");
+
+
+  if (!port->genIVT || !(port->genIVT (vBuf, interrupts, maxInterrupts)))
+    {
+      /* There's no such thing as a "generic" interrupt table header. */
+      wassert(0);
     }
 }
 
 char *iComments1 =
 {
     }
 }
 
 char *iComments1 =
 {
-    ";--------------------------------------------------------\n"
-    "; File Created by SDCC : FreeWare ANSI-C Compiler\n"};
+  ";--------------------------------------------------------\n"
+  "; File Created by SDCC : free open source ANSI-C Compiler\n"};
 
 char *iComments2 =
 {
 
 char *iComments2 =
 {
-    ";--------------------------------------------------------\n"};
+  ";--------------------------------------------------------\n"};
 
 
 /*-----------------------------------------------------------------*/
 /* initialComments - puts in some initial comments                 */
 /*-----------------------------------------------------------------*/
 
 
 /*-----------------------------------------------------------------*/
 /* initialComments - puts in some initial comments                 */
 /*-----------------------------------------------------------------*/
-void initialComments (FILE * afile)
+void
+initialComments (FILE * afile)
 {
 {
-    time_t t;
-    time(&t);
-    fprintf (afile, "%s", iComments1);
-    fprintf (afile, "; Version %s %s\n", VersionString,asctime(localtime(&t)));
-    fprintf (afile, "%s", iComments2);
+  time_t t;
+  time (&t);
+  fprintf (afile, "%s", iComments1);
+  fprintf (afile, "; Version " SDCC_VERSION_STR " #%s (%s) (%s)\n",
+           getBuildNumber(), getBuildDate(), getBuildEnvironment());
+  fprintf (afile, "; This file was generated %s", asctime (localtime (&t)));
+  fprintf (afile, "%s", iComments2);
 }
 
 /*-----------------------------------------------------------------*/
 /* printPublics - generates .global for publics                    */
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/
 /* printPublics - generates .global for publics                    */
 /*-----------------------------------------------------------------*/
-void printPublics (FILE * afile)
+void
+printPublics (FILE * afile)
 {
 {
-    symbol *sym;
-    
-    fprintf (afile, "%s", iComments2);
-    fprintf (afile, "; Public variables in this module\n");
-    fprintf (afile, "%s", iComments2);
-    
-    for (sym = setFirstItem (publics); sym;
-        sym = setNextItem (publics))
-       tfprintf(afile, "\t!global\n", sym->rname);
+  symbol *sym;
+
+  fprintf (afile, "%s", iComments2);
+  fprintf (afile, "; Public variables in this module\n");
+  fprintf (afile, "%s", iComments2);
+
+  for (sym = setFirstItem (publics); sym;
+       sym = setNextItem (publics))
+    tfprintf (afile, "\t!global\n", sym->rname);
 }
 
 /*-----------------------------------------------------------------*/
 /* printExterns - generates .global for externs                    */
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/
 /* printExterns - generates .global for externs                    */
 /*-----------------------------------------------------------------*/
-void printExterns (FILE * afile)
+void
+printExterns (FILE * afile)
 {
 {
-    symbol *sym;
-    
-    fprintf (afile, "%s", iComments2);
-    fprintf (afile, "; Externals used\n");
-    fprintf (afile, "%s", iComments2);
-    
-    for (sym = setFirstItem (externs); sym;
-        sym = setNextItem (externs))
-       tfprintf(afile, "\t!global\n", sym->rname);
+  symbol *sym;
+
+  fprintf (afile, "%s", iComments2);
+  fprintf (afile, "; Externals used\n");
+  fprintf (afile, "%s", iComments2);
+
+  for (sym = setFirstItem (externs); sym;
+       sym = setNextItem (externs))
+    tfprintf (afile, "\t!extern\n", sym->rname);
 }
 
 /*-----------------------------------------------------------------*/
 /* emitOverlay - will emit code for the overlay stuff              */
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/
 /* emitOverlay - will emit code for the overlay stuff              */
 /*-----------------------------------------------------------------*/
-static void emitOverlay(FILE *afile)
+static void
+emitOverlay (struct dbuf_s * aBuf)
 {
 {
-    set *ovrset;
-    
-    if (!elementsInSet(ovrSetSets))
-       tfprintf(afile,"\t!area\n", port->mem.overlay_name);
-
-    /* for each of the sets in the overlay segment do */
-    for (ovrset = setFirstItem(ovrSetSets); ovrset;
-        ovrset = setNextItem(ovrSetSets)) {
-
-       symbol *sym ;
-
-       if (elementsInSet(ovrset)) {
-           /* this dummy area is used to fool the assembler
-              otherwise the assembler will append each of these
-              declarations into one chunk and will not overlay 
-              sad but true */
-           fprintf(afile,"\t.area _DUMMY\n");
-           /* output the area informtion */
-           fprintf(afile,"\t.area\t%s\n", port->mem.overlay_name); /* MOF */
-       }
-       
-       for (sym = setFirstItem(ovrset); sym;
-            sym = setNextItem(ovrset)) {
-
-           /* if extern then add it to the publics tabledo nothing */
-           if (IS_EXTERN (sym->etype))
-               continue;
-           
-           /* if allocation required check is needed
-              then check if the symbol really requires
-              allocation only for local variables */
-           if (!IS_AGGREGATE(sym->type) &&
-               !(sym->_isparm && !IS_REGPARM(sym->etype))
-               && !sym->allocreq && sym->level)
-               continue ;
-           
-           /* if global variable & not static or extern 
-              and addPublics allowed then add it to the public set */
-           if ((sym->_isparm && !IS_REGPARM(sym->etype))
-               && !IS_STATIC (sym->etype))
-               addSetHead (&publics, sym);
-           
-           /* if extern then do nothing or is a function 
-              then do nothing */
-           if (IS_FUNC (sym->type))
-               continue;
-
-           /* print extra debug info if required */
-           if ((options.debug || sym->level == 0) && !options.nodebug) {
-               
-               cdbSymbol(sym,cdbFile,FALSE,FALSE);
-               
-               if (!sym->level) { /* global */
-                   if (IS_STATIC(sym->etype))
-                       fprintf(afile,"F%s$",moduleName); /* scope is file */
-                   else
-                       fprintf(afile,"G$"); /* scope is global */
-               }
-               else
-                   /* symbol is local */
-                   fprintf(afile,"L%s$",
-                           (sym->localof ? sym->localof->name : "-null-"));
-               fprintf(afile,"%s$%d$%d",sym->name,sym->level,sym->block);
-           }
-           
-           /* if is has an absolute address then generate
-              an equate for this no need to allocate space */
-           if (SPEC_ABSA (sym->etype)) {
-               
-               if ((options.debug || sym->level == 0) && !options.nodebug)
-                   fprintf (afile," == 0x%04x\n",SPEC_ADDR (sym->etype));          
-
-               fprintf (afile, "%s\t=\t0x%04x\n",
-                        sym->rname,
-                        SPEC_ADDR (sym->etype));
-           }
-           else {
-               if ((options.debug || sym->level == 0) && !options.nodebug)
-                   fprintf(afile,"==.\n");
-       
-               /* allocate space */
-               tfprintf(afile, "!labeldef\n", sym->rname);
-               tfprintf(afile, "\t!ds\n", (unsigned int)getSize (sym->type) & 0xffff);
-           }
-           
-       }
+  set *ovrset;
+
+  if (!elementsInSet (ovrSetSets))
+    dbuf_tprintf (aBuf, "\t!area\n", port->mem.overlay_name);
+
+  /* for each of the sets in the overlay segment do */
+  for (ovrset = setFirstItem (ovrSetSets); ovrset;
+       ovrset = setNextItem (ovrSetSets))
+    {
+
+      symbol *sym;
+
+      if (elementsInSet (ovrset))
+        {
+          /* output the area informtion */
+          dbuf_printf (aBuf, "\t.area\t%s\n", port->mem.overlay_name);     /* MOF */
+        }
+
+      for (sym = setFirstItem (ovrset); sym;
+           sym = setNextItem (ovrset))
+        {
+          /* if extern then it is in the publics table: do nothing */
+          if (IS_EXTERN (sym->etype))
+            continue;
+
+          /* if allocation required check is needed
+             then check if the symbol really requires
+             allocation only for local variables */
+          if (!IS_AGGREGATE (sym->type) &&
+              !(sym->_isparm && !IS_REGPARM (sym->etype))
+              && !sym->allocreq && sym->level)
+            continue;
+
+          /* if global variable & not static or extern
+             and addPublics allowed then add it to the public set */
+          if ((sym->_isparm && !IS_REGPARM (sym->etype))
+              && !IS_STATIC (sym->etype))
+            {
+              addSetHead (&publics, sym);
+            }
+
+          /* if extern then do nothing or is a function
+             then do nothing */
+          if (IS_FUNC (sym->type))
+            continue;
+
+          /* print extra debug info if required */
+          if (options.debug)
+            {
+              if (!sym->level)
+                {               /* global */
+                  if (IS_STATIC (sym->etype))
+                    dbuf_printf (aBuf, "F%s$", moduleName);        /* scope is file */
+                  else
+                    dbuf_printf (aBuf, "G$");      /* scope is global */
+                }
+              else
+                /* symbol is local */
+                dbuf_printf (aBuf, "L%s$",
+                         (sym->localof ? sym->localof->name : "-null-"));
+              dbuf_printf (aBuf, "%s$%d$%d", sym->name, sym->level, sym->block);
+            }
+
+          /* if is has an absolute address then generate
+             an equate for this no need to allocate space */
+          if (SPEC_ABSA (sym->etype))
+            {
+
+              if (options.debug)
+                dbuf_printf (aBuf, " == 0x%04x\n", SPEC_ADDR (sym->etype));
+
+              dbuf_printf (aBuf, "%s\t=\t0x%04x\n",
+                       sym->rname,
+                       SPEC_ADDR (sym->etype));
+            }
+          else
+            {
+              int size = getSize(sym->type);
+
+              if (size==0) {
+                  werrorfl (sym->fileDef, sym->lineDef, E_UNKNOWN_SIZE);
+              }
+              if (options.debug)
+                  dbuf_printf (aBuf, "==.\n");
+
+              /* allocate space */
+              dbuf_tprintf (aBuf, "!labeldef\n", sym->rname);
+              dbuf_tprintf (aBuf, "\t!ds\n", (unsigned int) getSize (sym->type) & 0xffff);
+          }
+
+        }
     }
 }
 
 /*-----------------------------------------------------------------*/
 /* glue - the final glue that hold the whole thing together        */
 /*-----------------------------------------------------------------*/
     }
 }
 
 /*-----------------------------------------------------------------*/
 /* glue - the final glue that hold the whole thing together        */
 /*-----------------------------------------------------------------*/
-void glue ()
+void
+glue (void)
 {
 {
-    FILE *vFile;
-    FILE *asmFile;
-    FILE *ovrFile = tempfile();
-    
-    addSetHead(&tmpfileSet,ovrFile);
-    /* print the global struct definitions */
-    if (options.debug)
-       cdbStructBlock (0,cdbFile);
-
-    vFile = tempfile();
-    /* PENDING: this isnt the best place but it will do */
-    if (port->general.glue_up_main) {
-       /* create the interrupt vector table */
-       createInterruptVect (vFile);
-    }
-
-    addSetHead(&tmpfileSet,vFile);
-    
-    /* emit code for the all the variables declared */
-    emitMaps ();
-    /* do the overlay segments */
-    emitOverlay(ovrFile);
-
-    /* now put it all together into the assembler file */
-    /* create the assembler file name */
-    
-    if (!options.c1mode) {
-       sprintf (buffer, srcFileName);
-       strcat (buffer, ".asm");
+  struct dbuf_s vBuf;
+  struct dbuf_s ovrBuf;
+  FILE *asmFile;
+  int mcs51_like;
+
+  dbuf_init (&vBuf, 4096);
+  dbuf_init (&ovrBuf, 4096);
+
+  mcs51_like = (port->general.glue_up_main &&
+    (TARGET_IS_MCS51 || TARGET_IS_DS390 || TARGET_IS_XA51 || TARGET_IS_DS400));
+
+  /* print the global struct definitions */
+  if (options.debug)
+    cdbStructBlock (0);
+
+  /* PENDING: this isn't the best place but it will do */
+  if (port->general.glue_up_main)
+    {
+      /* create the interrupt vector table */
+      createInterruptVect (&vBuf);
     }
     }
-    else {
-       strcpy(buffer, options.out_name);
+
+  /* emit code for the all the variables declared */
+  emitMaps ();
+  /* do the overlay segments */
+  emitOverlay (&ovrBuf);
+
+  outputDebugSymbols ();
+
+  /* now put it all together into the assembler file */
+  /* create the assembler file name */
+
+  /* -o option overrides default name? */
+  if ((noAssemble || options.c1mode) && fullDstFileName)
+    {
+      strncpyz (scratchFileName, fullDstFileName, PATH_MAX);
+    }
+  else
+    {
+      strncpyz (scratchFileName, dstFileName, PATH_MAX);
+      strncatz (scratchFileName, port->assembler.file_ext, PATH_MAX);
     }
 
     }
 
-    if (!(asmFile = fopen (buffer, "w"))) {
-       werror (E_FILE_OPEN_ERR, buffer);
-       exit (1);
+  if (!(asmFile = fopen (scratchFileName, "w")))
+    {
+      werror (E_FILE_OPEN_ERR, scratchFileName);
+      exit (EXIT_FAILURE);
     }
     }
-    
-    /* initial comments */
-    initialComments (asmFile);
-    
-    /* print module name */
-    tfprintf(asmFile, "\t!module\n", moduleName);
-    tfprintf(asmFile, "\t!fileprelude\n");
 
 
-    /* Let the port generate any global directives, etc. */
-    if (port->genAssemblerPreamble)
+  /* initial comments */
+  initialComments (asmFile);
+
+  /* print module name */
+  tfprintf (asmFile, "\t!module\n", moduleName);
+  if (mcs51_like)
     {
     {
-       port->genAssemblerPreamble(asmFile);
-    }
-    
-    /* print the global variables in this module */
-    printPublics (asmFile);
-    if (port->assembler.externGlobal)
-       printExterns (asmFile);
-
-    /* copy the sfr segment */
-    fprintf (asmFile, "%s", iComments2);
-    fprintf (asmFile, "; special function registers\n");
-    fprintf (asmFile, "%s", iComments2);
-    copyFile (asmFile, sfr->oFile);
-    
-    /* copy the sbit segment */
-    fprintf (asmFile, "%s", iComments2);
-    fprintf (asmFile, "; special function bits \n");
-    fprintf (asmFile, "%s", iComments2);
-    copyFile (asmFile, sfrbit->oFile);
-    
-    /* copy the data segment */
-    fprintf (asmFile, "%s", iComments2);
-    fprintf (asmFile, "; internal ram data\n");
-    fprintf (asmFile, "%s", iComments2);
-    copyFile (asmFile, data->oFile);
-
-
-    /* create the overlay segments */
-    fprintf (asmFile, "%s", iComments2);
-    fprintf (asmFile, "; overlayable items in internal ram \n");
-    fprintf (asmFile, "%s", iComments2);    
-    copyFile (asmFile, ovrFile);
-
-    /* create the stack segment MOF */
-    if (mainf && mainf->fbody) {
-       fprintf (asmFile, "%s", iComments2);
-       fprintf (asmFile, "; Stack segment in internal ram \n");
-       fprintf (asmFile, "%s", iComments2);
-       fprintf (asmFile, "\t.area\tSSEG\t(DATA)\n"
-                "__start__stack:\n\t.ds\t1\n\n");
-    }
-
-    /* create the idata segment */
-    fprintf (asmFile, "%s", iComments2);
-    fprintf (asmFile, "; indirectly addressable internal ram data\n");
-    fprintf (asmFile, "%s", iComments2);
-    copyFile (asmFile, idata->oFile);
-    
-    /* copy the bit segment */
-    fprintf (asmFile, "%s", iComments2);
-    fprintf (asmFile, "; bit data\n");
-    fprintf (asmFile, "%s", iComments2);
-    copyFile (asmFile, bit->oFile);
-
-    /* if external stack then reserve space of it */
-    if (mainf && mainf->fbody && options.useXstack ) {
-       fprintf (asmFile, "%s", iComments2);
-       fprintf (asmFile, "; external stack \n");
-       fprintf (asmFile, "%s", iComments2);
-       fprintf (asmFile,"\t.area XSEG (XDATA)\n"); /* MOF */
-       fprintf (asmFile,"\t.ds 256\n");
-    }
-       
-       
-    /* copy xtern ram data */
-    fprintf (asmFile, "%s", iComments2);
-    fprintf (asmFile, "; external ram data\n");
-    fprintf (asmFile, "%s", iComments2);
-    copyFile (asmFile, xdata->oFile);
-    
-    /* copy the interrupt vector table */
-    if (mainf && mainf->fbody) {
-       fprintf (asmFile, "%s", iComments2);
-       fprintf (asmFile, "; interrupt vector \n");
-       fprintf (asmFile, "%s", iComments2);
-       copyFile (asmFile, vFile);
-    }
-    
-    /* copy global & static initialisations */
-    fprintf (asmFile, "%s", iComments2);
-    fprintf (asmFile, "; global & static initialisations\n");
-    fprintf (asmFile, "%s", iComments2);
-    
-    /* Everywhere we generate a reference to the static_name area, 
-     * (which is currently only here), we immediately follow it with a 
-     * definition of the post_static_name area. This guarantees that
-     * the post_static_name area will immediately follow the static_name
-     * area.
-     */
-    tfprintf(asmFile, "\t!area\n", port->mem.static_name); /* MOF */
-    tfprintf(asmFile, "\t!area\n", port->mem.post_static_name);
-    tfprintf(asmFile, "\t!area\n", port->mem.static_name);
-    
-    if (mainf && mainf->fbody) {
-       fprintf (asmFile,"__sdcc_gsinit_startup:\n");
-       /* if external stack is specified then the
-          higher order byte of the xdatalocation is
-          going into P2 and the lower order going into
-          spx */
-       if (options.useXstack) {
-           fprintf(asmFile,"\tmov\tP2,#0x%02x\n",
-                   (((unsigned int)options.xdata_loc) >> 8) & 0xff);
-           fprintf(asmFile,"\tmov\t_spx,#0x%02x\n",
-                   (unsigned int)options.xdata_loc & 0xff);
-       }
-
-       /* initialise the stack pointer */
-       /* if the user specified a value then use it */
-       if (options.stack_loc) 
-           fprintf(asmFile,"\tmov\tsp,#%d\n",options.stack_loc);
-       else 
-           /* no: we have to compute it */
-           if (!options.stackOnData && maxRegBank <= 3)
-               fprintf(asmFile,"\tmov\tsp,#%d\n",((maxRegBank + 1) * 8) -1); 
-           else
-               fprintf(asmFile,"\tmov\tsp,#__start__stack\n"); /* MOF */
-
-       fprintf (asmFile,"\tlcall\t__sdcc_external_startup\n");
-       fprintf (asmFile,"\tmov\ta,dpl\n");
-       fprintf (asmFile,"\tjz\t__sdcc_init_data\n");
-       fprintf (asmFile,"\tljmp\t__sdcc_program_startup\n");
-       fprintf (asmFile,"__sdcc_init_data:\n");
-       
-    }
-    copyFile (asmFile, statsg->oFile);
-
-    if (port->general.glue_up_main && mainf && mainf->fbody)
+      fprintf (asmFile, "\t.optsdcc -m%s", port->target);
+
+      switch(options.model)
+        {
+        case MODEL_SMALL:   fprintf (asmFile, " --model-small");   break;
+        case MODEL_COMPACT: fprintf (asmFile, " --model-compact"); break;
+        case MODEL_MEDIUM:  fprintf (asmFile, " --model-medium");  break;
+        case MODEL_LARGE:   fprintf (asmFile, " --model-large");   break;
+        case MODEL_FLAT24:  fprintf (asmFile, " --model-flat24");  break;
+        case MODEL_PAGE0:   fprintf (asmFile, " --model-page0");   break;
+        default: break;
+        }
+      /*if(options.stackAuto)      fprintf (asmFile, " --stack-auto");*/
+      if(options.useXstack)      fprintf (asmFile, " --xstack");
+      /*if(options.intlong_rent)   fprintf (asmFile, " --int-long-rent");*/
+      /*if(options.float_rent)     fprintf (asmFile, " --float-rent");*/
+      if(options.noRegParams)    fprintf (asmFile, " --no-reg-params");
+      if(options.parms_in_bank1) fprintf (asmFile, " --parms-in-bank1");
+      fprintf (asmFile, "\n");
+    }
+  else if (TARGET_Z80_LIKE || TARGET_IS_HC08)
     {
     {
-        /* This code is generated in the post-static area.
-         * This area is guaranteed to follow the static area
-         * by the ugly shucking and jiving about 20 lines ago.
-         */
-       tfprintf(asmFile, "\t!area\n", port->mem.post_static_name);
-       fprintf (asmFile,"\tljmp\t__sdcc_program_startup\n");
-    }
-
-    fprintf (asmFile,
-            "%s"
-            "; Home\n"
-            "%s", iComments2, iComments2);
-    tfprintf(asmFile, "\t!areahome\n", HOME_NAME);
-    copyFile (asmFile, home->oFile);
-
-    /* copy over code */
-    fprintf (asmFile, "%s", iComments2);
-    fprintf (asmFile, "; code\n");
-    fprintf (asmFile, "%s", iComments2);
-    tfprintf(asmFile, "\t!areacode\n", CODE_NAME);
-    if (mainf && mainf->fbody) {
-       
-       /* entry point @ start of CSEG */
-       fprintf (asmFile,"__sdcc_program_startup:\n");
-       
-       /* put in the call to main */
-       fprintf(asmFile,"\tlcall\t_main\n");
-       if (options.mainreturn) {
-
-           fprintf(asmFile,";\treturn from main ; will return to caller\n");
-           fprintf(asmFile,"\tret\n");
-
-       } else {
-                  
-           fprintf(asmFile,";\treturn from main will lock up\n");
-           fprintf(asmFile,"\tsjmp     .\n");
-       }
-    }
-    copyFile (asmFile, code->oFile);
-    
-    fclose (asmFile);
-    applyToSet(tmpfileSet,closeTmpFiles);
-    applyToSet(tmpfileNameSet, rmTmpFiles);
-}
+      fprintf (asmFile, "\t.optsdcc -m%s\n", port->target);
+    }
 
 
-/** Creates a temporary file a'la tmpfile which avoids the bugs
-    in cygwin wrt c:\tmp.
-    Scans, in order: TMP, TEMP, TMPDIR, else uses tmpfile().
-*/
-FILE *tempfile(void)
-{
-    const char *tmpdir = NULL;
-    if (getenv("TMP"))
-       tmpdir = getenv("TMP");
-    else if (getenv("TEMP"))
-       tmpdir = getenv("TEMP");
-    else if (getenv("TMPDIR"))
-       tmpdir = getenv("TMPDIR");
-    if (tmpdir) {
-       char *name = tempnam(tmpdir, "sdcc");
-       if (name) {
-           FILE *fp = fopen(name, "w+b");
-           if (fp)
-               addSetHead(&tmpfileNameSet, name);
-           return fp;
-       }
-       return NULL;
-    }
-    return tmpfile();
-}
+  tfprintf (asmFile, "\t!fileprelude\n");
 
 
-char *gc_strdup(const char *s)
-{
-    char *ret;
-    ALLOC_ATOMIC(ret, strlen(s)+1);
-    strcpy(ret, s);
-    return ret;
+  /* Let the port generate any global directives, etc. */
+  if (port->genAssemblerPreamble)
+    {
+      port->genAssemblerPreamble (asmFile);
+    }
+
+  /* print the global variables in this module */
+  printPublics (asmFile);
+  if (port->assembler.externGlobal)
+    printExterns (asmFile);
+
+  if (( mcs51_like )
+     ||( TARGET_IS_Z80 )) /*.p.t.20030924 need to output SFR table for Z80 as well */
+    {
+      /* copy the sfr segment */
+      fprintf (asmFile, "%s", iComments2);
+      fprintf (asmFile, "; special function registers\n");
+      fprintf (asmFile, "%s", iComments2);
+      dbuf_write_and_destroy (&sfr->oBuf, asmFile);
+    }
+
+  if (mcs51_like)
+    {
+      /* copy the sbit segment */
+      fprintf (asmFile, "%s", iComments2);
+      fprintf (asmFile, "; special function bits\n");
+      fprintf (asmFile, "%s", iComments2);
+      dbuf_write_and_destroy (&sfrbit->oBuf, asmFile);
+
+      /*JCF: Create the areas for the register banks*/
+      if (RegBankUsed[0] || RegBankUsed[1] || RegBankUsed[2] || RegBankUsed[3])
+        {
+          fprintf (asmFile, "%s", iComments2);
+          fprintf (asmFile, "; overlayable register banks\n");
+          fprintf (asmFile, "%s", iComments2);
+          if (RegBankUsed[0])
+            fprintf (asmFile, "\t.area REG_BANK_0\t(REL,OVR,DATA)\n\t.ds 8\n");
+          if (RegBankUsed[1] || options.parms_in_bank1)
+            fprintf (asmFile, "\t.area REG_BANK_1\t(REL,OVR,DATA)\n\t.ds 8\n");
+          if (RegBankUsed[2])
+            fprintf (asmFile, "\t.area REG_BANK_2\t(REL,OVR,DATA)\n\t.ds 8\n");
+          if (RegBankUsed[3])
+            fprintf (asmFile, "\t.area REG_BANK_3\t(REL,OVR,DATA)\n\t.ds 8\n");
+        }
+      if (BitBankUsed)
+        {
+          fprintf (asmFile, "%s", iComments2);
+          fprintf (asmFile, "; overlayable bit register bank\n");
+          fprintf (asmFile, "%s", iComments2);
+          fprintf (asmFile, "\t.area BIT_BANK\t(REL,OVR,DATA)\n");
+          fprintf (asmFile, "bits:\n\t.ds 1\n");
+          fprintf (asmFile, "\tb0 = bits[0]\n");
+          fprintf (asmFile, "\tb1 = bits[1]\n");
+          fprintf (asmFile, "\tb2 = bits[2]\n");
+          fprintf (asmFile, "\tb3 = bits[3]\n");
+          fprintf (asmFile, "\tb4 = bits[4]\n");
+          fprintf (asmFile, "\tb5 = bits[5]\n");
+          fprintf (asmFile, "\tb6 = bits[6]\n");
+          fprintf (asmFile, "\tb7 = bits[7]\n");
+        }
+    }
+
+  /* copy the data segment */
+  fprintf (asmFile, "%s", iComments2);
+  fprintf (asmFile, "; %s ram data\n", mcs51_like?"internal":"");
+  fprintf (asmFile, "%s", iComments2);
+  dbuf_write_and_destroy (&data->oBuf, asmFile);
+
+
+  /* create the overlay segments */
+  if (overlay)
+    {
+      fprintf (asmFile, "%s", iComments2);
+      fprintf (asmFile, "; overlayable items in %s ram \n", mcs51_like?"internal":"");
+      fprintf (asmFile, "%s", iComments2);
+      dbuf_write_and_destroy (&ovrBuf, asmFile);
+    }
+
+  /* create the stack segment MOF */
+  if (mainf && IFFUNC_HASBODY (mainf->type))
+    {
+      fprintf (asmFile, "%s", iComments2);
+      fprintf (asmFile, "; Stack segment in internal ram \n");
+      fprintf (asmFile, "%s", iComments2);
+      fprintf (asmFile, "\t.area\tSSEG\t(DATA)\n"
+               "__start__stack:\n\t.ds\t1\n\n");
+    }
+
+  /* create the idata segment */
+  if ((idata) && (mcs51_like))
+    {
+      fprintf (asmFile, "%s", iComments2);
+      fprintf (asmFile, "; indirectly addressable internal ram data\n");
+      fprintf (asmFile, "%s", iComments2);
+      dbuf_write_and_destroy (&idata->oBuf, asmFile);
+    }
+
+  /* create the absolute idata/data segment */
+  if ((i_abs) && (mcs51_like))
+    {
+      fprintf (asmFile, "%s", iComments2);
+      fprintf (asmFile, "; absolute internal ram data\n");
+      fprintf (asmFile, "%s", iComments2);
+      dbuf_write_and_destroy (&d_abs->oBuf, asmFile);
+      dbuf_write_and_destroy (&i_abs->oBuf, asmFile);
+    }
+
+  /* copy the bit segment */
+  if (mcs51_like)
+    {
+      fprintf (asmFile, "%s", iComments2);
+      fprintf (asmFile, "; bit data\n");
+      fprintf (asmFile, "%s", iComments2);
+      dbuf_write_and_destroy (&bit->oBuf, asmFile);
+    }
+
+  /* copy paged external ram data */
+  if (mcs51_like)
+    {
+      fprintf (asmFile, "%s", iComments2);
+      fprintf (asmFile, "; paged external ram data\n");
+      fprintf (asmFile, "%s", iComments2);
+      dbuf_write_and_destroy (&pdata->oBuf, asmFile);
+    }
+
+  /* if external stack then reserve space for it */
+  if (mainf && IFFUNC_HASBODY (mainf->type) && options.useXstack)
+    {
+      fprintf (asmFile, "%s", iComments2);
+      fprintf (asmFile, "; external stack \n");
+      fprintf (asmFile, "%s", iComments2);
+      fprintf (asmFile, "\t.area XSTK (PAG,XDATA)\n"
+               "__start__xstack:\n\t.ds\t1\n\n");
+    }
+
+  /* copy external ram data */
+  if (mcs51_like)
+    {
+      fprintf (asmFile, "%s", iComments2);
+      fprintf (asmFile, "; external ram data\n");
+      fprintf (asmFile, "%s", iComments2);
+      dbuf_write_and_destroy (&xdata->oBuf, asmFile);
+    }
+
+  /* create the absolute xdata segment */
+  if (mcs51_like || TARGET_IS_HC08)
+    {
+      fprintf (asmFile, "%s", iComments2);
+      fprintf (asmFile, "; absolute external ram data\n");
+      fprintf (asmFile, "%s", iComments2);
+      dbuf_write_and_destroy (&x_abs->oBuf, asmFile);
+    }
+
+  /* copy external initialized ram data */
+  fprintf (asmFile, "%s", iComments2);
+  fprintf (asmFile, "; external initialized ram data\n");
+  fprintf (asmFile, "%s", iComments2);
+  dbuf_write_and_destroy (&xidata->oBuf, asmFile);
+
+  /* If the port wants to generate any extra areas, let it do so. */
+  if (port->extraAreas.genExtraAreaDeclaration)
+    {
+      port->extraAreas.genExtraAreaDeclaration(asmFile,
+                                               mainf && IFFUNC_HASBODY(mainf->type));
+    }
+
+  /* copy the interrupt vector table */
+  if (mainf && IFFUNC_HASBODY (mainf->type))
+    {
+      fprintf (asmFile, "%s", iComments2);
+      fprintf (asmFile, "; interrupt vector \n");
+      fprintf (asmFile, "%s", iComments2);
+      dbuf_write_and_destroy (&vBuf, asmFile);
+    }
+
+  /* copy global & static initialisations */
+  fprintf (asmFile, "%s", iComments2);
+  fprintf (asmFile, "; global & static initialisations\n");
+  fprintf (asmFile, "%s", iComments2);
+
+  /* Everywhere we generate a reference to the static_name area,
+   * (which is currently only here), we immediately follow it with a
+   * definition of the post_static_name area. This guarantees that
+   * the post_static_name area will immediately follow the static_name
+   * area.
+   */
+  tfprintf (asmFile, "\t!area\n", port->mem.home_name);
+  tfprintf (asmFile, "\t!area\n", port->mem.static_name);       /* MOF */
+  tfprintf (asmFile, "\t!area\n", port->mem.post_static_name);
+  tfprintf (asmFile, "\t!area\n", port->mem.static_name);
+
+  if (mainf && IFFUNC_HASBODY (mainf->type))
+    {
+      if (port->genInitStartup)
+        {
+           port->genInitStartup (asmFile);
+        }
+      else
+        {
+          assert (mcs51_like);
+          fprintf (asmFile, "__sdcc_gsinit_startup:\n");
+          /* if external stack is specified then the
+             higher order byte of the xdatalocation is
+             going into P2 and the lower order going into
+             spx */
+          if (options.useXstack)
+            {
+              fprintf (asmFile, "\tmov\tP2,#0x%02x\n",
+                       (((unsigned int) options.xdata_loc) >> 8) & 0xff);
+              fprintf (asmFile, "\tmov\t_spx,#0x%02x\n",
+                       (unsigned int) options.xdata_loc & 0xff);
+            }
+
+          // This should probably be a port option, but I'm being lazy.
+          // on the 400, the firmware boot loader gives us a valid stack
+          // (see '400 data sheet pg. 85 (TINI400 ROM Initialization code)
+          if (!TARGET_IS_DS400)
+            {
+              /* initialise the stack pointer.  JCF: aslink takes care of the location */
+              fprintf (asmFile, "\tmov\tsp,#__start__stack - 1\n");     /* MOF */
+            }
+
+          fprintf (asmFile, "\t%ccall\t__sdcc_external_startup\n", options.acall_ajmp?'a':'l');
+          fprintf (asmFile, "\tmov\ta,dpl\n");
+          fprintf (asmFile, "\tjz\t__sdcc_init_data\n");
+          fprintf (asmFile, "\t%cjmp\t__sdcc_program_startup\n", options.acall_ajmp?'a':'l');
+          fprintf (asmFile, "__sdcc_init_data:\n");
+
+          // if the port can copy the XINIT segment to XISEG
+          if (port->genXINIT)
+            {
+              port->genXINIT (asmFile);
+            }
+        }
+    }
+  dbuf_write_and_destroy (&statsg->oBuf, asmFile);
+
+  if (port->general.glue_up_main && mainf && IFFUNC_HASBODY (mainf->type))
+    {
+      /* This code is generated in the post-static area.
+       * This area is guaranteed to follow the static area
+       * by the ugly shucking and jiving about 20 lines ago.
+       */
+      tfprintf (asmFile, "\t!area\n", port->mem.post_static_name);
+      fprintf (asmFile, "\t%cjmp\t__sdcc_program_startup\n", options.acall_ajmp?'a':'l');
+    }
+
+  fprintf (asmFile,
+           "%s"
+           "; Home\n"
+           "%s", iComments2, iComments2);
+  tfprintf (asmFile, "\t!areahome\n", HOME_NAME);
+  dbuf_write_and_destroy (&home->oBuf, asmFile);
+
+  if (mainf && IFFUNC_HASBODY (mainf->type))
+    {
+      /* entry point @ start of HOME */
+      fprintf (asmFile, "__sdcc_program_startup:\n");
+
+      /* put in jump or call to main */
+      if (options.mainreturn)
+        {
+          fprintf (asmFile, "\t%cjmp\t_main\n", options.acall_ajmp?'a':'l');   /* needed? */
+          fprintf (asmFile, ";\treturn from main will return to caller\n");
+        }
+      else
+        {
+          fprintf (asmFile, "\t%ccall\t_main\n", options.acall_ajmp?'a':'l');
+          fprintf (asmFile, ";\treturn from main will lock up\n");
+          fprintf (asmFile, "\tsjmp .\n");
+        }
+    }
+  /* copy over code */
+  fprintf (asmFile, "%s", iComments2);
+  fprintf (asmFile, "; code\n");
+  fprintf (asmFile, "%s", iComments2);
+  tfprintf (asmFile, "\t!areacode\n", options.code_seg);
+  dbuf_write_and_destroy (&code->oBuf, asmFile);
+
+  if (port->genAssemblerEnd)
+    {
+      port->genAssemblerEnd (asmFile);
+    }
+  fclose (asmFile);
 }
 }