X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fds390%2Fgen.c;h=c412390a5978e259ab811682b5918e080b9546ec;hb=7e96e3019db9e62aefa193c1aeacd1a7d8a2e65f;hp=6a073a73168dcad7631415bd5d2df548a239fd1c;hpb=2a6a00a8ffd9e23e9808890f109182aa2c0f1d5b;p=fw%2Fsdcc

diff --git a/src/ds390/gen.c b/src/ds390/gen.c
index 6a073a73..c412390a 100644
--- a/src/ds390/gen.c
+++ b/src/ds390/gen.c
@@ -30,40 +30,24 @@
 #include <string.h>
 #include <ctype.h>
 
-#include <common.h>
+#include "common.h"
 #include "ralloc.h"
 #include "gen.h"
 #include "SDCCglobl.h"
 #include "newalloc.h"
 
-#ifdef HAVE_SYS_ISA_DEFS_H
-#include <sys/isa_defs.h>
-#else
-#ifdef HAVE_MACHINE_ENDIAN_H
-#include <machine/endian.h>
-#else
-#ifdef HAVE_ENDIAN_H
-#include <endian.h>
-#else
-#if !defined(__BORLANDC__) && !defined(_MSC_VER) && !defined(__MINGW32__) && !defined(__CYGWIN__)
-#warning "Cannot determine ENDIANESS of this machine assuming LITTLE_ENDIAN"
-#warning "If you running sdcc on an INTEL 80x86 Platform you are okay"
-#endif
-#endif
-#endif
-#endif
-
 #define BETTER_LITERAL_SHIFT
 
 char *aopLiteral (value * val, int offset);
+extern int allocInfo;
 
 /* this is the down and dirty file with all kinds of
    kludgy & hacky stuff. This is what it is all about
    CODE GENERATION for a specific MCU . some of the
    routines may be reusable, will have to see */
 
-static char *zero = "#0x00";
-static char *one = "#0x01";
+static char *zero = "#0";
+static char *one = "#1";
 static char *spname;
 
 #define D(x) x
@@ -79,7 +63,8 @@ static char *fReturn16[] =
 static char **fReturn = fReturn24;
 static char *accUse[] =
 {"a", "b"};
-
+static char *dptrn[2][3];
+static char *javaRet[] = { "r0","r1","r2","r3"};
 static short rbank = -1;
 
 static struct
@@ -91,30 +76,31 @@ static struct
     short inLine;
     short debugLine;
     short nRegsSaved;
+    short dptrInUse;
+    short dptr1InUse;
     set *sendSet;
   }
 _G;
 
+static char *rb1regs[] = {
+    "b1_0","b1_1","b1_2","b1_3","b1_4","b1_5","b1_6","b1_7"
+};
+
 static void saveRBank (int, iCode *, bool);
 
 #define RESULTONSTACK(x) \
                          (IC_RESULT(x) && IC_RESULT(x)->aop && \
                          IC_RESULT(x)->aop->type == AOP_STK )
 
-/* #define MOVA(x) if (strcmp(x,"a") && strcmp(x,"acc")) emitcode("mov","a,%s",x); */
-#define MOVA(x) { char *_mova_tmp = strdup(x); \
-                 if (strcmp(_mova_tmp,"a") && strcmp(_mova_tmp,"acc")) \
-                 { \
-                    emitcode("mov","a,%s",_mova_tmp); \
-                 } \
-                 free(_mova_tmp); \
-                }
+#define MOVA(x) _movA(x)
+#define MOVB(x) _movB(x)
+                
 #define CLRC    emitcode("clr","c")
 #define SETC    emitcode("setb","c")
 
 // A scratch register which will be used to hold
 // result bytes from operands in far space via DPTR2.
-#define DP2_RESULT_REG	"ap"
+#define DP2_RESULT_REG	"_ap"
 
 static lineNode *lineHead = NULL;
 static lineNode *lineCurr = NULL;
@@ -130,6 +116,20 @@ static unsigned char SRMask[] =
 #define MSB16   1
 #define MSB24   2
 #define MSB32   3
+#define PROTECT_SP 	{if (options.protect_sp_update) { 			\
+				symbol *lbl = newiTempLabel(NULL);		\
+				emitcode ("setb","F1");				\
+				emitcode ("jbc","EA,!tlabel",lbl->key+100);	\
+				emitcode ("clr","F1"); 				\
+				emitcode ("","!tlabeldef",lbl->key+100);	\
+    			}}
+#define UNPROTECT_SP 	{ if (options.protect_sp_update) { 			\
+    				symbol *lbl = newiTempLabel(NULL);		\
+				emitcode ("jnb","F1,!tlabel",lbl->key+100);	\
+    				emitcode ("setb","EA");				\
+				emitcode ("","!tlabeldef",lbl->key+100);	\
+    			}}
+
 
 /*-----------------------------------------------------------------*/
 /* emitcode - writes the code into a file : for now it is simple    */
@@ -137,33 +137,71 @@ static unsigned char SRMask[] =
 static void
 emitcode (char *inst, char *fmt,...)
 {
-  va_list ap;
-  char lb[INITIAL_INLINEASM];
-  char *lbp = lb;
+    va_list ap;
+    char lb[INITIAL_INLINEASM];
+    char *lbp = lb;
+    
+    va_start (ap, fmt);
+    
+    if (inst && *inst)
+    {
+	if (fmt && *fmt)
+	{
+	    SNPRINTF (lb, sizeof(lb), "%s\t", inst);
+	}
+	else
+	{
+	    SNPRINTF (lb, sizeof(lb), "%s", inst);
+	}
+	
+	tvsprintf (lb + strlen(lb), sizeof(lb) - strlen(lb), 
+		   fmt, ap);
+    }
+    else
+    {
+	tvsprintf (lb, sizeof(lb), fmt, ap);
+    }
+    
 
-  va_start (ap, fmt);
+    while (isspace (*lbp))
+    {
+	lbp++;
+    }
 
-  if (inst && *inst)
+    if (lbp && *lbp)
     {
-      if (fmt && *fmt)
-	sprintf (lb, "%s\t", inst);
-      else
-	sprintf (lb, "%s", inst);
-      tvsprintf (lb + (strlen (lb)), fmt, ap);
+	lineCurr = (lineCurr ?
+		    connectLine (lineCurr, newLineNode (lb)) :
+		    (lineHead = newLineNode (lb)));
     }
-  else
-    tvsprintf (lb, fmt, ap);
+    
+    lineCurr->isInline = _G.inLine;
+    lineCurr->isDebug = _G.debugLine;
+    va_end (ap);
+}
 
-  while (isspace (*lbp))
-    lbp++;
+//
+// Move the passed value into A unless it is already there.
+// 
+static void
+_movA(const char *s)
+{
+    if (strcmp(s,"a") && strcmp(s,"acc"))
+    { 
+	emitcode("mov","a,%s",s);
+    } 
+}
 
-  if (lbp && *lbp)
-    lineCurr = (lineCurr ?
-		connectLine (lineCurr, newLineNode (lb)) :
-		(lineHead = newLineNode (lb)));
-  lineCurr->isInline = _G.inLine;
-  lineCurr->isDebug = _G.debugLine;
-  va_end (ap);
+//
+// Move the passed value into B unless it is already there.
+// 
+static void
+_movB(const char *s)
+{
+    if (strcmp(s,"b"))
+    { 
+	emitcode("mov","b,%s",s);
+    } 
 }
 
 /*-----------------------------------------------------------------*/
@@ -172,8 +210,8 @@ emitcode (char *inst, char *fmt,...)
 static regs *
 getFreePtr (iCode * ic, asmop ** aopp, bool result)
 {
-  bool r0iu = FALSE, r1iu = FALSE;
-  bool r0ou = FALSE, r1ou = FALSE;
+  bool r0iu, r1iu;
+  bool r0ou, r1ou;
 
   /* the logic: if r0 & r1 used in the instruction
      then we are in trouble otherwise */
@@ -255,6 +293,8 @@ endOfWorld:
   werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
 	  "getFreePtr should never reach here");
   exit (1);
+    
+  return NULL; // notreached, but makes compiler happy.
 }
 
 /*-----------------------------------------------------------------*/
@@ -294,12 +334,12 @@ genSetDPTR (int n)
 
   if (!n)
     {
-      emitcode ("mov", "dps, #0x00");
+      emitcode ("mov", "dps,#0");
     }
   else
     {
       TR_DPTR("#1");
-      emitcode ("mov", "dps, #0x01");
+      emitcode ("mov", "dps,#1");
     }
 }
 
@@ -460,49 +500,88 @@ aopForSym (iCode * ic, symbol * sym, bool result, bool useDP2)
 
   if (sym->onStack && options.stack10bit)
     {
+	short stack_val = -((sym->stack < 0) ?
+			    ((short) (sym->stack - _G.nRegsSaved)) :
+			    ((short) sym->stack)) ;
+	if (useDP2 && _G.dptr1InUse) {
+	    emitcode ("push","dpl1");
+	    emitcode ("push","dph1");
+	    emitcode ("push","dpx1");
+	} else if (_G.dptrInUse	) {
+	    emitcode ("push","dpl");
+	    emitcode ("push","dph");
+	    emitcode ("push","dpx");
+	}
       /* It's on the 10 bit stack, which is located in
        * far data space.
-       */
-
-      if (_G.accInUse)
-	emitcode ("push", "acc");
-
-      if (_G.bInUse)
-	emitcode ("push", "b");
-
-      emitcode ("mov", "a,_bpx");
-      emitcode ("clr","c");
-      emitcode ("subb", "a,#!constbyte",
-		-((sym->stack < 0) ?
-		  ((short) (sym->stack - _G.nRegsSaved)) :
-		  ((short) sym->stack)) & 0xff);
-      emitcode ("mov","b,a");
-      emitcode ("mov","a,_bpx+1");
-      emitcode ("subb","a,#!constbyte",(-((sym->stack < 0) ?
-				     ((short) (sym->stack - _G.nRegsSaved)) :
-				     ((short) sym->stack)) >> 8) & 0xff);
-      if (useDP2) {
-	  if (options.model == MODEL_FLAT24)
-	      emitcode ("mov", "dpx1,#!constbyte", (options.stack_loc >> 16) & 0xff);
-	  TR_DPTR("#2");
-	  emitcode ("mov", "dph1,a");
-	  emitcode ("mov", "dpl1,b");
-      } else {
-	  if (options.model == MODEL_FLAT24)
-	      emitcode ("mov", "dpx,#!constbyte", (options.stack_loc >> 16) & 0xff);
-	  emitcode ("mov", "dph,a");
-	  emitcode ("mov", "dpl,b");
-      }
-
-      if (_G.bInUse)
-	emitcode ("pop", "b");
-
-      if (_G.accInUse)
-	emitcode ("pop", "acc");
-
-      sym->aop = aop = newAsmop ((short) (useDP2 ? AOP_DPTR2 : AOP_DPTR));
-      aop->size = getSize (sym->type);
-      return aop;
+       */	    
+	if (stack_val < 0 && stack_val > -5) { /* between -5 & -1 */
+	    if (useDP2) {
+		if (options.model == MODEL_FLAT24)
+		{
+		    emitcode ("mov", "dpx1,#!constbyte",
+			      (options.stack_loc >> 16) & 0xff);
+		}
+		emitcode ("mov", "dph1,_bpx+1");
+		
+		emitcode ("mov", "dpl1,_bpx");
+		emitcode ("mov","dps,#1");
+	    } else {
+		if (options.model == MODEL_FLAT24)
+		{
+		    emitcode ("mov", "dpx,#!constbyte",
+			      (options.stack_loc >> 16) & 0xff);
+		}
+		emitcode ("mov", "dph,_bpx+1");
+		emitcode ("mov", "dpl,_bpx");
+	    }
+	    stack_val = -stack_val;
+	    while (stack_val--) {
+		emitcode ("inc","dptr");
+	    }
+	    if (useDP2) {
+		emitcode("mov","dps,#0");
+	    }
+	}  else {
+	    if (_G.accInUse)
+		emitcode ("push", "acc");
+	    
+	    if (_G.bInUse)
+		emitcode ("push", "b");
+	
+	    emitcode ("mov", "a,_bpx");
+	    emitcode ("clr","c");
+	    emitcode ("subb", "a,#!constbyte", stack_val & 0xff);
+	    emitcode ("mov","b,a");
+	    emitcode ("mov","a,_bpx+1");
+	    emitcode ("subb","a,#!constbyte",(stack_val >> 8) & 0xff);
+	    if (useDP2) {
+		if (options.model == MODEL_FLAT24)
+		{
+		    emitcode ("mov", "dpx1,#!constbyte",
+			      (options.stack_loc >> 16) & 0xff);
+		}
+		emitcode ("mov", "dph1,a");
+		emitcode ("mov", "dpl1,b");
+	    } else {
+		if (options.model == MODEL_FLAT24)
+		{
+		    emitcode ("mov", "dpx,#!constbyte",
+			      (options.stack_loc >> 16) & 0xff);
+		}
+		emitcode ("mov", "dph,a");
+		emitcode ("mov", "dpl,b");
+	    }
+	    
+	    if (_G.bInUse)
+		emitcode ("pop", "b");
+	    
+	    if (_G.accInUse)
+		emitcode ("pop", "acc");
+	}
+	sym->aop = aop = newAsmop ((short) (useDP2 ? AOP_DPTR2 : AOP_DPTR));
+	aop->size = getSize (sym->type);
+	return aop;
     }
 
   /* if in bit space */
@@ -526,12 +605,11 @@ aopForSym (iCode * ic, symbol * sym, bool result, bool useDP2)
   if (IS_FUNC (sym->type))
     {
       sym->aop = aop = newAsmop (AOP_IMMD);
-      aop->aopu.aop_immd.aop_immd1 = Safe_calloc (1, strlen (sym->rname) + 1);
-      strcpy (aop->aopu.aop_immd.aop_immd1, sym->rname);
+      aop->aopu.aop_immd.aop_immd1 = Safe_strdup(sym->rname);	
       aop->size = FPTRSIZE;
       return aop;
     }
-
+  
   /* only remaining is far space */
   /* in which case DPTR gets the address */
   sym->aop = aop = newAsmop ((short) (useDP2 ? AOP_DPTR2 : AOP_DPTR));
@@ -588,25 +666,54 @@ aopForRemat (symbol * sym)
     }
 
   if (val)
-    sprintf (buffer, "(%s %c 0x%04x)",
-	     OP_SYMBOL (IC_LEFT (ic))->rname,
-	     val >= 0 ? '+' : '-',
-	     abs (val) & 0xffff);
-  else
-    strcpy (buffer, OP_SYMBOL (IC_LEFT (ic))->rname);
+  {
+      SNPRINTF (buffer, sizeof(buffer),
+		"(%s %c 0x%04x)",
+		OP_SYMBOL (IC_LEFT (ic))->rname,
+		val >= 0 ? '+' : '-',
+		abs (val) & 0xffffff);
+  }
+  else 
+  {
+      if (IS_ASSIGN_ICODE(ic) && isOperandLiteral(IC_RIGHT(ic)))
+      {
+	  SNPRINTF(buffer, sizeof(buffer), 
+		   "0x%x",(int) operandLitValue (IC_RIGHT (ic)));
+      }
+      else
+      {
+	  strncpyz (buffer, OP_SYMBOL (IC_LEFT (ic))->rname, sizeof(buffer));
+      }
+  }
 
-  aop->aopu.aop_immd.aop_immd1 = Safe_calloc (1, strlen (buffer) + 1);
-  strcpy (aop->aopu.aop_immd.aop_immd1, buffer);
+  aop->aopu.aop_immd.aop_immd1 = Safe_strdup(buffer);  
   /* set immd2 field if required */
-  if (aop->aopu.aop_immd.from_cast_remat) {
-	  tsprintf(buffer,"#!constbyte",ptr_type);
-	  aop->aopu.aop_immd.aop_immd2 = Safe_calloc (1, strlen (buffer) + 1);
-	  strcpy (aop->aopu.aop_immd.aop_immd2, buffer);
+  if (aop->aopu.aop_immd.from_cast_remat) 
+  {
+      tsprintf(buffer, sizeof(buffer), "#!constbyte",ptr_type);
+      aop->aopu.aop_immd.aop_immd2 = Safe_strdup(buffer);
   }
 
   return aop;
 }
 
+/*-----------------------------------------------------------------*/
+/* aopHasRegs - returns true if aop has regs between from-to       */
+/*-----------------------------------------------------------------*/
+static int aopHasRegs(asmop *aop, int from, int to)
+{
+    int size =0;
+
+    if (aop->type != AOP_REG) return 0; /* if not assigned to regs */
+
+    for (; size < aop->size ; size++) {
+	int reg;
+	for (reg = from ; reg <= to ; reg++)
+	    if (aop->aopu.aop_reg[size] == ds390_regWithIdx(reg)) return 1;
+    }
+    return 0;
+}
+
 /*-----------------------------------------------------------------*/
 /* regsInCommon - two operands have some registers in common       */
 /*-----------------------------------------------------------------*/
@@ -816,7 +923,7 @@ aopOp (operand * op, iCode * ic, bool result, bool useDP2)
 	      /* a AOP_STR uses DPTR, but DPTR is already in use;
 	       * we're just hosed.
 	       */
-	      fprintf (stderr, "*** Internal error: AOP_STR with DPTR in use! for operand %s\n",sym->name);
+		werror(E_INTERNAL_ERROR,__FILE__,__LINE__,"AOP_STR with DPTR in use!");
 	    }
 
 	  aop = op->aop = sym->aop = newAsmop (AOP_STR);
@@ -825,7 +932,13 @@ aopOp (operand * op, iCode * ic, bool result, bool useDP2)
 	    aop->aopu.aop_str[i] = fReturn[i];
 	  return;
 	}
-
+      
+      if (sym->dptr) { /* has been allocated to a DPTRn */
+	  aop = op->aop = sym->aop = newAsmop (AOP_DPTRn);
+	  aop->size = getSize (sym->type);
+	  aop->aopu.dptr = sym->dptr;
+	  return ;
+      }
       /* else spill location  */
       if (sym->usl.spillLoc && getSize(sym->type) != getSize(sym->usl.spillLoc->type)) {
 	  /* force a new aop if sizes differ */
@@ -944,8 +1057,21 @@ freeAsmop (operand * op, asmop * aaop, iCode * ic, bool pop)
 	    _G.r1Pushed--;
 	  }
       }
+    case AOP_DPTR2:
+	if (_G.dptr1InUse) {
+	    emitcode ("pop","dpx1");
+	    emitcode ("pop","dph1");
+	    emitcode ("pop","dpl1");
+	}
+	break;
+    case AOP_DPTR:
+	if (_G.dptrInUse) {
+	    emitcode ("pop","dpx");
+	    emitcode ("pop","dph");
+	    emitcode ("pop","dpl");
+	}
+	break;
     }
-
 dealloc:
   /* all other cases just dealloc */
   if (op)
@@ -961,24 +1087,25 @@ dealloc:
     }
 }
 
-/*------------------------------------------------------------------*/
-/* aopGet - for fetching value of the aop                           */
-/*                    */
-/* Set canClobberACC if you are sure it is OK to clobber the value  */
-/* in the accumulator. Set it FALSE otherwise; FALSE is always safe, */
-/* just less efficient.               */
-/*------------------------------------------------------------------*/
+#define DEFAULT_ACC_WARNING 0
+static int saveAccWarn = DEFAULT_ACC_WARNING;
+
+/*-------------------------------------------------------------------*/
+/* aopGet - for fetching value of the aop                            */
+/*                    						     */
+/* Set saveAcc to NULL if you are sure it is OK to clobber the value */
+/* in the accumulator. Set it to the name of a free register         */
+/* if acc must be preserved; the register will be used to preserve   */
+/* acc temporarily and to return the result byte.		     */
+/*-------------------------------------------------------------------*/
 
 static char *
-aopGet (asmop * aop,
-	int offset,
-	bool bit16,
-	bool dname,
-	bool canClobberACC)
+aopGet (asmop *aop,
+	int   offset,
+	bool  bit16,
+	bool  dname,
+	char  *saveAcc)
 {
-  char *s = buffer;
-  char *rs;
-
   /* offset is greater than
      size then zero */
   if (offset > (aop->size - 1) &&
@@ -1010,10 +1137,12 @@ aopGet (asmop * aop,
 	  emitcode ("movx", "a,@%s", aop->aopu.aop_ptr->name);
 	  return (dname ? "acc" : "a");
 	}
-      sprintf (s, "@%s", aop->aopu.aop_ptr->name);
-      rs = Safe_calloc (1, strlen (s) + 1);
-      strcpy (rs, s);
-      return rs;
+      SNPRINTF (buffer, sizeof(buffer), "@%s", aop->aopu.aop_ptr->name);
+      return Safe_strdup(buffer);	
+
+    case AOP_DPTRn:
+	assert(offset <= 3);
+	return dptrn[aop->aopu.dptr][offset];
 
     case AOP_DPTR:
     case AOP_DPTR2:
@@ -1021,11 +1150,18 @@ aopGet (asmop * aop,
       if (aop->type == AOP_DPTR2)
 	{
 	  genSetDPTR (1);
-	  if (!canClobberACC)
-	    {
-		    TR_AP("#1");
-		    emitcode ("xch", "a, %s", DP2_RESULT_REG);
-	    }
+	}
+	
+      if (saveAcc)
+	{
+	    TR_AP("#1");
+//	    if (aop->type != AOP_DPTR2)
+//	    {
+//		if (saveAccWarn) { fprintf(stderr, "saveAcc for DPTR...\n"); }
+//		emitcode(";", "spanky: saveAcc for DPTR");
+//	    }
+	    
+	    emitcode ("xch", "a, %s", saveAcc);
 	}
 
       _flushLazyDPS ();
@@ -1056,54 +1192,76 @@ aopGet (asmop * aop,
       if (aop->type == AOP_DPTR2)
 	{
 	  genSetDPTR (0);
-	  if (!canClobberACC)
-	    {
+	}
+	
+	if (saveAcc)
+	{
        TR_AP("#2");
-	      emitcode ("xch", "a, %s", DP2_RESULT_REG);
-	      return DP2_RESULT_REG;
-	    }
+	      emitcode ("xch", "a, %s", saveAcc);
+//	      if (strcmp(saveAcc, "_ap"))
+//	      {
+//		  emitcode(";", "spiffy: non _ap return from aopGet.");
+//	      }
+		  
+	      return saveAcc;
 	}
       return (dname ? "acc" : "a");
 
     case AOP_IMMD:
-      if (aop->aopu.aop_immd.from_cast_remat && (offset == (aop->size-1))) {
-	      sprintf(s,"%s",aop->aopu.aop_immd.aop_immd2);
-      } else if (bit16)
-	sprintf (s, "#%s", aop->aopu.aop_immd.aop_immd1);
-      else if (offset) {
+      if (aop->aopu.aop_immd.from_cast_remat && (offset == (aop->size-1))) 
+      {
+	  SNPRINTF(buffer, sizeof(buffer), 
+		   "%s",aop->aopu.aop_immd.aop_immd2);
+      } 
+      else if (bit16)
+      {
+	 SNPRINTF(buffer, sizeof(buffer), 
+		  "#%s", aop->aopu.aop_immd.aop_immd1);
+      }
+      else if (offset) 
+      {
 	  switch (offset) {
 	  case 1:
-	      tsprintf(s,"#!his",aop->aopu.aop_immd.aop_immd1);
+	      tsprintf(buffer, sizeof(buffer),
+		       "#!his",aop->aopu.aop_immd.aop_immd1);
 	      break;
 	  case 2:
-	      tsprintf(s,"#!hihis",aop->aopu.aop_immd.aop_immd1);
+	      tsprintf(buffer, sizeof(buffer), 
+		       "#!hihis",aop->aopu.aop_immd.aop_immd1);
 	      break;
 	  case 3:
-	      tsprintf(s,"#!hihihis",aop->aopu.aop_immd.aop_immd1);
+	      tsprintf(buffer, sizeof(buffer),
+		       "#!hihihis",aop->aopu.aop_immd.aop_immd1);
 	      break;
 	  default: /* should not need this (just in case) */
-	      sprintf (s, "#(%s >> %d)",
+	      SNPRINTF (buffer, sizeof(buffer), 
+			"#(%s >> %d)",
 		       aop->aopu.aop_immd.aop_immd1,
 		       offset * 8);
 	  }
       }
       else
-	sprintf (s, "#%s",
-		 aop->aopu.aop_immd.aop_immd1);
-      rs = Safe_calloc (1, strlen (s) + 1);
-      strcpy (rs, s);
-      return rs;
+      {
+	SNPRINTF (buffer, sizeof(buffer), 
+		  "#%s", aop->aopu.aop_immd.aop_immd1);
+      }
+      return Safe_strdup(buffer);	
 
     case AOP_DIR:
       if (offset)
-	sprintf (s, "(%s + %d)",
+      {
+	SNPRINTF (buffer, sizeof(buffer),
+		  "(%s + %d)",
 		 aop->aopu.aop_dir,
 		 offset);
+      }
       else
-	sprintf (s, "%s", aop->aopu.aop_dir);
-      rs = Safe_calloc (1, strlen (s) + 1);
-      strcpy (rs, s);
-      return rs;
+      {
+	SNPRINTF(buffer, sizeof(buffer), 
+		 "%s", aop->aopu.aop_dir);
+      }
+
+      return Safe_strdup(buffer);
 
     case AOP_REG:
       if (dname)
@@ -1138,6 +1296,8 @@ aopGet (asmop * aop,
   werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
 	  "aopget got unsupported aop->type");
   exit (1);
+    
+  return NULL;  // not reached, but makes compiler happy.
 }
 /*-----------------------------------------------------------------*/
 /* aopPut - puts a string for a aop                                */
@@ -1145,8 +1305,6 @@ aopGet (asmop * aop,
 static void
 aopPut (asmop * aop, char *s, int offset)
 {
-  char *d = buffer;
-
   if (aop->size && offset > (aop->size - 1))
     {
       werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
@@ -1159,15 +1317,23 @@ aopPut (asmop * aop, char *s, int offset)
   switch (aop->type)
     {
     case AOP_DIR:
-      if (offset)
-	sprintf (d, "(%s + %d)",
-		 aop->aopu.aop_dir, offset);
-      else
-	sprintf (d, "%s", aop->aopu.aop_dir);
-
-      if (strcmp (d, s))
-	emitcode ("mov", "%s,%s", d, s);
+        if (offset)
+	{
+	    SNPRINTF (buffer, sizeof(buffer),
+		      "(%s + %d)",
+		      aop->aopu.aop_dir, offset);
+	}
+	else
+	{
+	    SNPRINTF (buffer, sizeof(buffer), 
+		     "%s", aop->aopu.aop_dir);
+	}
+	
 
+	if (strcmp (buffer, s))
+	{
+	    emitcode ("mov", "%s,%s", buffer, s);
+	}
       break;
 
     case AOP_REG:
@@ -1183,14 +1349,22 @@ aopPut (asmop * aop, char *s, int offset)
 	      strcmp (s, "r5") == 0 ||
 	      strcmp (s, "r6") == 0 ||
 	      strcmp (s, "r7") == 0)
-	    emitcode ("mov", "%s,%s",
-		      aop->aopu.aop_reg[offset]->dname, s);
-	  else
-	    emitcode ("mov", "%s,%s",
-		      aop->aopu.aop_reg[offset]->name, s);
+	    {
+		emitcode ("mov", "%s,%s",
+			  aop->aopu.aop_reg[offset]->dname, s);
+	    }
+	    else
+	    {
+		emitcode ("mov", "%s,%s",
+			  aop->aopu.aop_reg[offset]->name, s);
+	    }
 	}
       break;
 
+    case AOP_DPTRn:
+	emitcode ("mov","%s,%s",dptrn[aop->aopu.dptr][offset],s);
+	break;
+
     case AOP_DPTR:
     case AOP_DPTR2:
 
@@ -1266,14 +1440,16 @@ aopPut (asmop * aop, char *s, int offset)
 	       strcmp (s, "r6") == 0 ||
 	       strcmp (s, "r7") == 0)
 	{
-	  char buffer[10];
-	  sprintf (buffer, "a%s", s);
+	  char buff[10];
+	  SNPRINTF(buff, sizeof(buff), 
+		   "a%s", s);
 	  emitcode ("mov", "@%s,%s",
-		    aop->aopu.aop_ptr->name, buffer);
+		    aop->aopu.aop_ptr->name, buff);
+	}
+	else
+	{
+	    emitcode ("mov", "@%s,%s", aop->aopu.aop_ptr->name, s);
 	}
-      else
-	emitcode ("mov", "@%s,%s", aop->aopu.aop_ptr->name, s);
-
       break;
 
     case AOP_STK:
@@ -1311,11 +1487,8 @@ aopPut (asmop * aop, char *s, int offset)
 		  MOVA (s);
 		}
 	      {
-		symbol *lbl = newiTempLabel (NULL);
-		emitcode ("clr", "c");
-		emitcode ("jz", "!tlabel", lbl->key + 100);
-		emitcode ("cpl", "c");
-		emitcode ("", "!tlabeldef", lbl->key + 100);
+		/* set C, if a >= 1 */
+		emitcode ("add", "a,#!constbyte",0xff);
 		emitcode ("mov", "%s,c", aop->aopu.aop_dir);
 	      }
 	    }
@@ -1398,6 +1571,13 @@ reAdjustPreg (asmop * aop)
 #define AOP_INPREG(x) (x && (x->type == AOP_REG &&                        \
                       (x->aopu.aop_reg[0] == ds390_regWithIdx(R0_IDX) || \
                       x->aopu.aop_reg[0] == ds390_regWithIdx(R1_IDX) )))
+#define AOP_INDPTRn(x) (AOP_TYPE(x) == AOP_DPTRn)
+#define AOP_USESDPTR(x) ((AOP_TYPE(x) == AOP_DPTR) || (AOP_TYPE(x) == AOP_STR))
+#define AOP_USESDPTR2(x) ((AOP_TYPE(x) == AOP_DPTR2) || (AOP_TYPE(x) == AOP_DPTRn))
+
+// The following two macros can be used even if the aop has not yet been aopOp'd.
+#define AOP_IS_STR(x) (IS_SYMOP(x) && OP_SYMBOL(x)->ruonly)
+#define AOP_IS_DPTRn(x) (IS_SYMOP(x) && OP_SYMBOL(x)->dptr)
 
 /* Workaround for DS80C390 bug: div ab may return bogus results
  * if A is accessed in instruction immediately before the div.
@@ -1413,15 +1593,16 @@ reAdjustPreg (asmop * aop)
        * thus avoiding touching A right before the div. \
        */             \
       D(emitcode(";", "DS80C390 div bug: rearranged ops.");); \
-      L = aopGet(AOP(LEFT),0,FALSE,FALSE,TRUE);     \
+      L = aopGet(AOP(LEFT),0,FALSE,FALSE,NULL);     \
       MOVA(L);            \
-      emitcode("mov","b,%s",aopGet(AOP(RIGHT),0,FALSE,FALSE,FALSE));\
+      L = aopGet(AOP(RIGHT),0,FALSE,FALSE,"b"); \
+      MOVB(L); \
     }               \
     else              \
     {               \
       /* Just stuff in a nop after loading A. */    \
-      emitcode("mov","b,%s",aopGet(AOP(RIGHT),0,FALSE,FALSE,FALSE));\
-      L = aopGet(AOP(LEFT),0,FALSE,FALSE,TRUE);   \
+      emitcode("mov","b,%s",aopGet(AOP(RIGHT),0,FALSE,FALSE,NULL));\
+      L = aopGet(AOP(LEFT),0,FALSE,FALSE,NULL);   \
       MOVA(L);            \
       emitcode("nop", "; workaround for DS80C390 div bug.");  \
     }
@@ -1433,11 +1614,9 @@ static void
 genNotFloat (operand * op, operand * res)
 {
   int size, offset;
-  char *l;
   symbol *tlbl;
 
-  D (emitcode (";", "genNotFloat ");
-    );
+  D (emitcode (";", "genNotFloat "););
 
   /* we will put 127 in the first byte of
      the result */
@@ -1446,14 +1625,14 @@ genNotFloat (operand * op, operand * res)
   offset = 1;
 
   _startLazyDPSEvaluation ();
-  l = aopGet (op->aop, offset++, FALSE, FALSE, TRUE);
-  MOVA (l);
+  MOVA(aopGet(op->aop, offset++, FALSE, FALSE, NULL));
 
   while (size--)
     {
       emitcode ("orl", "a,%s",
 		aopGet (op->aop,
-			offset++, FALSE, FALSE, FALSE));
+			offset++, FALSE, FALSE,
+			DP2_RESULT_REG));
     }
   _endLazyDPSEvaluation ();
 
@@ -1565,8 +1744,7 @@ toBoolean (operand * oper)
    */
   if (opIsGptr (oper))
     {
-      D (emitcode (";", "toBoolean: generic ptr special case.");
-	);
+      D (emitcode (";", "toBoolean: generic ptr special case."););
       size--;
     }
 
@@ -1574,22 +1752,28 @@ toBoolean (operand * oper)
   if (AOP_NEEDSACC (oper) && size)
     {
       usedB = TRUE;
-      emitcode ("push", "b");
-      emitcode ("mov", "b, %s", aopGet (AOP (oper), 0, FALSE, FALSE, FALSE));
+      if (_G.bInUse)
+      {
+	  emitcode ("push", "b");
+      }
+      MOVB (aopGet (AOP (oper), 0, FALSE, FALSE, NULL));
     }
   else
     {
-      MOVA (aopGet (AOP (oper), 0, FALSE, FALSE, TRUE));
+      MOVA (aopGet (AOP (oper), 0, FALSE, FALSE, NULL));
     }
+    
   while (size--)
     {
       if (usedB)
 	{
-	  emitcode ("orl", "b,%s", aopGet (AOP (oper), offset++, FALSE, FALSE, FALSE));
+	  emitcode ("orl", "b,%s",
+		    aopGet (AOP (oper), offset++, FALSE, FALSE, NULL));
 	}
       else
 	{
-	  emitcode ("orl", "a,%s", aopGet (AOP (oper), offset++, FALSE, FALSE, FALSE));
+	  emitcode ("orl", "a,%s",
+		    aopGet (AOP (oper), offset++, FALSE, FALSE, NULL));
 	}
     }
   _endLazyDPSEvaluation ();
@@ -1597,7 +1781,11 @@ toBoolean (operand * oper)
   if (usedB)
     {
       emitcode ("mov", "a,b");
-      emitcode ("pop", "b");
+      if (_G.bInUse)
+      {
+	  emitcode ("pop", "b");
+      }
+	
     }
 }
 
@@ -1611,12 +1799,11 @@ genNot (iCode * ic)
   symbol *tlbl;
   sym_link *optype = operandType (IC_LEFT (ic));
 
-  D (emitcode (";", "genNot ");
-    );
+  D (emitcode (";", "genNot "););
 
   /* assign asmOps to operand & result */
   aopOp (IC_LEFT (ic), ic, FALSE, FALSE);
-  aopOp (IC_RESULT (ic), ic, TRUE, AOP_TYPE (IC_LEFT (ic)) == AOP_DPTR);
+  aopOp (IC_RESULT (ic), ic, TRUE, AOP_USESDPTR(IC_LEFT (ic)));
 
   /* if in bit space then a special case */
   if (AOP_TYPE (IC_LEFT (ic)) == AOP_CRY)
@@ -1637,7 +1824,7 @@ genNot (iCode * ic)
   toBoolean (IC_LEFT (ic));
 
   tlbl = newiTempLabel (NULL);
-  emitcode ("cjne", "a,#0x01,!tlabel", tlbl->key + 100);
+  emitcode ("cjne", "a,#1,!tlabel", tlbl->key + 100);
   emitcode ("", "!tlabeldef", tlbl->key + 100);
   outBitC (IC_RESULT (ic));
 
@@ -1656,33 +1843,36 @@ genCpl (iCode * ic)
 {
   int offset = 0;
   int size;
+  symbol *tlbl;
 
-  D (emitcode (";", "genCpl ");
-    );
+  D (emitcode (";", "genCpl "););
 
 
   /* assign asmOps to operand & result */
   aopOp (IC_LEFT (ic), ic, FALSE, FALSE);
-  aopOp (IC_RESULT (ic), ic, TRUE, AOP_TYPE (IC_LEFT (ic)) == AOP_DPTR);
-
-  /* if both are in bit space then
-     a special case */
-  if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY &&
-      AOP_TYPE (IC_LEFT (ic)) == AOP_CRY)
-    {
+  aopOp (IC_RESULT (ic), ic, TRUE, AOP_USESDPTR(IC_LEFT (ic)));
 
+  /* special case if in bit space */
+  if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY) {
+    if (AOP_TYPE (IC_LEFT (ic)) == AOP_CRY) {
       emitcode ("mov", "c,%s", IC_LEFT (ic)->aop->aopu.aop_dir);
       emitcode ("cpl", "c");
       emitcode ("mov", "%s,c", IC_RESULT (ic)->aop->aopu.aop_dir);
       goto release;
     }
+    tlbl=newiTempLabel(NULL);
+    emitcode ("cjne", "%s,#0x01,%05d$", 
+	      aopGet(AOP(IC_LEFT(ic)), 0, FALSE,FALSE,NULL), tlbl->key+100);
+    emitcode ("", "%05d$:", tlbl->key+100);
+    outBitC (IC_RESULT(ic));
+    goto release;
+  }
 
   size = AOP_SIZE (IC_RESULT (ic));
   _startLazyDPSEvaluation ();
   while (size--)
     {
-      char *l = aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE, TRUE);
-      MOVA (l);
+      MOVA (aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE, NULL));
       emitcode ("cpl", "a");
       aopPut (AOP (IC_RESULT (ic)), "a", offset++);
     }
@@ -1702,27 +1892,26 @@ static void
 genUminusFloat (operand * op, operand * result)
 {
   int size, offset = 0;
-  char *l;
-  /* for this we just need to flip the
-     first it then copy the rest in place */
-  D (emitcode (";", "genUminusFloat");
-    );
-
+    
+  D(emitcode (";", "genUminusFloat"););
+  
+  /* for this we just copy and then flip the bit */
+    
   _startLazyDPSEvaluation ();
   size = AOP_SIZE (op) - 1;
-  l = aopGet (AOP (op), 3, FALSE, FALSE, TRUE);
-  MOVA (l);
-
-  emitcode ("cpl", "acc.7");
-  aopPut (AOP (result), "a", 3);
 
   while (size--)
-    {
+  {
       aopPut (AOP (result),
-	      aopGet (AOP (op), offset, FALSE, FALSE, FALSE),
+	      aopGet (AOP (op), offset, FALSE, FALSE, NULL),
 	      offset);
       offset++;
     }
+  
+  MOVA(aopGet (AOP (op), offset, FALSE, FALSE, NULL));
+
+  emitcode ("cpl", "acc.7");
+  aopPut (AOP (result), "a", offset);    
   _endLazyDPSEvaluation ();
 }
 
@@ -1733,15 +1922,13 @@ static void
 genUminus (iCode * ic)
 {
   int offset, size;
-  sym_link *optype, *rtype;
-
-  D (emitcode (";", "genUminus ");
-    );
+  sym_link *optype;
 
+  D (emitcode (";", "genUminus "););
 
   /* assign asmops */
   aopOp (IC_LEFT (ic), ic, FALSE, FALSE);
-  aopOp (IC_RESULT (ic), ic, TRUE, AOP_TYPE (IC_LEFT (ic)) == AOP_DPTR);
+  aopOp (IC_RESULT (ic), ic, TRUE, AOP_USESDPTR(IC_LEFT (ic)));
 
   /* if both in bit space then special
      case */
@@ -1756,7 +1943,6 @@ genUminus (iCode * ic)
     }
 
   optype = operandType (IC_LEFT (ic));
-  rtype = operandType (IC_RESULT (ic));
 
   /* if float then do float stuff */
   if (IS_FLOAT (optype))
@@ -1771,7 +1957,7 @@ genUminus (iCode * ic)
   _startLazyDPSEvaluation ();
   while (size--)
     {
-      char *l = aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE, TRUE);
+      char *l = aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE, NULL);
       if (!strcmp (l, "a"))
 	{
 	  if (offset == 0)
@@ -1792,7 +1978,7 @@ genUminus (iCode * ic)
 
   /* if any remaining bytes in the result */
   /* we just need to propagate the sign   */
-  if ((size = (AOP_SIZE (IC_RESULT (ic)) - AOP_SIZE (IC_LEFT (ic)))))
+  if ((size = (AOP_SIZE(IC_RESULT(ic)) - AOP_SIZE(IC_LEFT(ic)))) != 0)
     {
       emitcode ("rlc", "a");
       emitcode ("subb", "a,acc");
@@ -1806,16 +1992,45 @@ release:
   freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
 }
 
+/*-----------------------------------------------------------------*/
+/* savermask - saves registers in the mask                         */
+/*-----------------------------------------------------------------*/
+static void savermask(bitVect *rs_mask)
+{
+    int i;
+    if (options.useXstack) {
+	if (bitVectBitValue (rs_mask, R0_IDX))
+	    emitcode ("mov", "b,r0");
+	emitcode ("mov", "r0,%s", spname);
+	for (i = 0; i < ds390_nRegs; i++) {
+	    if (bitVectBitValue (rs_mask, i)) {
+		if (i == R0_IDX)
+		    emitcode ("mov", "a,b");
+		else
+		    emitcode ("mov", "a,%s", ds390_regWithIdx (i)->name);
+		emitcode ("movx", "@r0,a");
+		emitcode ("inc", "r0");
+	    }
+	}
+	emitcode ("mov", "%s,r0", spname);
+	if (bitVectBitValue (rs_mask, R0_IDX))
+	    emitcode ("mov", "r0,b");
+    } else {
+	for (i = 0; i < ds390_nRegs; i++) {
+	    if (bitVectBitValue (rs_mask, i))
+		emitcode ("push", "%s", ds390_regWithIdx (i)->dname);
+	}
+    }
+}
+
 /*-----------------------------------------------------------------*/
 /* saveRegisters - will look for a call and save the registers     */
 /*-----------------------------------------------------------------*/
 static void
 saveRegisters (iCode * lic)
 {
-  int i;
   iCode *ic;
   bitVect *rsave;
-  sym_link *detype;
 
   /* look for call */
   for (ic = lic; ic; ic = ic->next)
@@ -1830,17 +2045,21 @@ saveRegisters (iCode * lic)
 
   /* if the registers have been saved already then
      do nothing */
-  if (ic->regsSaved || IFFUNC_ISNAKED(OP_SYM_TYPE(IC_LEFT(ic)))) return ;
+  if (ic->regsSaved || 
+      (IS_SYMOP(IC_LEFT(ic)) && IFFUNC_ISNAKED(OP_SYM_TYPE(IC_LEFT(ic)))))
+    return ;
 
   /* special case if DPTR alive across a function call then must save it 
      even though callee saves */
-  if (IFFUNC_CALLEESAVES(OP_SYMBOL (IC_LEFT (ic))->type)) {
-      int i =0;
+  if (IS_SYMOP(IC_LEFT(ic)) &&
+      IFFUNC_CALLEESAVES(OP_SYMBOL (IC_LEFT (ic))->type)) {
+      int i;
       rsave = newBitVect(ic->rMask->size);
       for (i = DPL_IDX ; i <= B_IDX ; i++ ) {
 	  if (bitVectBitValue(ic->rMask,i))
 	      rsave = bitVectSetBit(rsave,i);
       }
+      rsave = bitVectCplAnd(rsave,ds390_rUmaskForOp (IC_RESULT(ic)));
   } else {
     /* safe the registers in use at this time but skip the
        ones for the result */
@@ -1848,35 +2067,36 @@ saveRegisters (iCode * lic)
 			   ds390_rUmaskForOp (IC_RESULT(ic)));
   }
   ic->regsSaved = 1;
-  if (options.useXstack)
-    {
-      if (bitVectBitValue (rsave, R0_IDX))
-	emitcode ("mov", "b,r0");
-      emitcode ("mov", "r0,%s", spname);
-      for (i = 0; i < ds390_nRegs; i++)
-	{
-	  if (bitVectBitValue (rsave, i))
-	    {
-	      if (i == R0_IDX)
-		emitcode ("mov", "a,b");
-	      else
-		emitcode ("mov", "a,%s", ds390_regWithIdx (i)->name);
-	      emitcode ("movx", "@r0,a");
-	      emitcode ("inc", "r0");
-	    }
+  savermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* usavermask - restore registers with mask                        */
+/*-----------------------------------------------------------------*/
+static void unsavermask(bitVect *rs_mask)
+{
+    int i;
+    if (options.useXstack) {
+	emitcode ("mov", "r0,%s", spname);
+	for (i = ds390_nRegs; i >= 0; i--) {
+	    if (bitVectBitValue (rs_mask, i)) {
+		emitcode ("dec", "r0");
+		emitcode ("movx", "a,@r0");
+		if (i == R0_IDX)
+		    emitcode ("mov", "b,a");
+		else
+		    emitcode ("mov", "%s,a", ds390_regWithIdx (i)->name);
+	    }	    
+	}
+	emitcode ("mov", "%s,r0", spname);
+	if (bitVectBitValue (rs_mask, R0_IDX))
+	    emitcode ("mov", "r0,b");
+    } else {
+	for (i = ds390_nRegs; i >= 0; i--) {
+	    if (bitVectBitValue (rs_mask, i))
+		emitcode ("pop", "%s", ds390_regWithIdx (i)->dname);
 	}
-      emitcode ("mov", "%s,r0", spname);
-      if (bitVectBitValue (rsave, R0_IDX))
-	emitcode ("mov", "r0,b");
     }
-  else
-    for (i = 0; i < ds390_nRegs; i++)
-      {
-	if (bitVectBitValue (rsave, i))
-	  emitcode ("push", "%s", ds390_regWithIdx (i)->dname);
-      }
-
-  detype = getSpec (operandType (IC_LEFT (ic)));
 }
 
 /*-----------------------------------------------------------------*/
@@ -1885,50 +2105,24 @@ saveRegisters (iCode * lic)
 static void
 unsaveRegisters (iCode * ic)
 {
-  int i;
   bitVect *rsave;
 
   if (IFFUNC_CALLEESAVES(OP_SYMBOL (IC_LEFT (ic))->type)) {
-      int i =0;
+      int i;
       rsave = newBitVect(ic->rMask->size);
       for (i = DPL_IDX ; i <= B_IDX ; i++ ) {
 	  if (bitVectBitValue(ic->rMask,i))
 	      rsave = bitVectSetBit(rsave,i);
       }
+      rsave = bitVectCplAnd(rsave,ds390_rUmaskForOp (IC_RESULT(ic)));
   } else {
     /* restore the registers in use at this time but skip the
        ones for the result */
     rsave = bitVectCplAnd (bitVectCopy (ic->rMask), 
 			   ds390_rUmaskForOp (IC_RESULT(ic)));
   }
-  if (options.useXstack)
-    {
-      emitcode ("mov", "r0,%s", spname);
-      for (i = ds390_nRegs; i >= 0; i--)
-	{
-	  if (bitVectBitValue (rsave, i))
-	    {
-	      emitcode ("dec", "r0");
-	      emitcode ("movx", "a,@r0");
-	      if (i == R0_IDX)
-		emitcode ("mov", "b,a");
-	      else
-		emitcode ("mov", "%s,a", ds390_regWithIdx (i)->name);
-	    }
-
-	}
-      emitcode ("mov", "%s,r0", spname);
-      if (bitVectBitValue (rsave, R0_IDX))
-	emitcode ("mov", "r0,b");
-    }
-  else
-    for (i = ds390_nRegs; i >= 0; i--)
-      {
-	if (bitVectBitValue (rsave, i))
-	  emitcode ("pop", "%s", ds390_regWithIdx (i)->dname);
-      }
-
-}
+  unsavermask(rsave);
+}
 
 
 /*-----------------------------------------------------------------*/
@@ -1941,7 +2135,7 @@ pushSide (operand * oper, int size)
   _startLazyDPSEvaluation ();
   while (size--)
     {
-      char *l = aopGet (AOP (oper), offset++, FALSE, TRUE, FALSE);
+      char *l = aopGet (AOP (oper), offset++, FALSE, TRUE, NULL);
       if (AOP_TYPE (oper) != AOP_REG &&
 	  AOP_TYPE (oper) != AOP_DIR &&
 	  strcmp (l, "a"))
@@ -1963,7 +2157,24 @@ assignResultValue (operand * oper)
 {
   int offset = 0;
   int size = AOP_SIZE (oper);
+  bool pushedAcc = FALSE;
 
+  if (size == fReturnSizeDS390)
+  {
+      /* I don't think this case can ever happen... */
+      /* ACC is the last part of this. If writing the result
+       * uses AC, we must preserve it.
+       */
+      if (AOP_NEEDSACC(oper))
+      {
+	  emitcode(";", "assignResultValue special case for ACC.");
+	  emitcode("push", "acc");
+	  pushedAcc = TRUE;
+	  size--;
+      }
+  }
+    
+    
   _startLazyDPSEvaluation ();
   while (size--)
     {
@@ -1971,6 +2182,12 @@ assignResultValue (operand * oper)
       offset++;
     }
   _endLazyDPSEvaluation ();
+    
+  if (pushedAcc)
+    {
+	emitcode("pop", "acc");
+	aopPut(AOP(oper), "a", offset);
+    }
 }
 
 
@@ -1998,9 +2215,8 @@ genXpush (iCode * ic)
   while (size--)
     {
 
-      char *l = aopGet (AOP (IC_LEFT (ic)),
-			offset++, FALSE, FALSE, TRUE);
-      MOVA (l);
+      MOVA (aopGet (AOP (IC_LEFT (ic)),
+			offset++, FALSE, FALSE, NULL));
       emitcode ("movx", "@%s,a", r->name);
       emitcode ("inc", "%s", r->name);
 
@@ -2015,7 +2231,7 @@ genXpush (iCode * ic)
 }
 
 /*-----------------------------------------------------------------*/
-/* genIpush - genrate code for pushing this gets a little complex  */
+/* genIpush - generate code for pushing this gets a little complex  */
 /*-----------------------------------------------------------------*/
 static void
 genIpush (iCode * ic)
@@ -2032,7 +2248,7 @@ genIpush (iCode * ic)
     {
 
       /* and the item is spilt then do nothing */
-      if (OP_SYMBOL (IC_LEFT (ic))->isspilt)
+      if (OP_SYMBOL (IC_LEFT (ic))->isspilt || OP_SYMBOL(IC_LEFT(ic))->dptr)
 	return;
 
       aopOp (IC_LEFT (ic), ic, FALSE, FALSE);
@@ -2041,7 +2257,7 @@ genIpush (iCode * ic)
       _startLazyDPSEvaluation ();
       while (size--)
 	{
-	  l = aopGet (AOP (IC_LEFT (ic)), offset++, FALSE, TRUE, TRUE);
+	  l = aopGet (AOP (IC_LEFT (ic)), offset++, FALSE, TRUE, NULL);
 	  if (*l == '#')
 	    {
 	      MOVA (l);
@@ -2075,16 +2291,18 @@ genIpush (iCode * ic)
   _startLazyDPSEvaluation ();
   while (size--)
     {
-      l = aopGet (AOP (IC_LEFT (ic)), offset++, FALSE, TRUE, FALSE);
+      l = aopGet (AOP (IC_LEFT (ic)), offset++, FALSE, TRUE, NULL);
       if (AOP_TYPE (IC_LEFT (ic)) != AOP_REG &&
 	  AOP_TYPE (IC_LEFT (ic)) != AOP_DIR &&
-	  strcmp (l, "a"))
+	  strcmp (l, "acc"))
 	{
 	  emitcode ("mov", "a,%s", l);
 	  emitcode ("push", "acc");
 	}
       else
-	emitcode ("push", "%s", l);
+	{
+	    emitcode ("push", "%s", l);
+	}
     }
   _endLazyDPSEvaluation ();
 
@@ -2104,7 +2322,7 @@ genIpop (iCode * ic)
 
 
   /* if the temp was not pushed then */
-  if (OP_SYMBOL (IC_LEFT (ic))->isspilt)
+  if (OP_SYMBOL (IC_LEFT (ic))->isspilt || OP_SYMBOL (IC_LEFT (ic))->dptr)
     return;
 
   aopOp (IC_LEFT (ic), ic, FALSE, FALSE);
@@ -2114,7 +2332,7 @@ genIpop (iCode * ic)
   while (size--)
     {
       emitcode ("pop", "%s", aopGet (AOP (IC_LEFT (ic)), offset--,
-				     FALSE, TRUE, TRUE));
+				     FALSE, TRUE, NULL));
     }
   _endLazyDPSEvaluation ();
 
@@ -2253,6 +2471,68 @@ saveRBank (int bank, iCode * ic, bool pushPsw)
   }
 }
 
+/*-----------------------------------------------------------------*/
+/* genSend - gen code for SEND	                                   */
+/*-----------------------------------------------------------------*/
+static void genSend(set *sendSet)
+{
+    iCode *sic;
+    int sendCount = 0 ;
+    static int rb1_count = 0;
+
+    for (sic = setFirstItem (sendSet); sic;
+	 sic = setNextItem (sendSet)) {	    
+	int size, offset = 0;
+	
+	size=getSize(operandType(IC_LEFT(sic)));
+	D (emitcode (";", "genSend argreg = %d, size = %d ",sic->argreg,size));
+	if (sendCount == 0) { /* first parameter */
+	    // we know that dpl(hxb) is the result, so
+	    rb1_count = 0 ;
+	    _startLazyDPSEvaluation ();
+	    if (size>1) {
+		aopOp (IC_LEFT (sic), sic, FALSE, 
+		       (AOP_IS_STR(IC_LEFT(sic)) ? FALSE : TRUE));
+	    } else {
+		aopOp (IC_LEFT (sic), sic, FALSE, FALSE);
+	    }
+	    while (size--) {
+		char *l = aopGet (AOP (IC_LEFT (sic)), offset,
+				  FALSE, FALSE, NULL);
+		if (strcmp (l, fReturn[offset])) {
+		    emitcode ("mov", "%s,%s",
+			      fReturn[offset],
+			      l);
+		}
+		offset++;
+	    }
+	    _endLazyDPSEvaluation ();
+	    freeAsmop (IC_LEFT (sic), NULL, sic, TRUE);
+	    rb1_count =0;
+	} else { /* if more parameter in registers */
+	    aopOp (IC_LEFT (sic), sic, FALSE, TRUE);
+	    while (size--) {
+		emitcode ("mov","b1_%d,%s",rb1_count++,aopGet (AOP (IC_LEFT (sic)), offset++,
+								FALSE, FALSE, NULL));
+	    }
+	    freeAsmop (IC_LEFT (sic), NULL, sic, TRUE);
+	}
+	sendCount++;
+    }
+}
+
+static void
+adjustEsp(const char *reg)
+{
+    emitcode ("anl","%s,#3", reg);
+    if (TARGET_IS_DS400)
+    {
+	emitcode ("orl","%s,#!constbyte",
+		  reg,
+		  (options.stack_loc >> 8) & 0xff);
+    }
+}
+
 /*-----------------------------------------------------------------*/
 /* genCall - generates a call statement                            */
 /*-----------------------------------------------------------------*/
@@ -2296,74 +2576,10 @@ genCall (iCode * ic)
   */
   if (_G.sendSet)
     {
-      iCode *sic;
-
-      for (sic = setFirstItem (_G.sendSet); sic;
-	   sic = setNextItem (_G.sendSet))
-	{
-	  int size, offset = 0;
-
-#if 0
-	  aopOp (IC_LEFT (sic), sic, FALSE, FALSE);
-	  size = AOP_SIZE (IC_LEFT (sic));
-
-	  _startLazyDPSEvaluation ();
-	  while (size--)
-	    {
-	      char *l = aopGet (AOP(IC_LEFT(sic)), offset,
-				FALSE, FALSE, TRUE);
-	        if ((AOP_TYPE(IC_LEFT(sic)) == AOP_DPTR) && size)
-	        {
-	            emitcode("mov", "%s,%s", regs390[offset].name, l);
-	        }
-	        else if (strcmp (l, fReturn[offset]))
-	        {
-		    emitcode ("mov", "%s,%s",
-			      fReturn[offset],
-			      l);
-	        }
-	      offset++;
-	    }
-	  _endLazyDPSEvaluation ();
-	  if (AOP_TYPE(IC_LEFT(sic)) == AOP_DPTR)
-	  {
-	      size = AOP_SIZE (IC_LEFT (sic));
-	      if (size)
-	      {
-	         size--;
-	      }
-	      while (size)
-	      {
-	      	   size--;
-		   emitcode("mov", "%s,%s",
-		   		    fReturn[size], regs390[size].name);
-	      }
-	  }
-#else
-	  // we know that dpl(hxb) is the result, so
-	  _startLazyDPSEvaluation ();
-	  size=getSize(operandType(IC_LEFT(sic)));
-	  if (size>1) {
-	    aopOp (IC_LEFT (sic), sic, FALSE, 
-		   (IS_SYMOP(IC_LEFT(sic)) && OP_SYMBOL(IC_LEFT(sic))->ruonly ? FALSE : TRUE));
-	  } else {
-	    aopOp (IC_LEFT (sic), sic, FALSE, FALSE);
-	  }
-	  while (size--)
-	    {
-	      char *l = aopGet (AOP (IC_LEFT (sic)), offset,
-				FALSE, FALSE, TRUE);
-	      if (strcmp (l, fReturn[offset]))
-		{
-		  emitcode ("mov", "%s,%s",
-			    fReturn[offset],
-			    l);
-		}
-	      offset++;
-	    }
-	  _endLazyDPSEvaluation ();
-#endif
-	  freeAsmop (IC_LEFT (sic), NULL, sic, TRUE);
+	if (IFFUNC_ISREENT(dtype)) { /* need to reverse the send set */
+	    genSend(reverseSet(_G.sendSet));
+	} else {
+	    genSend(_G.sendSet);
 	}
       _G.sendSet = NULL;
     }  
@@ -2428,16 +2644,26 @@ genCall (iCode * ic)
   /* adjust the stack for parameters if
      required */
   if (ic->parmBytes) {
+      int i;
       if (options.stack10bit) {
-	  emitcode ("clr","c");
-	  emitcode ("mov","a,sp");
-	  emitcode ("subb","a,#!constbyte",ic->parmBytes & 0xff);
-	  emitcode ("mov","sp,a");
-	  emitcode ("mov","a,esp");
-	  emitcode ("subb","a,#!constbyte",(ic->parmBytes >> 8) & 0xff);
-	  emitcode ("mov","esp,a");	  
+	  if (ic->parmBytes <= 10) {
+	      emitcode(";","stack adjustment for parms");
+	      for (i=0; i < ic->parmBytes ; i++) {
+		  emitcode("pop","acc");
+	      }
+	  } else {	      
+	      PROTECT_SP;
+	      emitcode ("clr","c");
+	      emitcode ("mov","a,sp");
+	      emitcode ("subb","a,#!constbyte",ic->parmBytes & 0xff);
+	      emitcode ("mov","sp,a");
+	      emitcode ("mov","a,esp");
+	      adjustEsp("a");
+	      emitcode ("subb","a,#!constbyte",(ic->parmBytes >> 8) & 0xff);
+	      emitcode ("mov","esp,a");	  
+	      UNPROTECT_SP;
+	  }
       } else {
-	  int i;
 	  if (ic->parmBytes > 3) {
 	      emitcode ("mov", "a,%s", spname);
 	      emitcode ("add", "a,#!constbyte", (-ic->parmBytes) & 0xff);
@@ -2508,37 +2734,8 @@ genPcall (iCode * ic)
   /* if send set is not empty the assign */
   if (_G.sendSet)
     {
-      iCode *sic;
-
-      for (sic = setFirstItem (_G.sendSet); sic;
-	   sic = setNextItem (_G.sendSet))
-	{
-	  int size, offset = 0;
-
-	  // we know that dpl(hxb) is the result, so
-	  _startLazyDPSEvaluation ();
-	  size=getSize(operandType(IC_LEFT(sic)));
-	  if (size>1) {
-	    aopOp (IC_LEFT (sic), sic, FALSE, TRUE);
-	  } else {
-	    aopOp (IC_LEFT (sic), sic, FALSE, FALSE);
-	  }
-	  while (size--)
-	    {
-	      char *l = aopGet (AOP (IC_LEFT (sic)), offset,
-				FALSE, FALSE, TRUE);
-	      if (strcmp (l, fReturn[offset]))
-		{
-		  emitcode ("mov", "%s,%s",
-			    fReturn[offset],
-			    l);
-		}
-	      offset++;
-	    }
-	  _endLazyDPSEvaluation ();
-	  freeAsmop (IC_LEFT (sic), NULL, sic, TRUE);
-	}
-      _G.sendSet = NULL;
+	genSend(reverseSet(_G.sendSet));
+	_G.sendSet = NULL;
     }
 
   emitcode ("ret", "");
@@ -2566,18 +2763,36 @@ genPcall (iCode * ic)
   if (ic->parmBytes)
     {
       int i;
-      if (ic->parmBytes > 3)
-	{
-	  emitcode ("mov", "a,%s", spname);
-	  emitcode ("add", "a,#!constbyte", (-ic->parmBytes) & 0xff);
-	  emitcode ("mov", "%s,a", spname);
-	}
-      else
-	for (i = 0; i < ic->parmBytes; i++)
-	  emitcode ("dec", "%s", spname);
-
+      if (options.stack10bit) {
+	  if (ic->parmBytes <= 10) {
+	      emitcode(";","stack adjustment for parms");
+	      for (i=0; i < ic->parmBytes ; i++) {
+		  emitcode("pop","acc");
+	      }
+	  } else {	      
+	      PROTECT_SP;
+	      emitcode ("clr","c");
+	      emitcode ("mov","a,sp");
+	      emitcode ("subb","a,#!constbyte",ic->parmBytes & 0xff);
+	      emitcode ("mov","sp,a");
+	      emitcode ("mov","a,esp");
+	      adjustEsp("a");
+	      emitcode ("subb","a,#!constbyte",(ic->parmBytes >> 8) & 0xff);
+	      emitcode ("mov","esp,a");	  
+	      UNPROTECT_SP;
+	  }
+      } else {
+	  if (ic->parmBytes > 3) {
+	      emitcode ("mov", "a,%s", spname);
+	      emitcode ("add", "a,#!constbyte", (-ic->parmBytes) & 0xff);
+	      emitcode ("mov", "%s,a", spname);
+	  }
+	  else
+	      for (i = 0; i < ic->parmBytes; i++)
+		  emitcode ("dec", "%s", spname);
+	  
+      }
     }
-
   /* if register bank was saved then unsave them */
   if (restoreBank)
     unsaveRBank (FUNC_REGBANK (dtype), ic, TRUE);
@@ -2679,11 +2894,11 @@ genFunction (iCode * ic)
 	{
 	  if (regs390[i].print) {
 	      if (strcmp (regs390[i].base, "0") == 0)
-		  emitcode ("", "%s = !constbyte",
+		  emitcode ("", "%s !equ !constbyte",
 			    regs390[i].dname,
 			    8 * rbank + regs390[i].offset);
 	      else
-		  emitcode ("", "%s = %s + !constbyte",
+		  emitcode ("", "%s !equ %s + !constbyte",
 			    regs390[i].dname,
 			    regs390[i].base,
 			    8 * rbank + regs390[i].offset);
@@ -2694,8 +2909,7 @@ genFunction (iCode * ic)
   /* if this is an interrupt service routine then
      save acc, b, dpl, dph  */
   if (IFFUNC_ISISR (sym->type))
-    {
-
+      { /* is ISR */
       if (!inExcludeList ("acc"))
 	emitcode ("push", "acc");
       if (!inExcludeList ("b"))
@@ -2709,7 +2923,7 @@ genFunction (iCode * ic)
 	  emitcode ("push", "dpx");
 	  /* Make sure we're using standard DPTR */
 	  emitcode ("push", "dps");
-	  emitcode ("mov", "dps, #0x00");
+	  emitcode ("mov", "dps,#0");
 	  if (options.stack10bit)
 	    {
 	      /* This ISR could conceivably use DPTR2. Better save it. */
@@ -2724,13 +2938,13 @@ genFunction (iCode * ic)
          registers :-) */
       if (!FUNC_REGBANK (sym->type))
 	{
+	    int i;
 
 	  /* if this function does not call any other
 	     function then we can be economical and
 	     save only those registers that are used */
 	  if (!IFFUNC_HASFCALL(sym->type))
 	    {
-	      int i;
 
 	      /* if any registers used */
 	      if (sym->regsUsed)
@@ -2751,6 +2965,11 @@ genFunction (iCode * ic)
 	         determines register usage so we will have to push the
 	         entire bank */
 	      saveRBank (0, ic, FALSE);
+	      if (options.parms_in_bank1) {
+		  for (i=0; i < 8 ; i++ ) {
+		      emitcode ("push","%s",rb1regs[i]);
+		  }
+	      }
 	    }
 	}
 	else
@@ -2840,7 +3059,7 @@ genFunction (iCode * ic)
 	             }
 	        }
 	    }
-	    // jwk: this needs a closer look
+	    // TODO: this needs a closer look
 	    SPEC_ISR_SAVED_BANKS(currFunc->etype) = banksToSave;
 	}
     }
@@ -2877,13 +3096,14 @@ genFunction (iCode * ic)
       emitcode ("mov", "psw,#!constbyte", (FUNC_REGBANK (sym->type) << 3) & 0x00ff);
     }
 
-  if (IFFUNC_ISREENT (sym->type) || options.stackAuto) {
+  if ( (IFFUNC_ISREENT (sym->type) || options.stackAuto) &&
+       (sym->stack || FUNC_HASSTACKPARM(sym->type))) {
       if (options.stack10bit) {
 	  emitcode ("push","_bpx");
 	  emitcode ("push","_bpx+1");
 	  emitcode ("mov","_bpx,%s",spname);
 	  emitcode ("mov","_bpx+1,esp");
-	  emitcode ("anl","_bpx+1,#3");
+	  adjustEsp("_bpx+1");
       } else {
 	  if (options.useXstack) {
 	      emitcode ("mov", "r0,%s", spname);
@@ -2902,14 +3122,21 @@ genFunction (iCode * ic)
   if (sym->stack) {
       int i = sym->stack;
       if (options.stack10bit) {
-	  if ( i > 1024) werror (W_STACK_OVERFLOW, sym->name);
+	  if ( i > 1024) werror (W_STACK_OVERFLOW, sym->name);	  
 	  assert (sym->recvSize <= 4);
-	  emitcode ("mov","a,sp");
-	  emitcode ("add","a,#!constbyte", ((short) sym->stack & 0xff));
-	  emitcode ("mov","sp,a");
-	  emitcode ("mov","a,esp");
-	  emitcode ("addc","a,#!constbyte", (((short) sym->stack) >> 8) & 0xff);
-	  emitcode ("mov","esp,a");
+	  if (sym->stack <= 8) {
+	      while (i--) emitcode ("push","acc");
+	  } else {
+	      PROTECT_SP;
+	      emitcode ("mov","a,sp");
+	      emitcode ("add","a,#!constbyte", ((short) sym->stack & 0xff));
+	      emitcode ("mov","sp,a");
+	      emitcode ("mov","a,esp");
+	      adjustEsp("a");
+	      emitcode ("addc","a,#!constbyte", (((short) sym->stack) >> 8) & 0xff);
+	      emitcode ("mov","esp,a");
+	      UNPROTECT_SP;
+	  }
       } else {
 	  if (i > 256)
 	      werror (W_STACK_OVERFLOW, sym->name);
@@ -2952,10 +3179,14 @@ genEndFunction (iCode * ic)
       return;
   }
 
-  if (IFFUNC_ISREENT (sym->type) || options.stackAuto) {
+  if ((IFFUNC_ISREENT (sym->type) || options.stackAuto) &&
+       (sym->stack || FUNC_HASSTACKPARM(sym->type))) {
+
       if (options.stack10bit) {
+	  PROTECT_SP;	  
 	  emitcode ("mov", "sp,_bpx", spname);
 	  emitcode ("mov", "esp,_bpx+1", spname);
+	  UNPROTECT_SP;
       } else {
 	  emitcode ("mov", "%s,_bp", spname);
       }
@@ -2971,7 +3202,9 @@ genEndFunction (iCode * ic)
   }
 
 
-  if ((IFFUNC_ISREENT (sym->type) || options.stackAuto)) {
+  if ((IFFUNC_ISREENT (sym->type) || options.stackAuto) &&
+       (sym->stack || FUNC_HASSTACKPARM(sym->type))) {
+
       if (options.useXstack) {
 	  emitcode ("mov", "r0,%s", spname);
 	  emitcode ("movx", "a,@r0");
@@ -2998,10 +3231,10 @@ genEndFunction (iCode * ic)
          */
         emitcode ("pop", "psw");
     }
-  }
+  } 
 
   if (IFFUNC_ISISR (sym->type))
-    {
+      { /* is ISR */  
 
       /* now we need to restore the registers */
       /* if this isr has no bank i.e. is going to
@@ -3009,12 +3242,12 @@ genEndFunction (iCode * ic)
          registers :-) */
       if (!FUNC_REGBANK (sym->type))
 	{
+	    int i;
 	  /* if this function does not call any other
 	     function then we can be economical and
 	     save only those registers that are used */
 	  if (!IFFUNC_HASFCALL(sym->type))
 	    {
-	      int i;
 
 	      /* if any registers used */
 	      if (sym->regsUsed)
@@ -3034,6 +3267,11 @@ genEndFunction (iCode * ic)
 	      /* this function has  a function call cannot
 	         determines register usage so we will have to pop the
 	         entire bank */
+	      if (options.parms_in_bank1) {
+		  for (i = 7 ; i >= 0 ; i-- ) {
+		      emitcode ("pop","%s",rb1regs[i]);
+		  }
+	      }
 	      unsaveRBank (0, ic, FALSE);
 	    }
 	}
@@ -3044,7 +3282,6 @@ genEndFunction (iCode * ic)
 	     * Restore any register banks saved by genFunction
 	     * in reverse order.
 	     */
-	  // jwk: this needs a closer look
 	    unsigned savedBanks = SPEC_ISR_SAVED_BANKS(currFunc->etype);
 	    int ix;
 	  
@@ -3146,6 +3383,39 @@ genEndFunction (iCode * ic)
 
 }
 
+/*-----------------------------------------------------------------*/
+/* genJavaNativeRet - generate code for return JavaNative          */
+/*-----------------------------------------------------------------*/
+static void genJavaNativeRet(iCode *ic)
+{
+    int i, size;
+
+    aopOp (IC_LEFT (ic), ic, FALSE, 
+	   AOP_IS_STR(IC_LEFT(ic)) ? FALSE :TRUE);
+    size = AOP_SIZE (IC_LEFT (ic));
+
+    assert (size <= 4);
+
+    /* it is assigned to GPR0-R3 then push them */
+    if (aopHasRegs(AOP(IC_LEFT(ic)),R0_IDX,R1_IDX) ||
+	aopHasRegs(AOP(IC_LEFT(ic)),R2_IDX,R3_IDX)) {
+	for (i = 0 ; i < size ; i++ ) {
+	    emitcode ("push","%s",
+		      aopGet(AOP(IC_LEFT(ic)),i,FALSE,TRUE,DP2_RESULT_REG));
+	}
+	for (i = (size-1) ; i >= 0 ; i--) {
+	    emitcode ("pop","a%s",javaRet[i]);
+	}
+    } else {
+	for (i = 0 ; i < size ; i++) 
+	    emitcode ("mov","%s,%s",javaRet[i],
+		      aopGet(AOP(IC_LEFT(ic)),i,FALSE,TRUE,DP2_RESULT_REG));
+    }
+    for (i = size ; i < 4 ; i++ )
+	    emitcode ("mov","%s,#0",javaRet[i]);
+    return;
+}
+
 /*-----------------------------------------------------------------*/
 /* genRet - generate code for return statement                     */
 /*-----------------------------------------------------------------*/
@@ -3154,18 +3424,23 @@ genRet (iCode * ic)
 {
   int size, offset = 0, pushed = 0;
 
-  D (emitcode (";", "genRet ");
-    );
+  D (emitcode (";", "genRet "););
 
   /* if we have no return value then
      just generate the "ret" */
   if (!IC_LEFT (ic))
     goto jumpret;
 
+  /* if this is a JavaNative function then return 
+     value in different register */
+  if (IFFUNC_ISJAVANATIVE(currFunc->type)) {
+      genJavaNativeRet(ic);
+      goto jumpret;
+  }
   /* we have something to return then
      move the return value into place */
   aopOp (IC_LEFT (ic), ic, FALSE, 
-	 (IS_SYMOP(IC_LEFT(ic)) && OP_SYMBOL(IC_LEFT(ic))->ruonly ? FALSE :TRUE));
+	 (AOP_IS_STR(IC_LEFT(ic)) ? FALSE :TRUE));
   size = AOP_SIZE (IC_LEFT (ic));
 
   _startLazyDPSEvaluation ();
@@ -3175,7 +3450,7 @@ genRet (iCode * ic)
       if (AOP_TYPE (IC_LEFT (ic)) == AOP_DPTR)
 	{
 	  l = aopGet (AOP (IC_LEFT (ic)), offset++,
-		      FALSE, TRUE, FALSE);
+		      FALSE, TRUE, NULL);
 	  emitcode ("push", "%s", l);
 	  pushed++;
 	}
@@ -3185,7 +3460,7 @@ genRet (iCode * ic)
 	   * is is OK to clobber it in the aopGet.
 	   */
 	  l = aopGet (AOP (IC_LEFT (ic)), offset,
-		      FALSE, FALSE, TRUE);
+		      FALSE, FALSE, NULL);
 	  if (strcmp (fReturn[offset], l))
 	    emitcode ("mov", "%s,%s", fReturn[offset++], l);
 	}
@@ -3258,6 +3533,13 @@ findLabelBackwards (iCode * ic, int key)
       ic = ic->prev;
       count++;
 
+      /* If we have any pushes or pops, we cannot predict the distance.
+	 I don't like this at all, this should be dealt with in the 
+	 back-end */
+      if (ic->op == IPUSH || ic->op == IPOP) {
+	return 0;
+      }
+
       if (ic->op == LABEL && IC_LABEL (ic)->key == key)
 	{
 	  /* printf("findLabelBackwards = %d\n", count); */
@@ -3288,6 +3570,13 @@ genPlusIncr (iCode * ic)
   if ((icount = (unsigned int) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit)) > 4)
     return FALSE;
 
+  if (size == 1 && AOP(IC_LEFT(ic)) == AOP(IC_RESULT(ic)) &&
+      AOP_TYPE(IC_LEFT(ic)) == AOP_DIR ) {
+      while (icount--) {
+	  emitcode("inc","%s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE,NULL));
+      }
+      return TRUE;
+  }
   /* if increment 16 bits in register */
   if (
        AOP_TYPE (IC_LEFT (ic)) == AOP_REG &&
@@ -3296,9 +3585,10 @@ genPlusIncr (iCode * ic)
        (size > 1) &&
        (icount == 1))
     {
-      symbol *tlbl;
-      int emitTlbl;
-      int labelRange;
+      symbol  *tlbl;
+      int     emitTlbl;
+      int     labelRange;
+      char    *l;
 
       /* If the next instruction is a goto and the goto target
        * is <= 5 instructions previous to this, we can generate
@@ -3308,7 +3598,7 @@ genPlusIncr (iCode * ic)
 	  && (labelRange = findLabelBackwards (ic, IC_LABEL (ic->next)->key)) != 0
 	  && labelRange <= 5)
 	{
-	  emitcode (";", "tail increment optimized (range %d)", labelRange);
+	  D(emitcode (";", "tail increment optimized (range %d)", labelRange););
 	  tlbl = IC_LABEL (ic->next);
 	  emitTlbl = 0;
 	}
@@ -3317,50 +3607,60 @@ genPlusIncr (iCode * ic)
 	  tlbl = newiTempLabel (NULL);
 	  emitTlbl = 1;
 	}
-      emitcode ("inc", "%s", aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE, FALSE));
+	
+      l = aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE, NULL);
+      emitcode ("inc", "%s", l);
+      
       if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
 	  IS_AOP_PREG (IC_RESULT (ic)))
-	emitcode ("cjne", "%s,#0x00,!tlabel"
-		  ,aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE, FALSE)
-		  ,tlbl->key + 100);
+      {	  
+	emitcode ("cjne", "%s,#0,!tlabel", l, tlbl->key + 100);
+      }
       else
-	{
+      {
 	  emitcode ("clr", "a");
-	  emitcode ("cjne", "a,%s,!tlabel"
-		    ,aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE, FALSE)
-		    ,tlbl->key + 100);
-	}
+	  emitcode ("cjne", "a,%s,!tlabel", l, tlbl->key + 100);
+      }
 
-      emitcode ("inc", "%s", aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE, FALSE));
+      l = aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE, NULL); 
+      emitcode ("inc", "%s", l);
       if (size > 2)
 	{
-	  if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
-	      IS_AOP_PREG (IC_RESULT (ic)))
-	    emitcode ("cjne", "%s,#0x00,!tlabel"
-		  ,aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE, FALSE)
-		      ,tlbl->key + 100);
-	  else
-	    emitcode ("cjne", "a,%s,!tlabel"
-		  ,aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE, FALSE)
-		      ,tlbl->key + 100);
+	    if (!strcmp(l, "acc"))
+	    {
+		emitcode("jnz", "!tlabel", tlbl->key + 100);
+	    }
+	    else if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
+		     IS_AOP_PREG (IC_RESULT (ic)))
+	    {
+		emitcode ("cjne", "%s,#0,!tlabel", l, tlbl->key + 100);
+	    }
+	    else
+	    {
+		emitcode ("cjne", "a,%s,!tlabel", l, tlbl->key + 100);
+	    }
 
-	  emitcode ("inc", "%s", aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE, FALSE));
+	    l = aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE, NULL);
+	    emitcode ("inc", "%s", l);
 	}
       if (size > 3)
 	{
-	  if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
-	      IS_AOP_PREG (IC_RESULT (ic)))
-	    emitcode ("cjne", "%s,#0x00,!tlabel"
-		  ,aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE, FALSE)
-		      ,tlbl->key + 100);
-	  else
+	    if (!strcmp(l, "acc"))
 	    {
-	      emitcode ("cjne", "a,%s,!tlabel"
-		  ,aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE, FALSE)
-			,tlbl->key + 100);
+		emitcode("jnz", "!tlabel", tlbl->key + 100);
+	    }
+	    else if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
+		     IS_AOP_PREG (IC_RESULT (ic)))
+	    {
+		emitcode ("cjne", "%s,#0,!tlabel", l, tlbl->key + 100);
+	    }
+	    else
+	    {
+		emitcode ("cjne", "a,%s,!tlabel", l, tlbl->key + 100);
 	    }
-	  emitcode ("inc", "%s", aopGet (AOP (IC_RESULT (ic)), MSB32, FALSE, FALSE, FALSE));
-	}
+
+	    l = aopGet (AOP (IC_RESULT (ic)), MSB32, FALSE, FALSE, NULL);
+	    emitcode ("inc", "%s", l);	}
 
       if (emitTlbl)
 	{
@@ -3369,6 +3669,32 @@ genPlusIncr (iCode * ic)
       return TRUE;
     }
 
+  if (AOP_TYPE(IC_RESULT(ic))==AOP_STR && IS_ITEMP(IC_RESULT(ic)) &&
+      !AOP_USESDPTR(IC_LEFT(ic)) && icount <= 5 && size <= 3 && 
+      options.model == MODEL_FLAT24 ) {
+
+      switch (size) {
+      case 3:
+	  emitcode ("mov","dpx,%s",aopGet(AOP (IC_LEFT (ic)), 2, FALSE, FALSE, NULL));
+      case 2:
+	  emitcode ("mov","dph,%s",aopGet(AOP (IC_LEFT (ic)), 1, FALSE, FALSE, NULL));
+      case 1:
+	  emitcode ("mov","dpl,%s",aopGet(AOP (IC_LEFT (ic)), 0, FALSE, FALSE, NULL));
+	  break;
+      }
+      while (icount--) emitcode ("inc","dptr");      
+      return TRUE;
+  }
+
+  if (AOP_INDPTRn(IC_LEFT(ic)) && AOP_INDPTRn(IC_RESULT(ic)) &&
+      AOP(IC_LEFT(ic))->aopu.dptr == AOP(IC_RESULT(ic))->aopu.dptr &&
+      icount <= 5 ) {
+      emitcode ("mov","dps,#!constbyte",AOP(IC_LEFT(ic))->aopu.dptr);
+      while (icount--) emitcode ("inc","dptr");
+      emitcode ("mov","dps,#0");
+      return TRUE;
+  }
+
   /* if the sizes are greater than 1 then we cannot */
   if (AOP_SIZE (IC_RESULT (ic)) > 1 ||
       AOP_SIZE (IC_LEFT (ic)) > 1)
@@ -3385,7 +3711,7 @@ genPlusIncr (iCode * ic)
 
       if (icount > 3)
 	{
-	  MOVA (aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE, TRUE));
+	  MOVA (aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE, NULL));
 	  emitcode ("add", "a,#!constbyte", ((char) icount) & 0xff);
 	  aopPut (AOP (IC_RESULT (ic)), "a", 0);
 	}
@@ -3395,7 +3721,7 @@ genPlusIncr (iCode * ic)
 	  _startLazyDPSEvaluation ();
 	  while (icount--)
 	    {
-	      emitcode ("inc", "%s", aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE, FALSE));
+	      emitcode ("inc", "%s", aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE, NULL));
 	    }
 	  _endLazyDPSEvaluation ();
 	}
@@ -3433,8 +3759,8 @@ outBitAcc (operand * result)
 static void
 genPlusBits (iCode * ic)
 {
-  D (emitcode (";", "genPlusBits ");
-    );
+  D (emitcode (";", "genPlusBits "););
+    
   if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY)
     {
       symbol *lbl = newiTempLabel (NULL);
@@ -3450,7 +3776,7 @@ genPlusBits (iCode * ic)
       emitcode ("mov", "c,%s", AOP (IC_LEFT (ic))->aopu.aop_dir);
       emitcode ("rlc", "a");
       emitcode ("mov", "c,%s", AOP (IC_RIGHT (ic))->aopu.aop_dir);
-      emitcode ("addc", "a,#0x00");
+      emitcode ("addc", "a,#0");
       outAcc (IC_RESULT (ic));
     }
 }
@@ -3463,7 +3789,7 @@ adjustArithmeticResult (iCode * ic)
       !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic))))
     {
       aopPut (AOP (IC_RESULT (ic)),
-	      aopGet (AOP (IC_LEFT (ic)), GPTRSIZE - 1, FALSE, FALSE, FALSE),
+	      aopGet (AOP (IC_LEFT (ic)), GPTRSIZE - 1, FALSE, FALSE, NULL),
 	      GPTRSIZE - 1);
     }
 
@@ -3472,7 +3798,7 @@ adjustArithmeticResult (iCode * ic)
       !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_RIGHT (ic))))
     {
       aopPut (AOP (IC_RESULT (ic)),
-	    aopGet (AOP (IC_RIGHT (ic)), GPTRSIZE - 1, FALSE, FALSE, FALSE),
+	    aopGet (AOP (IC_RIGHT (ic)), GPTRSIZE - 1, FALSE, FALSE, NULL),
 	      GPTRSIZE - 1);
     }
 
@@ -3482,62 +3808,144 @@ adjustArithmeticResult (iCode * ic)
       !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic))) &&
       !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_RIGHT (ic))))
     {
-      char buffer[5];
-      sprintf (buffer, "#%d", pointerCode (getSpec (operandType (IC_LEFT (ic)))));
-      aopPut (AOP (IC_RESULT (ic)), buffer, GPTRSIZE - 1);
+      char buff[5];
+      SNPRINTF (buff, sizeof(buff), 
+		"#%d", pointerCode (getSpec (operandType (IC_LEFT (ic)))));
+      aopPut (AOP (IC_RESULT (ic)), buff, GPTRSIZE - 1);
     }
 }
 
-#if 0 // AOP_OP_3 is deprecated; nobody likes Ack errors.
-      // Please don't bring it back without a really good reason.
-// Macro to aopOp all three operands of an ic. Will fatal if this cannot be done
-// (because all three operands are in far space).
-#define AOP_OP_3(ic) \
-    aopOp (IC_RIGHT(ic),ic,FALSE, FALSE); \
-    aopOp (IC_LEFT(ic),ic,FALSE, (AOP_TYPE(IC_RIGHT(ic)) == AOP_DPTR)); \
-    aopOp (IC_RESULT(ic),ic,TRUE, (AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR) || \
-              (AOP_TYPE(IC_RIGHT(ic)) == AOP_DPTR)); \
-    if (AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR2 && \
-        AOP_TYPE(IC_RESULT(ic)) == AOP_DPTR2) \
-    { \
-        /* werror(E_INTERNAL_ERROR,__FILE__,__LINE__, */ \
-        fprintf(stderr,                                  \
-               "Ack: three operands in far space! (%s:%d %s:%d)\n", __FILE__, __LINE__, ic->filename, ic->lineno);   \
+// The guts of AOP_OP_3_NOFATAL. Generates the left & right opcodes of an IC,
+// generates the result if possible. If result is generated, returns TRUE; otherwise
+// returns false and caller must deal with fact that result isn't aopOp'd.
+bool aopOp3(iCode * ic)
+{
+    bool dp1InUse, dp2InUse;
+    bool useDp2;
+    
+    // First, generate the right opcode. DPTR may be used if neither left nor result are
+    // of type AOP_STR.
+    
+//    D(emitcode(";", "aopOp3: AOP_IS_STR left: %s right: %s result: %s",
+//	       AOP_IS_STR(IC_LEFT(ic)) ? "true" : "false",
+//	       AOP_IS_STR(IC_RIGHT(ic)) ? "true" : "false",
+//	       AOP_IS_STR(IC_RESULT(ic)) ? "true" : "false");
+//      );
+//    D(emitcode(";", "aopOp3: AOP_IS_DPTRn left: %s right: %s result: %s",
+//	       AOP_IS_DPTRn(IC_LEFT(ic)) ? "true" : "false",
+//	       AOP_IS_DPTRn(IC_RIGHT(ic)) ? "true" : "false",
+//	       AOP_IS_DPTRn(IC_RESULT(ic)) ? "true" : "false");
+//      );
+    
+    // Right uses DPTR unless left or result is an AOP_STR; however,
+    // if right is an AOP_STR, it must use DPTR regardless.
+    if ((AOP_IS_STR(IC_LEFT(ic)) || AOP_IS_STR(IC_RESULT(ic)))
+     && !AOP_IS_STR(IC_RIGHT(ic)))
+    {
+	useDp2 = TRUE;
+    }
+    else
+    {
+	useDp2 = FALSE;
+    }
+	
+    aopOp (IC_RIGHT(ic),ic,FALSE, useDp2);
+    
+    // if the right used DPTR, left MUST use DPTR2.
+    // if the right used DPTR2, left MUST use DPTR.
+    // if both are still available, we prefer to use DPTR. But if result is an AOP_STR
+    // and left is not an AOP_STR, then we will get better code if we use DP2 for left,
+    // enabling us to assign DPTR to result.
+     
+    if (AOP_USESDPTR(IC_RIGHT(ic)))
+    {
+	useDp2 = TRUE;
+    }
+    else if (AOP_USESDPTR2(IC_RIGHT(ic)))
+    {
+	useDp2 = FALSE;
+    }
+    else
+    {
+	if (AOP_IS_STR(IC_RESULT(ic)) && !AOP_IS_STR(IC_LEFT(ic)))
+	{
+	    useDp2 = TRUE;
+	}
+	else
+	{
+	    useDp2 = FALSE;
+	}
+    }
+
+    aopOp(IC_LEFT(ic), ic, FALSE, useDp2);
+    
+    // We've op'd the left & right. So, if left or right are the same operand as result, 
+    // we know aopOp will succeed, and we can just do it & bail.
+    if (isOperandEqual(IC_LEFT(ic),IC_RESULT(ic)) ||
+	isOperandEqual(IC_RIGHT(ic),IC_RESULT(ic)))
+    {
+//	D(emitcode(";", "aopOp3: (left | right) & result equal"););
+	aopOp(IC_RESULT(ic),ic,TRUE, FALSE);
+	return TRUE;
     }
-#endif
+    
+    // Note which dptrs are currently in use.
+    dp1InUse = AOP_USESDPTR(IC_LEFT(ic)) || AOP_USESDPTR(IC_RIGHT(ic));
+    dp2InUse = AOP_USESDPTR2(IC_LEFT(ic)) || AOP_USESDPTR2(IC_RIGHT(ic));
+    
+    // OK, now if either left or right uses DPTR and the result is an AOP_STR, we cannot 
+    // generate it.
+    if (dp1InUse && AOP_IS_STR(IC_RESULT(ic)))
+    {
+	return FALSE;
+    }
+    
+    // Likewise, if left or right uses DPTR2 and the result is a DPTRn, we cannot generate it.
+    if (dp2InUse && AOP_IS_DPTRn(IC_RESULT(ic)))
+    {
+	return FALSE;
+    }
+    
+    // or, if both dp1 & dp2 are in use and the result needs a dptr, we're out of luck    
+    if (dp1InUse && dp2InUse && isOperandInFarSpace(IC_RESULT(ic)))
+    {
+	return FALSE;
+    }
+
+    aopOp (IC_RESULT(ic),ic,TRUE, dp1InUse);
+
+    // Some sanity checking...
+    if (dp1InUse && AOP_USESDPTR(IC_RESULT(ic)))
+    {
+	fprintf(stderr,
+		"Internal error: got unexpected DPTR (%s:%d %s:%d)\n",
+		__FILE__, __LINE__, ic->filename, ic->lineno);  
+	emitcode(";", ">>> unexpected DPTR here.");
+    }
+    
+    if (dp2InUse && AOP_USESDPTR2(IC_RESULT(ic)))
+    {
+	fprintf(stderr,
+		"Internal error: got unexpected DPTR2 (%s:%d %s:%d)\n",
+		__FILE__, __LINE__, ic->filename, ic->lineno);  
+	emitcode(";", ">>> unexpected DPTR2 here.");
+    }    
+    
+    return TRUE;
+}
 
 // Macro to aopOp all three operands of an ic. If this cannot be done, 
 // the IC_LEFT and IC_RIGHT operands will be aopOp'd, and the rc parameter
 // will be set TRUE. The caller must then handle the case specially, noting
 // that the IC_RESULT operand is not aopOp'd.
+// 
 #define AOP_OP_3_NOFATAL(ic, rc) \
-    aopOp (IC_RIGHT(ic),ic,FALSE, FALSE); \
-    aopOp (IC_LEFT(ic),ic,FALSE, (AOP_TYPE(IC_RIGHT(ic)) == AOP_DPTR) || \
-                                  (OP_SYMBOL(IC_RESULT(ic))->ruonly)); \
-    if (AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR2 && \
-        (isOperandInFarSpace(IC_RESULT(ic)) || OP_SYMBOL(IC_RESULT(ic))->ruonly )) \
-    { \
-       /* No can do; DPTR & DPTR2 in use, and we need another. */ \
-       rc = TRUE; \
-    }  \
-    else \
-    { \
-       aopOp (IC_RESULT(ic),ic,TRUE, (AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR) || \
-                                     (AOP_TYPE(IC_RIGHT(ic)) == AOP_DPTR)); \
-       rc = FALSE; \
-       if (AOP_TYPE(IC_LEFT(ic)) == AOP_DPTR2 && \
-           AOP_TYPE(IC_RESULT(ic)) == AOP_DPTR2) \
-       { \
-            /* werror(E_INTERNAL_ERROR,__FILE__,__LINE__, */ \
-            fprintf(stderr,                                  \
-                    "Ack: got unexpected DP2! (%s:%d %s:%d)\n", __FILE__, __LINE__, ic->filename, ic->lineno);   \
-       } \
-    }
+	    do { rc = !aopOp3(ic); } while (0)
 
 // aopOp the left & right operands of an ic.
 #define AOP_OP_2(ic) \
-    aopOp (IC_RIGHT(ic),ic,FALSE, FALSE); \
-    aopOp (IC_LEFT(ic),ic,FALSE, (AOP_TYPE(IC_RIGHT(ic)) == AOP_DPTR));
+    aopOp (IC_RIGHT(ic),ic,FALSE, AOP_IS_STR(IC_LEFT(ic))); \
+    aopOp (IC_LEFT(ic),ic,FALSE, AOP_USESDPTR(IC_RIGHT(ic)));
 
 // convienience macro.
 #define AOP_SET_LOCALS(ic) \
@@ -3583,13 +3991,13 @@ static void
 genPlus (iCode * ic)
 {
   int size, offset = 0;
-  bool pushResult = FALSE;
+  bool pushResult;
   int rSize;
 
   D (emitcode (";", "genPlus "););
 
   /* special cases :- */
-  if ( IS_SYMOP(IC_LEFT(ic)) && OP_SYMBOL(IC_LEFT(ic))->ruonly &&
+  if ( AOP_IS_STR(IC_LEFT(ic)) &&
       isOperandLiteral(IC_RIGHT(ic)) && OP_SYMBOL(IC_RESULT(ic))->ruonly) {
       aopOp (IC_RIGHT (ic), ic, TRUE, FALSE);
       size = floatFromVal (AOP (IC_RIGHT(ic))->aopu.aop_lit);
@@ -3618,6 +4026,7 @@ genPlus (iCode * ic)
   }
 		
   AOP_OP_3_NOFATAL (ic, pushResult);
+    
   if (pushResult)
     {
       D (emitcode (";", "genPlus: must push result: 3 ops in far space"););
@@ -3665,8 +4074,8 @@ genPlus (iCode * ic)
 	      _startLazyDPSEvaluation ();
 	      while (size--)
 		{
-		  MOVA (aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, TRUE));
-		  emitcode ("addc", "a,#00");
+		  MOVA (aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, NULL));
+		  emitcode ("addc", "a,#0");
 		  aopPut (AOP (IC_RESULT (ic)), "a", offset++);
 		}
 	      _endLazyDPSEvaluation ();
@@ -3690,13 +4099,13 @@ genPlus (iCode * ic)
     {
       if (AOP_TYPE(IC_LEFT(ic)) == AOP_ACC && !AOP_NEEDSACC(IC_RIGHT(ic)))
 	{
-	  MOVA (aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE, TRUE));
+	  MOVA (aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE, NULL));
 	  if (offset == 0)
 	    emitcode ("add", "a,%s",
-		 aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, FALSE));
+		 aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, NULL));
 	  else
 	    emitcode ("addc", "a,%s",
-		 aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, FALSE));
+		 aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, NULL));
 	}
       else
 	{
@@ -3710,7 +4119,7 @@ genPlus (iCode * ic)
 	      D(emitcode(";", "+ AOP_ACC special case."););
 	      emitcode("xch", "a, %s", DP2_RESULT_REG);
 	  }
-	  MOVA (aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, TRUE));
+	  MOVA (aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, NULL));
 	  if (offset == 0)
 	  {
 	    if (AOP_TYPE(IC_LEFT(ic)) == AOP_ACC)
@@ -3721,13 +4130,15 @@ genPlus (iCode * ic)
 	    else
 	    {
 	    	emitcode ("add", "a,%s",
-		  	aopGet (AOP(IC_LEFT(ic)), offset, FALSE, FALSE, FALSE));
+			  aopGet (AOP(IC_LEFT(ic)), offset, FALSE, FALSE,
+				  DP2_RESULT_REG));
 	    }
           }
 	  else
 	  {
 	    emitcode ("addc", "a,%s",
-		  aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE, FALSE));
+		  aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE,
+			  DP2_RESULT_REG));
 	  }
 	}
       if (!pushResult)
@@ -3788,6 +4199,13 @@ genMinusDec (iCode * ic)
   if ((icount = (unsigned int) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit)) > 4)
     return FALSE;
 
+  if (size == 1 && AOP(IC_LEFT(ic)) == AOP(IC_RESULT(ic)) &&
+      AOP_TYPE(IC_LEFT(ic)) == AOP_DIR ) {
+      while (icount--) {
+	  emitcode("dec","%s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE,NULL));
+      }
+      return TRUE;
+  }
   /* if decrement 16 bits in register */
   if (AOP_TYPE (IC_LEFT (ic)) == AOP_REG &&
       AOP_TYPE (IC_RESULT (ic)) == AOP_REG &&
@@ -3796,8 +4214,9 @@ genMinusDec (iCode * ic)
       (icount == 1))
     {
       symbol *tlbl;
-      int emitTlbl;
-      int labelRange;
+      int    emitTlbl;
+      int    labelRange;
+      char   *l;
 
       /* If the next instruction is a goto and the goto target
          * is <= 5 instructions previous to this, we can generate
@@ -3817,53 +4236,62 @@ genMinusDec (iCode * ic)
 	  emitTlbl = 1;
 	}
 
-      emitcode ("dec", "%s", aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE, FALSE));
+      l = aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE, NULL);
+      emitcode ("dec", "%s", l);
+ 
       if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
 	  AOP_TYPE (IC_RESULT (ic)) == AOP_DPTR ||
 	  IS_AOP_PREG (IC_RESULT (ic)))
-	emitcode ("cjne", "%s,#0xff,!tlabel"
-		  ,aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE, FALSE)
-		  ,tlbl->key + 100);
+      {	    
+	  emitcode ("cjne", "%s,#!constbyte,!tlabel", l, 0xff, tlbl->key + 100);
+      }
       else
-	{
-	  emitcode ("mov", "a,#0xff");
-	  emitcode ("cjne", "a,%s,!tlabel"
-		    ,aopGet (AOP (IC_RESULT (ic)), LSB, FALSE, FALSE, FALSE)
-		    ,tlbl->key + 100);
-	}
-      emitcode ("dec", "%s", aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE, FALSE));
+      {
+	  emitcode ("mov", "a,#!constbyte",0xff);
+	  emitcode ("cjne", "a,%s,!tlabel", l, tlbl->key + 100);
+      }
+      l = aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE, NULL);
+      emitcode ("dec", "%s", l);
       if (size > 2)
 	{
-	  if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
-	      AOP_TYPE (IC_RESULT (ic)) == AOP_DPTR ||
-	      IS_AOP_PREG (IC_RESULT (ic)))
-	    emitcode ("cjne", "%s,#0xff,!tlabel"
-		  ,aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE, FALSE)
-		      ,tlbl->key + 100);
-	  else
+	    if (!strcmp(l, "acc"))
+	    {
+		emitcode("jnz", "!tlabel", tlbl->key + 100);
+	    }
+	    else if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
+		     AOP_TYPE (IC_RESULT (ic)) == AOP_DPTR ||
+		     IS_AOP_PREG (IC_RESULT (ic)))
+	    {	    
+		emitcode ("cjne", "%s,#!constbyte,!tlabel", l, 0xff, tlbl->key + 100);
+	    }
+	    else
 	    {
-	      emitcode ("cjne", "a,%s,!tlabel"
-		  ,aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE, FALSE)
-			,tlbl->key + 100);
+		emitcode ("mov", "a,#!constbyte",0xff);
+		emitcode ("cjne", "a,%s,!tlabel", l, tlbl->key + 100);
 	    }
-	  emitcode ("dec", "%s", aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE, FALSE));
+	    l = aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE, NULL);
+	    emitcode ("dec", "%s", l);
 	}
       if (size > 3)
 	{
-	  if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
-	      AOP_TYPE (IC_RESULT (ic)) == AOP_DPTR ||
-	      IS_AOP_PREG (IC_RESULT (ic)))
-	    emitcode ("cjne", "%s,#0xff,!tlabel"
-		  ,aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE, FALSE)
-		      ,tlbl->key + 100);
-	  else
+	    if (!strcmp(l, "acc"))
 	    {
-	      emitcode ("cjne", "a,%s,!tlabel"
-		  ,aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE, FALSE)
-			,tlbl->key + 100);
+		emitcode("jnz", "!tlabel", tlbl->key + 100);
 	    }
-	  emitcode ("dec", "%s", aopGet (AOP (IC_RESULT (ic)), MSB32, FALSE, FALSE, FALSE));
-	}
+	    else if (AOP_TYPE (IC_RESULT (ic)) == AOP_REG ||
+		     AOP_TYPE (IC_RESULT (ic)) == AOP_DPTR ||
+		     IS_AOP_PREG (IC_RESULT (ic)))
+	    {	    
+		emitcode ("cjne", "%s,#!constbyte,!tlabel", l, 0xff, tlbl->key + 100);
+	    }
+	    else
+	    {
+		emitcode ("mov", "a,#!constbyte",0xff);
+		emitcode ("cjne", "a,%s,!tlabel", l, tlbl->key + 100);
+	    }	    
+	    l = aopGet (AOP (IC_RESULT (ic)), MSB32, FALSE, FALSE, NULL);
+	    emitcode ("dec", "%s", l);
+	}
       if (emitTlbl)
 	{
 	  emitcode ("", "!tlabeldef", tlbl->key + 100);
@@ -3888,7 +4316,8 @@ genMinusDec (iCode * ic)
       _startLazyDPSEvaluation ();
       while (icount--)
 	{
-	  emitcode ("dec", "%s", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE, FALSE));
+	  emitcode ("dec", "%s",
+		    aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE, NULL));
 	}
       _endLazyDPSEvaluation ();
 
@@ -3964,24 +4393,17 @@ genMinusBits (iCode * ic)
 static void
 genMinus (iCode * ic)
 {
-  int size, offset = 0;
-  int rSize;
-  unsigned long lit = 0L;
-  bool pushResult = FALSE;
+    int size, offset = 0;
+    int rSize;
+    long lit = 0L;
+    bool pushResult;
 
-  D (emitcode (";", "genMinus "););
+    D (emitcode (";", "genMinus "););
 
-  aopOp (IC_LEFT (ic), ic, FALSE, FALSE);
-  aopOp (IC_RIGHT (ic), ic, FALSE, TRUE);
-  if ((AOP_TYPE (IC_LEFT (ic)) == AOP_DPTR) &&
-      (AOP_TYPE (IC_RIGHT (ic)) == AOP_DPTR2))
-    {
-      pushResult = TRUE;
-    }
-  else
-    {
-      aopOp (IC_RESULT (ic), ic, TRUE, AOP_TYPE (IC_LEFT (ic)) == AOP_DPTR);
+    AOP_OP_3_NOFATAL(ic, pushResult);	
 
+    if (!pushResult)
+    {
       /* special cases :- */
       /* if both left & right are in bit space */
       if (AOP_TYPE (IC_LEFT (ic)) == AOP_CRY &&
@@ -4006,47 +4428,51 @@ genMinus (iCode * ic)
     }
   else
     {
-      lit = (unsigned long) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
-      lit = -(long) lit;
+      lit = (long) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
+      lit = -lit;
     }
 
 
   /* if literal, add a,#-lit, else normal subb */
   _startLazyDPSEvaluation ();
-  while (size--)
-    {
-      MOVA (aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE, TRUE));
-      if (AOP_TYPE (IC_RIGHT (ic)) != AOP_LIT)
-	emitcode ("subb", "a,%s",
-		  aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, FALSE));
-      else
-	{
+  while (size--) {
+      if (AOP_TYPE (IC_RIGHT (ic)) != AOP_LIT) {
+	  if (AOP_USESDPTR(IC_RIGHT(ic))) {
+	      emitcode ("mov","b,%s",
+			aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, NULL));
+	      MOVA(aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE, NULL));
+	      emitcode ("subb","a,b");
+	  } else {
+	      MOVA (aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE, NULL));
+	      emitcode ("subb", "a,%s",
+			aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, 
+				DP2_RESULT_REG));
+	  }
+      } else {
+	  MOVA (aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE, NULL));
 	  /* first add without previous c */
 	  if (!offset) {
-	    if (!size && lit==-1) {
-	      emitcode ("dec", "a");
-	    } else {
-	      emitcode ("add", "a,#!constbyte",
-			(unsigned int) (lit & 0x0FFL));
-	    }
+	      if (!size && lit==-1) {
+		  emitcode ("dec", "a");
+	      } else {
+		  emitcode ("add", "a,#!constbyte",
+			    (unsigned int) (lit & 0x0FFL));
+	      }
 	  } else {
-	    emitcode ("addc", "a,#!constbyte",
-		      (unsigned int) ((lit >> (offset * 8)) & 0x0FFL));
+	      emitcode ("addc", "a,#!constbyte",
+			(unsigned int) ((lit >> (offset * 8)) & 0x0FFL));
 	  }
-	}
-
-      if (pushResult)
-	{
+      }
+      
+      if (pushResult) {
 	  emitcode ("push", "acc");
-	}
-      else
-	{
+      } else {
 	  aopPut (AOP (IC_RESULT (ic)), "a", offset);
-	}
+      }
       offset++;
-    }
+  }
   _endLazyDPSEvaluation ();
-
+  
   if (pushResult)
     {
       aopOp (IC_RESULT (ic), ic, TRUE, FALSE);
@@ -4119,8 +4545,8 @@ genMultOneByte (operand * left,
 	  SPEC_USIGN(operandType(right)))) {
     // just an unsigned 8*8=8/16 multiply
     //emitcode (";","unsigned");
-    emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE, TRUE));
-    MOVA (aopGet (AOP (left), 0, FALSE, FALSE, TRUE));
+    emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE, NULL));
+    MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL));
     emitcode ("mul", "ab");
    
     _G.accInUse++; _G.bInUse++;
@@ -4147,7 +4573,7 @@ genMultOneByte (operand * left,
 
   emitcode (";", "signed");
   emitcode ("clr", "F0"); // reset sign flag
-  MOVA (aopGet (AOP (left), 0, FALSE, FALSE, TRUE));
+  MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL));
 
   lbl=newiTempLabel(NULL);
   emitcode ("jnb", "acc.7,!tlabel",  lbl->key+100);
@@ -4171,7 +4597,7 @@ genMultOneByte (operand * left,
   } else {
     lbl=newiTempLabel(NULL);
     emitcode ("mov", "b,a");
-    emitcode ("mov", "a,%s", aopGet (AOP (right), 0, FALSE, FALSE, TRUE));
+    emitcode ("mov", "a,%s", aopGet (AOP (right), 0, FALSE, FALSE, NULL));
     emitcode ("jnb", "acc.7,!tlabel", lbl->key+100);
     // right side is negative, 8-bit two's complement
     emitcode ("cpl", "F0"); // complement sign flag
@@ -4250,8 +4676,8 @@ static void genMultTwoByte (operand *left, operand *right,
 			emitcode ("mov","mb,#!constbyte",(val >> 8) & 0xff);		    
 		} else {
 			lbl = newiTempLabel(NULL);
-			emitcode ("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE,TRUE));
-			emitcode ("mov","a,%s",aopGet(AOP(right),1,FALSE,FALSE,TRUE));
+			emitcode ("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE,NULL));
+			emitcode ("mov","a,%s",aopGet(AOP(right),1,FALSE,FALSE,NULL));
 			emitcode ("jnb","acc.7,!tlabel",lbl->key+100);		
 			emitcode ("xch", "a,b");
 			emitcode ("cpl","a");
@@ -4265,14 +4691,14 @@ static void genMultTwoByte (operand *left, operand *right,
 			emitcode ("mov","mb,a");
 		}
 	} else {
-		emitcode ("mov","mb,%s",aopGet(AOP(right),0,FALSE,FALSE,TRUE));
-		emitcode ("mov","mb,%s",aopGet(AOP(right),1,FALSE,FALSE,TRUE));
+		emitcode ("mov","mb,%s",aopGet(AOP(right),0,FALSE,FALSE,NULL));
+		emitcode ("mov","mb,%s",aopGet(AOP(right),1,FALSE,FALSE,NULL));
 	}
 	/* load up MA with left */
 	if (!umult) {
 		lbl = newiTempLabel(NULL);
-		emitcode ("mov","b,%s",aopGet(AOP(left),0,FALSE,FALSE,TRUE));
-		emitcode ("mov","a,%s",aopGet(AOP(left),1,FALSE,FALSE,TRUE));
+		emitcode ("mov","b,%s",aopGet(AOP(left),0,FALSE,FALSE,NULL));
+		emitcode ("mov","a,%s",aopGet(AOP(left),1,FALSE,FALSE,NULL));
 		emitcode ("jnb","acc.7,!tlabel",lbl->key+100);
 		emitcode ("xch", "a,b");
 		emitcode ("cpl","a");
@@ -4286,14 +4712,14 @@ static void genMultTwoByte (operand *left, operand *right,
 		emitcode ("mov","ma,b");
 		emitcode ("mov","ma,a");
 	} else {
-		emitcode ("mov","ma,%s",aopGet(AOP(left),0,FALSE,FALSE,TRUE));
-		emitcode ("mov","ma,%s",aopGet(AOP(left),1,FALSE,FALSE,TRUE));
+		emitcode ("mov","ma,%s",aopGet(AOP(left),0,FALSE,FALSE,NULL));
+		emitcode ("mov","ma,%s",aopGet(AOP(left),1,FALSE,FALSE,NULL));
 	}
 	/* wait for multiplication to finish */
 	lbl = newiTempLabel(NULL);
 	emitcode("","!tlabeldef", lbl->key+100);
 	emitcode("mov","a,mcnt1");
-	emitcode("anl","a,#0x80");
+	emitcode("anl","a,#!constbyte",0x80);
 	emitcode("jnz","!tlabel",lbl->key+100);
 	
 	freeAsmop (left, NULL, ic, TRUE);
@@ -4480,14 +4906,12 @@ genDivOneByte (operand * left,
   /* signed is a little bit more difficult */
 
   /* save the signs of the operands */
-  l = aopGet (AOP (left), 0, FALSE, FALSE, TRUE);
-  MOVA (l);
+  MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL));
   emitcode ("xrl", "a,%s", aopGet (AOP (right), 0, FALSE, TRUE, FALSE));
   emitcode ("push", "acc");	/* save it on the stack */
 
   /* now sign adjust for both left & right */
-  l = aopGet (AOP (right), 0, FALSE, FALSE, TRUE);
-  MOVA (l);
+  MOVA (aopGet (AOP (right), 0, FALSE, FALSE, NULL));
   lbl = newiTempLabel (NULL);
   emitcode ("jnb", "acc.7,!tlabel", (lbl->key + 100));
   emitcode ("cpl", "a");
@@ -4496,8 +4920,7 @@ genDivOneByte (operand * left,
   emitcode ("mov", "b,a");
 
   /* sign adjust left side */
-  l = aopGet (AOP (left), 0, FALSE, FALSE, TRUE);
-  MOVA (l);
+  MOVA( aopGet (AOP (left), 0, FALSE, FALSE, NULL));
 
   lbl = newiTempLabel (NULL);
   emitcode ("jnb", "acc.7,!tlabel", (lbl->key + 100));
@@ -4566,8 +4989,8 @@ static void genDivTwoByte (operand *left, operand *right,
 	if (!umult) {
 		emitcode("clr","F0");
 		lbl = newiTempLabel(NULL);
-		emitcode ("mov","b,%s",aopGet(AOP(left),0,FALSE,FALSE,TRUE));
-		emitcode ("mov","a,%s",aopGet(AOP(left),1,FALSE,FALSE,TRUE));
+		emitcode ("mov","b,%s",aopGet(AOP(left),0,FALSE,FALSE,NULL));
+		emitcode ("mov","a,%s",aopGet(AOP(left),1,FALSE,FALSE,NULL));
 		emitcode ("jnb","acc.7,!tlabel",lbl->key+100);
 		emitcode ("xch", "a,b");
 		emitcode ("cpl","a");
@@ -4580,8 +5003,8 @@ static void genDivTwoByte (operand *left, operand *right,
 		emitcode ("mov","ma,b");
 		emitcode ("mov","ma,a");
 	} else {
-		emitcode ("mov","ma,%s",aopGet(AOP(left),0,FALSE,FALSE,TRUE));
-		emitcode ("mov","ma,%s",aopGet(AOP(left),1,FALSE,FALSE,TRUE));
+		emitcode ("mov","ma,%s",aopGet(AOP(left),0,FALSE,FALSE,NULL));
+		emitcode ("mov","ma,%s",aopGet(AOP(left),1,FALSE,FALSE,NULL));
 	}
 
 	/* load up MB with right */
@@ -4599,8 +5022,8 @@ static void genDivTwoByte (operand *left, operand *right,
 			emitcode ("mov","mb,#!constbyte",(val >> 8) & 0xff);
 		} else {
 			lbl = newiTempLabel(NULL);
-			emitcode ("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE,TRUE));
-			emitcode ("mov","a,%s",aopGet(AOP(right),1,FALSE,FALSE,TRUE));
+			emitcode ("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE,NULL));
+			emitcode ("mov","a,%s",aopGet(AOP(right),1,FALSE,FALSE,NULL));
 			emitcode ("jnb","acc.7,!tlabel",lbl->key+100);		
 			emitcode ("xch", "a,b");
 			emitcode ("cpl","a");
@@ -4615,15 +5038,15 @@ static void genDivTwoByte (operand *left, operand *right,
 			emitcode ("mov","mb,a");
 		}
 	} else {
-		emitcode ("mov","mb,%s",aopGet(AOP(right),0,FALSE,FALSE,TRUE));
-		emitcode ("mov","mb,%s",aopGet(AOP(right),1,FALSE,FALSE,TRUE));
+		emitcode ("mov","mb,%s",aopGet(AOP(right),0,FALSE,FALSE,NULL));
+		emitcode ("mov","mb,%s",aopGet(AOP(right),1,FALSE,FALSE,NULL));
 	}
 
 	/* wait for multiplication to finish */
 	lbl = newiTempLabel(NULL);
 	emitcode("","!tlabeldef", lbl->key+100);
 	emitcode("mov","a,mcnt1");
-	emitcode("anl","a,#0x80");
+	emitcode("anl","a,#!constbyte",0x80);
 	emitcode("jnz","!tlabel",lbl->key+100);
 	
 	freeAsmop (left, NULL, ic, TRUE);
@@ -4754,15 +5177,13 @@ genModOneByte (operand * left,
   /* signed is a little bit more difficult */
 
   /* save the signs of the operands */
-  l = aopGet (AOP (left), 0, FALSE, FALSE, TRUE);
-  MOVA (l);
+  MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL));
 
   emitcode ("xrl", "a,%s", aopGet (AOP (right), 0, FALSE, FALSE, FALSE));
   emitcode ("push", "acc");	/* save it on the stack */
 
   /* now sign adjust for both left & right */
-  l = aopGet (AOP (right), 0, FALSE, FALSE, TRUE);
-  MOVA (l);
+  MOVA (aopGet (AOP (right), 0, FALSE, FALSE, NULL));
 
   lbl = newiTempLabel (NULL);
   emitcode ("jnb", "acc.7,!tlabel", (lbl->key + 100));
@@ -4772,8 +5193,7 @@ genModOneByte (operand * left,
   emitcode ("mov", "b,a");
 
   /* sign adjust left side */
-  l = aopGet (AOP (left), 0, FALSE, FALSE, TRUE);
-  MOVA (l);
+  MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL));
 
   lbl = newiTempLabel (NULL);
   emitcode ("jnb", "acc.7,!tlabel", (lbl->key + 100));
@@ -4827,8 +5247,8 @@ static void genModTwoByte (operand *left, operand *right,
 
 	if (!umult) {
 		lbl = newiTempLabel(NULL);
-		emitcode ("mov","b,%s",aopGet(AOP(left),0,FALSE,FALSE,TRUE));
-		emitcode ("mov","a,%s",aopGet(AOP(left),1,FALSE,FALSE,TRUE));
+		emitcode ("mov","b,%s",aopGet(AOP(left),0,FALSE,FALSE,NULL));
+		emitcode ("mov","a,%s",aopGet(AOP(left),1,FALSE,FALSE,NULL));
 		emitcode ("jnb","acc.7,!tlabel",lbl->key+100);
 		emitcode ("xch", "a,b");
 		emitcode ("cpl","a");
@@ -4840,8 +5260,8 @@ static void genModTwoByte (operand *left, operand *right,
 		emitcode ("mov","ma,b");
 		emitcode ("mov","ma,a");
 	} else {
-		emitcode ("mov","ma,%s",aopGet(AOP(left),0,FALSE,FALSE,TRUE));
-		emitcode ("mov","ma,%s",aopGet(AOP(left),1,FALSE,FALSE,TRUE));
+		emitcode ("mov","ma,%s",aopGet(AOP(left),0,FALSE,FALSE,NULL));
+		emitcode ("mov","ma,%s",aopGet(AOP(left),1,FALSE,FALSE,NULL));
 	}
 
 	/* load up MB with right */
@@ -4855,8 +5275,8 @@ static void genModTwoByte (operand *left, operand *right,
 			emitcode ("mov","mb,#!constbyte",(val >> 8) & 0xff);		    
 		} else {
 			lbl = newiTempLabel(NULL);
-			emitcode ("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE,TRUE));
-			emitcode ("mov","a,%s",aopGet(AOP(right),1,FALSE,FALSE,TRUE));
+			emitcode ("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE,NULL));
+			emitcode ("mov","a,%s",aopGet(AOP(right),1,FALSE,FALSE,NULL));
 			emitcode ("jnb","acc.7,!tlabel",lbl->key+100);		
 			emitcode ("xch", "a,b");
 			emitcode ("cpl","a");
@@ -4869,15 +5289,15 @@ static void genModTwoByte (operand *left, operand *right,
 			emitcode ("mov","mb,a");
 		}
 	} else {
-		emitcode ("mov","mb,%s",aopGet(AOP(right),0,FALSE,FALSE,TRUE));
-		emitcode ("mov","mb,%s",aopGet(AOP(right),1,FALSE,FALSE,TRUE));
+		emitcode ("mov","mb,%s",aopGet(AOP(right),0,FALSE,FALSE,NULL));
+		emitcode ("mov","mb,%s",aopGet(AOP(right),1,FALSE,FALSE,NULL));
 	}
 
 	/* wait for multiplication to finish */
 	lbl = newiTempLabel(NULL);
 	emitcode("","!tlabeldef", lbl->key+100);
 	emitcode("mov","a,mcnt1");
-	emitcode("anl","a,#0x80");
+	emitcode("anl","a,#!constbyte",0x80);
 	emitcode("jnz","!tlabel",lbl->key+100);
 	
 	freeAsmop (left, NULL, ic, TRUE);
@@ -4953,8 +5373,7 @@ genIfxJump (iCode * ic, char *jval)
   symbol *tlbl = newiTempLabel (NULL);
   char *inst;
 
-  D (emitcode (";", "genIfxJump ");
-    );
+  D (emitcode (";", "genIfxJump"););
 
   /* if true label then we jump if condition
      supplied is true */
@@ -4993,8 +5412,7 @@ genCmp (operand * left, operand * right,
   unsigned long lit = 0L;
   operand *result;
 
-  D (emitcode (";", "genCmp");
-    );
+  D (emitcode (";", "genCmp"););
 
   result = IC_RESULT (ic);
 
@@ -5003,7 +5421,7 @@ genCmp (operand * left, operand * right,
       AOP_TYPE (right) == AOP_CRY)
     {
       emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
-      emitcode ("anl", "c,/%s", AOP (left)->aopu.aop_dir);
+      emitcode ("anl", "c,%s", AOP (left)->aopu.aop_dir);
     }
   else
     {
@@ -5013,13 +5431,13 @@ genCmp (operand * left, operand * right,
       size = max (AOP_SIZE (left), AOP_SIZE (right));
 
       /* if unsigned char cmp with lit, do cjne left,#right,zz */
-      if ((size == 1) && !sign &&
-	  (AOP_TYPE (right) == AOP_LIT && AOP_TYPE (left) != AOP_DIR))
+      if ((size == 1) && !sign 
+	  && (AOP_TYPE (right) == AOP_LIT && AOP_TYPE (left) != AOP_DIR && AOP_TYPE (left) != AOP_STR))
 	{
 	  symbol *lbl = newiTempLabel (NULL);
 	  emitcode ("cjne", "%s,%s,!tlabel",
-		    aopGet (AOP (left), offset, FALSE, FALSE, FALSE),
-		    aopGet (AOP (right), offset, FALSE, FALSE, FALSE),
+		    aopGet (AOP (left), offset, FALSE, FALSE, NULL),
+		    aopGet (AOP (right), offset, FALSE, FALSE, NULL),
 		    lbl->key + 100);
 	  emitcode ("", "!tlabeldef", lbl->key + 100);
 	}
@@ -5037,7 +5455,7 @@ genCmp (operand * left, operand * right,
 		    }
 		  else
 		    {
-		      MOVA (aopGet (AOP (left), AOP_SIZE (left) - 1, FALSE, FALSE, TRUE));
+		      MOVA (aopGet (AOP (left), AOP_SIZE (left) - 1, FALSE, FALSE, NULL));
 
 		      freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
 		      freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
@@ -5062,35 +5480,28 @@ genCmp (operand * left, operand * right,
 	  CLRC;
 	  while (size--)
 	    {
-	      emitcode (";", "genCmp #1: %d/%d/%d", size, sign, offset);
-	      MOVA (aopGet (AOP (left), offset, FALSE, FALSE, TRUE));
-	      emitcode (";", "genCmp #2");
+	      // emitcode (";", "genCmp #1: %d/%d/%d", size, sign, offset);
+	      MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
+	      // emitcode (";", "genCmp #2");
 	      if (sign && (size == 0))
 		{
-		  emitcode (";", "genCmp #3");
-		  emitcode ("xrl", "a,#0x80");
+		  // emitcode (";", "genCmp #3");
+		  emitcode ("xrl", "a,#!constbyte",0x80);
 		  if (AOP_TYPE (right) == AOP_LIT)
 		    {
 		      unsigned long lit = (unsigned long)
 		      floatFromVal (AOP (right)->aopu.aop_lit);
-		      emitcode (";", "genCmp #3.1");
+		      // emitcode (";", "genCmp #3.1");
 		      emitcode ("subb", "a,#!constbyte",
 				0x80 ^ (unsigned int) ((lit >> (offset * 8)) & 0x0FFL));
 		    }
 		  else
 		    {
-		      emitcode (";", "genCmp #3.2");
-		      if (AOP_NEEDSACC (right))
-			{
-			  emitcode ("push", "acc");
-			}
-		      emitcode ("mov", "b,%s", aopGet (AOP (right), offset++,
-						       FALSE, FALSE, FALSE));
-		      emitcode ("xrl", "b,#0x80");
-		      if (AOP_NEEDSACC (right))
-			{
-			  emitcode ("pop", "acc");
-			}
+		      // emitcode (";", "genCmp #3.2");
+		      saveAccWarn = 0;	
+		      MOVB(aopGet (AOP (right), offset++, FALSE, FALSE, "b"));
+		      saveAccWarn = DEFAULT_ACC_WARNING;
+		      emitcode ("xrl", "b,#!constbyte",0x80);
 		      emitcode ("subb", "a,b");
 		    }
 		}
@@ -5098,21 +5509,10 @@ genCmp (operand * left, operand * right,
 		{
 		  const char *s;
 
-		  emitcode (";", "genCmp #4");
-		  if (AOP_NEEDSACC (right))
-		    {
-		      /* Yuck!! */
-		      emitcode (";", "genCmp #4.1");
-		      emitcode ("xch", "a, b");
-		      MOVA (aopGet (AOP (right), offset++, FALSE, FALSE, TRUE));
-		      emitcode ("xch", "a, b");
-		      s = "b";
-		    }
-		  else
-		    {
-		      emitcode (";", "genCmp #4.2");
-		      s = aopGet (AOP (right), offset++, FALSE, FALSE, FALSE);
-		    }
+		  // emitcode (";", "genCmp #4");
+		  saveAccWarn = 0;
+		  s = aopGet (AOP (right), offset++, FALSE, FALSE, "b");
+		  saveAccWarn = DEFAULT_ACC_WARNING;
 
 		  emitcode ("subb", "a,%s", s);
 		}
@@ -5235,8 +5635,7 @@ gencjneshort (operand * left, operand * right, symbol * lbl)
        * Exclude the generic type byte from the comparison.
        */
       size--;
-      D (emitcode (";", "cjneshort: generic ptr special case.");
-	)
+      D (emitcode (";", "cjneshort: generic ptr special case."););
     }
 
 
@@ -5246,10 +5645,9 @@ gencjneshort (operand * left, operand * right, symbol * lbl)
     {
       while (size--)
 	{
-	  char *l = aopGet (AOP (left), offset, FALSE, FALSE, TRUE);
-	  MOVA (l);
+	  MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
 	  emitcode ("cjne", "a,%s,!tlabel",
-		    aopGet (AOP (right), offset, FALSE, FALSE, FALSE),
+		    aopGet (AOP (right), offset, FALSE, FALSE, NULL),
 		    lbl->key + 100);
 	  offset++;
 	}
@@ -5264,13 +5662,13 @@ gencjneshort (operand * left, operand * right, symbol * lbl)
     {
       while (size--)
 	{
-	  MOVA (aopGet (AOP (left), offset, FALSE, FALSE, TRUE));
+	  MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
 	  if ((AOP_TYPE (left) == AOP_DIR && AOP_TYPE (right) == AOP_LIT) &&
 	      ((unsigned int) ((lit >> (offset * 8)) & 0x0FFL) == 0))
 	    emitcode ("jnz", "!tlabel", lbl->key + 100);
 	  else
 	    emitcode ("cjne", "a,%s,!tlabel",
-		      aopGet (AOP (right), offset, FALSE, TRUE, FALSE),
+		      aopGet (AOP (right), offset, FALSE, TRUE, DP2_RESULT_REG),
 		      lbl->key + 100);
 	  offset++;
 	}
@@ -5280,10 +5678,8 @@ gencjneshort (operand * left, operand * right, symbol * lbl)
       /* right is a pointer reg need both a & b */
       while (size--)
 	{
-	  char *l = aopGet (AOP (left), offset, FALSE, FALSE, TRUE);
-	  if (strcmp (l, "b"))
-	    emitcode ("mov", "b,%s", l);
-	  MOVA (aopGet (AOP (right), offset, FALSE, FALSE, TRUE));
+	  MOVB (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
+	  MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL));
 	  emitcode ("cjne", "a,b,!tlabel", lbl->key + 100);
 	  offset++;
 	}
@@ -5517,7 +5913,7 @@ ifxForOp (operand * op, iCode * ic)
 /* hasInc - operand is incremented before any other use            */
 /*-----------------------------------------------------------------*/
 static iCode *
-hasInc (operand *op, iCode *ic)
+hasInc (operand *op, iCode *ic, int osize)
 {
   sym_link *type = operandType(op);
   sym_link *retype = getSpec (type);
@@ -5528,7 +5924,9 @@ hasInc (operand *op, iCode *ic)
   if (!IS_SYMOP(op)) return NULL;
 
   if (IS_BITVAR(retype)||!IS_PTR(type)) return NULL;
-  isize = getSize(type->next);
+  if (IS_AGGREGATE(type->next)) return NULL;
+  if (osize != (isize = getSize(type->next))) return NULL;
+
   while (lic) {
       /* if operand of the form op = op + <sizeof *op> */
       if (lic->op == '+' && isOperandEqual(IC_LEFT(lic),op) &&
@@ -5542,7 +5940,7 @@ hasInc (operand *op, iCode *ic)
 	  return NULL;
       }
       /* if GOTO or IFX */
-      if (lic->op == IFX || lic->op == GOTO) break;
+      if (lic->op == IFX || lic->op == GOTO || lic->op == LABEL) break;
       lic = lic->next;
   }
   return NULL;
@@ -5728,9 +6126,9 @@ genFarFarLogicOp(iCode *ic, char *logicOp)
       _startLazyDPSEvaluation();
       for (size = compSize; (size--); offset++)
       {
-      	  MOVA (aopGet (AOP (IC_LEFT(ic)), offset, FALSE, FALSE, TRUE));
+      	  MOVA (aopGet (AOP (IC_LEFT(ic)), offset, FALSE, FALSE, NULL));
       	  emitcode ("mov", "%s, acc", DP2_RESULT_REG);
-      	  MOVA (aopGet (AOP (IC_RIGHT(ic)), offset, FALSE, FALSE, TRUE));
+      	  MOVA (aopGet (AOP (IC_RIGHT(ic)), offset, FALSE, FALSE, NULL));
       	  
       	  emitcode (logicOp, "a,%s", DP2_RESULT_REG);
       	  emitcode ("push", "acc");
@@ -5765,8 +6163,8 @@ genAnd (iCode * ic, iCode * ifx)
   operand *left, *right, *result;
   int size, offset = 0;
   unsigned long lit = 0L;
-  int bytelit = 0;
-  char buffer[10];
+  int bytelit;
+  char buff[10];
   bool pushResult;
 
   D (emitcode (";", "genAnd "););
@@ -5863,7 +6261,7 @@ genAnd (iCode * ic, iCode * ifx)
 	  else
 	    {
 	      // c = bit & val;
-	      MOVA (aopGet (AOP (right), 0, FALSE, FALSE, TRUE));
+	      MOVA (aopGet (AOP (right), 0, FALSE, FALSE, NULL));
 	      // c = lsb
 	      emitcode ("rrc", "a");
 	      emitcode ("anl", "c,%s", AOP (left)->aopu.aop_dir);
@@ -5890,7 +6288,7 @@ genAnd (iCode * ic, iCode * ifx)
       if (posbit)
 	{
 	  posbit--;
-	  MOVA (aopGet (AOP (left), posbit >> 3, FALSE, FALSE, TRUE));
+	  MOVA (aopGet (AOP (left), posbit >> 3, FALSE, FALSE, NULL));
 	  // bit = left & 2^n
 	  if (size)
 	    emitcode ("mov", "c,acc.%d", posbit & 0x07);
@@ -5899,9 +6297,14 @@ genAnd (iCode * ic, iCode * ifx)
 	    {
 	      if (ifx)
 		{
-		  sprintf (buffer, "acc.%d", posbit & 0x07);
-		  genIfxJump (ifx, buffer);
+		  SNPRINTF (buff, sizeof(buff), 
+			    "acc.%d", posbit & 0x07);
+		  genIfxJump (ifx, buff);
 		}
+	      else 
+		  {
+		      emitcode ("anl","a,#!constbyte",1 << (posbit & 0x07));
+		  }
 	      goto release;
 	    }
 	}
@@ -5915,7 +6318,7 @@ genAnd (iCode * ic, iCode * ifx)
 	    {
 	      if ((bytelit = ((lit >> (offset * 8)) & 0x0FFL)) != 0x0L)
 		{
-		  MOVA (aopGet (AOP (left), offset, FALSE, FALSE, TRUE));
+		  MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
 		  // byte ==  2^n ?
 		  if ((posbit = isLiteralBit (bytelit)) != 0)
 		    emitcode ("jb", "acc.%d,!tlabel", (posbit - 1) & 0x07, tlbl->key + 100);
@@ -5923,7 +6326,7 @@ genAnd (iCode * ic, iCode * ifx)
 		    {
 		      if (bytelit != 0x0FFL)
 			emitcode ("anl", "a,%s",
-			  aopGet (AOP (right), offset, FALSE, TRUE, FALSE));
+			  aopGet (AOP (right), offset, FALSE, TRUE, DP2_RESULT_REG));
 		      emitcode ("jnz", "!tlabel", tlbl->key + 100);
 		    }
 		}
@@ -5960,31 +6363,33 @@ genAnd (iCode * ic, iCode * ifx)
 		aopPut (AOP (result), zero, offset);
 	      else if (IS_AOP_PREG (result))
 		{
-		  MOVA (aopGet (AOP (right), offset, FALSE, FALSE, TRUE));
-		  emitcode ("anl", "a,%s", aopGet (AOP (left), offset, FALSE, TRUE, FALSE));
+		  MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL));
+		  emitcode ("anl", "a,%s",
+			    aopGet (AOP (left), offset, FALSE, TRUE, DP2_RESULT_REG));
 		  aopPut (AOP (result), "a", offset);
 		}
 	      else
 		emitcode ("anl", "%s,%s",
-			  aopGet (AOP (left), offset, FALSE, TRUE, FALSE),
-			  aopGet (AOP (right), offset, FALSE, FALSE, FALSE));
+			  aopGet (AOP (left), offset, FALSE, TRUE, NULL),
+			  aopGet (AOP (right), offset, FALSE, FALSE, NULL));
 	    }
 	  else
 	    {
 	      if (AOP_TYPE (left) == AOP_ACC)
-		emitcode ("anl", "a,%s", aopGet (AOP (right), offset, FALSE, FALSE, FALSE));
+		emitcode ("anl", "a,%s",
+			  aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG));
 	      else
 		{
-		  MOVA (aopGet (AOP (right), offset, FALSE, FALSE, TRUE));
+		  MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL));
 		  if (IS_AOP_PREG (result))
 		    {
-		      emitcode ("anl", "a,%s", aopGet (AOP (left), offset, FALSE, TRUE, FALSE));
+		      emitcode ("anl", "a,%s",
+				aopGet (AOP (left), offset, FALSE, TRUE, DP2_RESULT_REG));
 		      aopPut (AOP (result), "a", offset);
-
 		    }
 		  else
 		    emitcode ("anl", "%s,a",
-			   aopGet (AOP (left), offset, FALSE, TRUE, FALSE));
+			   aopGet (AOP (left), offset, FALSE, TRUE, DP2_RESULT_REG));
 		}
 	    }
 	}
@@ -6005,16 +6410,16 @@ genAnd (iCode * ic, iCode * ifx)
 	    {
 	      if (AOP_TYPE(right)==AOP_REG && AOP_TYPE(left)==AOP_ACC) {
 		emitcode ("anl", "a,%s",
-			  aopGet (AOP (right), offset, FALSE, FALSE, FALSE));
+			  aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG));
 	      } else {
 		if (AOP_TYPE(left)==AOP_ACC) {
 		  emitcode("mov", "b,a");
-		  MOVA (aopGet (AOP (right), offset, FALSE, FALSE, TRUE));
+		  MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL));
 		  emitcode("anl", "a,b");
 		}else {
-		  MOVA (aopGet (AOP (right), offset, FALSE, FALSE, TRUE));
+		  MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL));
 		  emitcode ("anl", "a,%s",
-			    aopGet (AOP (left), offset, FALSE, FALSE, FALSE));
+			    aopGet (AOP (left), offset, FALSE, FALSE, DP2_RESULT_REG));
 		}
 	      }
 	      emitcode ("jnz", "!tlabel", tlbl->key + 100);
@@ -6040,7 +6445,7 @@ genAnd (iCode * ic, iCode * ifx)
 		  if ((bytelit = (int) ((lit >> (offset * 8)) & 0x0FFL)) == 0x0FF)
 		    {
 		      aopPut (AOP (result),
-			   aopGet (AOP (left), offset, FALSE, FALSE, FALSE),
+			   aopGet (AOP (left), offset, FALSE, FALSE, NULL),
 			      offset);
 		      continue;
 		    }
@@ -6050,9 +6455,9 @@ genAnd (iCode * ic, iCode * ifx)
 		      continue;
 		    }
 		  D (emitcode (";", "better literal AND."););
-		  MOVA (aopGet (AOP (left), offset, FALSE, FALSE, TRUE));
+		  MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
 		  emitcode ("anl", "a, %s", aopGet (AOP (right), offset,
-						    FALSE, FALSE, FALSE));
+						    FALSE, FALSE, DP2_RESULT_REG));
 
 		}
 	      else
@@ -6061,19 +6466,19 @@ genAnd (iCode * ic, iCode * ifx)
 		  // and better if result is SFR
 		  if (AOP_TYPE (left) == AOP_ACC)
 		    {
-		      emitcode ("anl", "a,%s", aopGet (AOP (right), offset,
-						       FALSE, FALSE, FALSE));
+		      emitcode ("anl", "a,%s", 
+				aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG));
 		    }
 		  else
 		    {
-		      char *rOp = aopGet (AOP (right), offset, FALSE, FALSE, TRUE);
+		      char *rOp = aopGet (AOP (right), offset, FALSE, FALSE, NULL);
 		      if (!strcmp(rOp, "a") || !strcmp(rOp, "acc"))
 		      {
 			  emitcode("mov", "b,a");
 			  rOp = "b";
 		      }
 			
-		      MOVA (aopGet (AOP (left), offset, FALSE, FALSE, TRUE));
+		      MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
 		      emitcode ("anl", "a,%s", rOp);
 		    }			
 		}
@@ -6218,7 +6623,7 @@ genOr (iCode * ic, iCode * ifx)
 	outBitC (result);
       // if(bit | ...)
       else if ((AOP_TYPE (result) == AOP_CRY) && ifx)
-	genIfxJump (ifx, "c");
+	   genIfxJump (ifx, "c");
       goto release;
     }
 
@@ -6275,15 +6680,16 @@ genOr (iCode * ic, iCode * ifx)
 		{
 		  if (IS_AOP_PREG (left))
 		    {
-		      MOVA (aopGet (AOP (right), offset, FALSE, FALSE, TRUE));
-		      emitcode ("orl", "a,%s", aopGet (AOP (left), offset, FALSE, TRUE, FALSE));
+		      MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL));
+		      emitcode ("orl", "a,%s",
+				aopGet (AOP (left), offset, FALSE, TRUE, DP2_RESULT_REG));
 		      aopPut (AOP (result), "a", offset);
 		    }
 		  else
 		    {
 		      emitcode ("orl", "%s,%s",
-			    aopGet (AOP (left), offset, FALSE, TRUE, FALSE),
-			 aopGet (AOP (right), offset, FALSE, FALSE, FALSE));
+				aopGet (AOP (left), offset, FALSE, TRUE, NULL),
+				aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG));
 		    }
 		}
 	    }
@@ -6291,20 +6697,22 @@ genOr (iCode * ic, iCode * ifx)
 	    {
 	      if (AOP_TYPE (left) == AOP_ACC)
 		{
-		  emitcode ("orl", "a,%s", aopGet (AOP (right), offset, FALSE, FALSE, FALSE));
+		  emitcode ("orl", "a,%s",
+			    aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG));
 		}
 	      else
 		{
-		  MOVA (aopGet (AOP (right), offset, FALSE, FALSE, TRUE));
+		  MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL));
 		  if (IS_AOP_PREG (left))
 		    {
-		      emitcode ("orl", "a,%s", aopGet (AOP (left), offset, FALSE, TRUE, FALSE));
+		      emitcode ("orl", "a,%s", 
+				aopGet (AOP (left), offset, FALSE, TRUE, DP2_RESULT_REG));
 		      aopPut (AOP (result), "a", offset);
 		    }
 		  else
 		    {
 		      emitcode ("orl", "%s,a",
-			   aopGet (AOP (left), offset, FALSE, TRUE, FALSE));
+			   aopGet (AOP (left), offset, FALSE, TRUE, DP2_RESULT_REG));
 		    }
 		}
 	    }
@@ -6326,11 +6734,11 @@ genOr (iCode * ic, iCode * ifx)
 	    {
 	      if (AOP_TYPE(right)==AOP_REG && AOP_TYPE(left)==AOP_ACC) {
 		emitcode ("orl", "a,%s",
-			  aopGet (AOP (right), offset, FALSE, FALSE, FALSE));
+			  aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG));
 	      } else {
-		MOVA (aopGet (AOP (right), offset, FALSE, FALSE, TRUE));
+		MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL));
 		emitcode ("orl", "a,%s",
-			  aopGet (AOP (left), offset, FALSE, FALSE, FALSE));
+			  aopGet (AOP (left), offset, FALSE, FALSE, DP2_RESULT_REG));
 	      }
 	      emitcode ("jnz", "!tlabel", tlbl->key + 100);
 	      offset++;
@@ -6356,14 +6764,15 @@ genOr (iCode * ic, iCode * ifx)
 		  if (((lit >> (offset * 8)) & 0x0FFL) == 0x00L)
 		    {
 		      aopPut (AOP (result),
-			   aopGet (AOP (left), offset, FALSE, FALSE, FALSE),
+			   aopGet (AOP (left), offset, FALSE, FALSE, NULL),
 			      offset);
 		      continue;
 		    }
 		  D (emitcode (";", "better literal OR."););
-		  MOVA (aopGet (AOP (left), offset, FALSE, FALSE, TRUE));
-		  emitcode ("orl", "a, %s", aopGet (AOP (right), offset,
-						    FALSE, FALSE, FALSE));
+		  MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
+		  emitcode ("orl", "a, %s",
+			    aopGet (AOP (right), offset,
+				    FALSE, FALSE, DP2_RESULT_REG));
 
 		}
 	      else
@@ -6372,12 +6781,13 @@ genOr (iCode * ic, iCode * ifx)
 		  // and better if result is SFR
 		  if (AOP_TYPE (left) == AOP_ACC)
 		    {
-		      emitcode ("orl", "a,%s", aopGet (AOP (right), offset,
-						       FALSE, FALSE, FALSE));
+		      emitcode ("orl", "a,%s",
+				aopGet (AOP (right), offset,
+					FALSE, FALSE, DP2_RESULT_REG));
 		    }
 		  else
 		    {
-		      char *rOp = aopGet (AOP (right), offset, FALSE, FALSE, TRUE);
+		      char *rOp = aopGet (AOP (right), offset, FALSE, FALSE, NULL);
 			
 		      if (!strcmp(rOp, "a") || !strcmp(rOp, "acc"))
 		      {
@@ -6385,7 +6795,7 @@ genOr (iCode * ic, iCode * ifx)
 			  rOp = "b";
 		      }
 			
-		      MOVA (aopGet (AOP (left), offset, FALSE, FALSE, TRUE));
+		      MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
 		      emitcode ("orl", "a,%s", rOp);
 		    }
 		}
@@ -6530,10 +6940,10 @@ genXor (iCode * ic, iCode * ifx)
 	      emitcode ("setb", "c");
 	      while (sizer)
 		{
-		  MOVA (aopGet (AOP (right), sizer - 1, FALSE, FALSE, TRUE));
+		  MOVA (aopGet (AOP (right), sizer - 1, FALSE, FALSE, NULL));
 		  if (sizer == 1)
 		    // test the msb of the lsb
-		    emitcode ("anl", "a,#0xfe");
+		    emitcode ("anl", "a,#!constbyte",0xfe);
 		  emitcode ("jnz", "!tlabel", tlbl->key + 100);
 		  sizer--;
 		}
@@ -6565,30 +6975,33 @@ genXor (iCode * ic, iCode * ifx)
 		continue;
 	      else if (IS_AOP_PREG (left))
 		{
-		  MOVA (aopGet (AOP (right), offset, FALSE, FALSE, TRUE));
-		  emitcode ("xrl", "a,%s", aopGet (AOP (left), offset, FALSE, TRUE, FALSE));
+		  MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL));
+		  emitcode ("xrl", "a,%s",
+			    aopGet (AOP (left), offset, FALSE, TRUE, DP2_RESULT_REG));
 		  aopPut (AOP (result), "a", offset);
 		}
 	      else
 		emitcode ("xrl", "%s,%s",
-			  aopGet (AOP (left), offset, FALSE, TRUE, FALSE),
-			  aopGet (AOP (right), offset, FALSE, FALSE, FALSE));
+			  aopGet (AOP (left), offset, FALSE, TRUE, NULL),
+			  aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG));
 	    }
 	  else
 	    {
 	      if (AOP_TYPE (left) == AOP_ACC)
-		emitcode ("xrl", "a,%s", aopGet (AOP (right), offset, FALSE, FALSE, FALSE));
+		emitcode ("xrl", "a,%s",
+			  aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG));
 	      else
 		{
-		  MOVA (aopGet (AOP (right), offset, FALSE, FALSE, TRUE));
+		  MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL));
 		  if (IS_AOP_PREG (left))
 		    {
-		      emitcode ("xrl", "a,%s", aopGet (AOP (left), offset, FALSE, TRUE, FALSE));
+		      emitcode ("xrl", "a,%s",
+				aopGet (AOP (left), offset, FALSE, TRUE, DP2_RESULT_REG));
 		      aopPut (AOP (result), "a", offset);
 		    }
 		  else
 		    emitcode ("xrl", "%s,a",
-			   aopGet (AOP (left), offset, FALSE, TRUE, FALSE));
+			   aopGet (AOP (left), offset, FALSE, TRUE, DP2_RESULT_REG));
 		}
 	    }
 	}
@@ -6611,22 +7024,22 @@ genXor (iCode * ic, iCode * ifx)
 	      if ((AOP_TYPE (right) == AOP_LIT) &&
 		  (((lit >> (offset * 8)) & 0x0FFL) == 0x00L))
 		{
-		  MOVA (aopGet (AOP (left), offset, FALSE, FALSE, TRUE));
+		  MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
 		}
 	      else
 		{
 		  if (AOP_TYPE(right)==AOP_REG && AOP_TYPE(left)==AOP_ACC) {
 		    emitcode ("xrl", "a,%s",
-			      aopGet (AOP (right), offset, FALSE, FALSE, FALSE));
+			      aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG));
 		  } else {
-		      char *rOp = aopGet (AOP (right), offset, FALSE, FALSE, TRUE);
+		      char *rOp = aopGet (AOP (right), offset, FALSE, FALSE, NULL);
 		      if (!strcmp(rOp, "a") || !strcmp(rOp, "acc"))
 		      {
 			  emitcode("mov", "b,a");
 			  rOp = "b";
 		      }
 			
-		      MOVA (aopGet (AOP (left), offset, FALSE, FALSE, TRUE));
+		      MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
 		      emitcode ("xrl", "a,%s", rOp);		      
 		  }
 		}
@@ -6653,14 +7066,14 @@ genXor (iCode * ic, iCode * ifx)
 		if (((lit >> (offset * 8)) & 0x0FFL) == 0x00L)
 		  {
 		    aopPut (AOP (result),
-			    aopGet (AOP (left), offset, FALSE, FALSE, FALSE),
+			    aopGet (AOP (left), offset, FALSE, FALSE, NULL),
 			    offset);
 		    continue;
 		  }
 		D (emitcode (";", "better literal XOR."););
-		MOVA (aopGet (AOP (left), offset, FALSE, FALSE, TRUE));
-		emitcode ("xrl", "a, %s", aopGet (AOP (right), offset,
-						  FALSE, FALSE, FALSE));
+		MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
+		emitcode ("xrl", "a, %s",
+			  aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG));
 	      }
 	    else
 	      {
@@ -6668,19 +7081,20 @@ genXor (iCode * ic, iCode * ifx)
 		// and better if result is SFR
 		if (AOP_TYPE (left) == AOP_ACC)
 		  {
-		    emitcode ("xrl", "a,%s", aopGet (AOP (right), offset,
-						     FALSE, FALSE, FALSE));
+		    emitcode ("xrl", "a,%s",
+			      aopGet (AOP (right), offset,
+				      FALSE, FALSE, DP2_RESULT_REG));
 		  }
 		else
 		  {
-		      char *rOp = aopGet (AOP (right), offset, FALSE, FALSE, TRUE);
+		      char *rOp = aopGet (AOP (right), offset, FALSE, FALSE, NULL);
 		      if (!strcmp(rOp, "a") || !strcmp(rOp, "acc"))
 		      {
 			  emitcode("mov", "b,a");
 			  rOp = "b";
 		      }
 			
-		      MOVA (aopGet (AOP (left), offset, FALSE, FALSE, TRUE));
+		      MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
 		      emitcode ("xrl", "a,%s", rOp);
 		  }
 	      }
@@ -6704,13 +7118,13 @@ genInline (iCode * ic)
 {
   char *buffer, *bp, *bp1;
 
-  D (emitcode (";", "genInline ");
-    );
+  D (emitcode (";", "genInline "); );
 
   _G.inLine += (!options.asmpeep);
 
-  buffer = bp = bp1 = Safe_calloc(1, strlen(IC_INLINE(ic))+1);
-  strcpy (buffer, IC_INLINE (ic));
+  buffer = Safe_strdup(IC_INLINE(ic));
+  bp = buffer;
+  bp1 = buffer;
 
   /* emit each line as a code */
   while (*bp)
@@ -6748,17 +7162,15 @@ static void
 genRRC (iCode * ic)
 {
   operand *left, *result;
-  int size, offset = 0;
-  char *l;
+  int 	  size, offset;
 
-  D (emitcode (";", "genRRC ");
-    );
+  D (emitcode (";", "genRRC "););
 
   /* rotate right with carry */
   left = IC_LEFT (ic);
   result = IC_RESULT (ic);
   aopOp (left, ic, FALSE, FALSE);
-  aopOp (result, ic, FALSE, AOP_TYPE (left) == AOP_DPTR);
+  aopOp (result, ic, FALSE, AOP_USESDPTR(left));
 
   /* move it to the result */
   size = AOP_SIZE (result);
@@ -6768,8 +7180,7 @@ genRRC (iCode * ic)
   _startLazyDPSEvaluation ();
   while (size--)
     {
-      l = aopGet (AOP (left), offset, FALSE, FALSE, TRUE);
-      MOVA (l);
+      MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
       emitcode ("rrc", "a");
       if (AOP_SIZE (result) > 1)
 	aopPut (AOP (result), "a", offset--);
@@ -6780,8 +7191,7 @@ genRRC (iCode * ic)
      highest order byte of the result */
   if (AOP_SIZE (result) > 1)
     {
-      l = aopGet (AOP (result), AOP_SIZE (result) - 1, FALSE, FALSE, TRUE);
-      MOVA (l);
+      MOVA (aopGet (AOP (result), AOP_SIZE (result) - 1, FALSE, FALSE, NULL));
     }
   emitcode ("mov", "acc.7,c");
   aopPut (AOP (result), "a", AOP_SIZE (result) - 1);
@@ -6796,24 +7206,23 @@ static void
 genRLC (iCode * ic)
 {
   operand *left, *result;
-  int size, offset = 0;
+  int size, offset;
   char *l;
 
-  D (emitcode (";", "genRLC ");
-    );
+  D (emitcode (";", "genRLC "););
 
   /* rotate right with carry */
   left = IC_LEFT (ic);
   result = IC_RESULT (ic);
   aopOp (left, ic, FALSE, FALSE);
-  aopOp (result, ic, FALSE, AOP_TYPE (left) == AOP_DPTR);
+  aopOp (result, ic, FALSE, AOP_USESDPTR(left));
 
   /* move it to the result */
   size = AOP_SIZE (result);
   offset = 0;
   if (size--)
     {
-      l = aopGet (AOP (left), offset, FALSE, FALSE, TRUE);
+      l = aopGet (AOP (left), offset, FALSE, FALSE, NULL);
       MOVA (l);
       emitcode ("add", "a,acc");
       if (AOP_SIZE (result) > 1)
@@ -6824,7 +7233,7 @@ genRLC (iCode * ic)
       _startLazyDPSEvaluation ();
       while (size--)
 	{
-	  l = aopGet (AOP (left), offset, FALSE, FALSE, TRUE);
+	  l = aopGet (AOP (left), offset, FALSE, FALSE, NULL);
 	  MOVA (l);
 	  emitcode ("rlc", "a");
 	  if (AOP_SIZE (result) > 1)
@@ -6836,7 +7245,7 @@ genRLC (iCode * ic)
      highest order byte of the result */
   if (AOP_SIZE (result) > 1)
     {
-      l = aopGet (AOP (result), 0, FALSE, FALSE, TRUE);
+      l = aopGet (AOP (result), 0, FALSE, FALSE, NULL);
       MOVA (l);
     }
   emitcode ("mov", "acc.0,c");
@@ -6855,13 +7264,12 @@ genGetHbit (iCode * ic)
   left = IC_LEFT (ic);
   result = IC_RESULT (ic);
   aopOp (left, ic, FALSE, FALSE);
-  aopOp (result, ic, FALSE, AOP_TYPE (left) == AOP_DPTR);
+  aopOp (result, ic, FALSE, AOP_USESDPTR(left));
 
-  D (emitcode (";", "genGetHbit ");
-    );
+  D (emitcode (";", "genGetHbit "););
 
   /* get the highest order byte into a */
-  MOVA (aopGet (AOP (left), AOP_SIZE (left) - 1, FALSE, FALSE, TRUE));
+  MOVA (aopGet (AOP (left), AOP_SIZE (left) - 1, FALSE, FALSE, NULL));
   if (AOP_TYPE (result) == AOP_CRY)
     {
       emitcode ("rlc", "a");
@@ -6870,7 +7278,7 @@ genGetHbit (iCode * ic)
   else
     {
       emitcode ("rl", "a");
-      emitcode ("anl", "a,#0x01");
+      emitcode ("anl", "a,#1");
       outAcc (result);
     }
 
@@ -7014,7 +7422,7 @@ shiftR1Left2Result (operand * left, int offl,
 		    operand * result, int offr,
 		    int shCount, int sign)
 {
-  MOVA (aopGet (AOP (left), offl, FALSE, FALSE, TRUE));
+  MOVA (aopGet (AOP (left), offl, FALSE, FALSE, NULL));
   /* shift right accumulator */
   if (sign)
     AccSRsh (shCount);
@@ -7032,7 +7440,7 @@ static void
 shiftL1Left2Result (operand * left, int offl,
 		    operand * result, int offr, int shCount)
 {
-  MOVA(aopGet (AOP (left), offl, FALSE, FALSE, TRUE));
+  MOVA(aopGet (AOP (left), offl, FALSE, FALSE, NULL));
   /* shift left accumulator */
   AccLsh (shCount);
   aopPut (AOP (result), "a", offr);
@@ -7050,7 +7458,7 @@ movLeft2Result (operand * left, int offl,
   char *l;
   if (!sameRegs (AOP (left), AOP (result)) || (offl != offr))
   {
-      l = aopGet (AOP (left), offl, FALSE, FALSE, TRUE);
+      l = aopGet (AOP (left), offl, FALSE, FALSE, NULL);
 
       if (*l == '@' && (IS_AOP_PREG (result)))
       {
@@ -7414,22 +7822,22 @@ _loadLeftIntoAx(char 	**lsb,
       if (AOP_TYPE(left) == AOP_DPTR2)
        {
            // Get MSB in A.
-       	   MOVA(aopGet(AOP(left), offl + MSB16, FALSE, FALSE, TRUE));
+       	   MOVA(aopGet(AOP(left), offl + MSB16, FALSE, FALSE, NULL));
        	   // get LSB in DP2_RESULT_REG.
-       	   leftByte = aopGet(AOP(left), offl, FALSE, FALSE, FALSE);
+       	   leftByte = aopGet(AOP(left), offl, FALSE, FALSE, DP2_RESULT_REG);
        	   assert(!strcmp(leftByte, DP2_RESULT_REG));
        }
        else
        {
            // get LSB into DP2_RESULT_REG
-       	   leftByte = aopGet (AOP(left), offl, FALSE, FALSE, TRUE);
+       	   leftByte = aopGet (AOP(left), offl, FALSE, FALSE, NULL);
            if (strcmp(leftByte, DP2_RESULT_REG))
            {
                TR_AP("#7");
                emitcode("mov","%s,%s", DP2_RESULT_REG, leftByte);
        	   }
        	   // And MSB in A.
-       	   leftByte = aopGet(AOP(left), offl + MSB16, FALSE, FALSE, TRUE);
+       	   leftByte = aopGet(AOP(left), offl + MSB16, FALSE, FALSE, NULL);
        	   assert(strcmp(leftByte, DP2_RESULT_REG));
        	   MOVA(leftByte);
        }
@@ -7442,16 +7850,16 @@ _loadLeftIntoAx(char 	**lsb,
       	((offl + MSB16) == offr))
       {
       	  /* don't crash result[offr] */
-      	  MOVA(aopGet(AOP(left), offl, FALSE, FALSE, TRUE));
+      	  MOVA(aopGet(AOP(left), offl, FALSE, FALSE, NULL));
       	  emitcode ("xch", "a,%s", 
-      	  	    aopGet(AOP(left), offl + MSB16, FALSE, FALSE, FALSE));
+      	  	    aopGet(AOP(left), offl + MSB16, FALSE, FALSE, DP2_RESULT_REG));
       }
       else
       {
       	  movLeft2Result (left, offl, result, offr, 0);
-      	  MOVA (aopGet (AOP (left), offl + MSB16, FALSE, FALSE, TRUE));
+      	  MOVA (aopGet (AOP (left), offl + MSB16, FALSE, FALSE, NULL));
       }
-      *lsb = aopGet(AOP (result), offr, FALSE, FALSE, FALSE);
+      *lsb = aopGet(AOP (result), offr, FALSE, FALSE, DP2_RESULT_REG);
       assert(strcmp(*lsb,"a"));      
   }
 }
@@ -7521,8 +7929,6 @@ shiftR2Left2Result (operand * left, int offl,
 }
 #endif
 
-#if 0
-//REMOVE ME!!!
 /*-----------------------------------------------------------------*/
 /* shiftLLeftOrResult - shift left one byte from left, or to result */
 /*-----------------------------------------------------------------*/
@@ -7530,15 +7936,15 @@ static void
 shiftLLeftOrResult (operand * left, int offl,
 		    operand * result, int offr, int shCount)
 {
-  MOVA (aopGet (AOP (left), offl, FALSE, FALSE, TRUE));
+  MOVA (aopGet (AOP (left), offl, FALSE, FALSE, NULL));
   /* shift left accumulator */
   AccLsh (shCount);
   /* or with result */
-  emitcode ("orl", "a,%s", aopGet (AOP (result), offr, FALSE, FALSE, FALSE));
+  emitcode ("orl", "a,%s",
+	    aopGet (AOP (result), offr, FALSE, FALSE, DP2_RESULT_REG));
   /* back to result */
   aopPut (AOP (result), "a", offr);
 }
-#endif
 
 #if 0
 //REMOVE ME!!!
@@ -7549,11 +7955,12 @@ static void
 shiftRLeftOrResult (operand * left, int offl,
 		    operand * result, int offr, int shCount)
 {
-  MOVA (aopGet (AOP (left), offl, FALSE, FALSE, TRUE));
+  MOVA (aopGet (AOP (left), offl, FALSE, FALSE, NULL));
   /* shift right accumulator */
   AccRsh (shCount);
   /* or with result */
-  emitcode ("orl", "a,%s", aopGet (AOP (result), offr, FALSE, FALSE, FALSE));
+  emitcode ("orl", "a,%s",
+	    aopGet (AOP (result), offr, FALSE, FALSE, DP2_RESULT_REG));
   /* back to result */
   aopPut (AOP (result), "a", offr);
 }
@@ -7642,13 +8049,13 @@ shiftLLong (operand * left, operand * result, int offr)
 
   if (size >= LSB + offr)
     {
-      l = aopGet (AOP (left), LSB, FALSE, FALSE, TRUE);
+      l = aopGet (AOP (left), LSB, FALSE, FALSE, NULL);
       MOVA (l);
       emitcode ("add", "a,acc");
       if (sameRegs (AOP (left), AOP (result)) &&
 	  size >= MSB16 + offr && offr != LSB)
 	emitcode ("xch", "a,%s",
-		  aopGet (AOP (left), LSB + offr, FALSE, FALSE, FALSE));
+		  aopGet (AOP (left), LSB + offr, FALSE, FALSE, DP2_RESULT_REG));
       else
 	aopPut (AOP (result), "a", LSB + offr);
     }
@@ -7657,14 +8064,13 @@ shiftLLong (operand * left, operand * result, int offr)
     {
       if (!(sameRegs (AOP (result), AOP (left)) && size >= MSB16 + offr && offr != LSB))
 	{
-	  l = aopGet (AOP (left), MSB16, FALSE, FALSE, TRUE);
-	  MOVA (l);
+	  MOVA (aopGet (AOP (left), MSB16, FALSE, FALSE, TRUE));
 	}
       emitcode ("rlc", "a");
       if (sameRegs (AOP (left), AOP (result)) &&
 	  size >= MSB24 + offr && offr != LSB)
 	emitcode ("xch", "a,%s",
-		  aopGet (AOP (left), MSB16 + offr, FALSE, FALSE, FALSE));
+		  aopGet (AOP (left), MSB16 + offr, FALSE, FALSE, DP2_RESULT_REG));
       else
 	aopPut (AOP (result), "a", MSB16 + offr);
     }
@@ -7673,14 +8079,13 @@ shiftLLong (operand * left, operand * result, int offr)
     {
       if (!(sameRegs (AOP (left), AOP (left)) && size >= MSB24 + offr && offr != LSB))
 	{
-	  l = aopGet (AOP (left), MSB24, FALSE, FALSE, TRUE);
-	  MOVA (l);
+	  MOVA (aopGet (AOP (left), MSB24, FALSE, FALSE, NULL));
 	}
       emitcode ("rlc", "a");
       if (sameRegs (AOP (left), AOP (result)) &&
 	  size >= MSB32 + offr && offr != LSB)
 	emitcode ("xch", "a,%s",
-		  aopGet (AOP (left), MSB24 + offr, FALSE, FALSE, FALSE));
+		  aopGet (AOP (left), MSB24 + offr, FALSE, FALSE, DP2_RESULT_REG));
       else
 	aopPut (AOP (result), "a", MSB24 + offr);
     }
@@ -7689,8 +8094,7 @@ shiftLLong (operand * left, operand * result, int offr)
     {
       if (!(sameRegs (AOP (result), AOP (left)) && size >= MSB32 + offr && offr != LSB))
 	{
-	  l = aopGet (AOP (left), MSB32, FALSE, FALSE, TRUE);
-	  MOVA (l);
+	  MOVA (aopGet (AOP (left), MSB32, FALSE, FALSE, NULL));
 	}
       emitcode ("rlc", "a");
       aopPut (AOP (result), "a", MSB32 + offr);
@@ -7829,9 +8233,9 @@ genLeftShiftLiteral (operand * left,
   freeAsmop (right, NULL, ic, TRUE);
 
   aopOp(left, ic, FALSE, FALSE);
-  aopOp(result, ic, FALSE, (AOP_TYPE(left) == AOP_DPTR));
+  aopOp(result, ic, FALSE, AOP_USESDPTR(left));
 
-#if 1 // debug spew
+#if 0 // debug spew
   if (IS_SYMOP(left) && OP_SYMBOL(left)->aop)
   {
   	emitcode(";", "left (%s) is %d", OP_SYMBOL(left)->rname, AOP_TYPE(left));
@@ -7950,12 +8354,12 @@ genLeftShift (iCode * ic)
   }
   else
   {
-  	emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE, FALSE));
-  	emitcode ("inc", "b");
+      MOVB(aopGet (AOP (right), 0, FALSE, FALSE, "b"));
+      emitcode ("inc", "b");
   }
   freeAsmop (right, NULL, ic, TRUE);
   aopOp (left, ic, FALSE, FALSE);
-  aopOp (result, ic, FALSE, AOP_TYPE (left) == AOP_DPTR);
+  aopOp (result, ic, FALSE, AOP_USESDPTR(left));
 
   /* now move the left to the result if they are not the
      same */
@@ -7968,7 +8372,7 @@ genLeftShift (iCode * ic)
       _startLazyDPSEvaluation ();
       while (size--)
 	{
-	  l = aopGet (AOP (left), offset, FALSE, TRUE, FALSE);
+	  l = aopGet (AOP (left), offset, FALSE, TRUE, NULL);
 	  if (*l == '@' && (IS_AOP_PREG (result)))
 	    {
 
@@ -7992,8 +8396,7 @@ genLeftShift (iCode * ic)
     {
       symbol *tlbl1 = newiTempLabel (NULL);
 
-      l = aopGet (AOP (left), 0, FALSE, FALSE, TRUE);
-      MOVA (l);
+      MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL));
       emitcode ("sjmp", "!tlabel", tlbl1->key + 100);
       emitcode ("", "!tlabeldef", tlbl->key + 100);
       emitcode ("add", "a,acc");
@@ -8007,15 +8410,13 @@ genLeftShift (iCode * ic)
 
   emitcode ("sjmp", "!tlabel", tlbl1->key + 100);
   emitcode ("", "!tlabeldef", tlbl->key + 100);
-  l = aopGet (AOP (result), offset, FALSE, FALSE, TRUE);
-  MOVA (l);
+  MOVA (aopGet (AOP (result), offset, FALSE, FALSE, NULL));
   emitcode ("add", "a,acc");
   aopPut (AOP (result), "a", offset++);
   _startLazyDPSEvaluation ();
   while (--size)
     {
-      l = aopGet (AOP (result), offset, FALSE, FALSE, TRUE);
-      MOVA (l);
+      MOVA (aopGet (AOP (result), offset, FALSE, FALSE, NULL));
       emitcode ("rlc", "a");
       aopPut (AOP (result), "a", offset++);
     }
@@ -8078,8 +8479,6 @@ genrshTwo (operand * result, operand * left,
 }
 #endif
 
-#if 0
-//REMOVE ME!!!
 /*-----------------------------------------------------------------*/
 /* shiftRLong - shift right one long from left to result           */
 /* offl = LSB or MSB16                                             */
@@ -8095,14 +8494,15 @@ shiftRLong (operand * left, int offl,
     werror(E_INTERNAL_ERROR, __FILE__, __LINE__);
   }
 
-  MOVA (aopGet (AOP (left), MSB32, FALSE, FALSE));
+  MOVA (aopGet (AOP (left), MSB32, FALSE, FALSE, NULL));
   
   if (offl==MSB16) {
     // shift is > 8
     if (sign) {
       emitcode ("rlc", "a");
       emitcode ("subb", "a,acc");
-      emitcode ("xch", "a,%s", aopGet(AOP(left), MSB32, FALSE, FALSE));
+      emitcode ("xch", "a,%s",
+		aopGet(AOP(left), MSB32, FALSE, FALSE, DP2_RESULT_REG));
     } else {
       aopPut (AOP(result), zero, MSB32);
     }
@@ -8117,33 +8517,32 @@ shiftRLong (operand * left, int offl,
   emitcode ("rrc", "a");
 
   if (isSameRegs && offl==MSB16) {
-    emitcode ("xch", "a,%s",aopGet (AOP (left), MSB24, FALSE, FALSE));
+    emitcode ("xch",
+	      "a,%s",aopGet (AOP (left), MSB24, FALSE, FALSE, DP2_RESULT_REG));
   } else {
     aopPut (AOP (result), "a", MSB32);
-    MOVA (aopGet (AOP (left), MSB24, FALSE, FALSE));
+    MOVA (aopGet (AOP (left), MSB24, FALSE, FALSE, NULL));
   }
 
   emitcode ("rrc", "a");
   if (isSameRegs && offl==1) {
-    emitcode ("xch", "a,%s",aopGet (AOP (left), MSB16, FALSE, FALSE));
+    emitcode ("xch", "a,%s",
+	      aopGet (AOP (left), MSB16, FALSE, FALSE, DP2_RESULT_REG));
   } else {
     aopPut (AOP (result), "a", MSB24);
-    MOVA (aopGet (AOP (left), MSB16, FALSE, FALSE));
+    MOVA (aopGet (AOP (left), MSB16, FALSE, FALSE, NULL));
   }
   emitcode ("rrc", "a");
   aopPut (AOP (result), "a", MSB16 - offl);
 
   if (offl == LSB)
     {
-      MOVA (aopGet (AOP (left), LSB, FALSE, FALSE));
+      MOVA (aopGet (AOP (left), LSB, FALSE, FALSE, NULL));
       emitcode ("rrc", "a");
       aopPut (AOP (result), "a", LSB);
     }
 }
-#endif
 
-#if 0
-//REMOVE ME!!!
 /*-----------------------------------------------------------------*/
 /* genrshFour - shift four byte by a known amount != 0             */
 /*-----------------------------------------------------------------*/
@@ -8151,22 +8550,24 @@ static void
 genrshFour (operand * result, operand * left,
 	    int shCount, int sign)
 {
-  D (emitcode (";", "genrshFour");
-    );
+  D (emitcode (";", "genrshFour"););
 
   /* if shifting more that 3 bytes */
   if (shCount >= 24)
     {
       shCount -= 24;
+      _startLazyDPSEvaluation();
       if (shCount)
 	shiftR1Left2Result (left, MSB32, result, LSB, shCount, sign);
       else
 	movLeft2Result (left, MSB32, result, LSB, sign);
       addSign (result, MSB16, sign);
+      _endLazyDPSEvaluation();
     }
   else if (shCount >= 16)
     {
       shCount -= 16;
+      _startLazyDPSEvaluation();
       if (shCount)
 	shiftR2Left2Result (left, MSB24, result, LSB, shCount, sign);
       else
@@ -8175,12 +8576,16 @@ genrshFour (operand * result, operand * left,
 	  movLeft2Result (left, MSB32, result, MSB16, sign);
 	}
       addSign (result, MSB24, sign);
+      _endLazyDPSEvaluation();
     }
   else if (shCount >= 8)
     {
       shCount -= 8;
+      _startLazyDPSEvaluation();
       if (shCount == 1)
-	shiftRLong (left, MSB16, result, sign);
+	{
+	    shiftRLong (left, MSB16, result, sign);
+	}
       else if (shCount == 0)
 	{
 	  movLeft2Result (left, MSB16, result, LSB, 0);
@@ -8196,9 +8601,11 @@ genrshFour (operand * result, operand * left,
 	  shiftR1Left2Result (left, MSB32, result, MSB24, shCount, sign);
 	  addSign (result, MSB32, sign);
 	}
+	_endLazyDPSEvaluation();
     }
   else
-    {				/* 1 <= shCount <= 7 */
+    {	
+	/* 1 <= shCount <= 7 */
       if (shCount <= 2)
 	{
 	  shiftRLong (left, LSB, result, sign);
@@ -8213,7 +8620,6 @@ genrshFour (operand * result, operand * left,
 	}
     }
 }
-#endif
 
 #ifdef BETTER_LITERAL_SHIFT
 /*-----------------------------------------------------------------*/
@@ -8237,7 +8643,8 @@ genRightShiftLiteral (operand * left,
   if ((shCount != 0)
    && (shCount < (size * 8))
    && (size != 1)
-   && (size != 2))
+   && (size != 2)
+   /* && (size != 4) in a minute... */)
   {
       D(emitcode (";", "genRightShiftLiteral wimping out"););	
       return FALSE;
@@ -8246,7 +8653,7 @@ genRightShiftLiteral (operand * left,
   freeAsmop (right, NULL, ic, TRUE);
 
   aopOp (left, ic, FALSE, FALSE);
-  aopOp (result, ic, FALSE, AOP_TYPE (left) == AOP_DPTR);
+  aopOp (result, ic, FALSE, AOP_USESDPTR(left));
 
 #if VIEW_SIZE
   emitcode ("; shift right ", "result %d, left %d", AOP_SIZE (result),
@@ -8271,7 +8678,7 @@ genRightShiftLiteral (operand * left,
       if (sign)
       {
 	/* get sign in acc.7 */
-	MOVA (aopGet (AOP (left), size - 1, FALSE, FALSE, TRUE));
+	MOVA (aopGet (AOP (left), size - 1, FALSE, FALSE, NULL));
       }
       addSign (result, LSB, sign);
     }
@@ -8286,7 +8693,7 @@ genRightShiftLiteral (operand * left,
 	case 2:
 	  genrshTwo (result, left, shCount, sign);
 	  break;
-#if 0
+#if 1
 	case 4:
 	  genrshFour (result, left, shCount, sign);
 	  break;
@@ -8294,11 +8701,11 @@ genRightShiftLiteral (operand * left,
 	default:
 	  break;
 	}
-
-      freeAsmop (left, NULL, ic, TRUE);
-      freeAsmop (result, NULL, ic, TRUE);
     }
-    return TRUE;
+  freeAsmop (left, NULL, ic, TRUE);
+  freeAsmop (result, NULL, ic, TRUE);
+  
+  return TRUE;
 }
 #endif
 
@@ -8350,12 +8757,12 @@ genSignedRightShift (iCode * ic)
   }
   else
   {
-  	emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE, FALSE));
+  	MOVB(aopGet (AOP (right), 0, FALSE, FALSE, "b"));
   	emitcode ("inc", "b");
   }
   freeAsmop (right, NULL, ic, TRUE);
   aopOp (left, ic, FALSE, FALSE);
-  aopOp (result, ic, FALSE, AOP_TYPE (left) == AOP_DPTR);
+  aopOp (result, ic, FALSE, AOP_USESDPTR(left)); 
 
   /* now move the left to the result if they are not the
      same */
@@ -8368,7 +8775,7 @@ genSignedRightShift (iCode * ic)
       _startLazyDPSEvaluation ();
       while (size--)
 	{
-	  l = aopGet (AOP (left), offset, FALSE, TRUE, FALSE);
+	  l = aopGet (AOP (left), offset, FALSE, TRUE, NULL);
 	  if (*l == '@' && IS_AOP_PREG (result))
 	    {
 
@@ -8388,14 +8795,13 @@ genSignedRightShift (iCode * ic)
 
   size = AOP_SIZE (result);
   offset = size - 1;
-  emitcode ("mov", "a,%s", aopGet (AOP (left), offset, FALSE, FALSE, FALSE));
+  MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
   emitcode ("rlc", "a");
   emitcode ("mov", "ov,c");
   /* if it is only one byte then */
   if (size == 1)
     {
-      l = aopGet (AOP (left), 0, FALSE, FALSE, TRUE);
-      MOVA (l);
+      MOVA( aopGet (AOP (left), 0, FALSE, FALSE, NULL));
       emitcode ("sjmp", "!tlabel", tlbl1->key + 100);
       emitcode ("", "!tlabeldef", tlbl->key + 100);
       emitcode ("mov", "c,ov");
@@ -8413,8 +8819,7 @@ genSignedRightShift (iCode * ic)
   _startLazyDPSEvaluation ();
   while (size--)
     {
-      l = aopGet (AOP (result), offset, FALSE, FALSE, TRUE);
-      MOVA (l);
+      MOVA (aopGet (AOP (result), offset, FALSE, FALSE, NULL));
       emitcode ("rrc", "a");
       aopPut (AOP (result), "a", offset--);
     }
@@ -8494,12 +8899,12 @@ genRightShift (iCode * ic)
   }
   else
   {
-  	emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE, FALSE));
-  	emitcode ("inc", "b");
+      MOVB(aopGet (AOP (right), 0, FALSE, FALSE, "b"));
+      emitcode ("inc", "b");
   }
   freeAsmop (right, NULL, ic, TRUE);
   aopOp (left, ic, FALSE, FALSE);
-  aopOp (result, ic, FALSE, AOP_TYPE (left) == AOP_DPTR);
+  aopOp (result, ic, FALSE, AOP_USESDPTR(left));
 
   /* now move the left to the result if they are not the
      same */
@@ -8512,7 +8917,7 @@ genRightShift (iCode * ic)
       _startLazyDPSEvaluation ();
       while (size--)
 	{
-	  l = aopGet (AOP (left), offset, FALSE, TRUE, FALSE);
+	  l = aopGet (AOP (left), offset, FALSE, TRUE, NULL);
 	  if (*l == '@' && IS_AOP_PREG (result))
 	    {
 
@@ -8534,8 +8939,7 @@ genRightShift (iCode * ic)
   /* if it is only one byte then */
   if (size == 1)
     {
-      l = aopGet (AOP (left), 0, FALSE, FALSE, TRUE);
-      MOVA (l);
+      MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL));
       emitcode ("sjmp", "!tlabel", tlbl1->key + 100);
       emitcode ("", "!tlabeldef", tlbl->key + 100);
       CLRC;
@@ -8553,8 +8957,7 @@ genRightShift (iCode * ic)
   _startLazyDPSEvaluation ();
   while (size--)
     {
-      l = aopGet (AOP (result), offset, FALSE, FALSE, TRUE);
-      MOVA (l);
+      MOVA (aopGet (AOP (result), offset, FALSE, FALSE, NULL));
       emitcode ("rrc", "a");
       aopPut (AOP (result), "a", offset--);
     }
@@ -8576,12 +8979,11 @@ static void
 genUnpackBits (operand * result, char *rname, int ptype)
 {
   int shCnt;
-  int rlen = 0;
+  int rlen;
   sym_link *etype;
   int offset = 0;
 
-  D (emitcode (";", "genUnpackBits ");
-    );
+  D (emitcode (";", "genUnpackBits "););
 
   etype = getSpec (operandType (result));
 
@@ -8615,8 +9017,7 @@ genUnpackBits (operand * result, char *rname, int ptype)
   /* if we have bitdisplacement then it fits   */
   /* into this byte completely or if length is */
   /* less than a byte                          */
-  if ((shCnt = SPEC_BSTR (etype)) ||
-      (SPEC_BLEN (etype) <= 8))
+  if (((shCnt = SPEC_BSTR (etype)) != 0) || (SPEC_BLEN (etype) <= 8))
     {
 
       /* shift right acc */
@@ -8693,21 +9094,27 @@ genDataPointerGet (operand * left,
 		   iCode * ic)
 {
   char *l;
-  char buffer[256];
+  char buff[256];
   int size, offset = 0;
   aopOp (result, ic, TRUE, FALSE);
 
   /* get the string representation of the name */
-  l = aopGet (AOP (left), 0, FALSE, TRUE, FALSE);
+  l = aopGet (AOP (left), 0, FALSE, TRUE, NULL);
   size = AOP_SIZE (result);
   _startLazyDPSEvaluation ();
   while (size--)
     {
-      if (offset)
-	sprintf (buffer, "(%s + %d)", l + 1, offset);
-      else
-	sprintf (buffer, "%s", l + 1);
-      aopPut (AOP (result), buffer, offset++);
+	if (offset)
+	{
+	    SNPRINTF (buff, sizeof(buff), 
+		      "(%s + %d)", l + 1, offset);
+	}
+	else
+	{
+	    SNPRINTF (buff, sizeof(buff), 
+		      "%s", l + 1);
+	}
+      aopPut (AOP (result), buff, offset++);
     }
   _endLazyDPSEvaluation ();
 
@@ -8725,11 +9132,11 @@ genNearPointerGet (operand * left,
 		   iCode *pi)
 {
   asmop *aop = NULL;
-  regs *preg = NULL;
+  regs *preg;
   char *rname;
   sym_link *rtype, *retype, *letype;
   sym_link *ltype = operandType (left);
-  char buffer[80];
+  char buff[80];
 
   rtype = operandType (result);
   retype = getSpec (rtype);
@@ -8759,11 +9166,11 @@ genNearPointerGet (operand * left,
       preg = getFreePtr (ic, &aop, FALSE);
       emitcode ("mov", "%s,%s",
 		preg->name,
-		aopGet (AOP (left), 0, FALSE, TRUE, FALSE));
+		aopGet (AOP (left), 0, FALSE, TRUE, DP2_RESULT_REG));
       rname = preg->name;
     }
   else
-    rname = aopGet (AOP (left), 0, FALSE, FALSE, FALSE);
+    rname = aopGet (AOP (left), 0, FALSE, FALSE, DP2_RESULT_REG);
 
   freeAsmop (left, NULL, ic, TRUE);
   aopOp (result, ic, FALSE, FALSE);
@@ -8787,12 +9194,14 @@ genNearPointerGet (operand * left,
 	    }
 	  else
 	    {
-	      sprintf (buffer, "@%s", rname);
-	      aopPut (AOP (result), buffer, offset);
+	      SNPRINTF (buff, sizeof(buff), "@%s", rname);
+	      aopPut (AOP (result), buff, offset);
 	    }
 	  offset++;
 	  if (size || pi)
-	    emitcode ("inc", "%s", rname);
+	    {
+		emitcode ("inc", "%s", rname);
+	    }
 	}
     }
 
@@ -8839,7 +9248,7 @@ genPagedPointerGet (operand * left,
 		    iCode * pi)
 {
   asmop *aop = NULL;
-  regs *preg = NULL;
+  regs *preg;
   char *rname;
   sym_link *rtype, *retype, *letype;
 
@@ -8857,11 +9266,11 @@ genPagedPointerGet (operand * left,
       preg = getFreePtr (ic, &aop, FALSE);
       emitcode ("mov", "%s,%s",
 		preg->name,
-		aopGet (AOP (left), 0, FALSE, TRUE, FALSE));
+		aopGet (AOP (left), 0, FALSE, TRUE, NULL));
       rname = preg->name;
     }
   else
-    rname = aopGet (AOP (left), 0, FALSE, FALSE, FALSE);
+    rname = aopGet (AOP (left), 0, FALSE, FALSE, NULL);
 
   freeAsmop (left, NULL, ic, TRUE);
   aopOp (result, ic, FALSE, FALSE);
@@ -8929,19 +9338,18 @@ genFarPointerGet (operand * left,
     int size, offset, dopi=1;
   sym_link *retype = getSpec (operandType (result));
   sym_link *letype = getSpec (operandType (left));
-  D (emitcode (";", "genFarPointerGet");
-    );
+  D (emitcode (";", "genFarPointerGet"););
 
   aopOp (left, ic, FALSE, FALSE);
 
   /* if the operand is already in dptr
      then we do nothing else we move the value to dptr */
-  if (AOP_TYPE (left) != AOP_STR)
+  if (AOP_TYPE (left) != AOP_STR && !AOP_INDPTRn(left) )
     {
       /* if this is remateriazable */
       if (AOP_TYPE (left) == AOP_IMMD)
 	{
-	  emitcode ("mov", "dptr,%s", aopGet (AOP (left), 0, TRUE, FALSE, FALSE));
+	  emitcode ("mov", "dptr,%s", aopGet (AOP (left), 0, TRUE, FALSE, NULL));
 	}
       else
 	{
@@ -8949,20 +9357,19 @@ genFarPointerGet (operand * left,
 	  _startLazyDPSEvaluation ();
 	  if (AOP_TYPE (left) != AOP_DPTR)
 	    {
-	      emitcode ("mov", "dpl,%s", aopGet (AOP (left), 0, FALSE, FALSE, TRUE));
-	      emitcode ("mov", "dph,%s", aopGet (AOP (left), 1, FALSE, FALSE, TRUE));
+	      emitcode ("mov", "dpl,%s", aopGet (AOP (left), 0, FALSE, FALSE, NULL));
+	      emitcode ("mov", "dph,%s", aopGet (AOP (left), 1, FALSE, FALSE, NULL));
 	      if (options.model == MODEL_FLAT24)
-		emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE, TRUE));
+		emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE, NULL));
 	    }
 	  else
 	    {
 	      /* We need to generate a load to DPTR indirect through DPTR. */
-	      D (emitcode (";", "genFarPointerGet -- indirection special case.");
-		);
-	      emitcode ("push", "%s", aopGet (AOP (left), 0, FALSE, TRUE, TRUE));
-	      emitcode ("push", "%s", aopGet (AOP (left), 1, FALSE, TRUE, TRUE));
+	      D (emitcode (";", "genFarPointerGet -- indirection special case."););
+	      emitcode ("push", "%s", aopGet (AOP (left), 0, FALSE, TRUE, NULL));
+	      emitcode ("push", "%s", aopGet (AOP (left), 1, FALSE, TRUE, NULL));
 	      if (options.model == MODEL_FLAT24)
-		emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE, TRUE));
+		emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE, NULL));
 	      emitcode ("pop", "dph");
 	      emitcode ("pop", "dpl");
 	      dopi =0;
@@ -8971,42 +9378,73 @@ genFarPointerGet (operand * left,
 	}
     }
   /* so dptr know contains the address */
-  aopOp (result, ic, FALSE, TRUE);
+  aopOp (result, ic, FALSE, (AOP_INDPTRn(left) ? FALSE : TRUE));
 
   /* if bit then unpack */
-  if (IS_BITVAR (retype) || IS_BITVAR (letype))
-    genUnpackBits (result, "dptr", FPOINTER);
-  else
+  if (IS_BITVAR (retype) || IS_BITVAR (letype)) {
+      if (AOP_INDPTRn(left)) {
+	  genSetDPTR(AOP(left)->aopu.dptr);
+      }
+      genUnpackBits (result, "dptr", FPOINTER);
+      if (AOP_INDPTRn(left)) {
+	  genSetDPTR(0);
+      }
+  } else
     {
       size = AOP_SIZE (result);
       offset = 0;
 
-      _startLazyDPSEvaluation ();
-      while (size--)
-	{
-
-	  genSetDPTR (0);
-	  _flushLazyDPS ();
-
-	  emitcode ("movx", "a,@dptr");
-	  if (size || (dopi && pi && AOP_TYPE (left) != AOP_IMMD))
-	    emitcode ("inc", "dptr");
-
-	  aopPut (AOP (result), "a", offset++);
-	}
-      _endLazyDPSEvaluation ();
+      if (AOP_INDPTRn(left) && AOP_USESDPTR(result)) {
+	  while (size--) {
+	      genSetDPTR(AOP(left)->aopu.dptr);
+	      emitcode ("movx", "a,@dptr");
+	      if (size || (dopi && pi && AOP_TYPE (left) != AOP_IMMD))
+		  emitcode ("inc", "dptr");
+	      genSetDPTR (0);
+	      aopPut (AOP (result), "a", offset++);
+	  }
+      } else {
+	  _startLazyDPSEvaluation ();
+	  while (size--) {
+	      if (AOP_INDPTRn(left)) {
+		  genSetDPTR(AOP(left)->aopu.dptr);
+	      } else {
+		  genSetDPTR (0);
+	      }
+	      _flushLazyDPS ();
+	      
+	      emitcode ("movx", "a,@dptr");
+	      if (size || (dopi && pi && AOP_TYPE (left) != AOP_IMMD))
+		  emitcode ("inc", "dptr");
+	      
+	      aopPut (AOP (result), "a", offset++);
+	  }
+	  _endLazyDPSEvaluation ();
+      }
     }
   if (dopi && pi && AOP_TYPE (left) != AOP_IMMD) {
-    aopPut ( AOP (left), "dpl", 0);
-    aopPut ( AOP (left), "dph", 1);
-    if (options.model == MODEL_FLAT24)
-	    aopPut ( AOP (left), "dpx", 2);
+      if (!AOP_INDPTRn(left)) {
+	  _startLazyDPSEvaluation ();
+	  aopPut ( AOP (left), "dpl", 0);
+	  aopPut ( AOP (left), "dph", 1);
+	  if (options.model == MODEL_FLAT24)
+	      aopPut ( AOP (left), "dpx", 2);
+	  _endLazyDPSEvaluation ();
+      }
     pi->generated = 1;
-  } else if (OP_SYMBOL(left)->ruonly && AOP_SIZE(result) > 1 &&
-	     (OP_SYMBOL (left)->liveTo > ic->seq || ic->depth)) {
+  } else if ((AOP_IS_STR(left) || AOP_INDPTRn(left)) && 
+	     AOP_SIZE(result) > 1 &&
+	     IS_SYMOP(left) &&
+	     (OP_SYMBOL(left)->liveTo > ic->seq || ic->depth)) {
       
       size = AOP_SIZE (result) - 1;
+      if (AOP_INDPTRn(left)) {
+	  genSetDPTR(AOP(left)->aopu.dptr);
+      }
       while (size--) emitcode ("lcall","__decdptr");
+      if (AOP_INDPTRn(left)) {
+	  genSetDPTR(0);
+      }
   }
 
   freeAsmop (left, NULL, ic, TRUE);
@@ -9014,10 +9452,10 @@ genFarPointerGet (operand * left,
 }
 
 /*-----------------------------------------------------------------*/
-/* emitcodePointerGet - gget value from code space                  */
+/* genCodePointerGet - get value from code space                  */
 /*-----------------------------------------------------------------*/
 static void
-emitcodePointerGet (operand * left,
+genCodePointerGet (operand * left,
 		    operand * result, iCode * ic, iCode *pi)
 {
   int size, offset, dopi=1;
@@ -9027,32 +9465,31 @@ emitcodePointerGet (operand * left,
 
   /* if the operand is already in dptr
      then we do nothing else we move the value to dptr */
-  if (AOP_TYPE (left) != AOP_STR)
+  if (AOP_TYPE (left) != AOP_STR && !AOP_INDPTRn(left))
     {
       /* if this is remateriazable */
       if (AOP_TYPE (left) == AOP_IMMD)
 	{
-	  emitcode ("mov", "dptr,%s", aopGet (AOP (left), 0, TRUE, FALSE, FALSE));
+	  emitcode ("mov", "dptr,%s", aopGet (AOP (left), 0, TRUE, FALSE, NULL));
 	}
       else
 	{			/* we need to get it byte by byte */
 	  _startLazyDPSEvaluation ();
 	  if (AOP_TYPE (left) != AOP_DPTR)
 	    {
-	      emitcode ("mov", "dpl,%s", aopGet (AOP (left), 0, FALSE, FALSE, TRUE));
-	      emitcode ("mov", "dph,%s", aopGet (AOP (left), 1, FALSE, FALSE, TRUE));
+	      emitcode ("mov", "dpl,%s", aopGet (AOP (left), 0, FALSE, FALSE, NULL));
+	      emitcode ("mov", "dph,%s", aopGet (AOP (left), 1, FALSE, FALSE, NULL));
 	      if (options.model == MODEL_FLAT24)
-	        emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE, TRUE));
+	        emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE, NULL));
 	    }
 	  else
 	    {
 	      /* We need to generate a load to DPTR indirect through DPTR. */
-	      D (emitcode (";", "gencodePointerGet -- indirection special case.");
-		);
-	      emitcode ("push", "%s", aopGet (AOP (left), 0, FALSE, TRUE, TRUE));
-	      emitcode ("push", "%s", aopGet (AOP (left), 1, FALSE, TRUE, TRUE));
+	      D (emitcode (";", "gencodePointerGet -- indirection special case."););
+	      emitcode ("push", "%s", aopGet (AOP (left), 0, FALSE, TRUE, NULL));
+	      emitcode ("push", "%s", aopGet (AOP (left), 1, FALSE, TRUE, NULL));
 	      if (options.model == MODEL_FLAT24)
-	        emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE, TRUE));
+	        emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE, NULL));
 	      emitcode ("pop", "dph");
 	      emitcode ("pop", "dpl");
 	      dopi=0;
@@ -9061,41 +9498,75 @@ emitcodePointerGet (operand * left,
 	}
     }
   /* so dptr know contains the address */
-  aopOp (result, ic, FALSE, TRUE);
+  aopOp (result, ic, FALSE, (AOP_INDPTRn(left) ? FALSE : TRUE));
 
   /* if bit then unpack */
-  if (IS_BITVAR (retype))
-    genUnpackBits (result, "dptr", CPOINTER);
-  else
+  if (IS_BITVAR (retype)) {
+      if (AOP_INDPTRn(left)) {
+	  genSetDPTR(AOP(left)->aopu.dptr);
+      }
+      genUnpackBits (result, "dptr", CPOINTER);
+      if (AOP_INDPTRn(left)) {
+	  genSetDPTR(0);
+      }
+  } else
     {
       size = AOP_SIZE (result);
       offset = 0;
-
-      _startLazyDPSEvaluation ();
-      while (size--)
-	{
-	  genSetDPTR (0);
-	  _flushLazyDPS ();
-
-	  emitcode ("clr", "a");
-	  emitcode ("movc", "a,@a+dptr");
-	  if (size || (dopi && pi && AOP_TYPE (left) != AOP_IMMD))
-	    emitcode ("inc", "dptr");
-	  aopPut (AOP (result), "a", offset++);
-	}
-      _endLazyDPSEvaluation ();
+      if (AOP_INDPTRn(left) && AOP_USESDPTR(result)) {
+	  while (size--) {
+	      genSetDPTR(AOP(left)->aopu.dptr);
+	      emitcode ("clr", "a");
+	      emitcode ("movc", "a,@a+dptr");
+	      if (size || (dopi && pi && AOP_TYPE (left) != AOP_IMMD))
+		  emitcode ("inc", "dptr");
+	      genSetDPTR (0);
+	      aopPut (AOP (result), "a", offset++);
+	  }
+      } else {
+	  _startLazyDPSEvaluation ();
+	  while (size--)
+	      {
+		  if (AOP_INDPTRn(left)) {
+		      genSetDPTR(AOP(left)->aopu.dptr);
+		  } else {
+		      genSetDPTR (0);
+		  }
+		  _flushLazyDPS ();
+		  
+		  emitcode ("clr", "a");
+		  emitcode ("movc", "a,@a+dptr");
+		  if (size || (dopi && pi && AOP_TYPE (left) != AOP_IMMD))
+		      emitcode ("inc", "dptr");
+		  aopPut (AOP (result), "a", offset++);
+	      }
+	  _endLazyDPSEvaluation ();
+      }
     }
   if (dopi && pi && AOP_TYPE (left) != AOP_IMMD) {
-      aopPut ( AOP (left), "dpl", 0);
-      aopPut ( AOP (left), "dph", 1);
-      if (options.model == MODEL_FLAT24)
-	  aopPut ( AOP (left), "dpx", 2);
+      if (!AOP_INDPTRn(left)) {
+	  _startLazyDPSEvaluation ();
+	  
+	  aopPut ( AOP (left), "dpl", 0);
+	  aopPut ( AOP (left), "dph", 1);
+	  if (options.model == MODEL_FLAT24)
+	      aopPut ( AOP (left), "dpx", 2);
+
+	  _endLazyDPSEvaluation ();
+      }
       pi->generated = 1;
-  } else if (OP_SYMBOL(left)->ruonly && AOP_SIZE(result) > 1 &&
+  } else if ((OP_SYMBOL(left)->ruonly || AOP_INDPTRn(left)) && 
+	     AOP_SIZE(result) > 1 &&
 	     (OP_SYMBOL (left)->liveTo > ic->seq || ic->depth)) {
       
       size = AOP_SIZE (result) - 1;
+      if (AOP_INDPTRn(left)) {
+	  genSetDPTR(AOP(left)->aopu.dptr);
+      }
       while (size--) emitcode ("lcall","__decdptr");
+      if (AOP_INDPTRn(left)) {
+	  genSetDPTR(0);
+      }
   }
   
   freeAsmop (left, NULL, ic, TRUE);
@@ -9115,7 +9586,7 @@ genGenPointerGet (operand * left,
 
   D (emitcode (";", "genGenPointerGet "); );
 
-  aopOp (left, ic, FALSE, (OP_SYMBOL(left)->ruonly ? FALSE : TRUE));
+  aopOp (left, ic, FALSE, (AOP_IS_STR(left) ? FALSE : TRUE));
 
   /* if the operand is already in dptr
      then we do nothing else we move the value to dptr */
@@ -9124,74 +9595,87 @@ genGenPointerGet (operand * left,
       /* if this is remateriazable */
       if (AOP_TYPE (left) == AOP_IMMD)
 	{
-	  emitcode ("mov", "dptr,%s", aopGet (AOP (left), 0, TRUE, FALSE, FALSE));
+	  emitcode ("mov", "dptr,%s", aopGet (AOP (left), 0, TRUE, FALSE, NULL));
 	  if (AOP(left)->aopu.aop_immd.from_cast_remat) 
-		  emitcode ("mov", "b,%s",aopGet(AOP (left), AOP_SIZE(left)-1, FALSE, FALSE, FALSE));
-	  else
-		  emitcode ("mov", "b,#%d", pointerCode (retype));
+	    {
+		MOVB(aopGet(AOP (left), AOP_SIZE(left)-1, FALSE, FALSE, NULL));
+	    }
+	    else
+	    {
+		emitcode ("mov", "b,#%d", pointerCode (retype));
+	    }
 	}
       else
 	{			/* we need to get it byte by byte */
-	  _startLazyDPSEvaluation ();
-	  if (AOP(left)->type==AOP_DPTR2) {
-	    char *l;
-	    l=aopGet(AOP(left),0,FALSE,FALSE,TRUE);
-	    genSetDPTR(0);
-	    _flushLazyDPS();
-	    emitcode ("mov", "dpl,%s", l);
-	    l=aopGet(AOP(left),1,FALSE,FALSE,TRUE);
-	    genSetDPTR(0);
-	    _flushLazyDPS();
-	    emitcode ("mov", "dph,%s", l);
-	    if (options.model == MODEL_FLAT24) {
-	      l=aopGet(AOP(left),2,FALSE,FALSE,TRUE);
-	      genSetDPTR(0);
-	      _flushLazyDPS();
-	      emitcode ("mov", "dpx,%s", l);
-	      emitcode ("mov", "b,%s", aopGet (AOP(left),3,FALSE,FALSE,TRUE));
-	    } else {
-	      emitcode ("mov", "b,%s", aopGet (AOP(left),2,FALSE,FALSE,TRUE));
-	    }
-	  } else {
-	    emitcode ("mov", "dpl,%s", aopGet (AOP(left),0,FALSE,FALSE,TRUE));
-	    emitcode ("mov", "dph,%s", aopGet (AOP(left),1,FALSE,FALSE,TRUE));
+	    _startLazyDPSEvaluation ();
+	    emitcode ("mov", "dpl,%s", aopGet (AOP(left),0,FALSE,FALSE,NULL));
+	    emitcode ("mov", "dph,%s", aopGet (AOP(left),1,FALSE,FALSE,NULL));
 	    if (options.model == MODEL_FLAT24) {
-	      emitcode ("mov", "dpx,%s", aopGet (AOP(left),2,FALSE,FALSE,TRUE));
-	      emitcode ("mov", "b,%s", aopGet (AOP(left),3,FALSE,FALSE,TRUE));
+		emitcode ("mov", "dpx,%s", aopGet (AOP(left),2,FALSE,FALSE,NULL));
+		emitcode ("mov", "b,%s", aopGet (AOP(left),3,FALSE,FALSE,NULL));
 	    } else {
-	      emitcode ("mov", "b,%s", aopGet (AOP(left),2,FALSE,FALSE,TRUE));
+		emitcode ("mov", "b,%s", aopGet (AOP(left),2,FALSE,FALSE,NULL));
 	    }
-	  }
-	  _endLazyDPSEvaluation ();
+	    _endLazyDPSEvaluation ();
 	}
     }
-  /* so dptr know contains the address */
+
+  /* so dptr-b now contains the address */
+  _G.bInUse++;
   aopOp (result, ic, FALSE, TRUE);
+  _G.bInUse--;
 
   /* if bit then unpack */
   if (IS_BITVAR (retype) || IS_BITVAR (letype))
+  {
     genUnpackBits (result, "dptr", GPOINTER);
+  }
   else
     {
-      size = AOP_SIZE (result);
-      offset = 0;
+	size = AOP_SIZE (result);
+	offset = 0;
 
-      while (size--)
+	while (size--)
 	{
-	  emitcode ("lcall", "__gptrget");
-	  aopPut (AOP (result), "a", offset++);
-	  if (size || (pi && AOP_TYPE (left) != AOP_IMMD))
-	    emitcode ("inc", "dptr");
+	    if (size)
+	    {
+		// Get two bytes at a time, results in _AP & A.
+		// dptr will be incremented ONCE by __gptrgetWord.
+		//
+		// Note: any change here must be coordinated
+		// with the implementation of __gptrgetWord
+		// in device/lib/_gptrget.c
+		emitcode ("lcall", "__gptrgetWord");
+		aopPut (AOP (result), DP2_RESULT_REG, offset++);
+		aopPut (AOP (result), "a", offset++);
+		size--;
+	    }
+	    else
+	    {
+		// Only one byte to get.
+		emitcode ("lcall", "__gptrget");
+		aopPut (AOP (result), "a", offset++);
+	    }
+	    
+	    if (size || (pi && AOP_TYPE (left) != AOP_IMMD))
+	    {
+		emitcode ("inc", "dptr");
+	    }
 	}
     }
 
   if (pi && AOP_TYPE (left) != AOP_IMMD) {
+    _startLazyDPSEvaluation ();
+      
     aopPut ( AOP (left), "dpl", 0);
     aopPut ( AOP (left), "dph", 1);
     if (options.model == MODEL_FLAT24) {
 	aopPut ( AOP (left), "dpx", 2);
 	aopPut ( AOP (left), "b", 3);	
     } else  aopPut ( AOP (left), "b", 2);	
+    
+    _endLazyDPSEvaluation ();
+      
     pi->generated = 1;
   } else if (OP_SYMBOL(left)->ruonly && AOP_SIZE(result) > 1 &&
 	     (OP_SYMBOL (left)->liveTo > ic->seq || ic->depth)) {
@@ -9236,7 +9720,7 @@ genPointerGet (iCode * ic, iCode *pi)
   if (p_type == GPOINTER && OP_SYMBOL(left)->remat &&
       IS_CAST_ICODE(OP_SYMBOL(left)->rematiCode)) {
 	  left = IC_RIGHT(OP_SYMBOL(left)->rematiCode);
-	  type =   type = operandType (left);
+	  type = operandType (left);
 	  p_type = DCL_TYPE (type);
   }
   /* now that we have the pointer type we assign
@@ -9258,7 +9742,7 @@ genPointerGet (iCode * ic, iCode *pi)
       break;
 
     case CPOINTER:
-      emitcodePointerGet (left, result, ic, pi);
+      genCodePointerGet (left, result, ic, pi);
       break;
 
     case GPOINTER:
@@ -9276,26 +9760,22 @@ genPackBits (sym_link * etype,
 	     operand * right,
 	     char *rname, int p_type)
 {
-  int shCount = 0;
   int offset = 0;
-  int rLen = 0;
+  int rLen;
   int blen, bstr;
   char *l;
 
   blen = SPEC_BLEN (etype);
   bstr = SPEC_BSTR (etype);
 
-  l = aopGet (AOP (right), offset++, FALSE, FALSE, TRUE);
-  MOVA (l);
+  MOVA (aopGet (AOP (right), offset++, FALSE, FALSE, NULL));
 
   /* if the bit lenth is less than or    */
   /* it exactly fits a byte then         */
   if (SPEC_BLEN (etype) <= 8)
     {
-      shCount = SPEC_BSTR (etype);
-
       /* shift left acc */
-      AccLsh (shCount);
+      AccLsh (SPEC_BSTR (etype));
 
       if (SPEC_BLEN (etype) < 8)
 	{			/* if smaller than a byte */
@@ -9356,7 +9836,7 @@ genPackBits (sym_link * etype,
   while (1)
     {
 
-      l = aopGet (AOP (right), offset++, FALSE, TRUE, FALSE);
+      l = aopGet (AOP (right), offset++, FALSE, TRUE, NULL);
 
       rLen -= 8;
       if (rLen < 8)
@@ -9445,20 +9925,25 @@ genDataPointerSet (operand * right,
 		   iCode * ic)
 {
   int size, offset = 0;
-  char *l, buffer[256];
+  char *l, buff[256];
 
   aopOp (right, ic, FALSE, FALSE);
 
-  l = aopGet (AOP (result), 0, FALSE, TRUE, FALSE);
+  l = aopGet (AOP (result), 0, FALSE, TRUE, NULL);
   size = AOP_SIZE (right);
   while (size--)
     {
       if (offset)
-	sprintf (buffer, "(%s + %d)", l + 1, offset);
+	{
+	    SNPRINTF (buff, sizeof(buff), "(%s + %d)", l + 1, offset);
+	}
       else
-	sprintf (buffer, "%s", l + 1);
-      emitcode ("mov", "%s,%s", buffer,
-		aopGet (AOP (right), offset++, FALSE, FALSE, FALSE));
+	{
+	    SNPRINTF (buff, sizeof(buff), "%s", l + 1);
+	}
+	
+      emitcode ("mov", "%s,%s", buff,
+		aopGet (AOP (right), offset++, FALSE, FALSE, NULL));
     }
 
   freeAsmop (right, NULL, ic, TRUE);
@@ -9475,7 +9960,6 @@ genNearPointerSet (operand * right,
 		   iCode * pi)
 {
   asmop *aop = NULL;
-  regs *preg = NULL;
   char *rname, *l;
   sym_link *retype, *letype;
   sym_link *ptype = operandType (result);
@@ -9501,15 +9985,17 @@ genNearPointerSet (operand * right,
   if (!AOP_INPREG (AOP (result)))
     {
       /* otherwise get a free pointer register */
+      regs *preg;
+	
       aop = newAsmop (0);
       preg = getFreePtr (ic, &aop, FALSE);
       emitcode ("mov", "%s,%s",
 		preg->name,
-		aopGet (AOP (result), 0, FALSE, TRUE, FALSE));
+		aopGet (AOP (result), 0, FALSE, TRUE, NULL));
       rname = preg->name;
     }
   else
-    rname = aopGet (AOP (result), 0, FALSE, FALSE, FALSE);
+    rname = aopGet (AOP (result), 0, FALSE, FALSE, NULL);
 
   aopOp (right, ic, FALSE, FALSE);
 
@@ -9524,7 +10010,7 @@ genNearPointerSet (operand * right,
 
       while (size--)
 	{
-	  l = aopGet (AOP (right), offset, FALSE, TRUE, FALSE);
+	  l = aopGet (AOP (right), offset, FALSE, TRUE, NULL);
 	  if (*l == '@')
 	    {
 	      MOVA (l);
@@ -9582,8 +10068,7 @@ genPagedPointerSet (operand * right,
 		    iCode *pi)
 {
   asmop *aop = NULL;
-  regs *preg = NULL;
-  char *rname, *l;
+  char *rname;
   sym_link *retype, *letype;
 
   retype = getSpec (operandType (right));
@@ -9596,15 +10081,17 @@ genPagedPointerSet (operand * right,
   if (!AOP_INPREG (AOP (result)))
     {
       /* otherwise get a free pointer register */
+      regs *preg;
+	
       aop = newAsmop (0);
       preg = getFreePtr (ic, &aop, FALSE);
       emitcode ("mov", "%s,%s",
 		preg->name,
-		aopGet (AOP (result), 0, FALSE, TRUE, FALSE));
+		aopGet (AOP (result), 0, FALSE, TRUE, NULL));
       rname = preg->name;
     }
   else
-    rname = aopGet (AOP (result), 0, FALSE, FALSE, FALSE);
+    rname = aopGet (AOP (result), 0, FALSE, FALSE, NULL);
 
   aopOp (right, ic, FALSE, FALSE);
 
@@ -9619,9 +10106,8 @@ genPagedPointerSet (operand * right,
 
       while (size--)
 	{
-	  l = aopGet (AOP (right), offset, FALSE, TRUE, TRUE);
+	  MOVA (aopGet (AOP (right), offset, FALSE, TRUE, NULL));
 
-	  MOVA (l);
 	  emitcode ("movx", "@%s,a", rname);
 
 	  if (size || pi)
@@ -9680,31 +10166,32 @@ genFarPointerSet (operand * right,
 
   /* if the operand is already in dptr
      then we do nothing else we move the value to dptr */
-  if (AOP_TYPE (result) != AOP_STR)
+  if (AOP_TYPE (result) != AOP_STR && !AOP_INDPTRn(result))
     {
       /* if this is remateriazable */
       if (AOP_TYPE (result) == AOP_IMMD)
-	emitcode ("mov", "dptr,%s", aopGet (AOP (result), 0, TRUE, FALSE, FALSE));
+	emitcode ("mov", "dptr,%s", 
+		  aopGet (AOP (result), 0, TRUE, FALSE, NULL));
       else
 	{
 	  /* we need to get it byte by byte */
 	  _startLazyDPSEvaluation ();
 	  if (AOP_TYPE (result) != AOP_DPTR)
 	    {
-	      emitcode ("mov", "dpl,%s", aopGet (AOP (result), 0, FALSE, FALSE, TRUE));
-	      emitcode ("mov", "dph,%s", aopGet (AOP (result), 1, FALSE, FALSE, TRUE));
+	      emitcode ("mov", "dpl,%s", aopGet (AOP (result), 0, FALSE, FALSE, NULL));
+	      emitcode ("mov", "dph,%s", aopGet (AOP (result), 1, FALSE, FALSE, NULL));
 	      if (options.model == MODEL_FLAT24)
-	        emitcode ("mov", "dpx,%s", aopGet (AOP (result), 2, FALSE, FALSE, TRUE));
+	        emitcode ("mov", "dpx,%s", aopGet (AOP (result), 2, FALSE, FALSE, NULL));
 	    }
 	  else
 	    {
 	      /* We need to generate a load to DPTR indirect through DPTR. */
-	      D (emitcode (";", "genFarPointerSet -- indirection special case.");
-		);
-	      emitcode ("push", "%s", aopGet (AOP (result), 0, FALSE, TRUE, TRUE));
-	      emitcode ("push", "%s", aopGet (AOP (result), 1, FALSE, TRUE, TRUE));
+	      D (emitcode (";", "genFarPointerSet -- indirection special case."););
+		
+	      emitcode ("push", "%s", aopGet (AOP (result), 0, FALSE, TRUE, NULL));
+	      emitcode ("push", "%s", aopGet (AOP (result), 1, FALSE, TRUE, NULL));
 	      if (options.model == MODEL_FLAT24)
-	        emitcode ("mov", "dpx,%s", aopGet (AOP (result), 2, FALSE, FALSE, TRUE));
+	        emitcode ("mov", "dpx,%s", aopGet (AOP (result), 2, FALSE, FALSE, NULL));
 	      emitcode ("pop", "dph");
 	      emitcode ("pop", "dpl");
 	      dopi=0;
@@ -9713,43 +10200,74 @@ genFarPointerSet (operand * right,
 	}
     }
   /* so dptr know contains the address */
-  aopOp (right, ic, FALSE, TRUE);
+  aopOp (right, ic, FALSE, (AOP_INDPTRn(result) ? FALSE : TRUE));
 
   /* if bit then unpack */
-  if (IS_BITVAR (retype) || IS_BITVAR (letype))
-    genPackBits ((IS_BITVAR (retype) ? retype : letype), right, "dptr", FPOINTER);
-  else
-    {
+  if (IS_BITVAR (retype) || IS_BITVAR (letype)) {
+      if (AOP_INDPTRn(result)) {
+	  genSetDPTR(AOP(result)->aopu.dptr);
+      }
+      genPackBits ((IS_BITVAR (retype) ? retype : letype), right, "dptr", FPOINTER);
+      if (AOP_INDPTRn(result)) {
+	  genSetDPTR(0);
+      }
+  } else {
       size = AOP_SIZE (right);
       offset = 0;
-
-      _startLazyDPSEvaluation ();
-      while (size--)
-	{
-	  char *l = aopGet (AOP (right), offset++, FALSE, FALSE, TRUE);
-	  MOVA (l);
-
-	  genSetDPTR (0);
-	  _flushLazyDPS ();
-
-	  emitcode ("movx", "@dptr,a");
-	  if (size || (dopi && pi && AOP_TYPE (result) != AOP_IMMD))
-	    emitcode ("inc", "dptr");
-	}
-      _endLazyDPSEvaluation ();
-    }
-
+      if (AOP_INDPTRn(result) && AOP_USESDPTR(right)) {
+	  while (size--) {
+	      MOVA (aopGet (AOP (right), offset++, FALSE, FALSE, NULL));
+	      
+	      genSetDPTR(AOP(result)->aopu.dptr);
+	      emitcode ("movx", "@dptr,a");
+	      if (size || (dopi && pi && AOP_TYPE (result) != AOP_IMMD))
+		  emitcode ("inc", "dptr");
+	      genSetDPTR (0);
+	  }
+      } else {
+	  _startLazyDPSEvaluation ();
+	  while (size--) {
+	      MOVA (aopGet (AOP (right), offset++, FALSE, FALSE, NULL));
+	      
+	      if (AOP_INDPTRn(result)) {
+		  genSetDPTR(AOP(result)->aopu.dptr);
+	      } else {
+		  genSetDPTR (0);
+	      }
+	      _flushLazyDPS ();
+	      
+	      emitcode ("movx", "@dptr,a");
+	      if (size || (dopi && pi && AOP_TYPE (result) != AOP_IMMD))
+		  emitcode ("inc", "dptr");
+	  }
+	  _endLazyDPSEvaluation ();
+      }
+  }
+  
   if (dopi && pi && AOP_TYPE (result) != AOP_IMMD) {
-      aopPut (AOP(result),"dpl",0);
-      aopPut (AOP(result),"dph",1);
-      if (options.model == MODEL_FLAT24)
-	  aopPut (AOP(result),"dpx",2);
+      if (!AOP_INDPTRn(result)) {
+	  _startLazyDPSEvaluation ();
+	  
+	  aopPut (AOP(result),"dpl",0);
+	  aopPut (AOP(result),"dph",1);
+	  if (options.model == MODEL_FLAT24)
+	      aopPut (AOP(result),"dpx",2);
+
+	  _endLazyDPSEvaluation ();
+      }
       pi->generated=1;
-  } else if (OP_SYMBOL(result)->ruonly && AOP_SIZE(right) > 1 &&
+  } else if ((OP_SYMBOL(result)->ruonly || AOP_INDPTRn(result)) && 
+	     AOP_SIZE(right) > 1 &&
 	     (OP_SYMBOL (result)->liveTo > ic->seq || ic->depth)) {
       
       size = AOP_SIZE (right) - 1;
+      if (AOP_INDPTRn(result)) {
+	  genSetDPTR(AOP(result)->aopu.dptr);
+      } 
       while (size--) emitcode ("lcall","__decdptr");
+      if (AOP_INDPTRn(result)) {
+	  genSetDPTR(0);
+      }
   }
   freeAsmop (result, NULL, ic, TRUE);
   freeAsmop (right, NULL, ic, TRUE);
@@ -9766,7 +10284,7 @@ genGenPointerSet (operand * right,
   sym_link *retype = getSpec (operandType (right));
   sym_link *letype = getSpec (operandType (result));
 
-  aopOp (result, ic, FALSE, OP_SYMBOL(result)->ruonly ? FALSE : TRUE);
+  aopOp (result, ic, FALSE, AOP_IS_STR(result) ? FALSE : TRUE);
 
   /* if the operand is already in dptr
      then we do nothing else we move the value to dptr */
@@ -9776,53 +10294,87 @@ genGenPointerSet (operand * right,
       /* if this is remateriazable */
       if (AOP_TYPE (result) == AOP_IMMD)
 	{
-	  emitcode ("mov", "dptr,%s", aopGet (AOP (result), 0, TRUE, FALSE, FALSE));
+	  emitcode ("mov", "dptr,%s", aopGet (AOP (result), 0, TRUE, FALSE, NULL));
 	  if (AOP(result)->aopu.aop_immd.from_cast_remat) 
-		  emitcode ("mov", "b,%s",aopGet(AOP (result), AOP_SIZE(result)-1, FALSE, FALSE, FALSE));
+	  {
+	      MOVB(aopGet(AOP (result), AOP_SIZE(result)-1, FALSE, FALSE, NULL));
+	  }
 	  else
-		  emitcode ("mov", "b,%s + 1", aopGet (AOP (result), 0, TRUE, FALSE, FALSE));
+	  {
+	      emitcode ("mov", 
+			"b,%s + 1", aopGet (AOP (result), 0, TRUE, FALSE, NULL));
+	  }
 	}
       else
 	{			/* we need to get it byte by byte */
-	  emitcode ("mov", "dpl,%s", aopGet (AOP (result), 0, FALSE, FALSE, TRUE));
-	  emitcode ("mov", "dph,%s", aopGet (AOP (result), 1, FALSE, FALSE, TRUE));
+	  emitcode ("mov", "dpl,%s", aopGet (AOP (result), 0, FALSE, FALSE, NULL));
+	  emitcode ("mov", "dph,%s", aopGet (AOP (result), 1, FALSE, FALSE, NULL));
 	  if (options.model == MODEL_FLAT24) {
-	    emitcode ("mov", "dpx,%s", aopGet (AOP (result), 2, FALSE, FALSE, TRUE));
-	    emitcode ("mov", "b,%s", aopGet (AOP (result), 3, FALSE, FALSE, TRUE));
+	    emitcode ("mov", "dpx,%s", aopGet (AOP (result), 2, FALSE, FALSE, NULL));
+	    emitcode ("mov", "b,%s", aopGet (AOP (result), 3, FALSE, FALSE, NULL));
 	  } else {
-	    emitcode ("mov", "b,%s", aopGet (AOP (result), 2, FALSE, FALSE, TRUE));
+	    emitcode ("mov", "b,%s", aopGet (AOP (result), 2, FALSE, FALSE, NULL));
 	  }
 	}
       _endLazyDPSEvaluation ();
     }
-  /* so dptr know contains the address */
+  /* so dptr + b now contains the address */
+  _G.bInUse++;
   aopOp (right, ic, FALSE, TRUE);
+  _G.bInUse--;
+    
 
   /* if bit then unpack */
   if (IS_BITVAR (retype) || IS_BITVAR (letype))
-    genPackBits ((IS_BITVAR (retype) ? retype : letype), right, "dptr", GPOINTER);
+    {
+	genPackBits ((IS_BITVAR (retype) ? retype : letype), right, "dptr", GPOINTER);
+    }
   else
     {
-      size = AOP_SIZE (right);
-      offset = 0;
+	size = AOP_SIZE (right);
+	offset = 0;
 
-      _startLazyDPSEvaluation ();
-      while (size--)
+	_startLazyDPSEvaluation ();
+	while (size--)
 	{
-	  char *l = aopGet (AOP (right), offset++, FALSE, FALSE, TRUE);
-	  MOVA (l);
-
-	  genSetDPTR (0);
-	  _flushLazyDPS ();
+	    if (size)
+	    {
+		// Set two bytes at a time, passed in _AP & A.
+		// dptr will be incremented ONCE by __gptrputWord.
+		//
+		// Note: any change here must be coordinated
+		// with the implementation of __gptrputWord
+		// in device/lib/_gptrput.c
+		emitcode("mov", "_ap, %s", 
+			 aopGet (AOP (right), offset++, FALSE, FALSE, NULL));
+		MOVA (aopGet (AOP (right), offset++, FALSE, FALSE, NULL));
+		
+		genSetDPTR (0);
+		_flushLazyDPS ();
+		emitcode ("lcall", "__gptrputWord");
+		size--;
+	    }
+	    else
+	    {
+		// Only one byte to put.
+		MOVA (aopGet (AOP (right), offset++, FALSE, FALSE, NULL));
 
-	  emitcode ("lcall", "__gptrput");
-	  if (size || (pi && AOP_TYPE (result) != AOP_IMMD))
-	    emitcode ("inc", "dptr");
+		genSetDPTR (0);
+		_flushLazyDPS ();		
+		emitcode ("lcall", "__gptrput");
+	    }
+	    
+	    if (size || (pi && AOP_TYPE (result) != AOP_IMMD))
+	    {
+		emitcode ("inc", "dptr");
+	    }
 	}
-      _endLazyDPSEvaluation ();
+	_endLazyDPSEvaluation ();
     }
 
   if (pi && AOP_TYPE (result) != AOP_IMMD) {
+      _startLazyDPSEvaluation ();
+      
       aopPut (AOP(result),"dpl",0);
       aopPut (AOP(result),"dph",1);
       if (options.model == MODEL_FLAT24) {
@@ -9831,6 +10383,8 @@ genGenPointerSet (operand * right,
       } else {
 	  aopPut (AOP(result),"b",2);
       }
+      _endLazyDPSEvaluation ();
+      
       pi->generated=1;
   } else if (OP_SYMBOL(result)->ruonly && AOP_SIZE(right) > 1 &&
 	     (OP_SYMBOL (result)->liveTo > ic->seq || ic->depth)) {
@@ -9852,8 +10406,7 @@ genPointerSet (iCode * ic, iCode *pi)
   sym_link *type, *etype;
   int p_type;
 
-  D (emitcode (";", "genPointerSet ");
-    );
+  D (emitcode (";", "genPointerSet "););
 
   right = IC_RIGHT (ic);
   result = IC_RESULT (ic);
@@ -9876,7 +10429,7 @@ genPointerSet (iCode * ic, iCode *pi)
   if (p_type == GPOINTER && OP_SYMBOL(result)->remat &&
       IS_CAST_ICODE(OP_SYMBOL(result)->rematiCode)) {
 	  result = IC_RIGHT(OP_SYMBOL(result)->rematiCode);
-	  type =   type = operandType (result);
+	  type = operandType (result);
 	  p_type = DCL_TYPE (type);
   }
 
@@ -9901,6 +10454,10 @@ genPointerSet (iCode * ic, iCode *pi)
     case GPOINTER:
       genGenPointerSet (right, result, ic, pi);
       break;
+
+    default:
+      werror (E_INTERNAL_ERROR, __FILE__, __LINE__, 
+	      "genPointerSet: illegal pointer type");
     }
 
 }
@@ -9920,9 +10477,14 @@ genIfx (iCode * ic, iCode * popIc)
 
   /* get the value into acc */
   if (AOP_TYPE (cond) != AOP_CRY)
-    toBoolean (cond);
+    {
+	toBoolean (cond);
+    }
   else
-    isbit = 1;
+    {
+	isbit = 1;
+    }
+    
   /* the result is now in the accumulator */
   freeAsmop (cond, NULL, ic, TRUE);
 
@@ -9933,11 +10495,17 @@ genIfx (iCode * ic, iCode * popIc)
   /* if the condition is  a bit variable */
   if (isbit && IS_ITEMP (cond) &&
       SPIL_LOC (cond))
-    genIfxJump (ic, SPIL_LOC (cond)->rname);
+    {
+	genIfxJump (ic, SPIL_LOC (cond)->rname);
+    }
   else if (isbit && !IS_ITEMP (cond))
-    genIfxJump (ic, OP_SYMBOL (cond)->rname);
+    {
+	genIfxJump (ic, OP_SYMBOL (cond)->rname);
+    }
   else
-    genIfxJump (ic, "a");
+    {
+	genIfxJump (ic, "a");
+    }
 
   ic->generated = 1;
 }
@@ -9964,16 +10532,19 @@ genAddrOf (iCode * ic)
       /* if 10 bit stack */
       if (options.stack10bit) {
 	  char buff[10];
-	  tsprintf(buff,"#!constbyte",(options.stack_loc >> 16) & 0xff);
+	  int  offset;
+	  
+	  tsprintf(buff, sizeof(buff), 
+		   "#!constbyte",(options.stack_loc >> 16) & 0xff);
 	  /* if it has an offset then we need to compute it */
-	  emitcode ("subb", "a,#!constbyte",
-		    -((sym->stack < 0) ?
-		      ((short) (sym->stack - _G.nRegsSaved)) :
-		      ((short) sym->stack)) & 0xff);
-	  emitcode ("mov","b,a");
-	  emitcode ("mov","a,#!constbyte",(-((sym->stack < 0) ?
-					 ((short) (sym->stack - _G.nRegsSaved)) :
-					 ((short) sym->stack)) >> 8) & 0xff);
+/* 	  emitcode ("subb", "a,#!constbyte", */
+/* 		    -((sym->stack < 0) ? */
+/* 		      ((short) (sym->stack - _G.nRegsSaved)) : */
+/* 		      ((short) sym->stack)) & 0xff); */
+/* 	  emitcode ("mov","b,a"); */
+/* 	  emitcode ("mov","a,#!constbyte",(-((sym->stack < 0) ? */
+/* 					 ((short) (sym->stack - _G.nRegsSaved)) : */
+/* 					 ((short) sym->stack)) >> 8) & 0xff); */
 	  if (sym->stack) {
 	      emitcode ("mov", "a,_bpx");
 	      emitcode ("add", "a,#!constbyte", ((sym->stack < 0) ? 
@@ -9981,9 +10552,13 @@ genAddrOf (iCode * ic)
 					     ((char) sym->stack )) & 0xff);
 	      emitcode ("mov", "b,a");
 	      emitcode ("mov", "a,_bpx+1");
-	      emitcode ("addc","a,#!constbyte", (((sym->stack < 0) ? 
-					      ((short) (sym->stack - _G.nRegsSaved)) :
-					      ((short) sym->stack )) >> 8) & 0xff);
+	      
+	      offset = (((sym->stack < 0) ? 
+			 ((short) (sym->stack - _G.nRegsSaved)) :
+			 ((short) sym->stack )) >> 8) & 0xff;
+	  
+	      emitcode ("addc","a,#!constbyte", offset);
+
 	      aopPut (AOP (IC_RESULT (ic)), "b", 0);
 	      aopPut (AOP (IC_RESULT (ic)), "a", 1);
 	      aopPut (AOP (IC_RESULT (ic)), buff, 2);
@@ -10030,21 +10605,25 @@ genAddrOf (iCode * ic)
       if (offset) {
 	  switch (offset) {
 	  case 1:
-	      tsprintf(s,"!his",sym->rname);
+	      tsprintf(s, sizeof(s), "#!his",sym->rname);
 	      break;
 	  case 2:
-	      tsprintf(s,"!hihis",sym->rname);
+	      tsprintf(s, sizeof(s), "#!hihis",sym->rname);
 	      break;
 	  case 3:
-	      tsprintf(s,"!hihihis",sym->rname);
+	      tsprintf(s, sizeof(s), "#!hihihis",sym->rname);
 	      break;
 	  default: /* should not need this (just in case) */
-	      sprintf (s, "#(%s >> %d)",
+	      SNPRINTF (s, sizeof(s), "#(%s >> %d)",
 		       sym->rname,
 		       offset * 8);
 	  }
-      } else
-	  sprintf (s, "#%s", sym->rname);
+      } 
+      else
+      {
+	  SNPRINTF (s, sizeof(s), "#%s", sym->rname);
+      }
+	
       aopPut (AOP (IC_RESULT (ic)), s, offset++);
     }
 
@@ -10053,6 +10632,7 @@ release:
 
 }
 
+#if 0 // obsolete, and buggy for != xdata
 /*-----------------------------------------------------------------*/
 /* genArrayInit - generates code for address of                       */
 /*-----------------------------------------------------------------*/
@@ -10074,7 +10654,7 @@ genArrayInit (iCode * ic)
     {
 	// Load immediate value into DPTR.
 	emitcode("mov", "dptr, %s",
-	     aopGet(AOP(IC_LEFT(ic)), 0, TRUE, FALSE, TRUE));
+	     aopGet(AOP(IC_LEFT(ic)), 0, TRUE, FALSE, NULL));
     }
     else if (AOP_TYPE(IC_LEFT(ic)) != AOP_DPTR)
     {
@@ -10084,10 +10664,10 @@ genArrayInit (iCode * ic)
       exit(1);
 #else
       // a regression because of SDCCcse.c:1.52
-      emitcode ("mov", "dpl,%s", aopGet (AOP (left), 0, FALSE, FALSE, TRUE));
-      emitcode ("mov", "dph,%s", aopGet (AOP (left), 1, FALSE, FALSE, TRUE));
+      emitcode ("mov", "dpl,%s", aopGet (AOP (left), 0, FALSE, FALSE, NULL));
+      emitcode ("mov", "dph,%s", aopGet (AOP (left), 1, FALSE, FALSE, NULL));
       if (options.model == MODEL_FLAT24)
-	emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE, TRUE));
+	emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE, NULL));
 #endif
     }
     
@@ -10161,6 +10741,7 @@ genArrayInit (iCode * ic)
     
     freeAsmop (IC_LEFT(ic), NULL, ic, TRUE);
 }
+#endif
 
 /*-----------------------------------------------------------------*/
 /* genFarFarAssign - assignment when both are in far space         */
@@ -10176,7 +10757,7 @@ genFarFarAssign (operand * result, operand * right, iCode * ic)
   {
       /* quick & easy case. */
       D(emitcode(";","genFarFarAssign (1 byte case)"););      
-      MOVA(aopGet(AOP(right), 0, FALSE, FALSE, TRUE));
+      MOVA(aopGet(AOP(right), 0, FALSE, FALSE, NULL));
       freeAsmop (right, NULL, ic, FALSE);
       /* now assign DPTR to result */
       _G.accInUse++;
@@ -10205,7 +10786,7 @@ genFarFarAssign (operand * result, operand * right, iCode * ic)
       /* We can use the '390 auto-toggle feature to good effect here. */
       
       D(emitcode(";","genFarFarAssign (390 auto-toggle fun)"););
-      emitcode("mov", "dps, #0x21"); 	/* Select DPTR2 & auto-toggle. */
+      emitcode("mov", "dps,#!constbyte",0x21); 	/* Select DPTR2 & auto-toggle. */
       emitcode ("mov", "dptr,#%s", rSym->rname); 
       /* DP2 = result, DP1 = right, DP1 is current. */
       while (size)
@@ -10218,13 +10799,13 @@ genFarFarAssign (operand * result, operand * right, iCode * ic)
                emitcode("inc", "dptr");
           }
       }
-      emitcode("mov", "dps, #0");
+      emitcode("mov", "dps,#0");
       freeAsmop (right, NULL, ic, FALSE);
 #if 0
 some alternative code for processors without auto-toggle
 no time to test now, so later well put in...kpb
         D(emitcode(";","genFarFarAssign (dual-dptr fun)"););
-        emitcode("mov", "dps, #0x01"); 	/* Select DPTR2. */
+        emitcode("mov", "dps,#1"); 	/* Select DPTR2. */
         emitcode ("mov", "dptr,#%s", rSym->rname); 
         /* DP2 = result, DP1 = right, DP1 is current. */
         while (size)
@@ -10239,7 +10820,7 @@ no time to test now, so later well put in...kpb
             emitcode("inc", "dptr");
           emitcode("inc", "dps");
         }
-        emitcode("mov", "dps, #0");
+        emitcode("mov", "dps,#0");
         freeAsmop (right, NULL, ic, FALSE);
 #endif
   }
@@ -10253,7 +10834,7 @@ no time to test now, so later well put in...kpb
       while (size--)
 	{
 	  aopPut (AOP (result),
-		  aopGet (AOP (right), offset, FALSE, FALSE, FALSE), offset);
+		  aopGet (AOP (right), offset, FALSE, FALSE, NULL), offset);
 	  offset++;
 	}
       _endLazyDPSEvaluation ();
@@ -10348,7 +10929,7 @@ genAssign (iCode * ic)
       while (size && ((unsigned int) (lit >> (offset * 8)) != 0))
 	{
 	  aopPut (AOP (result),
-		  aopGet (AOP (right), offset, FALSE, FALSE, TRUE),
+		  aopGet (AOP (right), offset, FALSE, FALSE, NULL),
 		  offset);
 	  offset++;
 	  size--;
@@ -10370,7 +10951,7 @@ genAssign (iCode * ic)
       while (size--)
 	{
 	  aopPut (AOP (result),
-		  aopGet (AOP (right), offset, FALSE, FALSE, FALSE),
+		  aopGet (AOP (right), offset, FALSE, FALSE, NULL),
 		  offset);
 	  offset++;
 	}
@@ -10396,7 +10977,7 @@ genJumpTab (iCode * ic)
 
   aopOp (IC_JTCOND (ic), ic, FALSE, FALSE);
   /* get the condition into accumulator */
-  l = aopGet (AOP (IC_JTCOND (ic)), 0, FALSE, FALSE, TRUE);
+  l = aopGet (AOP (IC_JTCOND (ic)), 0, FALSE, FALSE, NULL);
   MOVA (l);
   /* multiply by four! */
   emitcode ("add", "a,acc");
@@ -10426,15 +11007,14 @@ genCast (iCode * ic)
   operand *right = IC_RIGHT (ic);
   int size, offset;
 
-  D (emitcode (";", "genCast ");
-    );
+  D (emitcode (";", "genCast "););
 
   /* if they are equivalent then do nothing */
   if (operandsEqu (IC_RESULT (ic), IC_RIGHT (ic)))
     return;
 
   aopOp (right, ic, FALSE, FALSE);
-  aopOp (result, ic, FALSE, AOP_TYPE (right) == AOP_DPTR);
+  aopOp (result, ic, FALSE, AOP_USESDPTR(right));
 
   /* if the result is a bit */
   // if (AOP_TYPE (result) == AOP_CRY) /* works only for true symbols */
@@ -10481,7 +11061,7 @@ genCast (iCode * ic)
       while (size--)
 	{
 	  aopPut (AOP (result),
-		  aopGet (AOP (right), offset, FALSE, FALSE, FALSE),
+		  aopGet (AOP (right), offset, FALSE, FALSE, NULL),
 		  offset);
 	  offset++;
 	}
@@ -10500,8 +11080,6 @@ genCast (iCode * ic)
       /* pointer to generic pointer */
       if (IS_GENPTR (ctype))
 	{
-	  char *l = zero;
-
 	  if (IS_PTR (type))
 	    {
 	      p_type = DCL_TYPE (type);
@@ -10554,36 +11132,26 @@ genCast (iCode * ic)
 	  while (size--)
 	    {
 	      aopPut (AOP (result),
-		      aopGet (AOP (right), offset, FALSE, FALSE, FALSE),
+		      aopGet (AOP (right), offset, FALSE, FALSE, NULL),
 		      offset);
 	      offset++;
 	    }
 	  _endLazyDPSEvaluation ();
 
 	  /* the last byte depending on type */
-	  switch (p_type)
 	    {
-	    case IPOINTER:
-	    case POINTER:
-	      l = zero;
-	      break;
-	    case FPOINTER:
-	      l = one;
-	      break;
-	    case CPOINTER:
-	      l = "#0x02";
-	      break;
-	    case PPOINTER:
-	      l = "#0x03";
-	      break;
-
-	    default:
-	      /* this should never happen */
-	      werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
-		      "got unknown pointer type");
-	      exit (1);
+		int gpVal = pointerTypeToGPByte(p_type, NULL, NULL);
+		char gpValStr[10];
+	    
+		if (gpVal == -1)
+		{
+		    // pointerTypeToGPByte will have bitched.
+		    exit(1);
+		}
+	    
+		SNPRINTF(gpValStr, sizeof(gpValStr), "#0x%d", gpVal);
+		aopPut (AOP (result), gpValStr, GPTRSIZE - 1);
 	    }
-	  aopPut (AOP (result), l, GPTRSIZE - 1);
 	  goto release;
 	}
 
@@ -10594,7 +11162,7 @@ genCast (iCode * ic)
       while (size--)
 	{
 	  aopPut (AOP (result),
-		  aopGet (AOP (right), offset, FALSE, FALSE, FALSE),
+		  aopGet (AOP (right), offset, FALSE, FALSE, NULL),
 		  offset);
 	  offset++;
 	}
@@ -10611,7 +11179,7 @@ genCast (iCode * ic)
   while (size--)
     {
       aopPut (AOP (result),
-	      aopGet (AOP (right), offset, FALSE, FALSE, FALSE),
+	      aopGet (AOP (right), offset, FALSE, FALSE, NULL),
 	      offset);
       offset++;
     }
@@ -10623,7 +11191,7 @@ genCast (iCode * ic)
   /* also, if the source is a bit, we don't need to sign extend, because
    * it can't possibly have set the sign bit.
    */
-  if (SPEC_USIGN (rtype) || !IS_SPEC (rtype) || AOP_TYPE (right) == AOP_CRY)
+  if (!IS_SPEC (rtype) || SPEC_USIGN (rtype) || AOP_TYPE (right) == AOP_CRY)
     {
       while (size--)
 	{
@@ -10633,9 +11201,8 @@ genCast (iCode * ic)
   else
     {
       /* we need to extend the sign :{ */
-      char *l = aopGet (AOP (right), AOP_SIZE (right) - 1,
-			FALSE, FALSE, TRUE);
-      MOVA (l);
+      MOVA (aopGet (AOP (right), AOP_SIZE (right) - 1,
+			FALSE, FALSE, NULL));
       emitcode ("rlc", "a");
       emitcode ("subb", "a,acc");
       while (size--)
@@ -10693,7 +11260,7 @@ genDjnz (iCode * ic, iCode * ifx)
        * the accumulator, we must explicitly write
        * it back after the decrement.
        */
-      char *rByte = aopGet(AOP(IC_RESULT(ic)), 0, FALSE, FALSE, TRUE);
+      char *rByte = aopGet(AOP(IC_RESULT(ic)), 0, FALSE, FALSE, NULL);
       
       if (strcmp(rByte, "a"))
       {
@@ -10713,13 +11280,13 @@ genDjnz (iCode * ic, iCode * ifx)
   else if (IS_AOP_PREG (IC_RESULT (ic)))
     {
       emitcode ("dec", "%s",
-		aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE, FALSE));
-      emitcode ("mov", "a,%s", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE, FALSE));
+		aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE, NULL));
+      emitcode ("mov", "a,%s", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE, NULL));
       emitcode ("jnz", "!tlabel", lbl->key + 100);
     }
   else
     {
-      emitcode ("djnz", "%s,!tlabel", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, TRUE, FALSE),
+      emitcode ("djnz", "%s,!tlabel", aopGet (AOP (IC_RESULT (ic)), 0, FALSE, TRUE, NULL),
 		lbl->key + 100);
     }
   emitcode ("sjmp", "!tlabel", lbl1->key + 100);
@@ -10738,41 +11305,55 @@ genDjnz (iCode * ic, iCode * ifx)
 static void
 genReceive (iCode * ic)
 {
+    int size = getSize (operandType (IC_RESULT (ic)));
+    int offset = 0;
+    int rb1off ;
+    
+    D (emitcode (";", "genReceive "););
 
-  D (emitcode (";", "genReceive ");
-    );
-
-  if (isOperandInFarSpace (IC_RESULT (ic)) &&
-      (OP_SYMBOL (IC_RESULT (ic))->isspilt ||
-       IS_TRUE_SYMOP (IC_RESULT (ic))))
+    if (ic->argreg == 1) 
     {
-      int size = getSize (operandType (IC_RESULT (ic)));
-      int offset = fReturnSizeDS390 - size;
-      while (size--)
+	/* first parameter */
+	if (AOP_IS_STR(IC_RESULT(ic)))
 	{
-	  emitcode ("push", "%s", (strcmp (fReturn[fReturnSizeDS390 - offset - 1], "a") ?
-			    fReturn[fReturnSizeDS390 - offset - 1] : "acc"));
-	  offset++;
+	    /* Nothing to do: it's already in the proper place. */
+	    return;
 	}
-      aopOp (IC_RESULT (ic), ic, FALSE, FALSE);
-      size = AOP_SIZE (IC_RESULT (ic));
-      offset = 0;
-      while (size--)
+	else
 	{
-	  emitcode ("pop", "acc");
-	  aopPut (AOP (IC_RESULT (ic)), "a", offset++);
+	    bool useDp2;
+	    
+	    useDp2 = isOperandInFarSpace (IC_RESULT (ic)) &&
+		(OP_SYMBOL (IC_RESULT (ic))->isspilt ||
+		 IS_TRUE_SYMOP (IC_RESULT (ic)));
+	    
+	    _G.accInUse++;
+	    aopOp (IC_RESULT (ic), ic, FALSE, useDp2);
+	    _G.accInUse--; 
+	    
+	    /* Sanity checking... */
+	    if (AOP_USESDPTR(IC_RESULT(ic)))
+	    {
+		werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
+			"genReceive got unexpected DPTR.");
+	    }
+	    assignResultValue (IC_RESULT (ic));
+	}
+    } 
+    else 
+    { 
+	/* second receive onwards */
+	/* this gets a little tricky since unused recevies will be
+	 eliminated, we have saved the reg in the type field . and
+	 we use that to figure out which register to use */
+	aopOp (IC_RESULT (ic), ic, FALSE, FALSE);
+	rb1off = ic->argreg;
+	while (size--) 
+	{
+	    aopPut (AOP (IC_RESULT (ic)), rb1regs[rb1off++ -5], offset++);
 	}
-
-    }
-  else
-    {
-      _G.accInUse++;
-      aopOp (IC_RESULT (ic), ic, FALSE, FALSE);
-      _G.accInUse--;
-      assignResultValue (IC_RESULT (ic));
     }
-
-  freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+    freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
 }
 
 /*-----------------------------------------------------------------*/
@@ -10782,10 +11363,22 @@ static void genMemcpyX2X( iCode *ic, int nparms, operand **parms, int fromc)
 {
     operand *from , *to , *count;
     symbol *lbl;
+    bitVect *rsave;
+    int i;
 
     /* we know it has to be 3 parameters */
     assert (nparms == 3);
     
+    rsave = newBitVect(16);
+    /* save DPTR if it needs to be saved */
+    for (i = DPL_IDX ; i <= B_IDX ; i++ ) {
+	    if (bitVectBitValue(ic->rMask,i))
+		    rsave = bitVectSetBit(rsave,i);
+    }
+    rsave = bitVectIntersect(rsave,bitVectCplAnd (bitVectCopy (ic->rMask),
+						  ds390_rUmaskForOp (IC_RESULT(ic))));
+    savermask(rsave);
+    
     to = parms[0];
     from = parms[1];
     count = parms[2];
@@ -10793,10 +11386,10 @@ static void genMemcpyX2X( iCode *ic, int nparms, operand **parms, int fromc)
     aopOp (from, ic->next, FALSE, FALSE);
 
     /* get from into DPTR1 */
-    emitcode ("mov", "dpl1,%s", aopGet (AOP (from), 0, FALSE, FALSE, TRUE));
-    emitcode ("mov", "dph1,%s", aopGet (AOP (from), 1, FALSE, FALSE, TRUE));
+    emitcode ("mov", "dpl1,%s", aopGet (AOP (from), 0, FALSE, FALSE, NULL));
+    emitcode ("mov", "dph1,%s", aopGet (AOP (from), 1, FALSE, FALSE, NULL));
     if (options.model == MODEL_FLAT24) {
-	emitcode ("mov", "dpx1,%s", aopGet (AOP (from), 2, FALSE, FALSE, TRUE));
+	emitcode ("mov", "dpx1,%s", aopGet (AOP (from), 2, FALSE, FALSE, NULL));
     }
 
     freeAsmop (from, NULL, ic, FALSE);
@@ -10807,38 +11400,50 @@ static void genMemcpyX2X( iCode *ic, int nparms, operand **parms, int fromc)
     if (AOP_TYPE (to) != AOP_STR) {
 	/* if already in DPTR then we need to push */
 	if (AOP_TYPE(to) == AOP_DPTR) {
-	    emitcode ("push", "%s", aopGet (AOP (to), 0, FALSE, TRUE, TRUE));
-	    emitcode ("push", "%s", aopGet (AOP (to), 1, FALSE, TRUE, TRUE));
+	    emitcode ("push", "%s", aopGet (AOP (to), 0, FALSE, TRUE, NULL));
+	    emitcode ("push", "%s", aopGet (AOP (to), 1, FALSE, TRUE, NULL));
 	    if (options.model == MODEL_FLAT24)
-		emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, TRUE));
+		emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, NULL));
 	    emitcode ("pop", "dph");
 	    emitcode ("pop", "dpl");	    
 	} else {
 	    _startLazyDPSEvaluation ();
 	    /* if this is remateriazable */
 	    if (AOP_TYPE (to) == AOP_IMMD) {
-		emitcode ("mov", "dptr,%s", aopGet (AOP (to), 0, TRUE, FALSE, FALSE));
+		emitcode ("mov", "dptr,%s", aopGet (AOP (to), 0, TRUE, FALSE, NULL));
 	    } else {			/* we need to get it byte by byte */
-		emitcode ("mov", "dpl,%s", aopGet (AOP (to), 0, FALSE, FALSE, TRUE));
-		emitcode ("mov", "dph,%s", aopGet (AOP (to), 1, FALSE, FALSE, TRUE));
+		emitcode ("mov", "dpl,%s", aopGet (AOP (to), 0, FALSE, FALSE, NULL));
+		emitcode ("mov", "dph,%s", aopGet (AOP (to), 1, FALSE, FALSE, NULL));
 		if (options.model == MODEL_FLAT24) {
-		    emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, TRUE));
+		    emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, NULL));
 		}
 	    }
 	    _endLazyDPSEvaluation ();
 	}
     }
     freeAsmop (to, NULL, ic, FALSE);
-
+    _G.dptrInUse = _G.dptr1InUse = 1;
     aopOp (count, ic->next->next, FALSE,FALSE);
     lbl =newiTempLabel(NULL);
 
     /* now for the actual copy */
     if (AOP_TYPE(count) == AOP_LIT && 
 	(int)floatFromVal (AOP(count)->aopu.aop_lit) <= 256) {
-	emitcode (";","OH! JOY auto increment with djnz (very fast)");
-	emitcode ("mov", "dps, #0x21"); 	/* Select DPTR2 & auto-toggle. */
-	emitcode ("mov", "b,%s",aopGet(AOP(count),0,FALSE,FALSE,FALSE));
+	emitcode ("mov", "b,%s",aopGet(AOP(count),0,FALSE,FALSE,NULL));
+	if (fromc) {
+	    emitcode ("lcall","__bi_memcpyc2x_s");
+	} else {
+	    emitcode ("lcall","__bi_memcpyx2x_s");
+	}
+	freeAsmop (count, NULL, ic, FALSE);
+    } else {
+	symbol *lbl1 = newiTempLabel(NULL);
+	
+	emitcode (";"," Auto increment but no djnz");
+	emitcode ("mov","_ap,%s",aopGet (AOP (count), 0, FALSE, TRUE, NULL));
+	emitcode ("mov","b,%s",aopGet (AOP (count), 1, FALSE, TRUE, NULL));
+	freeAsmop (count, NULL, ic, FALSE);
+	emitcode ("mov", "dps,#!constbyte",0x21); 	/* Select DPTR2 & auto-toggle. */
 	emitcode ("","!tlabeldef",lbl->key+100);
 	if (fromc) {
 	    emitcode ("clr","a");
@@ -10848,55 +11453,192 @@ static void genMemcpyX2X( iCode *ic, int nparms, operand **parms, int fromc)
 	emitcode ("movx", "@dptr,a");
 	emitcode ("inc", "dptr");
 	emitcode ("inc", "dptr");
-	emitcode ("djnz","b,!tlabel",lbl->key+100);
+	emitcode ("mov","a,b");
+	emitcode ("orl","a,_ap");
+	emitcode ("jz","!tlabel",lbl1->key+100);
+	emitcode ("mov","a,_ap");
+	emitcode ("add","a,#!constbyte",0xFF);
+	emitcode ("mov","_ap,a");
+	emitcode ("mov","a,b");
+	emitcode ("addc","a,#!constbyte",0xFF);
+	emitcode ("mov","b,a");
+	emitcode ("sjmp","!tlabel",lbl->key+100);
+	emitcode ("","!tlabeldef",lbl1->key+100);
+    }
+    emitcode ("mov", "dps,#0"); 
+    _G.dptrInUse = _G.dptr1InUse = 0;
+    unsavermask(rsave);
+
+}
+
+/*-----------------------------------------------------------------*/
+/* genMemcmpX2X - gen code for memcmp xdata to xdata               */
+/*-----------------------------------------------------------------*/
+static void genMemcmpX2X( iCode *ic, int nparms, operand **parms, int fromc)
+{
+    operand *from , *to , *count;
+    symbol *lbl,*lbl2;
+    bitVect *rsave;
+    int i;
+
+    /* we know it has to be 3 parameters */
+    assert (nparms == 3);
+    
+    rsave = newBitVect(16);
+    /* save DPTR if it needs to be saved */
+    for (i = DPL_IDX ; i <= B_IDX ; i++ ) {
+	    if (bitVectBitValue(ic->rMask,i))
+		    rsave = bitVectSetBit(rsave,i);
+    }
+    rsave = bitVectIntersect(rsave,bitVectCplAnd (bitVectCopy (ic->rMask),
+						  ds390_rUmaskForOp (IC_RESULT(ic))));
+    savermask(rsave);
+    
+    to = parms[0];
+    from = parms[1];
+    count = parms[2];
+
+    aopOp (from, ic->next, FALSE, FALSE);
+
+    /* get from into DPTR1 */
+    emitcode ("mov", "dpl1,%s", aopGet (AOP (from), 0, FALSE, FALSE, NULL));
+    emitcode ("mov", "dph1,%s", aopGet (AOP (from), 1, FALSE, FALSE, NULL));
+    if (options.model == MODEL_FLAT24) {
+	emitcode ("mov", "dpx1,%s", aopGet (AOP (from), 2, FALSE, FALSE, NULL));
+    }
+
+    freeAsmop (from, NULL, ic, FALSE);
+    aopOp (to, ic, FALSE, FALSE);
+    /* get "to" into DPTR */
+    /* if the operand is already in dptr
+       then we do nothing else we move the value to dptr */
+    if (AOP_TYPE (to) != AOP_STR) {
+	/* if already in DPTR then we need to push */
+	if (AOP_TYPE(to) == AOP_DPTR) {
+	    emitcode ("push", "%s", aopGet (AOP (to), 0, FALSE, TRUE, NULL));
+	    emitcode ("push", "%s", aopGet (AOP (to), 1, FALSE, TRUE, NULL));
+	    if (options.model == MODEL_FLAT24)
+		emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, NULL));
+	    emitcode ("pop", "dph");
+	    emitcode ("pop", "dpl");	    
+	} else {
+	    _startLazyDPSEvaluation ();
+	    /* if this is remateriazable */
+	    if (AOP_TYPE (to) == AOP_IMMD) {
+		emitcode ("mov", "dptr,%s", aopGet (AOP (to), 0, TRUE, FALSE, NULL));
+	    } else {			/* we need to get it byte by byte */
+		emitcode ("mov", "dpl,%s", aopGet (AOP (to), 0, FALSE, FALSE, NULL));
+		emitcode ("mov", "dph,%s", aopGet (AOP (to), 1, FALSE, FALSE, NULL));
+		if (options.model == MODEL_FLAT24) {
+		    emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, NULL));
+		}
+	    }
+	    _endLazyDPSEvaluation ();
+	}
+    }
+    freeAsmop (to, NULL, ic, FALSE);
+    _G.dptrInUse = _G.dptr1InUse = 1;
+    aopOp (count, ic->next->next, FALSE,FALSE);
+    lbl =newiTempLabel(NULL);
+    lbl2 =newiTempLabel(NULL);
+
+    /* now for the actual compare */
+    if (AOP_TYPE(count) == AOP_LIT && 
+	(int)floatFromVal (AOP(count)->aopu.aop_lit) <= 256) {
+	emitcode ("mov", "b,%s",aopGet(AOP(count),0,FALSE,FALSE,NULL));
+	if (fromc)
+	    emitcode("lcall","__bi_memcmpc2x_s");
+	else
+	    emitcode("lcall","__bi_memcmpx2x_s");
+	freeAsmop (count, NULL, ic, FALSE);
+	aopOp (IC_RESULT(ic), ic, FALSE,FALSE);
+	aopPut(AOP(IC_RESULT(ic)),"a",0);
+	freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
     } else {
 	symbol *lbl1 = newiTempLabel(NULL);
-	
+
+	emitcode("push","ar0"); 	
 	emitcode (";"," Auto increment but no djnz");
-	emitcode ("mov","ap,%s",aopGet (AOP (count), 0, FALSE, TRUE, TRUE));
-	emitcode ("mov","b,%s",aopGet (AOP (count), 1, FALSE, TRUE, TRUE));
-	emitcode ("mov", "dps, #0x21"); 	/* Select DPTR2 & auto-toggle. */
+	emitcode ("mov","_ap,%s",aopGet (AOP (count), 0, FALSE, TRUE, NULL));
+	emitcode ("mov","b,%s",aopGet (AOP (count), 1, FALSE, TRUE, NULL));
+	freeAsmop (count, NULL, ic, FALSE);
+	emitcode ("mov", "dps,#!constbyte",0x21); 	/* Select DPTR2 & auto-toggle. */
 	emitcode ("","!tlabeldef",lbl->key+100);
 	if (fromc) {
 	    emitcode ("clr","a");
 	    emitcode ("movc", "a,@a+dptr");
 	} else 
 	    emitcode ("movx", "a,@dptr");
-	emitcode ("movx", "@dptr,a");
+	emitcode ("mov","r0,a");
+	emitcode ("movx", "a,@dptr");
+	emitcode ("clr","c");
+	emitcode ("subb","a,r0");
+	emitcode ("jnz","!tlabel",lbl2->key+100);
 	emitcode ("inc", "dptr");
 	emitcode ("inc", "dptr");
 	emitcode ("mov","a,b");
-	emitcode ("orl","a,ap");
+	emitcode ("orl","a,_ap");
 	emitcode ("jz","!tlabel",lbl1->key+100);
-	emitcode ("mov","a,ap");
-	emitcode ("add","a,#0xFF");
-	emitcode ("mov","ap,a");
+	emitcode ("mov","a,_ap");
+	emitcode ("add","a,#!constbyte",0xFF);
+	emitcode ("mov","_ap,a");
 	emitcode ("mov","a,b");
-	emitcode ("addc","a,#0xFF");
+	emitcode ("addc","a,#!constbyte",0xFF);
 	emitcode ("mov","b,a");
 	emitcode ("sjmp","!tlabel",lbl->key+100);
 	emitcode ("","!tlabeldef",lbl1->key+100);
+	emitcode ("clr","a");
+	emitcode ("","!tlabeldef",lbl2->key+100);
+	aopOp (IC_RESULT(ic), ic, FALSE,FALSE);
+	aopPut(AOP(IC_RESULT(ic)),"a",0);
+	freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+	emitcode("pop","ar0");
+	emitcode ("mov", "dps,#0");      
     }
-    emitcode ("mov", "dps, #0"); 
-    freeAsmop (count, NULL, ic, FALSE);
+    _G.dptrInUse = _G.dptr1InUse = 0;
+    unsavermask(rsave);
 
 }
 
 /*-----------------------------------------------------------------*/
-/* genMemsetX - gencode for memSetX data                           */
+/* genInp - gen code for __builtin_inp read data from a mem mapped */
+/* port, first parameter output area second parameter pointer to   */
+/* port third parameter count                                      */
 /*-----------------------------------------------------------------*/
-static void genMemsetX(iCode *ic, int nparms, operand **parms)
+static void genInp( iCode *ic, int nparms, operand **parms)
 {
-    operand *to , *val , *count;
+    operand *from , *to , *count;
     symbol *lbl;
-    char *l;
+    bitVect *rsave;
+    int i;
+
     /* we know it has to be 3 parameters */
     assert (nparms == 3);
     
+    rsave = newBitVect(16);
+    /* save DPTR if it needs to be saved */
+    for (i = DPL_IDX ; i <= B_IDX ; i++ ) {
+	    if (bitVectBitValue(ic->rMask,i))
+		    rsave = bitVectSetBit(rsave,i);
+    }
+    rsave = bitVectIntersect(rsave,bitVectCplAnd (bitVectCopy (ic->rMask),
+						  ds390_rUmaskForOp (IC_RESULT(ic))));
+    savermask(rsave);
+    
     to = parms[0];
-    val = parms[1];
+    from = parms[1];
     count = parms[2];
 
+    aopOp (from, ic->next, FALSE, FALSE);
+
+    /* get from into DPTR1 */
+    emitcode ("mov", "dpl1,%s", aopGet (AOP (from), 0, FALSE, FALSE, NULL));
+    emitcode ("mov", "dph1,%s", aopGet (AOP (from), 1, FALSE, FALSE, NULL));
+    if (options.model == MODEL_FLAT24) {
+	emitcode ("mov", "dpx1,%s", aopGet (AOP (from), 2, FALSE, FALSE, NULL));
+    }
+
+    freeAsmop (from, NULL, ic, FALSE);
     aopOp (to, ic, FALSE, FALSE);
     /* get "to" into DPTR */
     /* if the operand is already in dptr
@@ -10904,22 +11646,22 @@ static void genMemsetX(iCode *ic, int nparms, operand **parms)
     if (AOP_TYPE (to) != AOP_STR) {
 	/* if already in DPTR then we need to push */
 	if (AOP_TYPE(to) == AOP_DPTR) {
-	    emitcode ("push", "%s", aopGet (AOP (to), 0, FALSE, TRUE, TRUE));
-	    emitcode ("push", "%s", aopGet (AOP (to), 1, FALSE, TRUE, TRUE));
+	    emitcode ("push", "%s", aopGet (AOP (to), 0, FALSE, TRUE, NULL));
+	    emitcode ("push", "%s", aopGet (AOP (to), 1, FALSE, TRUE, NULL));
 	    if (options.model == MODEL_FLAT24)
-		emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, TRUE));
+		emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, NULL));
 	    emitcode ("pop", "dph");
 	    emitcode ("pop", "dpl");	    
 	} else {
 	    _startLazyDPSEvaluation ();
 	    /* if this is remateriazable */
 	    if (AOP_TYPE (to) == AOP_IMMD) {
-		emitcode ("mov", "dptr,%s", aopGet (AOP (to), 0, TRUE, FALSE, FALSE));
+		emitcode ("mov", "dptr,%s", aopGet (AOP (to), 0, TRUE, FALSE, NULL));
 	    } else {			/* we need to get it byte by byte */
-		emitcode ("mov", "dpl,%s", aopGet (AOP (to), 0, FALSE, FALSE, TRUE));
-		emitcode ("mov", "dph,%s", aopGet (AOP (to), 1, FALSE, FALSE, TRUE));
+		emitcode ("mov", "dpl,%s", aopGet (AOP (to), 0, FALSE, FALSE, NULL));
+		emitcode ("mov", "dph,%s", aopGet (AOP (to), 1, FALSE, FALSE, NULL));
 		if (options.model == MODEL_FLAT24) {
-		    emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, TRUE));
+		    emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, NULL));
 		}
 	    }
 	    _endLazyDPSEvaluation ();
@@ -10927,73 +11669,1051 @@ static void genMemsetX(iCode *ic, int nparms, operand **parms)
     }
     freeAsmop (to, NULL, ic, FALSE);
 
-    aopOp (val, ic->next->next, FALSE,FALSE);
-    aopOp (count, ic->next->next, FALSE,FALSE);    
+    _G.dptrInUse = _G.dptr1InUse = 1;
+    aopOp (count, ic->next->next, FALSE,FALSE);
     lbl =newiTempLabel(NULL);
+
     /* now for the actual copy */
     if (AOP_TYPE(count) == AOP_LIT && 
 	(int)floatFromVal (AOP(count)->aopu.aop_lit) <= 256) {
-	l = aopGet(AOP (val), 0, FALSE, FALSE, TRUE);
-	emitcode ("mov", "b,%s",aopGet(AOP(count),0,FALSE,FALSE,FALSE));
-	MOVA(l);
+	emitcode (";","OH  JOY auto increment with djnz (very fast)");
+	emitcode ("mov", "dps,#!constbyte",0x1); 	/* Select DPTR2 */
+	emitcode ("mov", "b,%s",aopGet(AOP(count),0,FALSE,FALSE,NULL));
+	freeAsmop (count, NULL, ic, FALSE);
 	emitcode ("","!tlabeldef",lbl->key+100);
-	emitcode ("movx", "@dptr,a");
-	emitcode ("inc", "dptr");
+	emitcode ("movx", "a,@dptr");	/* read data from port */
+	emitcode ("dec","dps");		/* switch to DPTR */
+	emitcode ("movx", "@dptr,a");	/* save into location */
+	emitcode ("inc", "dptr");	/* point to next area */
+	emitcode ("inc","dps");		/* switch to DPTR2 */
 	emitcode ("djnz","b,!tlabel",lbl->key+100);
     } else {
 	symbol *lbl1 = newiTempLabel(NULL);
 	
-	emitcode ("mov","ap,%s",aopGet (AOP (count), 0, FALSE, TRUE, TRUE));
-	emitcode ("mov","b,%s",aopGet (AOP (count), 1, FALSE, TRUE, TRUE));
+	emitcode (";"," Auto increment but no djnz");
+	emitcode ("mov","_ap,%s",aopGet (AOP (count), 0, FALSE, TRUE, NULL));
+	emitcode ("mov","b,%s",aopGet (AOP (count), 1, FALSE, TRUE, NULL));
+	freeAsmop (count, NULL, ic, FALSE);
+	emitcode ("mov", "dps,#!constbyte",0x1); 	/* Select DPTR2 */
 	emitcode ("","!tlabeldef",lbl->key+100);
-	l = aopGet(AOP (val), 0, FALSE, FALSE, TRUE);
-	MOVA(l);
 	emitcode ("movx", "a,@dptr");
+	emitcode ("dec","dps");		/* switch to DPTR */
+	emitcode ("movx", "@dptr,a");
 	emitcode ("inc", "dptr");
+	emitcode ("inc","dps");		/* switch to DPTR2 */
+/* 	emitcode ("djnz","b,!tlabel",lbl->key+100); */
+/* 	emitcode ("djnz","_ap,!tlabel",lbl->key+100); */
 	emitcode ("mov","a,b");
-	emitcode ("orl","a,ap");
+	emitcode ("orl","a,_ap");
 	emitcode ("jz","!tlabel",lbl1->key+100);
-	emitcode ("mov","a,ap");
-	emitcode ("add","a,#0xFF");
-	emitcode ("mov","ap,a");
+	emitcode ("mov","a,_ap");
+	emitcode ("add","a,#!constbyte",0xFF);
+	emitcode ("mov","_ap,a");
 	emitcode ("mov","a,b");
-	emitcode ("addc","a,#0xFF");
+	emitcode ("addc","a,#!constbyte",0xFF);
 	emitcode ("mov","b,a");
 	emitcode ("sjmp","!tlabel",lbl->key+100);
 	emitcode ("","!tlabeldef",lbl1->key+100);
     }
-    freeAsmop (count, NULL, ic, FALSE);
+    emitcode ("mov", "dps,#0"); 
+    _G.dptrInUse = _G.dptr1InUse = 0;
+    unsavermask(rsave);
+
 }
 
 /*-----------------------------------------------------------------*/
-/* genBuiltIn - calls the appropriate function to  generating code */
-/* for a built in function 					   */
+/* genOutp - gen code for __builtin_inp write data to a mem mapped */
+/* port, first parameter output area second parameter pointer to   */
+/* port third parameter count                                      */
 /*-----------------------------------------------------------------*/
-static void genBuiltIn (iCode *ic)
+static void genOutp( iCode *ic, int nparms, operand **parms)
 {
-    operand *bi_parms[MAX_BUILTIN_ARGS];
-    int nbi_parms;
-    iCode *bi_iCode;
-    symbol *bif;
-
-    /* get all the arguments for a built in function */
-    bi_iCode = getBuiltinParms(ic,&nbi_parms,bi_parms);
-
-    /* which function is it */
-    bif = OP_SYMBOL(IC_LEFT(bi_iCode));
-    if (strcmp(bif->name,"__builtin_memcpy_x2x")==0) {
-	genMemcpyX2X(bi_iCode,nbi_parms,bi_parms,0);
-    } else if (strcmp(bif->name,"__builtin_memcpy_c2x")==0) {
-	genMemcpyX2X(bi_iCode,nbi_parms,bi_parms,1);
-    } else if (strcmp(bif->name,"__builtin_memset_x")==0) {
-	genMemsetX(bi_iCode,nbi_parms,bi_parms);
-    } else {
-	werror(E_INTERNAL_ERROR,"unknown builtin function encountered\n");
-	return ;
-    }
-    return ;    
-}
-
+    operand *from , *to , *count;
+    symbol *lbl;
+    bitVect *rsave;
+    int i;
+
+    /* we know it has to be 3 parameters */
+    assert (nparms == 3);
+    
+    rsave = newBitVect(16);
+    /* save DPTR if it needs to be saved */
+    for (i = DPL_IDX ; i <= B_IDX ; i++ ) {
+	    if (bitVectBitValue(ic->rMask,i))
+		    rsave = bitVectSetBit(rsave,i);
+    }
+    rsave = bitVectIntersect(rsave,bitVectCplAnd (bitVectCopy (ic->rMask),
+						  ds390_rUmaskForOp (IC_RESULT(ic))));
+    savermask(rsave);
+    
+    to = parms[0];
+    from = parms[1];
+    count = parms[2];
+
+    aopOp (from, ic->next, FALSE, FALSE);
+
+    /* get from into DPTR1 */
+    emitcode ("mov", "dpl1,%s", aopGet (AOP (from), 0, FALSE, FALSE, NULL));
+    emitcode ("mov", "dph1,%s", aopGet (AOP (from), 1, FALSE, FALSE, NULL));
+    if (options.model == MODEL_FLAT24) {
+	emitcode ("mov", "dpx1,%s", aopGet (AOP (from), 2, FALSE, FALSE, NULL));
+    }
+
+    freeAsmop (from, NULL, ic, FALSE);
+    aopOp (to, ic, FALSE, FALSE);
+    /* get "to" into DPTR */
+    /* if the operand is already in dptr
+       then we do nothing else we move the value to dptr */
+    if (AOP_TYPE (to) != AOP_STR) {
+	/* if already in DPTR then we need to push */
+	if (AOP_TYPE(to) == AOP_DPTR) {
+	    emitcode ("push", "%s", aopGet (AOP (to), 0, FALSE, TRUE, NULL));
+	    emitcode ("push", "%s", aopGet (AOP (to), 1, FALSE, TRUE, NULL));
+	    if (options.model == MODEL_FLAT24)
+		emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, NULL));
+	    emitcode ("pop", "dph");
+	    emitcode ("pop", "dpl");	    
+	} else {
+	    _startLazyDPSEvaluation ();
+	    /* if this is remateriazable */
+	    if (AOP_TYPE (to) == AOP_IMMD) {
+		emitcode ("mov", "dptr,%s", aopGet (AOP (to), 0, TRUE, FALSE, NULL));
+	    } else {			/* we need to get it byte by byte */
+		emitcode ("mov", "dpl,%s", aopGet (AOP (to), 0, FALSE, FALSE, NULL));
+		emitcode ("mov", "dph,%s", aopGet (AOP (to), 1, FALSE, FALSE, NULL));
+		if (options.model == MODEL_FLAT24) {
+		    emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, NULL));
+		}
+	    }
+	    _endLazyDPSEvaluation ();
+	}
+    }
+    freeAsmop (to, NULL, ic, FALSE);
+
+    _G.dptrInUse = _G.dptr1InUse = 1;
+    aopOp (count, ic->next->next, FALSE,FALSE);
+    lbl =newiTempLabel(NULL);
+
+    /* now for the actual copy */
+    if (AOP_TYPE(count) == AOP_LIT && 
+	(int)floatFromVal (AOP(count)->aopu.aop_lit) <= 256) {
+	emitcode (";","OH  JOY auto increment with djnz (very fast)");
+	emitcode ("mov", "dps,#!constbyte",0x0); 	/* Select DPTR */
+	emitcode ("mov", "b,%s",aopGet(AOP(count),0,FALSE,FALSE,NULL));
+	emitcode ("","!tlabeldef",lbl->key+100);
+	emitcode ("movx", "a,@dptr");	/* read data from port */
+	emitcode ("inc","dps");		/* switch to DPTR2 */
+	emitcode ("movx", "@dptr,a");	/* save into location */
+	emitcode ("inc", "dptr");	/* point to next area */
+	emitcode ("dec","dps");		/* switch to DPTR */
+	emitcode ("djnz","b,!tlabel",lbl->key+100);
+	freeAsmop (count, NULL, ic, FALSE);
+    } else {
+	symbol *lbl1 = newiTempLabel(NULL);
+	
+	emitcode (";"," Auto increment but no djnz");
+	emitcode ("mov","_ap,%s",aopGet (AOP (count), 0, FALSE, TRUE, NULL));
+	emitcode ("mov","b,%s",aopGet (AOP (count), 1, FALSE, TRUE, NULL));
+	freeAsmop (count, NULL, ic, FALSE);
+	emitcode ("mov", "dps,#!constbyte",0x0); 	/* Select DPTR */
+	emitcode ("","!tlabeldef",lbl->key+100);
+	emitcode ("movx", "a,@dptr");
+	emitcode ("inc", "dptr");
+	emitcode ("inc","dps");		/* switch to DPTR2 */
+	emitcode ("movx", "@dptr,a");
+	emitcode ("dec","dps");		/* switch to DPTR */
+	emitcode ("mov","a,b");
+	emitcode ("orl","a,_ap");
+	emitcode ("jz","!tlabel",lbl1->key+100);
+	emitcode ("mov","a,_ap");
+	emitcode ("add","a,#!constbyte",0xFF);
+	emitcode ("mov","_ap,a");
+	emitcode ("mov","a,b");
+	emitcode ("addc","a,#!constbyte",0xFF);
+	emitcode ("mov","b,a");
+	emitcode ("sjmp","!tlabel",lbl->key+100);
+	emitcode ("","!tlabeldef",lbl1->key+100);
+    }
+    emitcode ("mov", "dps,#0"); 
+    _G.dptrInUse = _G.dptr1InUse = 0;
+    unsavermask(rsave);
+
+}
+
+/*-----------------------------------------------------------------*/
+/* genSwapW - swap lower & high order bytes                        */
+/*-----------------------------------------------------------------*/
+static void genSwapW(iCode *ic, int nparms, operand **parms)
+{
+    operand *dest;
+    operand *src;
+    assert (nparms==1);
+
+    src = parms[0];
+    dest=IC_RESULT(ic);
+
+    assert(getSize(operandType(src))==2);
+
+    aopOp (src, ic, FALSE, FALSE);
+    emitcode ("mov","a,%s",aopGet(AOP(src),0,FALSE,FALSE,NULL));
+    _G.accInUse++;
+    MOVB(aopGet(AOP(src),1,FALSE,FALSE,"b"));
+    _G.accInUse--;
+    freeAsmop (src, NULL, ic, FALSE);
+    
+    aopOp (dest,ic, FALSE, FALSE);
+    aopPut(AOP(dest),"b",0);
+    aopPut(AOP(dest),"a",1);
+    freeAsmop (dest, NULL, ic, FALSE);    
+}
+
+/*-----------------------------------------------------------------*/
+/* genMemsetX - gencode for memSetX data                           */
+/*-----------------------------------------------------------------*/
+static void genMemsetX(iCode *ic, int nparms, operand **parms)
+{
+    operand *to , *val , *count;
+    symbol *lbl;
+    char *l;
+    int i;
+    bitVect *rsave;
+
+    /* we know it has to be 3 parameters */
+    assert (nparms == 3);
+    
+    to = parms[0];
+    val = parms[1];
+    count = parms[2];
+        
+    /* save DPTR if it needs to be saved */
+    rsave = newBitVect(16);
+    for (i = DPL_IDX ; i <= B_IDX ; i++ ) {
+	    if (bitVectBitValue(ic->rMask,i))
+		    rsave = bitVectSetBit(rsave,i);
+    }
+    rsave = bitVectIntersect(rsave,bitVectCplAnd (bitVectCopy (ic->rMask),
+						  ds390_rUmaskForOp (IC_RESULT(ic))));
+    savermask(rsave);
+
+    aopOp (to, ic, FALSE, FALSE);
+    /* get "to" into DPTR */
+    /* if the operand is already in dptr
+       then we do nothing else we move the value to dptr */
+    if (AOP_TYPE (to) != AOP_STR) {
+	/* if already in DPTR then we need to push */
+	if (AOP_TYPE(to) == AOP_DPTR) {
+	    emitcode ("push", "%s", aopGet (AOP (to), 0, FALSE, TRUE, NULL));
+	    emitcode ("push", "%s", aopGet (AOP (to), 1, FALSE, TRUE, NULL));
+	    if (options.model == MODEL_FLAT24)
+		emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, NULL));
+	    emitcode ("pop", "dph");
+	    emitcode ("pop", "dpl");	    
+	} else {
+	    _startLazyDPSEvaluation ();
+	    /* if this is remateriazable */
+	    if (AOP_TYPE (to) == AOP_IMMD) {
+		emitcode ("mov", "dptr,%s", aopGet (AOP (to), 0, TRUE, FALSE, NULL));
+	    } else {			/* we need to get it byte by byte */
+		emitcode ("mov", "dpl,%s", aopGet (AOP (to), 0, FALSE, FALSE, NULL));
+		emitcode ("mov", "dph,%s", aopGet (AOP (to), 1, FALSE, FALSE, NULL));
+		if (options.model == MODEL_FLAT24) {
+		    emitcode ("mov", "dpx,%s", aopGet (AOP (to), 2, FALSE, FALSE, NULL));
+		}
+	    }
+	    _endLazyDPSEvaluation ();
+	}
+    }
+    freeAsmop (to, NULL, ic, FALSE);
+
+    aopOp (val, ic->next->next, FALSE,FALSE);
+    aopOp (count, ic->next->next, FALSE,FALSE);    
+    lbl =newiTempLabel(NULL);
+    /* now for the actual copy */
+    if (AOP_TYPE(count) == AOP_LIT && 
+	(int)floatFromVal (AOP(count)->aopu.aop_lit) <= 256) {
+	l = aopGet(AOP (val), 0, FALSE, FALSE, NULL);
+	emitcode ("mov", "b,%s",aopGet(AOP(count),0,FALSE,FALSE,NULL));
+	MOVA(l);
+	emitcode ("","!tlabeldef",lbl->key+100);
+	emitcode ("movx", "@dptr,a");
+	emitcode ("inc", "dptr");
+	emitcode ("djnz","b,!tlabel",lbl->key+100);
+    } else {
+	symbol *lbl1 = newiTempLabel(NULL);
+	
+	emitcode ("mov","_ap,%s",aopGet (AOP (count), 0, FALSE, TRUE, NULL));
+	emitcode ("mov","b,%s",aopGet (AOP (count), 1, FALSE, TRUE, NULL));
+	emitcode ("","!tlabeldef",lbl->key+100);
+	MOVA (aopGet(AOP (val), 0, FALSE, FALSE, NULL));
+	emitcode ("movx", "@dptr,a");
+	emitcode ("inc", "dptr");
+	emitcode ("mov","a,b");
+	emitcode ("orl","a,_ap");
+	emitcode ("jz","!tlabel",lbl1->key+100);
+	emitcode ("mov","a,_ap");
+	emitcode ("add","a,#!constbyte",0xFF);
+	emitcode ("mov","_ap,a");
+	emitcode ("mov","a,b");
+	emitcode ("addc","a,#!constbyte",0xFF);
+	emitcode ("mov","b,a");
+	emitcode ("sjmp","!tlabel",lbl->key+100);
+	emitcode ("","!tlabeldef",lbl1->key+100);
+    }
+    freeAsmop (count, NULL, ic, FALSE);
+    unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genNatLibLoadPrimitive - calls TINI api function to load primitive */
+/*-----------------------------------------------------------------*/
+static void genNatLibLoadPrimitive(iCode *ic, int nparms, operand **parms,int size)
+{
+	bitVect *rsave ;
+	operand *pnum, *result;
+	int i;
+    
+	assert (nparms==1);
+	/* save registers that need to be saved */
+	savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+					 ds390_rUmaskForOp (IC_RESULT(ic))));
+    
+	pnum = parms[0]; 
+	aopOp (pnum, ic, FALSE, FALSE);
+	emitcode ("mov","a,%s",aopGet(AOP(pnum),0,FALSE,FALSE,DP2_RESULT_REG));
+	freeAsmop (pnum, NULL, ic, FALSE);
+	emitcode ("lcall","NatLib_LoadPrimitive");
+	aopOp (result=IC_RESULT(ic), ic, FALSE, FALSE);
+	if (aopHasRegs(AOP(result),R0_IDX,R1_IDX) || 
+	    aopHasRegs(AOP(result),R2_IDX,R3_IDX) ) {
+		for (i = (size-1) ; i >= 0 ; i-- ) {
+			emitcode ("push","a%s",javaRet[i]);
+		}
+		for (i=0; i < size ; i++ ) {
+			emitcode ("pop","a%s",
+				  aopGet(AOP(result),i,FALSE,FALSE,DP2_RESULT_REG));
+		}
+	} else {
+		for (i = 0 ; i < size ; i++ ) {
+			aopPut(AOP(result),javaRet[i],i);
+		}
+	}    
+	freeAsmop (result, NULL, ic, FALSE);
+	unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genNatLibLoadPointer - calls TINI api function to load pointer  */
+/*-----------------------------------------------------------------*/
+static void genNatLibLoadPointer(iCode *ic, int nparms, operand **parms)
+{
+	bitVect *rsave ;
+	operand *pnum, *result;
+	int size = 3;
+	int i;
+    
+	assert (nparms==1);
+	/* save registers that need to be saved */
+	savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+					 ds390_rUmaskForOp (IC_RESULT(ic))));
+    
+	pnum = parms[0]; 
+	aopOp (pnum, ic, FALSE, FALSE);
+	emitcode ("mov","a,%s",aopGet(AOP(pnum),0,FALSE,FALSE,DP2_RESULT_REG));
+	freeAsmop (pnum, NULL, ic, FALSE);
+	emitcode ("lcall","NatLib_LoadPointer");
+	aopOp (result=IC_RESULT(ic), ic, FALSE, FALSE);
+	if (AOP_TYPE(result)!=AOP_STR) {
+		for (i = 0 ; i < size ; i++ ) {
+			aopPut(AOP(result),fReturn[i],i);
+		}
+	}    
+	freeAsmop (result, NULL, ic, FALSE);
+	unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genNatLibInstallStateBlock - 				   */
+/*-----------------------------------------------------------------*/
+static void genNatLibInstallStateBlock(iCode *ic, int nparms, 
+				       operand **parms, const char *name)
+{
+	bitVect *rsave ;
+	operand *psb, *handle;
+	assert (nparms==2);
+
+	/* save registers that need to be saved */
+	savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+					 ds390_rUmaskForOp (IC_RESULT(ic))));
+	psb = parms[0];
+	handle = parms[1];
+
+	/* put pointer to state block into DPTR1 */
+	aopOp (psb, ic, FALSE, FALSE);
+	if (AOP_TYPE (psb) == AOP_IMMD) {
+		emitcode ("mov","dps,#1");
+		emitcode ("mov", "dptr,%s",
+			  aopGet (AOP (psb), 0, TRUE, FALSE, DP2_RESULT_REG));
+		emitcode ("mov","dps,#0");
+	} else {
+		emitcode ("mov","dpl1,%s",aopGet(AOP(psb),0,FALSE,FALSE,DP2_RESULT_REG));
+		emitcode ("mov","dph1,%s",aopGet(AOP(psb),1,FALSE,FALSE,DP2_RESULT_REG));
+		emitcode ("mov","dpx1,%s",aopGet(AOP(psb),2,FALSE,FALSE,DP2_RESULT_REG));
+	}
+	freeAsmop (psb, NULL, ic, FALSE);
+
+	/* put libraryID into DPTR */
+	emitcode ("mov","dptr,#LibraryID");
+
+	/* put handle into r3:r2 */
+	aopOp (handle, ic, FALSE, FALSE);
+	if (aopHasRegs(AOP(handle),R2_IDX,R3_IDX)) {
+		emitcode ("push","%s",aopGet(AOP(handle),0,FALSE,TRUE,DP2_RESULT_REG));
+		emitcode ("push","%s",aopGet(AOP(handle),1,FALSE,TRUE,DP2_RESULT_REG));
+		emitcode ("pop","ar3");
+		emitcode ("pop","ar2");
+	} else {	
+		emitcode ("mov","r2,%s",aopGet(AOP(handle),0,FALSE,TRUE,DP2_RESULT_REG));	
+		emitcode ("mov","r3,%s",aopGet(AOP(handle),1,FALSE,TRUE,DP2_RESULT_REG));
+	}
+	freeAsmop (psb, NULL, ic, FALSE);
+
+	/* make the call */
+	emitcode ("lcall","NatLib_Install%sStateBlock",name);
+
+	/* put return value into place*/
+	_G.accInUse++;
+	aopOp (IC_RESULT(ic), ic, FALSE, FALSE);
+	_G.accInUse--;
+	aopPut(AOP(IC_RESULT(ic)),"a",0);
+	freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+	unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genNatLibRemoveStateBlock -                                     */
+/*-----------------------------------------------------------------*/
+static void genNatLibRemoveStateBlock(iCode *ic,int nparms,const char *name)
+{
+	bitVect *rsave ;
+
+	assert(nparms==0);
+
+	/* save registers that need to be saved */
+	savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+					 ds390_rUmaskForOp (IC_RESULT(ic))));
+
+	/* put libraryID into DPTR */
+	emitcode ("mov","dptr,#LibraryID");
+	/* make the call */
+	emitcode ("lcall","NatLib_Remove%sStateBlock",name);
+	unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genNatLibGetStateBlock -                                        */
+/*-----------------------------------------------------------------*/
+static void genNatLibGetStateBlock(iCode *ic,int nparms,
+				   operand **parms,const char *name)
+{
+	bitVect *rsave ;
+	symbol *lbl = newiTempLabel(NULL);
+	
+	assert(nparms==0);
+	/* save registers that need to be saved */
+	savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+					 ds390_rUmaskForOp (IC_RESULT(ic))));
+
+	/* put libraryID into DPTR */
+	emitcode ("mov","dptr,#LibraryID");
+	/* make the call */
+	emitcode ("lcall","NatLib_Remove%sStateBlock",name);
+	emitcode ("jnz","!tlabel",lbl->key+100);
+
+	/* put return value into place */
+	aopOp(IC_RESULT(ic),ic,FALSE,FALSE);
+	if (aopHasRegs(AOP(IC_RESULT(ic)),R2_IDX,R3_IDX)) {
+		emitcode ("push","ar3");
+		emitcode ("push","ar2");
+		emitcode ("pop","%s",
+			  aopGet(AOP(IC_RESULT(ic)),0,FALSE,TRUE,DP2_RESULT_REG));
+		emitcode ("pop","%s",
+			  aopGet(AOP(IC_RESULT(ic)),1,FALSE,TRUE,DP2_RESULT_REG));
+	} else {
+		aopPut(AOP(IC_RESULT(ic)),"r2",0);
+		aopPut(AOP(IC_RESULT(ic)),"r3",1);
+	}
+	freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+	emitcode ("","!tlabeldef",lbl->key+100);
+	unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genMMMalloc -                                                   */
+/*-----------------------------------------------------------------*/
+static void genMMMalloc (iCode *ic,int nparms, operand **parms,
+			 int size, const char *name)
+{
+	bitVect *rsave ;
+	operand *bsize;
+	symbol *rsym;
+	symbol *lbl = newiTempLabel(NULL);
+
+	assert (nparms == 1);
+	/* save registers that need to be saved */
+	savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+					 ds390_rUmaskForOp (IC_RESULT(ic))));	
+	
+	bsize=parms[0];
+	aopOp (bsize,ic,FALSE,FALSE);
+
+	/* put the size in R4-R2 */
+	if (aopHasRegs(AOP(bsize),R2_IDX, (size==3 ? R4_IDX: R3_IDX))) {
+		emitcode("push","%s",aopGet(AOP(bsize),0,FALSE,TRUE,DP2_RESULT_REG));
+		emitcode("push","%s",aopGet(AOP(bsize),1,FALSE,TRUE,DP2_RESULT_REG));
+		if (size==3) {
+			emitcode("push","%s",aopGet(AOP(bsize),2,FALSE,TRUE,DP2_RESULT_REG));
+			emitcode("pop","ar4");
+		}
+		emitcode("pop","ar3");
+		emitcode("pop","ar2");		
+	} else {
+		emitcode ("mov","r2,%s",aopGet(AOP(bsize),0,FALSE,TRUE,DP2_RESULT_REG));
+		emitcode ("mov","r3,%s",aopGet(AOP(bsize),1,FALSE,TRUE,DP2_RESULT_REG));
+		if (size==3) {
+			emitcode("mov","r4,%s",aopGet(AOP(bsize),2,FALSE,TRUE,DP2_RESULT_REG));
+		}
+	}
+	freeAsmop (bsize, NULL, ic, FALSE);
+
+	/* make the call */
+	emitcode ("lcall","MM_%s",name);
+	emitcode ("jz","!tlabel",lbl->key+100);
+	emitcode ("mov","r2,#!constbyte",0xff);
+	emitcode ("mov","r3,#!constbyte",0xff);
+	emitcode ("","!tlabeldef",lbl->key+100);
+	/* we don't care about the pointer : we just save the handle */
+	rsym = OP_SYMBOL(IC_RESULT(ic));
+	if (rsym->liveFrom != rsym->liveTo) {
+		aopOp(IC_RESULT(ic),ic,FALSE,FALSE);
+		if (aopHasRegs(AOP(IC_RESULT(ic)),R2_IDX,R3_IDX)) {
+			emitcode ("push","ar3");
+			emitcode ("push","ar2");
+			emitcode ("pop","%s",
+				  aopGet(AOP(IC_RESULT(ic)),0,FALSE,TRUE,DP2_RESULT_REG));
+			emitcode ("pop","%s",
+				  aopGet(AOP(IC_RESULT(ic)),1,FALSE,TRUE,DP2_RESULT_REG));
+		} else {
+			aopPut(AOP(IC_RESULT(ic)),"r2",0);
+			aopPut(AOP(IC_RESULT(ic)),"r3",1);
+		}
+		freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+	}
+	unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genMMDeref -                                                    */
+/*-----------------------------------------------------------------*/
+static void genMMDeref (iCode *ic,int nparms, operand **parms)
+{
+	bitVect *rsave ;
+	operand *handle;
+
+	assert (nparms == 1);
+	/* save registers that need to be saved */
+	savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+					 ds390_rUmaskForOp (IC_RESULT(ic))));	
+	
+	handle=parms[0];
+	aopOp (handle,ic,FALSE,FALSE);
+
+	/* put the size in R4-R2 */
+	if (aopHasRegs(AOP(handle),R2_IDX,R3_IDX)) {
+		emitcode("push","%s",
+			 aopGet(AOP(handle),0,FALSE,TRUE,DP2_RESULT_REG));
+		emitcode("push","%s",
+			 aopGet(AOP(handle),1,FALSE,TRUE,DP2_RESULT_REG));
+		emitcode("pop","ar3");
+		emitcode("pop","ar2");		
+	} else {
+		emitcode ("mov","r2,%s",
+			  aopGet(AOP(handle),0,FALSE,TRUE,DP2_RESULT_REG));
+		emitcode ("mov","r3,%s",
+			  aopGet(AOP(handle),1,FALSE,TRUE,DP2_RESULT_REG));
+	}
+	freeAsmop (handle, NULL, ic, FALSE);
+
+	/* make the call */
+	emitcode ("lcall","MM_Deref");
+	
+	{
+		symbol *rsym = OP_SYMBOL(IC_RESULT(ic));
+		if (rsym->liveFrom != rsym->liveTo) {			
+			aopOp (IC_RESULT(ic),ic,FALSE,FALSE);
+			if (AOP_TYPE(IC_RESULT(ic)) != AOP_STR) {
+			    _startLazyDPSEvaluation ();
+			    
+				aopPut(AOP(IC_RESULT(ic)),"dpl",0);
+				aopPut(AOP(IC_RESULT(ic)),"dph",1);
+				aopPut(AOP(IC_RESULT(ic)),"dpx",2);
+
+			    _endLazyDPSEvaluation ();
+			    
+			}
+		}
+	}
+	freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+	unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genMMUnrestrictedPersist -                                      */
+/*-----------------------------------------------------------------*/
+static void genMMUnrestrictedPersist(iCode *ic,int nparms, operand **parms)
+{
+	bitVect *rsave ;
+	operand *handle;
+
+	assert (nparms == 1);
+	/* save registers that need to be saved */
+	savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+					 ds390_rUmaskForOp (IC_RESULT(ic))));	
+	
+	handle=parms[0];
+	aopOp (handle,ic,FALSE,FALSE);
+
+	/* put the size in R3-R2 */
+	if (aopHasRegs(AOP(handle),R2_IDX,R3_IDX)) {
+		emitcode("push","%s",
+			 aopGet(AOP(handle),0,FALSE,TRUE,DP2_RESULT_REG));
+		emitcode("push","%s",
+			 aopGet(AOP(handle),1,FALSE,TRUE,DP2_RESULT_REG));
+		emitcode("pop","ar3");
+		emitcode("pop","ar2");		
+	} else {
+		emitcode ("mov","r2,%s",
+			  aopGet(AOP(handle),0,FALSE,TRUE,DP2_RESULT_REG));
+		emitcode ("mov","r3,%s",
+			  aopGet(AOP(handle),1,FALSE,TRUE,DP2_RESULT_REG));
+	}
+	freeAsmop (handle, NULL, ic, FALSE);
+
+	/* make the call */
+	emitcode ("lcall","MM_UnrestrictedPersist");
+
+	{
+		symbol *rsym = OP_SYMBOL(IC_RESULT(ic));
+		if (rsym->liveFrom != rsym->liveTo) {	
+			aopOp (IC_RESULT(ic),ic,FALSE,FALSE);
+			aopPut(AOP(IC_RESULT(ic)),"a",0);
+			freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+		}
+	}
+	unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genSystemExecJavaProcess -                                      */
+/*-----------------------------------------------------------------*/
+static void genSystemExecJavaProcess(iCode *ic,int nparms, operand **parms)
+{
+	bitVect *rsave ;
+	operand *handle, *pp;
+
+	assert (nparms==2);
+	/* save registers that need to be saved */
+	savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+					 ds390_rUmaskForOp (IC_RESULT(ic))));	
+	
+	pp = parms[0];
+	handle = parms[1];
+	
+	/* put the handle in R3-R2 */
+	aopOp (handle,ic,FALSE,FALSE);
+	if (aopHasRegs(AOP(handle),R2_IDX,R3_IDX)) {
+		emitcode("push","%s",
+			 aopGet(AOP(handle),0,FALSE,TRUE,DP2_RESULT_REG));
+		emitcode("push","%s",
+			 aopGet(AOP(handle),1,FALSE,TRUE,DP2_RESULT_REG));
+		emitcode("pop","ar3");
+		emitcode("pop","ar2");		
+	} else {
+		emitcode ("mov","r2,%s",
+			  aopGet(AOP(handle),0,FALSE,TRUE,DP2_RESULT_REG));
+		emitcode ("mov","r3,%s",
+			  aopGet(AOP(handle),1,FALSE,TRUE,DP2_RESULT_REG));
+	}
+	freeAsmop (handle, NULL, ic, FALSE);
+	
+	/* put pointer in DPTR */
+	aopOp (pp,ic,FALSE,FALSE);
+	if (AOP_TYPE(pp) == AOP_IMMD) {
+		emitcode ("mov", "dptr,%s",
+			  aopGet (AOP (pp), 0, TRUE, FALSE, NULL));
+	} else if (AOP_TYPE(pp) != AOP_STR) { /* not already in dptr */
+		emitcode ("mov","dpl,%s",aopGet(AOP(pp),0,FALSE,FALSE,NULL));
+		emitcode ("mov","dph,%s",aopGet(AOP(pp),1,FALSE,FALSE,NULL));
+		emitcode ("mov","dpx,%s",aopGet(AOP(pp),2,FALSE,FALSE,NULL));
+	}
+	freeAsmop (handle, NULL, ic, FALSE);
+
+	/* make the call */
+	emitcode ("lcall","System_ExecJavaProcess");
+	
+	/* put result in place */
+	{
+		symbol *rsym = OP_SYMBOL(IC_RESULT(ic));
+		if (rsym->liveFrom != rsym->liveTo) {	
+			aopOp (IC_RESULT(ic),ic,FALSE,FALSE);
+			aopPut(AOP(IC_RESULT(ic)),"a",0);
+			freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+		}
+	}
+	
+	unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genSystemRTCRegisters -                                         */
+/*-----------------------------------------------------------------*/
+static void genSystemRTCRegisters(iCode *ic,int nparms, operand **parms,
+				  char *name)
+{
+	bitVect *rsave ;
+	operand *pp;
+
+	assert (nparms==1);
+	/* save registers that need to be saved */
+	savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+					 ds390_rUmaskForOp (IC_RESULT(ic))));	
+	
+	pp=parms[0];
+	/* put pointer in DPTR */
+	aopOp (pp,ic,FALSE,FALSE);
+	if (AOP_TYPE (pp) == AOP_IMMD) {
+		emitcode ("mov","dps,#1");
+		emitcode ("mov", "dptr,%s", 
+			  aopGet (AOP (pp), 0, TRUE, FALSE, NULL));
+		emitcode ("mov","dps,#0");
+	} else {
+		emitcode ("mov","dpl1,%s",
+			  aopGet(AOP(pp),0,FALSE,FALSE,DP2_RESULT_REG));
+		emitcode ("mov","dph1,%s",
+			  aopGet(AOP(pp),1,FALSE,FALSE,DP2_RESULT_REG));
+		emitcode ("mov","dpx1,%s",
+			  aopGet(AOP(pp),2,FALSE,FALSE,DP2_RESULT_REG));
+	}
+	freeAsmop (pp, NULL, ic, FALSE);
+
+	/* make the call */
+	emitcode ("lcall","System_%sRTCRegisters",name);
+
+	unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genSystemThreadSleep -                                          */
+/*-----------------------------------------------------------------*/
+static void genSystemThreadSleep(iCode *ic,int nparms, operand **parms, char *name)
+{
+	bitVect *rsave ;
+	operand *to, *s;
+
+	assert (nparms==1);
+	/* save registers that need to be saved */
+	savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+					 ds390_rUmaskForOp (IC_RESULT(ic))));	
+
+	to = parms[0];
+	aopOp(to,ic,FALSE,FALSE);
+	if (aopHasRegs(AOP(to),R2_IDX,R3_IDX) ||
+	    aopHasRegs(AOP(to),R0_IDX,R1_IDX) ) {
+		emitcode ("push","%s",
+			  aopGet(AOP(to),0,FALSE,TRUE,DP2_RESULT_REG));
+		emitcode ("push","%s",
+			  aopGet(AOP(to),1,FALSE,TRUE,DP2_RESULT_REG));
+		emitcode ("push","%s",
+			  aopGet(AOP(to),2,FALSE,TRUE,DP2_RESULT_REG));
+		emitcode ("push","%s",
+			  aopGet(AOP(to),3,FALSE,TRUE,DP2_RESULT_REG));
+		emitcode ("pop","ar3");
+		emitcode ("pop","ar2");
+		emitcode ("pop","ar1");
+		emitcode ("pop","ar0");
+	} else {
+		emitcode ("mov","r0,%s",
+			  aopGet(AOP(to),0,FALSE,TRUE,DP2_RESULT_REG));
+		emitcode ("mov","r1,%s",
+			  aopGet(AOP(to),1,FALSE,TRUE,DP2_RESULT_REG));
+		emitcode ("mov","r2,%s",
+			  aopGet(AOP(to),2,FALSE,TRUE,DP2_RESULT_REG));
+		emitcode ("mov","r3,%s",
+			  aopGet(AOP(to),3,FALSE,TRUE,DP2_RESULT_REG));
+	}
+	freeAsmop (to, NULL, ic, FALSE);
+
+	/* suspend in acc */
+	s = parms[1];
+	aopOp(s,ic,FALSE,FALSE);
+	emitcode ("mov","a,%s",
+		  aopGet(AOP(s),0,FALSE,TRUE,NULL));
+	freeAsmop (s, NULL, ic, FALSE);
+
+	/* make the call */
+	emitcode ("lcall","System_%s",name);
+
+	unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genSystemThreadResume -                                         */
+/*-----------------------------------------------------------------*/
+static void genSystemThreadResume(iCode *ic,int nparms, operand **parms)
+{
+	bitVect *rsave ;
+	operand *tid,*pid;
+
+	assert (nparms==2);
+	/* save registers that need to be saved */
+	savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+					 ds390_rUmaskForOp (IC_RESULT(ic))));
+	
+	tid = parms[0];
+	pid = parms[1];
+	
+	/* PID in R0 */
+	aopOp(pid,ic,FALSE,FALSE);
+	emitcode ("mov","r0,%s",
+		  aopGet(AOP(pid),0,FALSE,TRUE,DP2_RESULT_REG));
+	freeAsmop (pid, NULL, ic, FALSE);
+	
+	/* tid into ACC */
+	aopOp(tid,ic,FALSE,FALSE);
+	emitcode ("mov","a,%s",
+		  aopGet(AOP(tid),0,FALSE,TRUE,DP2_RESULT_REG));
+	freeAsmop (tid, NULL, ic, FALSE);
+	
+	emitcode ("lcall","System_ThreadResume");
+
+	/* put result into place */
+	{
+		symbol *rsym = OP_SYMBOL(IC_RESULT(ic));
+		if (rsym->liveFrom != rsym->liveTo) {	
+			aopOp (IC_RESULT(ic),ic,FALSE,FALSE);
+			aopPut(AOP(IC_RESULT(ic)),"a",0);
+			freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+		}
+	}
+	unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genSystemProcessResume -                                        */
+/*-----------------------------------------------------------------*/
+static void genSystemProcessResume(iCode *ic,int nparms, operand **parms)
+{
+	bitVect *rsave ;
+	operand *pid;
+
+	assert (nparms==1);
+	/* save registers that need to be saved */
+	savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+					 ds390_rUmaskForOp (IC_RESULT(ic))));
+	
+	pid = parms[0];
+	
+	/* pid into ACC */
+	aopOp(pid,ic,FALSE,FALSE);
+	emitcode ("mov","a,%s",
+		  aopGet(AOP(pid),0,FALSE,TRUE,DP2_RESULT_REG));
+	freeAsmop (pid, NULL, ic, FALSE);
+	
+	emitcode ("lcall","System_ProcessResume");
+
+	unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genSystem -                                                     */
+/*-----------------------------------------------------------------*/
+static void genSystem (iCode *ic,int nparms,char *name)
+{
+	assert(nparms == 0);
+
+	emitcode ("lcall","System_%s",name);
+}
+
+/*-----------------------------------------------------------------*/
+/* genSystemPoll -                                                  */
+/*-----------------------------------------------------------------*/
+static void genSystemPoll(iCode *ic,int nparms, operand **parms,char *name)
+{
+	bitVect *rsave ;
+	operand *fp;
+
+	assert (nparms==1);
+	/* save registers that need to be saved */
+	savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+					 ds390_rUmaskForOp (IC_RESULT(ic))));
+
+	fp = parms[0];
+	aopOp (fp,ic,FALSE,FALSE);
+	if (AOP_TYPE (fp) == AOP_IMMD) {
+		emitcode ("mov", "dptr,%s", 
+			  aopGet (AOP (fp), 0, TRUE, FALSE, DP2_RESULT_REG));
+	} else if (AOP_TYPE(fp) != AOP_STR) { /* not already in dptr */
+		emitcode ("mov","dpl,%s",
+			  aopGet(AOP(fp),0,FALSE,FALSE,DP2_RESULT_REG));
+		emitcode ("mov","dph,%s",
+			  aopGet(AOP(fp),1,FALSE,FALSE,DP2_RESULT_REG));
+		emitcode ("mov","dpx,%s",
+			  aopGet(AOP(fp),2,FALSE,FALSE,DP2_RESULT_REG));
+	}
+	freeAsmop (fp, NULL, ic, FALSE);
+
+	emitcode ("lcall","System_%sPoll",name);
+
+	/* put result into place */
+	{
+		symbol *rsym = OP_SYMBOL(IC_RESULT(ic));
+		if (rsym->liveFrom != rsym->liveTo) {	
+			aopOp (IC_RESULT(ic),ic,FALSE,FALSE);
+			aopPut(AOP(IC_RESULT(ic)),"a",0);
+			freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+		}
+	}
+	unsavermask(rsave);
+}
+
+/*-----------------------------------------------------------------*/
+/* genSystemGetCurrentID -                                         */
+/*-----------------------------------------------------------------*/
+static void genSystemGetCurrentID(iCode *ic,int nparms, operand **parms,char *name)
+{
+	assert (nparms==0);
+
+	emitcode ("lcall","System_GetCurrent%sId",name);
+	/* put result into place */
+	{
+		symbol *rsym = OP_SYMBOL(IC_RESULT(ic));
+		if (rsym->liveFrom != rsym->liveTo) {	
+			aopOp (IC_RESULT(ic),ic,FALSE,FALSE);
+			aopPut(AOP(IC_RESULT(ic)),"a",0);
+			freeAsmop (IC_RESULT(ic), NULL, ic, FALSE);
+		}
+	}
+}
+
+/*-----------------------------------------------------------------*/
+/* genBuiltIn - calls the appropriate function to  generating code */
+/* for a built in function 					   */
+/*-----------------------------------------------------------------*/
+static void genBuiltIn (iCode *ic)
+{
+	operand *bi_parms[MAX_BUILTIN_ARGS];
+	int nbi_parms;
+	iCode *bi_iCode;
+	symbol *bif;
+
+	/* get all the arguments for a built in function */
+	bi_iCode = getBuiltinParms(ic,&nbi_parms,bi_parms);
+
+	/* which function is it */
+	bif = OP_SYMBOL(IC_LEFT(bi_iCode));
+	if (strcmp(bif->name,"__builtin_memcpy_x2x")==0) {
+		genMemcpyX2X(bi_iCode,nbi_parms,bi_parms,0);
+	} else if (strcmp(bif->name,"__builtin_memcpy_c2x")==0) {
+		genMemcpyX2X(bi_iCode,nbi_parms,bi_parms,1);
+	} else	if (strcmp(bif->name,"__builtin_memcmp_x2x")==0) {
+		genMemcmpX2X(bi_iCode,nbi_parms,bi_parms,0);
+	} else if (strcmp(bif->name,"__builtin_memcmp_c2x")==0) {
+		genMemcmpX2X(bi_iCode,nbi_parms,bi_parms,1);
+	} else if (strcmp(bif->name,"__builtin_memset_x")==0) {
+		genMemsetX(bi_iCode,nbi_parms,bi_parms);
+	} else if (strcmp(bif->name,"__builtin_inp")==0) {
+		genInp(bi_iCode,nbi_parms,bi_parms);
+	} else if (strcmp(bif->name,"__builtin_outp")==0) {
+		genOutp(bi_iCode,nbi_parms,bi_parms);
+	} else if (strcmp(bif->name,"__builtin_swapw")==0) {
+	        genSwapW(bi_iCode,nbi_parms,bi_parms);
+		/* JavaNative builtIns */		
+	} else if (strcmp(bif->name,"NatLib_LoadByte")==0) {
+		genNatLibLoadPrimitive(bi_iCode,nbi_parms,bi_parms,1);
+	} else if (strcmp(bif->name,"NatLib_LoadShort")==0) {
+		genNatLibLoadPrimitive(bi_iCode,nbi_parms,bi_parms,2);
+	} else if (strcmp(bif->name,"NatLib_LoadInt")==0) {
+		genNatLibLoadPrimitive(bi_iCode,nbi_parms,bi_parms,4);
+	} else if (strcmp(bif->name,"NatLib_LoadPointer")==0) {
+		genNatLibLoadPointer(bi_iCode,nbi_parms,bi_parms);
+	} else if (strcmp(bif->name,"NatLib_InstallImmutableStateBlock")==0) {
+		genNatLibInstallStateBlock(bi_iCode,nbi_parms,bi_parms,"Immutable");
+	} else if (strcmp(bif->name,"NatLib_InstallEphemeralStateBlock")==0) {
+		genNatLibInstallStateBlock(bi_iCode,nbi_parms,bi_parms,"Ephemeral");
+	} else if (strcmp(bif->name,"NatLib_RemoveImmutableStateBlock")==0) {
+		genNatLibRemoveStateBlock(bi_iCode,nbi_parms,"Immutable");
+	} else if (strcmp(bif->name,"NatLib_RemoveEphemeralStateBlock")==0) {
+		genNatLibRemoveStateBlock(bi_iCode,nbi_parms,"Ephemeral");
+	} else if (strcmp(bif->name,"NatLib_GetImmutableStateBlock")==0) {
+		genNatLibGetStateBlock(bi_iCode,nbi_parms,bi_parms,"Immutable");
+	} else if (strcmp(bif->name,"NatLib_GetEphemeralStateBlock")==0) {
+		genNatLibGetStateBlock(bi_iCode,nbi_parms,bi_parms,"Ephemeral");
+	} else if (strcmp(bif->name,"MM_XMalloc")==0) {
+		genMMMalloc(bi_iCode,nbi_parms,bi_parms,3,"XMalloc");
+	} else if (strcmp(bif->name,"MM_Malloc")==0) {
+		genMMMalloc(bi_iCode,nbi_parms,bi_parms,2,"Malloc");
+	} else if (strcmp(bif->name,"MM_ApplicationMalloc")==0) {
+		genMMMalloc(bi_iCode,nbi_parms,bi_parms,2,"ApplicationMalloc");
+	} else if (strcmp(bif->name,"MM_Free")==0) {
+		genMMMalloc(bi_iCode,nbi_parms,bi_parms,2,"Free");
+	} else if (strcmp(bif->name,"MM_Deref")==0) {
+		genMMDeref(bi_iCode,nbi_parms,bi_parms);
+	} else if (strcmp(bif->name,"MM_UnrestrictedPersist")==0) {
+		genMMUnrestrictedPersist(bi_iCode,nbi_parms,bi_parms);
+	} else if (strcmp(bif->name,"System_ExecJavaProcess")==0) {
+		genSystemExecJavaProcess(bi_iCode,nbi_parms,bi_parms);
+	} else if (strcmp(bif->name,"System_GetRTCRegisters")==0) {
+		genSystemRTCRegisters(bi_iCode,nbi_parms,bi_parms,"Get");
+	} else if (strcmp(bif->name,"System_SetRTCRegisters")==0) {
+		genSystemRTCRegisters(bi_iCode,nbi_parms,bi_parms,"Set");
+	} else if (strcmp(bif->name,"System_ThreadSleep")==0) {
+		genSystemThreadSleep(bi_iCode,nbi_parms,bi_parms,"ThreadSleep");
+	} else if (strcmp(bif->name,"System_ThreadSleep_ExitCriticalSection")==0) {
+		genSystemThreadSleep(bi_iCode,nbi_parms,bi_parms,"ThreadSleep_ExitCriticalSection");
+	} else if (strcmp(bif->name,"System_ProcessSleep")==0) {
+		genSystemThreadSleep(bi_iCode,nbi_parms,bi_parms,"ProcessSleep");
+	} else if (strcmp(bif->name,"System_ProcessSleep_ExitCriticalSection")==0) {
+		genSystemThreadSleep(bi_iCode,nbi_parms,bi_parms,"ProcessSleep_ExitCriticalSection");
+	} else if (strcmp(bif->name,"System_ThreadResume")==0) {
+		genSystemThreadResume(bi_iCode,nbi_parms,bi_parms);
+	} else if (strcmp(bif->name,"System_SaveThread")==0) {
+		genSystemThreadResume(bi_iCode,nbi_parms,bi_parms);
+	} else if (strcmp(bif->name,"System_ThreadResume")==0) {
+		genSystemThreadResume(bi_iCode,nbi_parms,bi_parms);
+	} else if (strcmp(bif->name,"System_ProcessResume")==0) {
+		genSystemProcessResume(bi_iCode,nbi_parms,bi_parms);
+	} else if (strcmp(bif->name,"System_SaveJavaThreadState")==0) {
+		genSystem(bi_iCode,nbi_parms,"SaveJavaThreadState");
+	} else if (strcmp(bif->name,"System_RestoreJavaThreadState")==0) {
+		genSystem(bi_iCode,nbi_parms,"RestoreJavaThreadState");
+	} else if (strcmp(bif->name,"System_ProcessYield")==0) {
+		genSystem(bi_iCode,nbi_parms,"ProcessYield");
+	} else if (strcmp(bif->name,"System_ProcessSuspend")==0) {
+		genSystem(bi_iCode,nbi_parms,"ProcessSuspend");
+	} else if (strcmp(bif->name,"System_RegisterPoll")==0) {
+		genSystemPoll(bi_iCode,nbi_parms,bi_parms,"Register");
+	} else if (strcmp(bif->name,"System_RemovePoll")==0) {
+		genSystemPoll(bi_iCode,nbi_parms,bi_parms,"Remove");
+	} else if (strcmp(bif->name,"System_GetCurrentThreadId")==0) {
+		genSystemGetCurrentID(bi_iCode,nbi_parms,bi_parms,"Thread");
+	} else if (strcmp(bif->name,"System_GetCurrentProcessId")==0) {
+		genSystemGetCurrentID(bi_iCode,nbi_parms,bi_parms,"Process");
+	} else {
+		werror(E_INTERNAL_ERROR,__FILE__,__LINE__,"unknown builtin function encountered\n");
+		return ;
+	}
+	return ;    
+}
+
 /*-----------------------------------------------------------------*/
 /* gen390Code - generate code for Dallas 390 based controllers     */
 /*-----------------------------------------------------------------*/
@@ -11004,7 +12724,10 @@ gen390Code (iCode * lic)
   int cln = 0;
 
   lineHead = lineCurr = NULL;
-
+  dptrn[1][0] = "dpl1";
+  dptrn[1][1] = "dph1";
+  dptrn[1][2] = "dpx1";
+  
   if (options.model == MODEL_FLAT24) {
     fReturnSizeDS390 = 5;
     fReturn = fReturn24;
@@ -11013,16 +12736,15 @@ gen390Code (iCode * lic)
     fReturn = fReturn16;
     options.stack10bit=0;
   }
-#if 0
-  //REMOVE ME!!!
+#if 1
   /* print the allocation information */
-  if (allocInfo)
+  if (allocInfo && currFunc)
     printAllocInfo (currFunc, codeOutFile);
 #endif
   /* if debug information required */
   if (options.debug && currFunc)
     {
-      cdbSymbol (currFunc, cdbFile, FALSE, TRUE);
+      debugFile->writeFunction(currFunc);
       _G.debugLine = 1;
       if (IS_STATIC (currFunc->etype))
 	emitcode ("", "F%s$%s$0$0 ==.", moduleName, currFunc->name);
@@ -11040,7 +12762,7 @@ gen390Code (iCode * lic)
   for (ic = lic; ic; ic = ic->next)
     {
 
-      if (cln != ic->lineno)
+      if (ic->lineno && cln != ic->lineno)
 	{
 	  if (options.debug)
 	    {
@@ -11050,9 +12772,15 @@ gen390Code (iCode * lic)
 			ic->level, ic->block);
 	      _G.debugLine = 0;
 	    }
-	  emitcode (";", "%s %d", ic->filename, ic->lineno);
+	  if (!options.noCcodeInAsm) {
+	    emitcode ("", ";\t%s:%d: %s", ic->filename, ic->lineno, 
+		      printCLine(ic->filename, ic->lineno));
+	  }
 	  cln = ic->lineno;
 	}
+      if (options.iCodeInAsm) {
+	emitcode("", ";ic:%d: %s", ic->key, printILine(ic));
+      }
       /* if the result is marked as
          spilt and rematerializable or code for
          this has already been generated then
@@ -11210,12 +12938,12 @@ gen390Code (iCode * lic)
 	  break;
 
 	case GET_VALUE_AT_ADDRESS:
-	  genPointerGet (ic,hasInc(IC_LEFT(ic),ic));
+	  genPointerGet (ic,hasInc(IC_LEFT(ic),ic, getSize(operandType(IC_RESULT(ic)))));
 	  break;
 
 	case '=':
 	  if (POINTER_SET (ic))
-	    genPointerSet (ic,hasInc(IC_RESULT(ic),ic));
+	    genPointerSet (ic,hasInc(IC_RESULT(ic),ic,getSize(operandType(IC_RIGHT(ic)))));
 	  else
 	    genAssign (ic);
 	  break;
@@ -11245,9 +12973,11 @@ gen390Code (iCode * lic)
 	  else addSet (&_G.sendSet, ic);
 	  break;
 
+#if 0 // obsolete, and buggy for != xdata
 	case ARRAYINIT:
 	    genArrayInit(ic);
 	    break;
+#endif
 	    
 	default:
 	  ic = ic;