X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fds390%2Fgen.c;h=3cdc68bad8341177be91406415ae851d3f0a58bf;hb=195ee3f3ee25ce2c5f2a59fbd2779c4cb80527c3;hp=411e019f03b3c693e230c15740ede0341f316d9f;hpb=10cd3fdad4b5b2b6bec63afc7f059f4cdfcbcaf6;p=fw%2Fsdcc

diff --git a/src/ds390/gen.c b/src/ds390/gen.c
index 411e019f..3cdc68ba 100644
--- a/src/ds390/gen.c
+++ b/src/ds390/gen.c
@@ -31,6 +31,7 @@
 #include <ctype.h>
 
 #include "common.h"
+#include "main.h"
 #include "ralloc.h"
 #include "gen.h"
 #include "SDCCglobl.h"
@@ -55,7 +56,7 @@ static char *spname;
 #define TR_DPTR(s) if (options.model != MODEL_FLAT24) { emitcode(";", " Use_DPTR1 %s ", s); }
 #define TR_AP(s) if (options.model != MODEL_FLAT24) { emitcode(";", " Use_AP %s ", s); }
 
-unsigned fReturnSizeDS390 = 5;	/* shared with ralloc.c */
+short fReturnSizeDS390 = 5;
 static char *fReturn24[] =
 {"dpl", "dph", "dpx", "b", "a"};
 static char *fReturn16[] =
@@ -79,6 +80,7 @@ static struct
     short dptrInUse;
     short dptr1InUse;
     set *sendSet;
+    iCode *current_iCode;
   }
 _G;
 
@@ -94,13 +96,13 @@ static void saveRBank (int, iCode *, bool);
 
 #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;
@@ -116,92 +118,107 @@ 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);	\
-    			}}
-
+#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);        \
+                        }}
+
+static int _currentDPS;         /* Current processor DPS. */
+static int _desiredDPS;         /* DPS value compiler thinks we should be using. */
+static int _lazyDPS = 0;        /* if non-zero, we are doing lazy evaluation of DPS changes. */
 
 /*-----------------------------------------------------------------*/
 /* emitcode - writes the code into a file : for now it is simple    */
 /*-----------------------------------------------------------------*/
 static void
-emitcode (char *inst, char *fmt,...)
-{
-    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);
+emitcode (char *inst, const char *fmt,...)
+{
+  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
+  else
     {
-	tvsprintf (lb, sizeof(lb), fmt, ap);
+      tvsprintf (lb, sizeof(lb), fmt, ap);
     }
-    
 
-    while (isspace (*lbp))
+  while (isspace ((unsigned char)*lbp))
     {
-	lbp++;
+      lbp++;
     }
 
-    if (lbp && *lbp)
+  if (lbp && *lbp)
     {
-	lineCurr = (lineCurr ?
-		    connectLine (lineCurr, newLineNode (lb)) :
-		    (lineHead = newLineNode (lb)));
+      lineCurr = (lineCurr ?
+                  connectLine (lineCurr, newLineNode (lb)) :
+                  (lineHead = newLineNode (lb)));
     }
-    
-    lineCurr->isInline = _G.inLine;
-    lineCurr->isDebug = _G.debugLine;
-    va_end (ap);
+
+  lineCurr->isInline = _G.inLine;
+  lineCurr->isDebug = _G.debugLine;
+  lineCurr->ic = _G.current_iCode;
+  lineCurr->aln = ds390newAsmLineNode(_currentDPS);
+  va_end (ap);
+}
+
+/*-----------------------------------------------------------------*/
+/* ds390_emitDebuggerSymbol - associate the current code location  */
+/*   with a debugger symbol                                        */
+/*-----------------------------------------------------------------*/
+void
+ds390_emitDebuggerSymbol (char * debugSym)
+{
+  _G.debugLine = 1;
+  emitcode ("", "%s ==.", debugSym);
+  _G.debugLine = 0;
 }
 
 //
 // 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);
-    } 
+    {
+        emitcode("mov","a,%s",s);
+    }
 }
 
 //
 // 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);
-    } 
+    {
+        emitcode("mov","b,%s",s);
+    }
 }
 
 /*-----------------------------------------------------------------*/
@@ -251,11 +268,11 @@ getFreePtr (iCode * ic, asmop ** aopp, bool result)
     {
       /* push it if not already pushed */
       if (!_G.r0Pushed)
-	{
-	  emitcode ("push", "%s",
-		    ds390_regWithIdx (R0_IDX)->dname);
-	  _G.r0Pushed++;
-	}
+        {
+          emitcode ("push", "%s",
+                    ds390_regWithIdx (R0_IDX)->dname);
+          _G.r0Pushed++;
+        }
 
       ic->rUsed = bitVectSetBit (ic->rUsed, R0_IDX);
       (*aopp)->type = AOP_R0;
@@ -269,11 +286,11 @@ getFreePtr (iCode * ic, asmop ** aopp, bool result)
     {
       /* push it if not already pushed */
       if (!_G.r1Pushed)
-	{
-	  emitcode ("push", "%s",
-		    ds390_regWithIdx (R1_IDX)->dname);
-	  _G.r1Pushed++;
-	}
+        {
+          emitcode ("push", "%s",
+                    ds390_regWithIdx (R1_IDX)->dname);
+          _G.r1Pushed++;
+        }
 
       ic->rUsed = bitVectSetBit (ic->rUsed, R1_IDX);
       (*aopp)->type = AOP_R1;
@@ -291,9 +308,9 @@ endOfWorld:
 
   /* other wise this is true end of the world */
   werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
-	  "getFreePtr should never reach here");
+          "getFreePtr should never reach here");
   exit (1);
-    
+
   return NULL; // notreached, but makes compiler happy.
 }
 
@@ -310,9 +327,6 @@ newAsmop (short type)
   return aop;
 }
 
-static int _currentDPS;		/* Current processor DPS. */
-static int _desiredDPS;		/* DPS value compiler thinks we should be using. */
-static int _lazyDPS = 0;	/* if non-zero, we are doing lazy evaluation of DPS changes. */
 
 /*-----------------------------------------------------------------*/
 /* genSetDPTR: generate code to select which DPTR is in use (zero  */
@@ -365,11 +379,11 @@ _startLazyDPSEvaluation (void)
 {
   _currentDPS = 0;
   _desiredDPS = 0;
-#ifdef BETTER_LITERAL_SHIFT  
+#ifdef BETTER_LITERAL_SHIFT
   _lazyDPS++;
 #else
   _lazyDPS = 1;
-#endif  
+#endif
 }
 
 /*-----------------------------------------------------------------*/
@@ -389,13 +403,13 @@ _flushLazyDPS (void)
   if (_desiredDPS != _currentDPS)
     {
       if (_desiredDPS)
-	{
-	  emitcode ("inc", "dps");
-	}
+        {
+          emitcode ("inc", "dps");
+        }
       else
-	{
-	  emitcode ("dec", "dps");
-	}
+        {
+          emitcode ("dec", "dps");
+        }
       _currentDPS = _desiredDPS;
     }
 }
@@ -408,11 +422,11 @@ _flushLazyDPS (void)
 static void
 _endLazyDPSEvaluation (void)
 {
-#ifdef BETTER_LITERAL_SHIFT  
+#ifdef BETTER_LITERAL_SHIFT
   _lazyDPS--;
 #else
   _lazyDPS = 0;
-#endif    
+#endif
   if (!_lazyDPS)
   {
     if (_currentDPS)
@@ -448,11 +462,11 @@ leftRightUseAcc(iCode *ic)
   int size;
   int accuseSize = 0;
   int accuse = 0;
-  
+
   if (!ic)
     {
       werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
-	      "null iCode pointer");
+              "null iCode pointer");
       return 0;
     }
 
@@ -497,7 +511,7 @@ leftRightUseAcc(iCode *ic)
             accuseSize = size;
         }
     }
-  
+
   if (accuseSize)
     return accuseSize;
   else
@@ -516,7 +530,13 @@ aopForSym (iCode * ic, symbol * sym, bool result, bool useDP2)
 
   /* if already has one */
   if (sym->aop)
-    return sym->aop;
+    {
+      if ((sym->aop->type == AOP_DPTR && useDP2)
+          || (sym->aop->type == AOP_DPTR2 && !useDP2))
+        sym->aop = NULL;
+      else
+        return sym->aop;
+    }
 
   /* assign depending on the storage class */
   /* if it is on the stack or indirectly addressable */
@@ -530,125 +550,125 @@ aopForSym (iCode * ic, symbol * sym, bool result, bool useDP2)
       /* now assign the address of the variable to
          the pointer register */
       if (aop->type != AOP_STK)
-	{
-
-	  if (sym->onStack)
-	    {
-	      if (_G.accInUse || accuse)
-		emitcode ("push", "acc");
-
-	      if (_G.bInUse || (accuse>1))
-		emitcode ("push", "b");
-
-	      emitcode ("mov", "a,_bp");
-	      emitcode ("add", "a,#!constbyte",
-			((sym->stack < 0) ?
-			 ((char) (sym->stack - _G.nRegsSaved)) :
-			 ((char) sym->stack)) & 0xff);
-	      emitcode ("mov", "%s,a",
-			aop->aopu.aop_ptr->name);
-
-	      if (_G.bInUse || (accuse>1))
-		emitcode ("pop", "b");
-
-	      if (_G.accInUse || accuse)
-		emitcode ("pop", "acc");
-	    }
-	  else
-	    emitcode ("mov", "%s,#%s",
-		      aop->aopu.aop_ptr->name,
-		      sym->rname);
-	  aop->paged = space->paged;
-	}
+        {
+
+          if (sym->onStack)
+            {
+              if (_G.accInUse || accuse)
+                emitcode ("push", "acc");
+
+              if (_G.bInUse || (accuse>1))
+                emitcode ("push", "b");
+
+              emitcode ("mov", "a,_bp");
+              emitcode ("add", "a,#!constbyte",
+                        ((sym->stack < 0) ?
+                         ((char) (sym->stack - _G.nRegsSaved)) :
+                         ((char) sym->stack)) & 0xff);
+              emitcode ("mov", "%s,a",
+                        aop->aopu.aop_ptr->name);
+
+              if (_G.bInUse || (accuse>1))
+                emitcode ("pop", "b");
+
+              if (_G.accInUse || accuse)
+                emitcode ("pop", "acc");
+            }
+          else
+            emitcode ("mov", "%s,#%s",
+                      aop->aopu.aop_ptr->name,
+                      sym->rname);
+          aop->paged = space->paged;
+        }
       else
-	aop->aopu.aop_stk = sym->stack;
+        aop->aopu.aop_stk = sym->stack;
       return aop;
     }
 
   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");
-	}
+        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 (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 || accuse)
-		emitcode ("push", "acc");
-	    
-	    if (_G.bInUse || (accuse>1))
-		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 || (accuse>1))
-		emitcode ("pop", "b");
-	    
-	    if (_G.accInUse || accuse)
-		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 || accuse)
+                emitcode ("push", "acc");
+
+            if (_G.bInUse || (accuse>1))
+                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 || (accuse>1))
+                emitcode ("pop", "b");
+
+            if (_G.accInUse || accuse)
+                emitcode ("pop", "acc");
+        }
+        sym->aop = aop = newAsmop ((short) (useDP2 ? AOP_DPTR2 : AOP_DPTR));
+        aop->size = getSize (sym->type);
+        return aop;
     }
 
   /* if in bit space */
@@ -708,54 +728,50 @@ aopForRemat (symbol * sym)
 {
   iCode *ic = sym->rematiCode;
   asmop *aop = newAsmop (AOP_IMMD);
-  int ptr_type =0;
+  int ptr_type = 0;
   int val = 0;
 
   for (;;)
     {
       if (ic->op == '+')
-	val += (int) operandLitValue (IC_RIGHT (ic));
+        val += (int) operandLitValue (IC_RIGHT (ic));
       else if (ic->op == '-')
-	val -= (int) operandLitValue (IC_RIGHT (ic));
+        val -= (int) operandLitValue (IC_RIGHT (ic));
       else if (IS_CAST_ICODE(ic)) {
-	      sym_link *from_type = operandType(IC_RIGHT(ic));
-	      aop->aopu.aop_immd.from_cast_remat = 1;
-	      ic = OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
-	      ptr_type = DCL_TYPE(from_type);
-	      if (ptr_type == IPOINTER) {
-		// bug #481053
-		ptr_type = POINTER;
-	      }
-	      continue ;
+              sym_link *from_type = operandType(IC_RIGHT(ic));
+              aop->aopu.aop_immd.from_cast_remat = 1;
+              ic = OP_SYMBOL (IC_RIGHT (ic))->rematiCode;
+              ptr_type = pointerTypeToGPByte (DCL_TYPE(from_type), NULL, NULL);
+              continue;
       } else break;
-      
+
       ic = OP_SYMBOL (IC_LEFT (ic))->rematiCode;
     }
 
   if (val)
   {
       SNPRINTF (buffer, sizeof(buffer),
-		"(%s %c 0x%04x)",
-		OP_SYMBOL (IC_LEFT (ic))->rname,
-		val >= 0 ? '+' : '-',
-		abs (val) & 0xffffff);
+                "(%s %c 0x%04x)",
+                OP_SYMBOL (IC_LEFT (ic))->rname,
+                val >= 0 ? '+' : '-',
+                abs (val) & 0xffffff);
   }
-  else 
+  else
   {
       if (IS_ASSIGN_ICODE(ic) && isOperandLiteral(IC_RIGHT(ic)))
       {
-	  SNPRINTF(buffer, sizeof(buffer), 
-		   "0x%x",(int) operandLitValue (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));
+          strncpyz (buffer, OP_SYMBOL (IC_LEFT (ic))->rname, sizeof(buffer));
       }
   }
 
-  aop->aopu.aop_immd.aop_immd1 = Safe_strdup(buffer);  
+  aop->aopu.aop_immd.aop_immd1 = Safe_strdup(buffer);
   /* set immd2 field if required */
-  if (aop->aopu.aop_immd.from_cast_remat) 
+  if (aop->aopu.aop_immd.from_cast_remat)
   {
       tsprintf(buffer, sizeof(buffer), "#!constbyte",ptr_type);
       aop->aopu.aop_immd.aop_immd2 = Safe_strdup(buffer);
@@ -774,9 +790,9 @@ static int aopHasRegs(asmop *aop, int from, int to)
     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;
+        int reg;
+        for (reg = from ; reg <= to ; reg++)
+            if (aop->aopu.aop_reg[size] == ds390_regWithIdx(reg)) return 1;
     }
     return 0;
 }
@@ -804,16 +820,16 @@ regsInCommon (operand * op1, operand * op2)
     {
       int j;
       if (!sym1->regs[i])
-	continue;
+        continue;
 
       for (j = 0; j < sym2->nRegs; j++)
-	{
-	  if (!sym2->regs[j])
-	    continue;
+        {
+          if (!sym2->regs[j])
+            continue;
 
-	  if (sym2->regs[j] == sym1->regs[i])
-	    return TRUE;
-	}
+          if (sym2->regs[j] == sym1->regs[i])
+            return TRUE;
+        }
     }
 
   return FALSE;
@@ -844,10 +860,10 @@ operandsEqu (operand * op1, operand * op2)
   if (sym1 == sym2)
     return TRUE;
 
-  if (strcmp (sym1->rname, sym2->rname) == 0)
+  if (sym1->rname[0] && sym2->rname[0]
+      && strcmp (sym1->rname, sym2->rname) == 0)
     return TRUE;
 
-
   /* if left is a tmp & right is not */
   if (IS_ITEMP (op1) &&
       !IS_ITEMP (op2) &&
@@ -862,6 +878,14 @@ operandsEqu (operand * op1, operand * op2)
       (sym2->usl.spillLoc == sym1))
     return TRUE;
 
+  /* are they spilt to the same location */
+  if (IS_ITEMP (op2) &&
+      IS_ITEMP (op1) &&
+      sym2->isspilt &&
+      sym1->isspilt &&
+      (sym1->usl.spillLoc == sym2->usl.spillLoc))
+    return TRUE;
+
   return FALSE;
 }
 
@@ -876,9 +900,9 @@ sameRegs (asmop * aop1, asmop * aop2)
   if (aop1 == aop2)
     {
       if (aop1->type == AOP_DPTR || aop1->type == AOP_DPTR2)
-	{
-	  return FALSE;
-	}
+        {
+          return FALSE;
+        }
       return TRUE;
     }
 
@@ -891,7 +915,7 @@ sameRegs (asmop * aop1, asmop * aop2)
 
   for (i = 0; i < aop1->size; i++)
     if (aop1->aopu.aop_reg[i] !=
-	aop2->aopu.aop_reg[i])
+        aop2->aopu.aop_reg[i])
       return FALSE;
 
   return TRUE;
@@ -921,13 +945,23 @@ aopOp (operand * op, iCode * ic, bool result, bool useDP2)
 
   /* if already has a asmop then continue */
   if (op->aop)
-    return;
+    {
+      if ((op->aop->type == AOP_DPTR && useDP2)
+          || (op->aop->type == AOP_DPTR2 && !useDP2))
+        op->aop = NULL;
+      else
+        return;
+    }
 
   /* if the underlying symbol has a aop */
   if (IS_SYMOP (op) && OP_SYMBOL (op)->aop)
     {
       op->aop = OP_SYMBOL (op)->aop;
-      return;
+      if ((op->aop->type == AOP_DPTR && useDP2)
+          || (op->aop->type == AOP_DPTR2 && !useDP2))
+        op->aop = NULL;
+      else
+        return;
     }
 
   /* if this is a true symbol */
@@ -947,7 +981,6 @@ aopOp (operand * op, iCode * ic, bool result, bool useDP2)
 
   sym = OP_SYMBOL (op);
 
-
   /* if the type is a conditional */
   if (sym->regType == REG_CND)
     {
@@ -964,55 +997,64 @@ aopOp (operand * op, iCode * ic, bool result, bool useDP2)
 
       /* rematerialize it NOW */
       if (sym->remat)
-	{
-	  sym->aop = op->aop = aop =
-	    aopForRemat (sym);
-	  aop->size = getSize (sym->type);
-	  return;
-	}
+        {
+          sym->aop = op->aop = aop =
+            aopForRemat (sym);
+          aop->size = getSize (sym->type);
+          return;
+        }
 
       if (sym->accuse)
-	{
-	  int i;
-	  aop = op->aop = sym->aop = newAsmop (AOP_ACC);
-	  aop->size = getSize (sym->type);
-	  for (i = 0; i < 2; i++)
-	    aop->aopu.aop_str[i] = accUse[i];
-	  return;
-	}
+        {
+          int i;
+          aop = op->aop = sym->aop = newAsmop (AOP_ACC);
+          aop->size = getSize (sym->type);
+          for (i = 0; i < 2; i++)
+            aop->aopu.aop_str[i] = accUse[i];
+          return;
+        }
 
       if (sym->ruonly)
-	{
-	  int i;
-
-	  if (useDP2)
-	    {
-	      /* a AOP_STR uses DPTR, but DPTR is already in use;
-	       * we're just hosed.
-	       */
-		werror(E_INTERNAL_ERROR,__FILE__,__LINE__,"AOP_STR with DPTR in use!");
-	    }
-
-	  aop = op->aop = sym->aop = newAsmop (AOP_STR);
-	  aop->size = getSize (sym->type);
-	  for (i = 0; i < (int) fReturnSizeDS390; i++)
-	    aop->aopu.aop_str[i] = fReturn[i];
-	  return;
-	}
-      
+        {
+          int i;
+
+          if (useDP2)
+            {
+              /* a AOP_STR uses DPTR, but DPTR is already in use;
+               * we're just hosed.
+               */
+                werror(E_INTERNAL_ERROR,__FILE__,__LINE__,"AOP_STR with DPTR in use!");
+            }
+
+          aop = op->aop = sym->aop = newAsmop (AOP_STR);
+          aop->size = getSize (sym->type);
+          for (i = 0; i < fReturnSizeDS390; i++)
+            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 */
-	  sym->usl.spillLoc->aop = NULL;
+          aop = op->aop = sym->aop = newAsmop (AOP_DPTRn);
+          aop->size = getSize (sym->type);
+          aop->aopu.dptr = sym->dptr;
+          return ;
       }
-      sym->aop = op->aop = aop =
-	aopForSym (ic, sym->usl.spillLoc, result, useDP2);
+
+      if (sym->usl.spillLoc)
+        {
+          if (getSize(sym->type) != getSize(sym->usl.spillLoc->type))
+            {
+              /* force a new aop if sizes differ */
+              sym->usl.spillLoc->aop = NULL;
+            }
+          sym->aop = op->aop = aop =
+                     aopForSym (ic, sym->usl.spillLoc, result, useDP2);
+          aop->size = getSize (sym->type);
+          return;
+        }
+
+      /* else must be a dummy iTemp */
+      sym->aop = op->aop = aop = newAsmop (AOP_DUMMY);
       aop->size = getSize (sym->type);
       return;
     }
@@ -1051,93 +1093,93 @@ freeAsmop (operand * op, asmop * aaop, iCode * ic, bool pop)
     {
     case AOP_R0:
       if (_G.r0Pushed)
-	{
-	  if (pop)
-	    {
-	      emitcode ("pop", "ar0");
-	      _G.r0Pushed--;
-	    }
-	}
+        {
+          if (pop)
+            {
+              emitcode ("pop", "ar0");
+              _G.r0Pushed--;
+            }
+        }
       bitVectUnSetBit (ic->rUsed, R0_IDX);
       break;
 
     case AOP_R1:
       if (_G.r1Pushed)
-	{
-	  if (pop)
-	    {
-	      emitcode ("pop", "ar1");
-	      _G.r1Pushed--;
-	    }
-	}
+        {
+          if (pop)
+            {
+              emitcode ("pop", "ar1");
+              _G.r1Pushed--;
+            }
+        }
       bitVectUnSetBit (ic->rUsed, R1_IDX);
       break;
 
     case AOP_STK:
       {
-	int sz = aop->size;
-	int stk = aop->aopu.aop_stk + aop->size;
-	bitVectUnSetBit (ic->rUsed, R0_IDX);
-	bitVectUnSetBit (ic->rUsed, R1_IDX);
-
-	getFreePtr (ic, &aop, FALSE);
-
-	if (options.stack10bit)
-	  {
-	    /* I'm not sure what to do here yet... */
-	    /* #STUB */
-	    fprintf (stderr,
-		     "*** Warning: probably generating bad code for "
-		     "10 bit stack mode.\n");
-	  }
-
-	if (stk)
-	  {
-	    emitcode ("mov", "a,_bp");
-	    emitcode ("add", "a,#!constbyte", ((char) stk) & 0xff);
-	    emitcode ("mov", "%s,a", aop->aopu.aop_ptr->name);
-	  }
-	else
-	  {
-	    emitcode ("mov", "%s,_bp", aop->aopu.aop_ptr->name);
-	  }
-
-	while (sz--)
-	  {
-	    emitcode ("pop", "acc");
-	    emitcode ("mov", "@%s,a", aop->aopu.aop_ptr->name);
-	    if (!sz)
-	      break;
-	    emitcode ("dec", "%s", aop->aopu.aop_ptr->name);
-	  }
-	op->aop = aop;
-	freeAsmop (op, NULL, ic, TRUE);
-	if (_G.r0Pushed)
-	  {
-	    emitcode ("pop", "ar0");
-	    _G.r0Pushed--;
-	  }
-
-	if (_G.r1Pushed)
-	  {
-	    emitcode ("pop", "ar1");
-	    _G.r1Pushed--;
-	  }
+        int sz = aop->size;
+        int stk = aop->aopu.aop_stk + aop->size;
+        bitVectUnSetBit (ic->rUsed, R0_IDX);
+        bitVectUnSetBit (ic->rUsed, R1_IDX);
+
+        getFreePtr (ic, &aop, FALSE);
+
+        if (options.stack10bit)
+          {
+            /* I'm not sure what to do here yet... */
+            /* #STUB */
+            fprintf (stderr,
+                     "*** Warning: probably generating bad code for "
+                     "10 bit stack mode.\n");
+          }
+
+        if (stk)
+          {
+            emitcode ("mov", "a,_bp");
+            emitcode ("add", "a,#!constbyte", ((char) stk) & 0xff);
+            emitcode ("mov", "%s,a", aop->aopu.aop_ptr->name);
+          }
+        else
+          {
+            emitcode ("mov", "%s,_bp", aop->aopu.aop_ptr->name);
+          }
+
+        while (sz--)
+          {
+            emitcode ("pop", "acc");
+            emitcode ("mov", "@%s,a", aop->aopu.aop_ptr->name);
+            if (!sz)
+              break;
+            emitcode ("dec", "%s", aop->aopu.aop_ptr->name);
+          }
+        op->aop = aop;
+        freeAsmop (op, NULL, ic, TRUE);
+        if (_G.r0Pushed)
+          {
+            emitcode ("pop", "ar0");
+            _G.r0Pushed--;
+          }
+
+        if (_G.r1Pushed)
+          {
+            emitcode ("pop", "ar1");
+            _G.r1Pushed--;
+          }
       }
     case AOP_DPTR2:
-	if (_G.dptr1InUse) {
-	    emitcode ("pop","dpx1");
-	    emitcode ("pop","dph1");
-	    emitcode ("pop","dpl1");
-	}
-	break;
+        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;
+        if (_G.dptrInUse) {
+            emitcode ("pop","dpx");
+            emitcode ("pop","dph");
+            emitcode ("pop","dpl");
+        }
+        break;
     }
 dealloc:
   /* all other cases just dealloc */
@@ -1145,12 +1187,12 @@ dealloc:
     {
       op->aop = NULL;
       if (IS_SYMOP (op))
-	{
-	  OP_SYMBOL (op)->aop = NULL;
-	  /* if the symbol has a spill */
-	  if (SPIL_LOC (op))
-	    SPIL_LOC (op)->aop = NULL;
-	}
+        {
+          OP_SYMBOL (op)->aop = NULL;
+          /* if the symbol has a spill */
+          if (SPIL_LOC (op))
+            SPIL_LOC (op)->aop = NULL;
+        }
     }
 }
 
@@ -1159,19 +1201,19 @@ 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.		     */
+/* acc temporarily and to return the result byte.                    */
 /*-------------------------------------------------------------------*/
 
 static char *
 aopGet (asmop *aop,
-	int   offset,
-	bool  bit16,
-	bool  dname,
-	char  *saveAcc)
+        int   offset,
+        bool  bit16,
+        bool  dname,
+        char  *saveAcc)
 {
   /* offset is greater than
      size then zero */
@@ -1182,159 +1224,161 @@ aopGet (asmop *aop,
   /* depending on type */
   switch (aop->type)
     {
+    case AOP_DUMMY:
+      return zero;
 
     case AOP_R0:
     case AOP_R1:
       /* if we need to increment it */
       while (offset > aop->coff)
-	{
-	  emitcode ("inc", "%s", aop->aopu.aop_ptr->name);
-	  aop->coff++;
-	}
+        {
+          emitcode ("inc", "%s", aop->aopu.aop_ptr->name);
+          aop->coff++;
+        }
 
       while (offset < aop->coff)
-	{
-	  emitcode ("dec", "%s", aop->aopu.aop_ptr->name);
-	  aop->coff--;
-	}
+        {
+          emitcode ("dec", "%s", aop->aopu.aop_ptr->name);
+          aop->coff--;
+        }
 
       aop->coff = offset;
       if (aop->paged)
-	{
-	  emitcode ("movx", "a,@%s", aop->aopu.aop_ptr->name);
-	  return (dname ? "acc" : "a");
-	}
+        {
+          emitcode ("movx", "a,@%s", aop->aopu.aop_ptr->name);
+          return (dname ? "acc" : "a");
+        }
       SNPRINTF (buffer, sizeof(buffer), "@%s", aop->aopu.aop_ptr->name);
-      return Safe_strdup(buffer);	
+      return Safe_strdup(buffer);
 
     case AOP_DPTRn:
-	assert(offset <= 3);
-	return dptrn[aop->aopu.dptr][offset];
+        assert(offset <= 3);
+        return dptrn[aop->aopu.dptr][offset];
 
     case AOP_DPTR:
     case AOP_DPTR2:
 
       if (aop->type == AOP_DPTR2)
-	{
-	  genSetDPTR (1);
-	}
-	
+        {
+          genSetDPTR (1);
+        }
+
       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);
-	}
+        {
+            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 ();
 
       while (offset > aop->coff)
-	{
-	  emitcode ("inc", "dptr");
-	  aop->coff++;
-	}
+        {
+          emitcode ("inc", "dptr");
+          aop->coff++;
+        }
 
       while (offset < aop->coff)
-	{
-	  emitcode ("lcall", "__decdptr");
-	  aop->coff--;
-	}
+        {
+          emitcode ("lcall", "__decdptr");
+          aop->coff--;
+        }
 
       aop->coff = offset;
       if (aop->code)
-	{
-	  emitcode ("clr", "a");
-	  emitcode ("movc", "a,@a+dptr");
-	}
+        {
+          emitcode ("clr", "a");
+          emitcode ("movc", "a,@a+dptr");
+        }
       else
-	{
-	  emitcode ("movx", "a,@dptr");
-	}
+        {
+          emitcode ("movx", "a,@dptr");
+        }
 
       if (aop->type == AOP_DPTR2)
-	{
-	  genSetDPTR (0);
-	}
-	
-	if (saveAcc)
-	{
+        {
+          genSetDPTR (0);
+        }
+
+        if (saveAcc)
+        {
        TR_AP("#2");
-	      emitcode ("xch", "a, %s", saveAcc);
-//	      if (strcmp(saveAcc, "_ap"))
-//	      {
-//		  emitcode(";", "spiffy: non _ap return from aopGet.");
-//	      }
-		  
-	      return saveAcc;
-	}
+              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))) 
+      if (aop->aopu.aop_immd.from_cast_remat && (offset == (aop->size-1)))
       {
-	  SNPRINTF(buffer, sizeof(buffer), 
-		   "%s",aop->aopu.aop_immd.aop_immd2);
-      } 
+          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);
+         SNPRINTF(buffer, sizeof(buffer),
+                  "#%s", aop->aopu.aop_immd.aop_immd1);
       }
-      else if (offset) 
+      else if (offset)
       {
-	  switch (offset) {
-	  case 1:
-	      tsprintf(buffer, sizeof(buffer),
-		       "#!his",aop->aopu.aop_immd.aop_immd1);
-	      break;
-	  case 2:
-	      tsprintf(buffer, sizeof(buffer), 
-		       "#!hihis",aop->aopu.aop_immd.aop_immd1);
-	      break;
-	  case 3:
-	      tsprintf(buffer, sizeof(buffer),
-		       "#!hihihis",aop->aopu.aop_immd.aop_immd1);
-	      break;
-	  default: /* should not need this (just in case) */
-	      SNPRINTF (buffer, sizeof(buffer), 
-			"#(%s >> %d)",
-		       aop->aopu.aop_immd.aop_immd1,
-		       offset * 8);
-	  }
+          switch (offset) {
+          case 1:
+              tsprintf(buffer, sizeof(buffer),
+                       "#!his",aop->aopu.aop_immd.aop_immd1);
+              break;
+          case 2:
+              tsprintf(buffer, sizeof(buffer),
+                       "#!hihis",aop->aopu.aop_immd.aop_immd1);
+              break;
+          case 3:
+              tsprintf(buffer, sizeof(buffer),
+                       "#!hihihis",aop->aopu.aop_immd.aop_immd1);
+              break;
+          default: /* should not need this (just in case) */
+              SNPRINTF (buffer, sizeof(buffer),
+                        "#(%s >> %d)",
+                       aop->aopu.aop_immd.aop_immd1,
+                       offset * 8);
+          }
       }
       else
       {
-	SNPRINTF (buffer, sizeof(buffer), 
-		  "#%s", aop->aopu.aop_immd.aop_immd1);
+        SNPRINTF (buffer, sizeof(buffer),
+                  "#%s", aop->aopu.aop_immd.aop_immd1);
       }
-      return Safe_strdup(buffer);	
+      return Safe_strdup(buffer);
 
     case AOP_DIR:
       if (offset)
       {
-	SNPRINTF (buffer, sizeof(buffer),
-		  "(%s + %d)",
-		 aop->aopu.aop_dir,
-		 offset);
+        SNPRINTF (buffer, sizeof(buffer),
+                  "(%s + %d)",
+                 aop->aopu.aop_dir,
+                 offset);
       }
       else
       {
-	SNPRINTF(buffer, sizeof(buffer), 
-		 "%s", aop->aopu.aop_dir);
+        SNPRINTF(buffer, sizeof(buffer),
+                 "%s", aop->aopu.aop_dir);
       }
 
       return Safe_strdup(buffer);
 
     case AOP_REG:
       if (dname)
-	return aop->aopu.aop_reg[offset]->dname;
+        return aop->aopu.aop_reg[offset]->dname;
       else
-	return aop->aopu.aop_reg[offset]->name;
+        return aop->aopu.aop_reg[offset]->name;
 
     case AOP_CRY:
       emitcode ("clr", "a");
@@ -1344,7 +1388,7 @@ aopGet (asmop *aop,
 
     case AOP_ACC:
       if (!offset && dname)
-	return "acc";
+        return "acc";
       return aop->aopu.aop_str[offset];
 
     case AOP_LIT:
@@ -1353,17 +1397,17 @@ aopGet (asmop *aop,
     case AOP_STR:
       aop->coff = offset;
       if (strcmp (aop->aopu.aop_str[offset], "a") == 0 &&
-	  dname)
-	return "acc";
+          dname)
+        return "acc";
 
       return aop->aopu.aop_str[offset];
 
     }
 
   werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
-	  "aopget got unsupported aop->type");
+          "aopget got unsupported aop->type");
   exit (1);
-    
+
   return NULL;  // not reached, but makes compiler happy.
 }
 /*-----------------------------------------------------------------*/
@@ -1375,7 +1419,7 @@ aopPut (asmop * aop, char *s, int offset)
   if (aop->size && offset > (aop->size - 1))
     {
       werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
-	      "aopPut got offset > aop->size");
+              "aopPut got offset > aop->size");
       exit (1);
     }
 
@@ -1383,82 +1427,86 @@ aopPut (asmop * aop, char *s, int offset)
   /* depending on where it is ofcourse */
   switch (aop->type)
     {
+    case AOP_DUMMY:
+      MOVA (s);         /* read s in case it was volatile */
+      break;
+
     case AOP_DIR:
         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);
-	}
+        {
+            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:
       if (strcmp (aop->aopu.aop_reg[offset]->name, s) != 0 &&
-	  strcmp (aop->aopu.aop_reg[offset]->dname, s) != 0)
-	{
-	  if (*s == '@' ||
-	      strcmp (s, "r0") == 0 ||
-	      strcmp (s, "r1") == 0 ||
-	      strcmp (s, "r2") == 0 ||
-	      strcmp (s, "r3") == 0 ||
-	      strcmp (s, "r4") == 0 ||
-	      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);
-	    }
-	}
+          strcmp (aop->aopu.aop_reg[offset]->dname, s) != 0)
+        {
+          if (*s == '@' ||
+              strcmp (s, "r0") == 0 ||
+              strcmp (s, "r1") == 0 ||
+              strcmp (s, "r2") == 0 ||
+              strcmp (s, "r3") == 0 ||
+              strcmp (s, "r4") == 0 ||
+              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);
+            }
+        }
       break;
 
     case AOP_DPTRn:
-	emitcode ("mov","%s,%s",dptrn[aop->aopu.dptr][offset],s);
-	break;
+        emitcode ("mov","%s,%s",dptrn[aop->aopu.dptr][offset],s);
+        break;
 
     case AOP_DPTR:
     case AOP_DPTR2:
 
       if (aop->type == AOP_DPTR2)
-	{
-	  genSetDPTR (1);
-	}
+        {
+          genSetDPTR (1);
+        }
       _flushLazyDPS ();
 
       if (aop->code)
-	{
-	  werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
-		  "aopPut writting to code space");
-	  exit (1);
-	}
+        {
+          werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
+                  "aopPut writting to code space");
+          exit (1);
+        }
 
       while (offset > aop->coff)
-	{
-	  aop->coff++;
-	  emitcode ("inc", "dptr");
-	}
+        {
+          aop->coff++;
+          emitcode ("inc", "dptr");
+        }
 
       while (offset < aop->coff)
-	{
-	  aop->coff--;
-	  emitcode ("lcall", "__decdptr");
-	}
+        {
+          aop->coff--;
+          emitcode ("lcall", "__decdptr");
+        }
 
       aop->coff = offset;
 
@@ -1468,118 +1516,118 @@ aopPut (asmop * aop, char *s, int offset)
       emitcode ("movx", "@dptr,a");
 
       if (aop->type == AOP_DPTR2)
-	{
-	  genSetDPTR (0);
-	}
+        {
+          genSetDPTR (0);
+        }
       break;
 
     case AOP_R0:
     case AOP_R1:
       while (offset > aop->coff)
-	{
-	  aop->coff++;
-	  emitcode ("inc", "%s", aop->aopu.aop_ptr->name);
-	}
+        {
+          aop->coff++;
+          emitcode ("inc", "%s", aop->aopu.aop_ptr->name);
+        }
       while (offset < aop->coff)
-	{
-	  aop->coff--;
-	  emitcode ("dec", "%s", aop->aopu.aop_ptr->name);
-	}
+        {
+          aop->coff--;
+          emitcode ("dec", "%s", aop->aopu.aop_ptr->name);
+        }
       aop->coff = offset;
 
       if (aop->paged)
-	{
-	  MOVA (s);
-	  emitcode ("movx", "@%s,a", aop->aopu.aop_ptr->name);
+        {
+          MOVA (s);
+          emitcode ("movx", "@%s,a", aop->aopu.aop_ptr->name);
 
-	}
+        }
       else if (*s == '@')
-	{
-	  MOVA (s);
-	  emitcode ("mov", "@%s,a", aop->aopu.aop_ptr->name);
-	}
+        {
+          MOVA (s);
+          emitcode ("mov", "@%s,a", aop->aopu.aop_ptr->name);
+        }
       else if (strcmp (s, "r0") == 0 ||
-	       strcmp (s, "r1") == 0 ||
-	       strcmp (s, "r2") == 0 ||
-	       strcmp (s, "r3") == 0 ||
-	       strcmp (s, "r4") == 0 ||
-	       strcmp (s, "r5") == 0 ||
-	       strcmp (s, "r6") == 0 ||
-	       strcmp (s, "r7") == 0)
-	{
-	  char buff[10];
-	  SNPRINTF(buff, sizeof(buff), 
-		   "a%s", s);
-	  emitcode ("mov", "@%s,%s",
-		    aop->aopu.aop_ptr->name, buff);
-	}
-	else
-	{
-	    emitcode ("mov", "@%s,%s", aop->aopu.aop_ptr->name, s);
-	}
+               strcmp (s, "r1") == 0 ||
+               strcmp (s, "r2") == 0 ||
+               strcmp (s, "r3") == 0 ||
+               strcmp (s, "r4") == 0 ||
+               strcmp (s, "r5") == 0 ||
+               strcmp (s, "r6") == 0 ||
+               strcmp (s, "r7") == 0)
+        {
+          char buff[10];
+          SNPRINTF(buff, sizeof(buff),
+                   "a%s", s);
+          emitcode ("mov", "@%s,%s",
+                    aop->aopu.aop_ptr->name, buff);
+        }
+        else
+        {
+            emitcode ("mov", "@%s,%s", aop->aopu.aop_ptr->name, s);
+        }
       break;
 
     case AOP_STK:
       if (strcmp (s, "a") == 0)
-	emitcode ("push", "acc");
+        emitcode ("push", "acc");
       else
-	if (*s=='@') {
-	  MOVA(s);
-	  emitcode ("push", "acc");
-	} else {
-	  emitcode ("push", s);
-	}
+        if (*s=='@') {
+          MOVA(s);
+          emitcode ("push", "acc");
+        } else {
+          emitcode ("push", s);
+        }
 
       break;
 
     case AOP_CRY:
       /* if bit variable */
       if (!aop->aopu.aop_dir)
-	{
-	  emitcode ("clr", "a");
-	  emitcode ("rlc", "a");
-	}
+        {
+          emitcode ("clr", "a");
+          emitcode ("rlc", "a");
+        }
       else
-	{
-	  if (s == zero)
-	    emitcode ("clr", "%s", aop->aopu.aop_dir);
-	  else if (s == one)
-	    emitcode ("setb", "%s", aop->aopu.aop_dir);
-	  else if (!strcmp (s, "c"))
-	    emitcode ("mov", "%s,c", aop->aopu.aop_dir);
-	  else
-	    {
-	      if (strcmp (s, "a"))
-		{
-		  MOVA (s);
-		}
-	      {
-		/* set C, if a >= 1 */
-		emitcode ("add", "a,#!constbyte",0xff);
-		emitcode ("mov", "%s,c", aop->aopu.aop_dir);
-	      }
-	    }
-	}
+        {
+          if (s == zero)
+            emitcode ("clr", "%s", aop->aopu.aop_dir);
+          else if (s == one)
+            emitcode ("setb", "%s", aop->aopu.aop_dir);
+          else if (!strcmp (s, "c"))
+            emitcode ("mov", "%s,c", aop->aopu.aop_dir);
+          else
+            {
+              if (strcmp (s, "a"))
+                {
+                  MOVA (s);
+                }
+              {
+                /* set C, if a >= 1 */
+                emitcode ("add", "a,#!constbyte",0xff);
+                emitcode ("mov", "%s,c", aop->aopu.aop_dir);
+              }
+            }
+        }
       break;
 
     case AOP_STR:
       aop->coff = offset;
       if (strcmp (aop->aopu.aop_str[offset], s))
-	emitcode ("mov", "%s,%s", aop->aopu.aop_str[offset], s);
+        emitcode ("mov", "%s,%s", aop->aopu.aop_str[offset], s);
       break;
 
     case AOP_ACC:
       aop->coff = offset;
       if (!offset && (strcmp (s, "acc") == 0))
-	break;
+        break;
 
       if (strcmp (aop->aopu.aop_str[offset], s))
-	emitcode ("mov", "%s,%s", aop->aopu.aop_str[offset], s);
+        emitcode ("mov", "%s,%s", aop->aopu.aop_str[offset], s);
       break;
 
     default:
       werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
-	      "aopPut got unsupported aop->type");
+              "aopPut got unsupported aop->type");
       exit (1);
     }
 
@@ -1601,24 +1649,24 @@ reAdjustPreg (asmop * aop)
     case AOP_R0:
     case AOP_R1:
       while (aop->coff--)
-	emitcode ("dec", "%s", aop->aopu.aop_ptr->name);
+        emitcode ("dec", "%s", aop->aopu.aop_ptr->name);
       break;
     case AOP_DPTR:
     case AOP_DPTR2:
       if (aop->type == AOP_DPTR2)
-	{
-	  genSetDPTR (1);
-	  _flushLazyDPS ();
-	}
+        {
+          genSetDPTR (1);
+          _flushLazyDPS ();
+        }
       while (aop->coff--)
-	{
-	  emitcode ("lcall", "__decdptr");
-	}
+        {
+          emitcode ("lcall", "__decdptr");
+        }
 
       if (aop->type == AOP_DPTR2)
-	{
-	  genSetDPTR (0);
-	}
+        {
+          genSetDPTR (0);
+        }
       break;
 
     }
@@ -1703,12 +1751,12 @@ getDataSize (operand * op)
     {
       sym_link *type = operandType (op);
       if (IS_GENPTR (type))
-	{
-	  /* generic pointer; arithmetic operations
-	   * should ignore the high byte (pointer type).
-	   */
-	  size--;
-	}
+        {
+          /* generic pointer; arithmetic operations
+           * should ignore the high byte (pointer type).
+           */
+          size--;
+        }
     }
   return size;
 }
@@ -1728,9 +1776,9 @@ outAcc (operand * result)
       offset = 1;
       /* unsigned or positive */
       while (size--)
-	{
-	  aopPut (AOP (result), zero, offset++);
-	}
+        {
+          aopPut (AOP (result), zero, offset++);
+        }
     }
 }
 
@@ -1759,8 +1807,8 @@ outBitC (operand * result)
 static void
 toBoolean (operand * oper)
 {
-  int 	size = AOP_SIZE (oper) - 1;
-  int 	offset = 1;
+  int   size = AOP_SIZE (oper) - 1;
+  int   offset = 1;
   bool usedB = FALSE;
 
   /* The generic part of a generic pointer should
@@ -1780,7 +1828,7 @@ toBoolean (operand * oper)
       usedB = TRUE;
       if (_G.bInUse)
       {
-	  emitcode ("push", "b");
+          emitcode ("push", "b");
       }
       MOVB (aopGet (AOP (oper), 0, FALSE, FALSE, NULL));
     }
@@ -1788,19 +1836,19 @@ toBoolean (operand * oper)
     {
       MOVA (aopGet (AOP (oper), 0, FALSE, FALSE, NULL));
     }
-    
+
   while (size--)
     {
       if (usedB)
-	{
-	  emitcode ("orl", "b,%s",
-		    aopGet (AOP (oper), offset++, FALSE, FALSE, NULL));
-	}
+        {
+          emitcode ("orl", "b,%s",
+                    aopGet (AOP (oper), offset++, FALSE, FALSE, NULL));
+        }
       else
-	{
-	  emitcode ("orl", "a,%s",
-		    aopGet (AOP (oper), offset++, FALSE, FALSE, NULL));
-	}
+        {
+          emitcode ("orl", "a,%s",
+                    aopGet (AOP (oper), offset++, FALSE, FALSE, NULL));
+        }
     }
   _endLazyDPSEvaluation ();
 
@@ -1809,9 +1857,9 @@ toBoolean (operand * oper)
       emitcode ("mov", "a,b");
       if (_G.bInUse)
       {
-	  emitcode ("pop", "b");
+          emitcode ("pop", "b");
       }
-	
+
     }
 }
 
@@ -1862,29 +1910,47 @@ genCpl (iCode * ic)
   int offset = 0;
   int size;
   symbol *tlbl;
+  sym_link *letype = getSpec (operandType (IC_LEFT (ic)));
 
-  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_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);
+  if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY)
+    {
+      char *l;
+
+      if (AOP_TYPE (IC_LEFT (ic)) == AOP_CRY ||
+          (SPEC_USIGN (letype) && IS_CHAR (letype)))
+        {
+          /* promotion rules are responsible for this strange result:
+             bit -> int -> ~int -> bit
+             uchar -> int -> ~int -> bit
+          */
+          werror(W_COMPLEMENT);
+          emitcode ("setb", "%s", IC_RESULT (ic)->aop->aopu.aop_dir);
+          goto release;
+        }
+      tlbl=newiTempLabel(NULL);
+      l = aopGet (AOP (IC_LEFT (ic)), offset++, FALSE, FALSE, NULL);
+      if (AOP_TYPE (IC_LEFT (ic)) == AOP_ACC ||
+          AOP_TYPE (IC_LEFT (ic)) == AOP_REG ||
+          IS_AOP_PREG (IC_LEFT (ic)))
+        {
+          emitcode ("cjne", "%s,#0xFF,%05d$", l, tlbl->key + 100);
+        }
+      else
+        {
+          MOVA (l);
+          emitcode ("cjne", "a,#0xFF,%05d$", tlbl->key + 100);
+        }
+      emitcode ("", "%05d$:", tlbl->key+100);
+      outBitC (IC_RESULT(ic));
       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 ();
@@ -1910,26 +1976,26 @@ static void
 genUminusFloat (operand * op, operand * result)
 {
   int size, offset = 0;
-    
+
   D(emitcode (";", "genUminusFloat"););
-  
+
   /* for this we just copy and then flip the bit */
-    
+
   _startLazyDPSEvaluation ();
   size = AOP_SIZE (op) - 1;
 
   while (size--)
-  {
+    {
       aopPut (AOP (result),
-	      aopGet (AOP (op), offset, FALSE, FALSE, NULL),
-	      offset);
+              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);    
+  aopPut (AOP (result), "a", offset);
   _endLazyDPSEvaluation ();
 }
 
@@ -1946,7 +2012,7 @@ genUminus (iCode * ic)
 
   /* assign asmops */
   aopOp (IC_LEFT (ic), ic, FALSE, FALSE);
-  aopOp (IC_RESULT (ic), ic, TRUE, AOP_USESDPTR(IC_LEFT (ic)));
+  aopOp (IC_RESULT (ic), ic, TRUE, (AOP_TYPE(IC_LEFT (ic)) == AOP_DPTR));
 
   /* if both in bit space then special
      case */
@@ -1977,19 +2043,19 @@ genUminus (iCode * ic)
     {
       char *l = aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE, NULL);
       if (!strcmp (l, "a"))
-	{
-	  if (offset == 0)
-	    SETC;
-	  emitcode ("cpl", "a");
-	  emitcode ("addc", "a,#0");
-	}
+        {
+          if (offset == 0)
+            SETC;
+          emitcode ("cpl", "a");
+          emitcode ("addc", "a,#0");
+        }
       else
-	{
-	  if (offset == 0)
-	    CLRC;
-	  emitcode ("clr", "a");
-	  emitcode ("subb", "a,%s", l);
-	}
+        {
+          if (offset == 0)
+            CLRC;
+          emitcode ("clr", "a");
+          emitcode ("subb", "a,%s", l);
+        }
       aopPut (AOP (IC_RESULT (ic)), "a", offset++);
     }
   _endLazyDPSEvaluation ();
@@ -2001,7 +2067,7 @@ genUminus (iCode * ic)
       emitcode ("rlc", "a");
       emitcode ("subb", "a,acc");
       while (size--)
-	aopPut (AOP (IC_RESULT (ic)), "a", offset++);
+        aopPut (AOP (IC_RESULT (ic)), "a", offset++);
     }
 
 release:
@@ -2017,27 +2083,27 @@ 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");
+        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);
-	}
+        for (i = 0; i < ds390_nRegs; i++) {
+            if (bitVectBitValue (rs_mask, i))
+                emitcode ("push", "%s", ds390_regWithIdx (i)->dname);
+        }
     }
 }
 
@@ -2063,26 +2129,26 @@ saveRegisters (iCode * lic)
 
   /* if the registers have been saved already then
      do nothing */
-  if (ic->regsSaved 
+  if (ic->regsSaved
       || (IS_SYMOP(IC_LEFT(ic)) && IFFUNC_ISNAKED(OP_SYM_TYPE(IC_LEFT(ic))) && !TARGET_IS_DS400) )
     return ;
 
-  /* special case if DPTR alive across a function call then must save it 
+  /* special case if DPTR alive across a function call then must save it
      even though callee saves */
   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);
+          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 */
     rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
-			   ds390_rUmaskForOp (IC_RESULT(ic)));
+                           ds390_rUmaskForOp (IC_RESULT(ic)));
   }
   ic->regsSaved = 1;
   savermask(rsave);
@@ -2095,25 +2161,25 @@ 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");
+        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);
-	}
+        for (i = ds390_nRegs; i >= 0; i--) {
+            if (bitVectBitValue (rs_mask, i))
+                emitcode ("pop", "%s", ds390_regWithIdx (i)->dname);
+        }
     }
 }
 
@@ -2129,15 +2195,15 @@ unsaveRegisters (iCode * ic)
       int i;
       rsave = newBitVect(ic->rMask->size);
       for (i = DPL_IDX ; i <= B_IDX ; i++ ) {
-	  if (bitVectBitValue(ic->rMask,i))
-	      rsave = bitVectSetBit(rsave,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)));
+    rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
+                           ds390_rUmaskForOp (IC_RESULT(ic)));
   }
   unsavermask(rsave);
 }
@@ -2155,14 +2221,14 @@ pushSide (operand * oper, int size)
     {
       char *l = aopGet (AOP (oper), offset++, FALSE, TRUE, NULL);
       if (AOP_TYPE (oper) != AOP_REG &&
-	  AOP_TYPE (oper) != AOP_DIR &&
-	  strcmp (l, "a"))
-	{
-	  emitcode ("mov", "a,%s", l);
-	  emitcode ("push", "acc");
-	}
+          AOP_TYPE (oper) != AOP_DIR &&
+          strcmp (l, "a"))
+        {
+          emitcode ("mov", "a,%s", l);
+          emitcode ("push", "acc");
+        }
       else
-	emitcode ("push", "%s", l);
+        emitcode ("push", "%s", l);
     }
   _endLazyDPSEvaluation ();
 }
@@ -2185,14 +2251,14 @@ assignResultValue (operand * oper)
        */
       if (AOP_NEEDSACC(oper))
       {
-	  emitcode(";", "assignResultValue special case for ACC.");
-	  emitcode("push", "acc");
-	  pushedAcc = TRUE;
-	  size--;
+          emitcode(";", "assignResultValue special case for ACC.");
+          emitcode("push", "acc");
+          pushedAcc = TRUE;
+          size--;
       }
   }
-    
-    
+
+
   _startLazyDPSEvaluation ();
   while (size--)
     {
@@ -2200,11 +2266,11 @@ assignResultValue (operand * oper)
       offset++;
     }
   _endLazyDPSEvaluation ();
-    
+
   if (pushedAcc)
     {
-	emitcode("pop", "acc");
-	aopPut(AOP(oper), "a", offset);
+        emitcode("pop", "acc");
+        aopPut(AOP(oper), "a", offset);
     }
 }
 
@@ -2234,7 +2300,7 @@ genXpush (iCode * ic)
     {
 
       MOVA (aopGet (AOP (IC_LEFT (ic)),
-			offset++, FALSE, FALSE, NULL));
+                        offset++, FALSE, FALSE, NULL));
       emitcode ("movx", "@%s,a", r->name);
       emitcode ("inc", "%s", r->name);
 
@@ -2267,22 +2333,22 @@ genIpush (iCode * ic)
 
       /* and the item is spilt then do nothing */
       if (OP_SYMBOL (IC_LEFT (ic))->isspilt || OP_SYMBOL(IC_LEFT(ic))->dptr)
-	return;
+        return;
 
       aopOp (IC_LEFT (ic), ic, FALSE, FALSE);
       size = AOP_SIZE (IC_LEFT (ic));
       /* push it on the stack */
       _startLazyDPSEvaluation ();
       while (size--)
-	{
-	  l = aopGet (AOP (IC_LEFT (ic)), offset++, FALSE, TRUE, NULL);
-	  if (*l == '#')
-	    {
-	      MOVA (l);
-	      l = "acc";
-	    }
-	  emitcode ("push", "%s", l);
-	}
+        {
+          l = aopGet (AOP (IC_LEFT (ic)), offset++, FALSE, TRUE, NULL);
+          if (*l == '#')
+            {
+              MOVA (l);
+              l = "acc";
+            }
+          emitcode ("push", "%s", l);
+        }
       _endLazyDPSEvaluation ();
       return;
     }
@@ -2311,16 +2377,16 @@ genIpush (iCode * ic)
     {
       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, "acc"))
-	{
-	  emitcode ("mov", "a,%s", l);
-	  emitcode ("push", "acc");
-	}
+          AOP_TYPE (IC_LEFT (ic)) != AOP_DIR &&
+          strcmp (l, "acc"))
+        {
+          emitcode ("mov", "a,%s", l);
+          emitcode ("push", "acc");
+        }
       else
-	{
-	    emitcode ("push", "%s", l);
-	}
+        {
+            emitcode ("push", "%s", l);
+        }
     }
   _endLazyDPSEvaluation ();
 
@@ -2350,7 +2416,7 @@ genIpop (iCode * ic)
   while (size--)
     {
       emitcode ("pop", "%s", aopGet (AOP (IC_LEFT (ic)), offset--,
-				     FALSE, TRUE, NULL));
+                                     FALSE, TRUE, NULL));
     }
   _endLazyDPSEvaluation ();
 
@@ -2371,55 +2437,55 @@ unsaveRBank (int bank, iCode * ic, bool popPsw)
   {
       if (!ic)
       {
-      	  /* Assume r0 is available for use. */
-      	  r = ds390_regWithIdx (R0_IDX);;          
-      }	
+          /* Assume r0 is available for use. */
+          r = ds390_regWithIdx (R0_IDX);;
+      }
       else
       {
-	  aop = newAsmop (0);
-	  r = getFreePtr (ic, &aop, FALSE);
+          aop = newAsmop (0);
+          r = getFreePtr (ic, &aop, FALSE);
       }
-      emitcode ("mov", "%s,_spx", r->name);      
+      emitcode ("mov", "%s,_spx", r->name);
   }
-  
+
   if (popPsw)
     {
       if (options.useXstack)
       {
-	  emitcode ("movx", "a,@%s", r->name);
-	  emitcode ("mov", "psw,a");
-	  emitcode ("dec", "%s", r->name);
-	}
+          emitcode ("movx", "a,@%s", r->name);
+          emitcode ("mov", "psw,a");
+          emitcode ("dec", "%s", r->name);
+        }
       else
       {
-	emitcode ("pop", "psw");
+        emitcode ("pop", "psw");
       }
     }
 
   for (i = 7; i >= 0; i--) /* only R7-R0 needs to be popped */
     {
       if (options.useXstack)
-	{
-	  emitcode ("movx", "a,@%s", r->name);
-	  emitcode ("mov", "(%s+%d),a",
-		    regs390[i].base, 8 * bank + regs390[i].offset);
-	  emitcode ("dec", "%s", r->name);
+        {
+          emitcode ("movx", "a,@%s", r->name);
+          emitcode ("mov", "(%s+%d),a",
+                    regs390[i].base, 8 * bank + regs390[i].offset);
+          emitcode ("dec", "%s", r->name);
 
-	}
+        }
       else
-	emitcode ("pop", "(%s+%d)",
-		  regs390[i].base, 8 * bank + regs390[i].offset);
+        emitcode ("pop", "(%s+%d)",
+                  regs390[i].base, 8 * bank + regs390[i].offset);
     }
 
   if (options.useXstack)
     {
       emitcode ("mov", "_spx,%s", r->name);
     }
-    
+
   if (aop)
   {
-      freeAsmop (NULL, aop, ic, TRUE);  
-  }    
+      freeAsmop (NULL, aop, ic, TRUE);
+  }
 }
 
 /*-----------------------------------------------------------------*/
@@ -2436,61 +2502,61 @@ saveRBank (int bank, iCode * ic, bool pushPsw)
     {
         if (!ic)
         {
-       	  /* Assume r0 is available for use. */
-        	  r = ds390_regWithIdx (R0_IDX);;
+          /* Assume r0 is available for use. */
+                  r = ds390_regWithIdx (R0_IDX);;
         }
         else
         {
-       	  aop = newAsmop (0);
-       	  r = getFreePtr (ic, &aop, FALSE);
+          aop = newAsmop (0);
+          r = getFreePtr (ic, &aop, FALSE);
         }
-        emitcode ("mov", "%s,_spx", r->name);    
+        emitcode ("mov", "%s,_spx", r->name);
     }
 
   for (i = 0; i < 8 ; i++) /* only R0-R7 needs saving */
     {
       if (options.useXstack)
-	{
-	  emitcode ("inc", "%s", r->name);
-	  emitcode ("mov", "a,(%s+%d)",
-		    regs390[i].base, 8 * bank + regs390[i].offset);
-	  emitcode ("movx", "@%s,a", r->name);
-	}
+        {
+          emitcode ("inc", "%s", r->name);
+          emitcode ("mov", "a,(%s+%d)",
+                    regs390[i].base, 8 * bank + regs390[i].offset);
+          emitcode ("movx", "@%s,a", r->name);
+        }
       else
-	emitcode ("push", "(%s+%d)",
-		  regs390[i].base, 8 * bank + regs390[i].offset);
+        emitcode ("push", "(%s+%d)",
+                  regs390[i].base, 8 * bank + regs390[i].offset);
     }
 
   if (pushPsw)
     {
       if (options.useXstack)
-	{
-	  emitcode ("mov", "a,psw");
-	  emitcode ("movx", "@%s,a", r->name);
-	  emitcode ("inc", "%s", r->name);
-	  emitcode ("mov", "_spx,%s", r->name);
-	}
+        {
+          emitcode ("mov", "a,psw");
+          emitcode ("movx", "@%s,a", r->name);
+          emitcode ("inc", "%s", r->name);
+          emitcode ("mov", "_spx,%s", r->name);
+        }
       else
       {
-	emitcode ("push", "psw");
+        emitcode ("push", "psw");
       }
 
       emitcode ("mov", "psw,#!constbyte", (bank << 3) & 0x00ff);
     }
-  
+
   if (aop)
   {
-       freeAsmop (NULL, aop, ic, TRUE);
-  }    
-    
+    freeAsmop (NULL, aop, ic, TRUE);
+  }
+
   if (ic)
-  {  
-      ic->bankSaved = 1;
+  {
+    ic->bankSaved = 1;
   }
 }
 
 /*-----------------------------------------------------------------*/
-/* genSend - gen code for SEND	                                   */
+/* genSend - gen code for SEND                                     */
 /*-----------------------------------------------------------------*/
 static void genSend(set *sendSet)
 {
@@ -2499,43 +2565,43 @@ static void genSend(set *sendSet)
     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++;
+         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++;
     }
 }
 
@@ -2545,9 +2611,9 @@ adjustEsp(const char *reg)
     emitcode ("anl","%s,#3", reg);
     if (TARGET_IS_DS400)
     {
-	emitcode ("orl","%s,#!constbyte",
-		  reg,
-		  (options.stack_loc >> 8) & 0xff);
+        emitcode ("orl","%s,#!constbyte",
+                  reg,
+                  (options.stack_loc >> 8) & 0xff);
     }
 }
 
@@ -2571,22 +2637,22 @@ genCall (iCode * ic)
       (FUNC_REGBANK (currFunc->type) != FUNC_REGBANK (dtype)) &&
       IFFUNC_ISISR (currFunc->type))
   {
-      if (!ic->bankSaved) 
+      if (!ic->bankSaved)
       {
            /* This is unexpected; the bank should have been saved in
             * genFunction.
             */
-    	   saveRBank (FUNC_REGBANK (dtype), ic, FALSE);
-    	   restoreBank = TRUE;
+           saveRBank (FUNC_REGBANK (dtype), ic, FALSE);
+           restoreBank = TRUE;
       }
       swapBanks = TRUE;
   }
-  
+
     /* if caller saves & we have not saved then */
     if (!ic->regsSaved)
       saveRegisters (ic);
-  
-  /* if send set is not empty the assign */
+
+  /* if send set is not empty then assign */
   /* We've saved all the registers we care about;
   * therefore, we may clobber any register not used
   * in the calling convention (i.e. anything not in
@@ -2594,69 +2660,76 @@ genCall (iCode * ic)
   */
   if (_G.sendSet)
     {
-	if (IFFUNC_ISREENT(dtype)) { /* need to reverse the send set */
-	    genSend(reverseSet(_G.sendSet));
-	} else {
-	    genSend(_G.sendSet);
-	}
+        if (IFFUNC_ISREENT(dtype)) { /* need to reverse the send set */
+            genSend(reverseSet(_G.sendSet));
+        } else {
+            genSend(_G.sendSet);
+        }
       _G.sendSet = NULL;
-    }  
-    
+    }
+
   if (swapBanks)
   {
-        emitcode ("mov", "psw,#!constbyte", 
+        emitcode ("mov", "psw,#!constbyte",
            ((FUNC_REGBANK(dtype)) << 3) & 0xff);
   }
 
   /* make the call */
   emitcode ("lcall", "%s", (OP_SYMBOL (IC_LEFT (ic))->rname[0] ?
-			    OP_SYMBOL (IC_LEFT (ic))->rname :
-			    OP_SYMBOL (IC_LEFT (ic))->name));
+                            OP_SYMBOL (IC_LEFT (ic))->rname :
+                            OP_SYMBOL (IC_LEFT (ic))->name));
 
   if (swapBanks)
   {
-       emitcode ("mov", "psw,#!constbyte", 
+       emitcode ("mov", "psw,#!constbyte",
           ((FUNC_REGBANK(currFunc->type)) << 3) & 0xff);
   }
 
   /* if we need assign a result value */
   if ((IS_ITEMP (IC_RESULT (ic)) &&
        (OP_SYMBOL (IC_RESULT (ic))->nRegs ||
-	OP_SYMBOL (IC_RESULT (ic))->accuse ||
-	OP_SYMBOL (IC_RESULT (ic))->spildir)) ||
+        OP_SYMBOL (IC_RESULT (ic))->accuse ||
+        OP_SYMBOL (IC_RESULT (ic))->spildir)) ||
       IS_TRUE_SYMOP (IC_RESULT (ic)))
     {
       if (isOperandInFarSpace (IC_RESULT (ic))
-	  && getSize (operandType (IC_RESULT (ic))) <= 2)
-	{
-	  int size = getSize (operandType (IC_RESULT (ic)));
-
-	  /* Special case for 1 or 2 byte return in far space. */
-	  MOVA (fReturn[0]);
-	  if (size > 1)
-	    {
-	      emitcode ("mov", "b,%s", fReturn[1]);
-	    }
-
-	  aopOp (IC_RESULT (ic), ic, FALSE, FALSE);
-	  aopPut (AOP (IC_RESULT (ic)), "a", 0);
-
-	  if (size > 1)
-	    {
-	      aopPut (AOP (IC_RESULT (ic)), "b", 1);
-	    }
-	  freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
-	}
+          && getSize (operandType (IC_RESULT (ic))) <= 2)
+        {
+          int size = getSize (operandType (IC_RESULT (ic)));
+
+          /* Special case for 1 or 2 byte return in far space. */
+          MOVA (fReturn[0]);
+          if (size > 1)
+            {
+              emitcode ("mov", "b,%s", fReturn[1]);
+              _G.bInUse++;
+            }
+
+          _G.accInUse++;
+          aopOp (IC_RESULT (ic), ic, FALSE, FALSE);
+          _G.accInUse--;
+
+          if (size > 1)
+            _G.bInUse--;
+
+          aopPut (AOP (IC_RESULT (ic)), "a", 0);
+
+          if (size > 1)
+            {
+              aopPut (AOP (IC_RESULT (ic)), "b", 1);
+            }
+          freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+        }
       else
-	{
-	  _G.accInUse++;
-	  aopOp (IC_RESULT (ic), ic, FALSE, TRUE);
-	  _G.accInUse--;
+        {
+          _G.bInUse++;
+          aopOp (IC_RESULT (ic), ic, FALSE, TRUE);
+          _G.bInUse--;
 
-	  assignResultValue (IC_RESULT (ic));
+          assignResultValue (IC_RESULT (ic));
 
-	  freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
-	}
+          freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+        }
     }
 
   /* adjust the stack for parameters if
@@ -2664,31 +2737,31 @@ genCall (iCode * ic)
   if (ic->parmBytes) {
       int i;
       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;
-	  }
+          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 (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);
       }
   }
 
@@ -2752,8 +2825,8 @@ genPcall (iCode * ic)
   /* if send set is not empty the assign */
   if (_G.sendSet)
     {
-	genSend(reverseSet(_G.sendSet));
-	_G.sendSet = NULL;
+        genSend(reverseSet(_G.sendSet));
+        _G.sendSet = NULL;
     }
 
   emitcode ("ret", "");
@@ -2763,7 +2836,7 @@ genPcall (iCode * ic)
   /* if we need assign a result value */
   if ((IS_ITEMP (IC_RESULT (ic)) &&
        (OP_SYMBOL (IC_RESULT (ic))->nRegs ||
-	OP_SYMBOL (IC_RESULT (ic))->spildir)) ||
+        OP_SYMBOL (IC_RESULT (ic))->spildir)) ||
       IS_TRUE_SYMOP (IC_RESULT (ic)))
     {
 
@@ -2782,39 +2855,39 @@ genPcall (iCode * ic)
     {
       int i;
       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;
-	  }
+          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 (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);
-  
+
   /* if we hade saved some registers then
      unsave them */
   if (ic->regsSaved)
@@ -2835,7 +2908,7 @@ resultRemat (iCode * ic)
     {
       symbol *sym = OP_SYMBOL (IC_RESULT (ic));
       if (sym->remat && !POINTER_SET (ic))
-	return 1;
+        return 1;
     }
 
   return 0;
@@ -2894,12 +2967,9 @@ genFunction (iCode * ic)
       emitcode(";", "naked function: no prologue.");
       return;
   }
-  
-  if (options.stack_probe) 
+
+  if (options.stack_probe)
       emitcode ("lcall","__stack_probe");
-  /* if critical function then turn interrupts off */
-  if (IFFUNC_ISCRITICAL (ftype))
-    emitcode ("clr", "ea");
 
   /* here we need to generate the equates for the
      register bank if required */
@@ -2909,19 +2979,19 @@ genFunction (iCode * ic)
 
       rbank = FUNC_REGBANK (ftype);
       for (i = 0; i < ds390_nRegs; i++)
-	{
-	  if (regs390[i].print) {
-	      if (strcmp (regs390[i].base, "0") == 0)
-		  emitcode ("", "%s !equ !constbyte",
-			    regs390[i].dname,
-			    8 * rbank + regs390[i].offset);
-	      else
-		  emitcode ("", "%s !equ %s + !constbyte",
-			    regs390[i].dname,
-			    regs390[i].base,
-			    8 * rbank + regs390[i].offset);
-	  }
-	}
+        {
+          if (regs390[i].print) {
+              if (strcmp (regs390[i].base, "0") == 0)
+                  emitcode ("", "%s !equ !constbyte",
+                            regs390[i].dname,
+                            8 * rbank + regs390[i].offset);
+              else
+                  emitcode ("", "%s !equ %s + !constbyte",
+                            regs390[i].dname,
+                            regs390[i].base,
+                            8 * rbank + regs390[i].offset);
+          }
+        }
     }
 
   /* if this is an interrupt service routine then
@@ -2929,181 +2999,178 @@ genFunction (iCode * ic)
   if (IFFUNC_ISISR (sym->type))
       { /* is ISR */
       if (!inExcludeList ("acc"))
-	emitcode ("push", "acc");
+        emitcode ("push", "acc");
       if (!inExcludeList ("b"))
-	emitcode ("push", "b");
+        emitcode ("push", "b");
       if (!inExcludeList ("dpl"))
-	emitcode ("push", "dpl");
+        emitcode ("push", "dpl");
       if (!inExcludeList ("dph"))
-	emitcode ("push", "dph");
+        emitcode ("push", "dph");
       if (options.model == MODEL_FLAT24 && !inExcludeList ("dpx"))
-	{
-	  emitcode ("push", "dpx");
-	  /* Make sure we're using standard DPTR */
-	  emitcode ("push", "dps");
-	  emitcode ("mov", "dps,#0");
-	  if (options.stack10bit)
-	    {
-	      /* This ISR could conceivably use DPTR2. Better save it. */
-	      emitcode ("push", "dpl1");
-	      emitcode ("push", "dph1");
-	      emitcode ("push", "dpx1");
-	      emitcode ("push",  DP2_RESULT_REG);
-	    }
-	}
+        {
+          emitcode ("push", "dpx");
+          /* Make sure we're using standard DPTR */
+          emitcode ("push", "dps");
+          emitcode ("mov", "dps,#0");
+          if (options.stack10bit)
+            {
+              /* This ISR could conceivably use DPTR2. Better save it. */
+              emitcode ("push", "dpl1");
+              emitcode ("push", "dph1");
+              emitcode ("push", "dpx1");
+              emitcode ("push",  DP2_RESULT_REG);
+            }
+        }
       /* if this isr has no bank i.e. is going to
          run with bank 0 , then we need to save more
          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))
-	    {
-
-	      /* if any registers used */
-	      if (sym->regsUsed)
-		{
-		  /* save the registers used */
-		  for (i = 0; i < sym->regsUsed->size; i++)
-		    {
-		      if (bitVectBitValue (sym->regsUsed, i) ||
-			  (ds390_ptrRegReq && (i == R0_IDX || i == R1_IDX)))
-			emitcode ("push", "%s", ds390_regWithIdx (i)->dname);
-		    }
-		}
-
-	    }
-	  else
-	    {
-	      /* this function has  a function call cannot
-	         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
-	{
-	    /* This ISR uses a non-zero bank.
-	     *
-	     * We assume that the bank is available for our
-	     * exclusive use.
-	     *
-	     * However, if this ISR calls a function which uses some
-	     * other bank, we must save that bank entirely.
-	     */
-	    unsigned long banksToSave = 0;
-	    
-	    if (IFFUNC_HASFCALL(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))
+            {
+
+              /* if any registers used */
+              if (sym->regsUsed)
+                {
+                  /* save the registers used */
+                  for (i = 0; i < sym->regsUsed->size; i++)
+                    {
+                      if (bitVectBitValue (sym->regsUsed, i))
+                        emitcode ("push", "%s", ds390_regWithIdx (i)->dname);
+                    }
+                }
+            }
+          else
+            {
+              /* this function has  a function call cannot
+                 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
+        {
+            /* This ISR uses a non-zero bank.
+             *
+             * We assume that the bank is available for our
+             * exclusive use.
+             *
+             * However, if this ISR calls a function which uses some
+             * other bank, we must save that bank entirely.
+             */
+            unsigned long banksToSave = 0;
+
+            if (IFFUNC_HASFCALL(sym->type))
+            {
 
 #define MAX_REGISTER_BANKS 4
 
-	        iCode *i;
-	        int ix;
-
-	        for (i = ic; i; i = i->next)
-	        {
-	            if (i->op == ENDFUNCTION)
-	            {
-	                /* we got to the end OK. */
-	                break;
-	            }
-	            
-	            if (i->op == CALL)
-	            {
-	                sym_link *dtype;
-	                
-	                dtype = operandType (IC_LEFT(i));
-	                if (dtype 
-	                 && FUNC_REGBANK(dtype) != FUNC_REGBANK(sym->type))
-	                {
-	                     /* Mark this bank for saving. */
-	                     if (FUNC_REGBANK(dtype) >= MAX_REGISTER_BANKS)
-	                     {
-	                         werror(E_NO_SUCH_BANK, FUNC_REGBANK(dtype));
-	                     }
-	                     else
-	                     {
-	                         banksToSave |= (1 << FUNC_REGBANK(dtype));
-	                     }
-	                     
-	                     /* And note that we don't need to do it in 
-	                      * genCall.
-	                      */
-	                     i->bankSaved = 1;
-	                }
-	            }
-	            if (i->op == PCALL)
-	            {
-	             	/* This is a mess; we have no idea what
-	             	 * register bank the called function might
-	             	 * use.
-	             	 *
-	             	 * The only thing I can think of to do is
-	             	 * throw a warning and hope.
-	             	 */
-	             	werror(W_FUNCPTR_IN_USING_ISR);   
-	            }
-	        }
-
-		if (banksToSave && options.useXstack)
-		{
-		    /* Since we aren't passing it an ic, 
-		     * saveRBank will assume r0 is available to abuse.
-		     *
-		     * So switch to our (trashable) bank now, so
-		     * the caller's R0 isn't trashed.
-		     */
-		    emitcode ("push", "psw");
-		    emitcode ("mov", "psw,#!constbyte", 
-		    	      (FUNC_REGBANK (sym->type) << 3) & 0x00ff);
-		    switchedPSW = TRUE;
-		}
-		
-	        for (ix = 0; ix < MAX_REGISTER_BANKS; ix++)
-	        {
-	             if (banksToSave & (1 << ix))
-	             {
-	                 saveRBank(ix, NULL, FALSE);
-	             }
-	        }
-	    }
-	    // TODO: this needs a closer look
-	    SPEC_ISR_SAVED_BANKS(currFunc->etype) = banksToSave;
-	}
+                iCode *i;
+                int ix;
+
+                for (i = ic; i; i = i->next)
+                {
+                    if (i->op == ENDFUNCTION)
+                    {
+                        /* we got to the end OK. */
+                        break;
+                    }
+
+                    if (i->op == CALL)
+                    {
+                        sym_link *dtype;
+
+                        dtype = operandType (IC_LEFT(i));
+                        if (dtype
+                         && FUNC_REGBANK(dtype) != FUNC_REGBANK(sym->type))
+                        {
+                             /* Mark this bank for saving. */
+                             if (FUNC_REGBANK(dtype) >= MAX_REGISTER_BANKS)
+                             {
+                                 werror(E_NO_SUCH_BANK, FUNC_REGBANK(dtype));
+                             }
+                             else
+                             {
+                                 banksToSave |= (1 << FUNC_REGBANK(dtype));
+                             }
+
+                             /* And note that we don't need to do it in
+                              * genCall.
+                              */
+                             i->bankSaved = 1;
+                        }
+                    }
+                    if (i->op == PCALL)
+                    {
+                        /* This is a mess; we have no idea what
+                         * register bank the called function might
+                         * use.
+                         *
+                         * The only thing I can think of to do is
+                         * throw a warning and hope.
+                         */
+                        werror(W_FUNCPTR_IN_USING_ISR);
+                    }
+                }
+
+                if (banksToSave && options.useXstack)
+                {
+                    /* Since we aren't passing it an ic,
+                     * saveRBank will assume r0 is available to abuse.
+                     *
+                     * So switch to our (trashable) bank now, so
+                     * the caller's R0 isn't trashed.
+                     */
+                    emitcode ("push", "psw");
+                    emitcode ("mov", "psw,#!constbyte",
+                              (FUNC_REGBANK (sym->type) << 3) & 0x00ff);
+                    switchedPSW = TRUE;
+                }
+
+                for (ix = 0; ix < MAX_REGISTER_BANKS; ix++)
+                {
+                     if (banksToSave & (1 << ix))
+                     {
+                         saveRBank(ix, NULL, FALSE);
+                     }
+                }
+            }
+            // TODO: this needs a closer look
+            SPEC_ISR_SAVED_BANKS(currFunc->etype) = banksToSave;
+        }
     }
   else
     {
       /* if callee-save to be used for this function
          then save the registers being used in this function */
       if (IFFUNC_CALLEESAVES(sym->type))
-	{
-	  int i;
-
-	  /* if any registers used */
-	  if (sym->regsUsed)
-	    {
-	      /* save the registers used */
-	      for (i = 0; i < sym->regsUsed->size; i++)
-		{
-		  if (bitVectBitValue (sym->regsUsed, i) ||
-		      (ds390_ptrRegReq && (i == R0_IDX || i == R1_IDX)))
-		    {
-		      emitcode ("push", "%s", ds390_regWithIdx (i)->dname);
-		      _G.nRegsSaved++;
-		    }
-		}
-	    }
-	}
+        {
+          int i;
+
+          /* if any registers used */
+          if (sym->regsUsed)
+            {
+              /* save the registers used */
+              for (i = 0; i < sym->regsUsed->size; i++)
+                {
+                  if (bitVectBitValue (sym->regsUsed, i))
+                    {
+                      emitcode ("push", "%s", ds390_regWithIdx (i)->dname);
+                      _G.nRegsSaved++;
+                    }
+                }
+            }
+        }
     }
 
   /* set the register bank to the desired value */
@@ -3117,22 +3184,22 @@ genFunction (iCode * ic)
   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");
-	  adjustEsp("_bpx+1");
+          emitcode ("push","_bpx");
+          emitcode ("push","_bpx+1");
+          emitcode ("mov","_bpx,%s",spname);
+          emitcode ("mov","_bpx+1,esp");
+          adjustEsp("_bpx+1");
       } else {
-	  if (options.useXstack) {
-	      emitcode ("mov", "r0,%s", spname);
-	      emitcode ("mov", "a,_bp");
-	      emitcode ("movx", "@r0,a");
-	      emitcode ("inc", "%s", spname);
-	  } else {
-	      /* set up the stack */
-	      emitcode ("push", "_bp");	/* save the callers stack  */
-	  }
-	  emitcode ("mov", "_bp,%s", spname);
+          if (options.useXstack) {
+              emitcode ("mov", "r0,%s", spname);
+              emitcode ("mov", "a,_bp");
+              emitcode ("movx", "@r0,a");
+              emitcode ("inc", "%s", spname);
+          } else {
+              /* set up the stack */
+              emitcode ("push", "_bp"); /* save the callers stack  */
+          }
+          emitcode ("mov", "_bp,%s", spname);
       }
   }
 
@@ -3140,34 +3207,34 @@ genFunction (iCode * ic)
   if (sym->stack) {
       int i = sym->stack;
       if (options.stack10bit) {
-	  if ( i > 1024) werror (W_STACK_OVERFLOW, sym->name);	  
-	  assert (sym->recvSize <= 4);
-	  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;
-	  }
+          if ( i > 1024) werror (W_STACK_OVERFLOW, sym->name);
+          assert (sym->recvSize <= 4);
+          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);
-	  
-	  if (i > 3 && sym->recvSize < 4) {
-	      
-	      emitcode ("mov", "a,sp");
-	      emitcode ("add", "a,#!constbyte", ((char) sym->stack & 0xff));
-	      emitcode ("mov", "sp,a");
-	      
-	  } else
-	      while (i--)
-		  emitcode ("inc", "sp");
+          if (i > 256)
+              werror (W_STACK_OVERFLOW, sym->name);
+
+          if (i > 3 && sym->recvSize < 4) {
+
+              emitcode ("mov", "a,sp");
+              emitcode ("add", "a,#!constbyte", ((char) sym->stack & 0xff));
+              emitcode ("mov", "sp,a");
+
+          } else
+              while (i--)
+                  emitcode ("inc", "sp");
       }
   }
 
@@ -3179,6 +3246,17 @@ genFunction (iCode * ic)
       emitcode ("mov", "_spx,a");
     }
 
+  /* if critical function then turn interrupts off */
+  if (IFFUNC_ISCRITICAL (ftype))
+    {
+      symbol *tlbl = newiTempLabel (NULL);
+      emitcode ("setb", "c");
+      emitcode ("jbc", "ea,%05d$", (tlbl->key + 100)); /* atomic test & clear */
+      emitcode ("clr", "c");
+      emitcode ("", "%05d$:", (tlbl->key + 100));
+      emitcode ("push", "psw"); /* save old ea via c in psw */
+    }
+
 }
 
 /*-----------------------------------------------------------------*/
@@ -3188,25 +3266,38 @@ static void
 genEndFunction (iCode * ic)
 {
   symbol *sym = OP_SYMBOL (IC_LEFT (ic));
+  lineNode *lnp = lineCurr;
+  bitVect *regsUsed;
+  bitVect *regsUsedPrologue;
+  bitVect *regsUnneeded;
+  int idx;
 
   D (emitcode (";", "genEndFunction "););
 
   if (IFFUNC_ISNAKED(sym->type))
   {
       emitcode(";", "naked function: no epilogue.");
+      if (options.debug && currFunc)
+        debugFile->writeEndFunction (currFunc, ic, 0);
       return;
   }
 
+  if (IFFUNC_ISCRITICAL (sym->type))
+    {
+      emitcode ("pop", "psw"); /* restore ea via c in psw */
+      emitcode ("mov", "ea,c");
+    }
+
   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;
+          PROTECT_SP;
+          emitcode ("mov", "sp,_bpx", spname);
+          emitcode ("mov", "esp,_bpx+1", spname);
+          UNPROTECT_SP;
       } else {
-	  emitcode ("mov", "%s,_bp", spname);
+          emitcode ("mov", "%s,_bp", spname);
       }
   }
 
@@ -3224,17 +3315,17 @@ genEndFunction (iCode * ic)
        (sym->stack || FUNC_HASSTACKPARM(sym->type))) {
 
       if (options.useXstack) {
-	  emitcode ("mov", "r0,%s", spname);
-	  emitcode ("movx", "a,@r0");
-	  emitcode ("mov", "_bp,a");
-	  emitcode ("dec", "%s", spname);
+          emitcode ("mov", "r0,%s", spname);
+          emitcode ("movx", "a,@r0");
+          emitcode ("mov", "_bp,a");
+          emitcode ("dec", "%s", spname);
       } else {
-	  if (options.stack10bit) {
-	      emitcode ("pop", "_bpx+1");
-	      emitcode ("pop", "_bpx");
-	  } else {
-	      emitcode ("pop", "_bp");
-	  }
+          if (options.stack10bit) {
+              emitcode ("pop", "_bpx+1");
+              emitcode ("pop", "_bpx");
+          } else {
+              emitcode ("pop", "_bp");
+          }
       }
   }
 
@@ -3249,156 +3340,235 @@ genEndFunction (iCode * ic)
          */
         emitcode ("pop", "psw");
     }
-  } 
+  }
 
   if (IFFUNC_ISISR (sym->type))
-      { /* is ISR */  
+      { /* is ISR */
 
       /* now we need to restore the registers */
       /* if this isr has no bank i.e. is going to
          run with bank 0 , then we need to save more
          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))
-	    {
-
-	      /* if any registers used */
-	      if (sym->regsUsed)
-		{
-		  /* save the registers used */
-		  for (i = sym->regsUsed->size; i >= 0; i--)
-		    {
-		      if (bitVectBitValue (sym->regsUsed, i) ||
-			  (ds390_ptrRegReq && (i == R0_IDX || i == R1_IDX)))
-			emitcode ("pop", "%s", ds390_regWithIdx (i)->dname);
-		    }
-		}
-
-	    }
-	  else
-	    {
-	      /* 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);
-	    }
-	}
-	else
-	{
-	    /* This ISR uses a non-zero bank.
-	     *
-	     * Restore any register banks saved by genFunction
-	     * in reverse order.
-	     */
-	    unsigned savedBanks = SPEC_ISR_SAVED_BANKS(currFunc->etype);
-	    int ix;
-	  
-	    for (ix = MAX_REGISTER_BANKS - 1; ix >= 0; ix--)
-	    {
-	        if (savedBanks & (1 << ix))
-	        {
-	            unsaveRBank(ix, NULL, FALSE);
-	        }
-	    }
-	    
-	    if (options.useXstack)
-	    {
-	    	/* Restore bank AFTER calling unsaveRBank,
-	     	 * since it can trash r0.
-	     	 */
-	    	emitcode ("pop", "psw");
-	    }
-	}
+        {
+            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))
+            {
+
+              /* if any registers used */
+              if (sym->regsUsed)
+                {
+                  /* save the registers used */
+                  for (i = sym->regsUsed->size; i >= 0; i--)
+                    {
+                      if (bitVectBitValue (sym->regsUsed, i))
+                        emitcode ("pop", "%s", ds390_regWithIdx (i)->dname);
+                    }
+                }
+            }
+          else
+            {
+              /* 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);
+            }
+        }
+        else
+        {
+            /* This ISR uses a non-zero bank.
+             *
+             * Restore any register banks saved by genFunction
+             * in reverse order.
+             */
+            unsigned savedBanks = SPEC_ISR_SAVED_BANKS(currFunc->etype);
+            int ix;
+
+            for (ix = MAX_REGISTER_BANKS - 1; ix >= 0; ix--)
+            {
+                if (savedBanks & (1 << ix))
+                {
+                    unsaveRBank(ix, NULL, FALSE);
+                }
+            }
+
+            if (options.useXstack)
+            {
+                /* Restore bank AFTER calling unsaveRBank,
+                 * since it can trash r0.
+                 */
+                emitcode ("pop", "psw");
+            }
+        }
 
       if (options.model == MODEL_FLAT24 && !inExcludeList ("dpx"))
-	{
-	  if (options.stack10bit)
-	    {
-	      emitcode ("pop", DP2_RESULT_REG);
-	      emitcode ("pop", "dpx1");
-	      emitcode ("pop", "dph1");
-	      emitcode ("pop", "dpl1");
-	    }
-	  emitcode ("pop", "dps");
-	  emitcode ("pop", "dpx");
-	}
+        {
+          if (options.stack10bit)
+            {
+              emitcode ("pop", DP2_RESULT_REG);
+              emitcode ("pop", "dpx1");
+              emitcode ("pop", "dph1");
+              emitcode ("pop", "dpl1");
+            }
+          emitcode ("pop", "dps");
+          emitcode ("pop", "dpx");
+        }
       if (!inExcludeList ("dph"))
-	emitcode ("pop", "dph");
+        emitcode ("pop", "dph");
       if (!inExcludeList ("dpl"))
-	emitcode ("pop", "dpl");
+        emitcode ("pop", "dpl");
       if (!inExcludeList ("b"))
-	emitcode ("pop", "b");
+        emitcode ("pop", "b");
       if (!inExcludeList ("acc"))
-	emitcode ("pop", "acc");
-
-      if (IFFUNC_ISCRITICAL (sym->type))
-	emitcode ("setb", "ea");
+        emitcode ("pop", "acc");
 
       /* if debug then send end of function */
       if (options.debug && currFunc) {
-	  _G.debugLine = 1;
-	  emitcode ("", "C$%s$%d$%d$%d ==.",
-		    FileBaseName (ic->filename), currFunc->lastLine,
-		    ic->level, ic->block);
-	  if (IS_STATIC (currFunc->etype))
-	    emitcode ("", "XF%s$%s$0$0 ==.", moduleName, currFunc->name);
-	  else
-	    emitcode ("", "XG$%s$0$0 ==.", currFunc->name);
-	  _G.debugLine = 0;
-	}
+          debugFile->writeEndFunction (currFunc, ic, 1);
+        }
 
       emitcode ("reti", "");
     }
   else
     {
-      if (IFFUNC_ISCRITICAL (sym->type))
-	emitcode ("setb", "ea");
-
       if (IFFUNC_CALLEESAVES(sym->type))
-	{
-	  int i;
-
-	  /* if any registers used */
-	  if (sym->regsUsed)
-	    {
-	      /* save the registers used */
-	      for (i = sym->regsUsed->size; i >= 0; i--)
-		{
-		  if (bitVectBitValue (sym->regsUsed, i) ||
-		      (ds390_ptrRegReq && (i == R0_IDX || i == R1_IDX)))
-		    emitcode ("pop", "%s", ds390_regWithIdx (i)->dname);
-		}
-	    }
-
-	}
+        {
+          int i;
+
+          /* if any registers used */
+          if (sym->regsUsed)
+            {
+              /* save the registers used */
+              for (i = sym->regsUsed->size; i >= 0; i--)
+                {
+                  if (bitVectBitValue (sym->regsUsed, i))
+                    emitcode ("pop", "%s", ds390_regWithIdx (i)->dname);
+                }
+            }
+        }
 
       /* if debug then send end of function */
       if (options.debug && currFunc)
-	{
-	  _G.debugLine = 1;
-	  emitcode ("", "C$%s$%d$%d$%d ==.",
-		    FileBaseName (ic->filename), currFunc->lastLine,
-		    ic->level, ic->block);
-	  if (IS_STATIC (currFunc->etype))
-	    emitcode ("", "XF%s$%s$0$0 ==.", moduleName, currFunc->name);
-	  else
-	    emitcode ("", "XG$%s$0$0 ==.", currFunc->name);
-	  _G.debugLine = 0;
-	}
+        {
+          debugFile->writeEndFunction (currFunc, ic, 1);
+        }
 
       emitcode ("ret", "");
     }
 
+  if (!port->peep.getRegsRead || !port->peep.getRegsWritten || options.nopeep)
+    return;
+
+  /* If this was an interrupt handler using bank 0 that called another */
+  /* function, then all registers must be saved; nothing to optimized. */
+  if (IFFUNC_ISISR (sym->type) && IFFUNC_HASFCALL(sym->type)
+      && !FUNC_REGBANK(sym->type))
+    return;
+
+  /* There are no push/pops to optimize if not callee-saves or ISR */
+  if (!(FUNC_CALLEESAVES (sym->type) || FUNC_ISISR (sym->type)))
+    return;
+
+  /* If there were stack parameters, we cannot optimize without also    */
+  /* fixing all of the stack offsets; this is too dificult to consider. */
+  if (FUNC_HASSTACKPARM(sym->type))
+    return;
+
+  /* Compute the registers actually used */
+  regsUsed = newBitVect (ds390_nRegs);
+  regsUsedPrologue = newBitVect (ds390_nRegs);
+  while (lnp)
+    {
+      if (lnp->ic && lnp->ic->op == FUNCTION)
+        regsUsedPrologue = bitVectUnion (regsUsedPrologue, port->peep.getRegsWritten(lnp));
+      else
+        regsUsed = bitVectUnion (regsUsed, port->peep.getRegsWritten(lnp));
+
+      if (lnp->ic && lnp->ic->op == FUNCTION && lnp->prev
+          && lnp->prev->ic && lnp->prev->ic->op == ENDFUNCTION)
+        break;
+      if (!lnp->prev)
+        break;
+      lnp = lnp->prev;
+    }
+
+  if (bitVectBitValue (regsUsedPrologue, DPS_IDX)
+      && !bitVectBitValue (regsUsed, DPS_IDX))
+    {
+      bitVectUnSetBit (regsUsedPrologue, DPS_IDX);
+    }
+
+  if (bitVectBitValue (regsUsedPrologue, CND_IDX)
+      && !bitVectBitValue (regsUsed, CND_IDX))
+    {
+      regsUsed = bitVectUnion (regsUsed, regsUsedPrologue);
+      if (IFFUNC_ISISR (sym->type) && !FUNC_REGBANK (sym->type)
+          && !sym->stack && !FUNC_ISCRITICAL (sym->type))
+        bitVectUnSetBit (regsUsed, CND_IDX);
+    }
+  else
+    regsUsed = bitVectUnion (regsUsed, regsUsedPrologue);
+
+  /* If this was an interrupt handler that called another function */
+  /* function, then assume working registers may be modified by it. */
+  if (IFFUNC_ISISR (sym->type) && IFFUNC_HASFCALL(sym->type))
+    {
+      regsUsed = bitVectSetBit (regsUsed, AP_IDX);
+      regsUsed = bitVectSetBit (regsUsed, DPX1_IDX);
+      regsUsed = bitVectSetBit (regsUsed, DPL1_IDX);
+      regsUsed = bitVectSetBit (regsUsed, DPH1_IDX);
+      regsUsed = bitVectSetBit (regsUsed, DPX_IDX);
+      regsUsed = bitVectSetBit (regsUsed, DPL_IDX);
+      regsUsed = bitVectSetBit (regsUsed, DPH_IDX);
+      regsUsed = bitVectSetBit (regsUsed, DPS_IDX);
+      regsUsed = bitVectSetBit (regsUsed, B_IDX);
+      regsUsed = bitVectSetBit (regsUsed, A_IDX);
+      regsUsed = bitVectSetBit (regsUsed, CND_IDX);
+    }
+
+  /* Remove the unneeded push/pops */
+  regsUnneeded = newBitVect (ds390_nRegs);
+  while (lnp)
+    {
+      if (lnp->ic && (lnp->ic->op == FUNCTION || lnp->ic->op == ENDFUNCTION))
+        {
+          if (!strncmp(lnp->line, "push", 4))
+            {
+              idx = bitVectFirstBit (port->peep.getRegsRead(lnp));
+              if (idx>=0 && !bitVectBitValue (regsUsed, idx))
+                {
+                  connectLine (lnp->prev, lnp->next);
+                  regsUnneeded = bitVectSetBit (regsUnneeded, idx);
+                }
+            }
+          if (!strncmp(lnp->line, "pop", 3) || !strncmp(lnp->line, "mov", 3))
+            {
+              idx = bitVectFirstBit (port->peep.getRegsWritten(lnp));
+              if (idx>=0 && !bitVectBitValue (regsUsed, idx))
+                {
+                  connectLine (lnp->prev, lnp->next);
+                  regsUnneeded = bitVectSetBit (regsUnneeded, idx);
+                }
+            }
+        }
+      lnp = lnp->next;
+    }
+
+  for (idx = 0; idx < regsUnneeded->size; idx++)
+    if (bitVectBitValue (regsUnneeded, idx))
+      emitcode ("", ";\teliminated unneeded push/pop %s", ds390_regWithIdx (idx)->dname);
+
+  freeBitVect (regsUnneeded);
+  freeBitVect (regsUsed);
+  freeBitVect (regsUsedPrologue);
 }
 
 /*-----------------------------------------------------------------*/
@@ -3408,29 +3578,29 @@ static void genJavaNativeRet(iCode *ic)
 {
     int i, size;
 
-    aopOp (IC_LEFT (ic), ic, FALSE, 
-	   AOP_IS_STR(IC_LEFT(ic)) ? FALSE :TRUE);
+    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]);
-	}
+        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 = 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]);
+            emitcode ("mov","%s,#0",javaRet[i]);
     return;
 }
 
@@ -3449,7 +3619,7 @@ genRet (iCode * ic)
   if (!IC_LEFT (ic))
     goto jumpret;
 
-  /* if this is a JavaNative function then return 
+  /* if this is a JavaNative function then return
      value in different register */
   if (IFFUNC_ISJAVANATIVE(currFunc->type)) {
       genJavaNativeRet(ic);
@@ -3457,8 +3627,8 @@ genRet (iCode * ic)
   }
   /* we have something to return then
      move the return value into place */
-  aopOp (IC_LEFT (ic), ic, FALSE, 
-	 (AOP_IS_STR(IC_LEFT(ic)) ? FALSE :TRUE));
+  aopOp (IC_LEFT (ic), ic, FALSE,
+         (AOP_IS_STR(IC_LEFT(ic)) ? FALSE :TRUE));
   size = AOP_SIZE (IC_LEFT (ic));
 
   _startLazyDPSEvaluation ();
@@ -3466,35 +3636,35 @@ genRet (iCode * ic)
     {
       char *l;
       if (AOP_TYPE (IC_LEFT (ic)) == AOP_DPTR)
-	{
-	  l = aopGet (AOP (IC_LEFT (ic)), offset++,
-		      FALSE, TRUE, NULL);
-	  emitcode ("push", "%s", l);
-	  pushed++;
-	}
+        {
+          l = aopGet (AOP (IC_LEFT (ic)), offset++,
+                      FALSE, TRUE, NULL);
+          emitcode ("push", "%s", l);
+          pushed++;
+        }
       else
-	{
-	  /* Since A is the last element of fReturn,
-	   * is is OK to clobber it in the aopGet.
-	   */
-	  l = aopGet (AOP (IC_LEFT (ic)), offset,
-		      FALSE, FALSE, NULL);
-	  if (strcmp (fReturn[offset], l))
-	    emitcode ("mov", "%s,%s", fReturn[offset++], l);
-	}
+        {
+          /* Since A is the last element of fReturn,
+           * is is OK to clobber it in the aopGet.
+           */
+          l = aopGet (AOP (IC_LEFT (ic)), offset,
+                      FALSE, FALSE, NULL);
+          if (strcmp (fReturn[offset], l))
+            emitcode ("mov", "%s,%s", fReturn[offset++], l);
+        }
     }
   _endLazyDPSEvaluation ();
 
   if (pushed)
     {
       while (pushed)
-	{
-	  pushed--;
-	  if (strcmp (fReturn[pushed], "a"))
-	    emitcode ("pop", fReturn[pushed]);
-	  else
-	    emitcode ("pop", "acc");
-	}
+        {
+          pushed--;
+          if (strcmp (fReturn[pushed], "a"))
+            emitcode ("pop", fReturn[pushed]);
+          else
+            emitcode ("pop", "acc");
+        }
     }
   freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
 
@@ -3502,7 +3672,7 @@ jumpret:
   /* generate a jump to the return label
      if the next is not the return statement */
   if (!(ic->next && ic->next->op == LABEL &&
-	IC_LABEL (ic->next) == returnLabel))
+        IC_LABEL (ic->next) == returnLabel))
 
     emitcode ("ljmp", "!tlabel", (returnLabel->key + 100));
 
@@ -3552,17 +3722,17 @@ findLabelBackwards (iCode * ic, int key)
       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 */
+         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;
+        return 0;
       }
 
       if (ic->op == LABEL && IC_LABEL (ic)->key == key)
-	{
-	  /* printf("findLabelBackwards = %d\n", count); */
-	  return count;
-	}
+        {
+          /* printf("findLabelBackwards = %d\n", count); */
+          return count;
+        }
     }
 
   return 0;
@@ -3591,7 +3761,7 @@ genPlusIncr (iCode * ic)
   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));
+          emitcode("inc","%s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE,NULL));
       }
       return TRUE;
   }
@@ -3613,94 +3783,99 @@ genPlusIncr (iCode * ic)
        * jumps straight to that target.
        */
       if (ic->next && ic->next->op == GOTO
-	  && (labelRange = findLabelBackwards (ic, IC_LABEL (ic->next)->key)) != 0
-	  && labelRange <= 5)
-	{
-	  D(emitcode (";", "tail increment optimized (range %d)", labelRange););
-	  tlbl = IC_LABEL (ic->next);
-	  emitTlbl = 0;
-	}
+          && (labelRange = findLabelBackwards (ic, IC_LABEL (ic->next)->key)) != 0
+          && labelRange <= 5)
+        {
+          D(emitcode (";", "tail increment optimized (range %d)", labelRange););
+          tlbl = IC_LABEL (ic->next);
+          emitTlbl = 0;
+        }
       else
-	{
-	  tlbl = newiTempLabel (NULL);
-	  emitTlbl = 1;
-	}
-	
+        {
+          tlbl = newiTempLabel (NULL);
+          emitTlbl = 1;
+        }
+
       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,#0,!tlabel", l, tlbl->key + 100);
-      }
+          IS_AOP_PREG (IC_RESULT (ic)))
+        {
+          emitcode ("cjne", "%s,#0,!tlabel", l, tlbl->key + 100);
+        }
       else
-      {
-	  emitcode ("clr", "a");
-	  emitcode ("cjne", "a,%s,!tlabel", l, tlbl->key + 100);
-      }
+        {
+          emitcode ("clr", "a");
+          emitcode ("cjne", "a,%s,!tlabel", l, tlbl->key + 100);
+        }
 
-      l = aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE, NULL); 
+      l = aopGet (AOP (IC_RESULT (ic)), MSB16, FALSE, FALSE, NULL);
       emitcode ("inc", "%s", l);
       if (size > 2)
-	{
-	    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);
-	    }
-
-	    l = aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE, NULL);
-	    emitcode ("inc", "%s", l);
-	}
+        {
+          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);
+            }
+
+          l = aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE, NULL);
+          emitcode ("inc", "%s", l);
+        }
       if (size > 3)
-	{
-	    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);
-	    }
-
-	    l = aopGet (AOP (IC_RESULT (ic)), MSB32, FALSE, FALSE, NULL);
-	    emitcode ("inc", "%s", l);	}
+        {
+          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);
+            }
 
-      if (emitTlbl)
-	{
-	  emitcode ("", "!tlabeldef", tlbl->key + 100);
-	}
+          l = aopGet (AOP (IC_RESULT (ic)), MSB32, FALSE, FALSE, NULL);
+          emitcode ("inc", "%s", l);
+        }
+
+      if (emitTlbl)
+        {
+          emitcode ("", "!tlabeldef", tlbl->key + 100);
+        }
       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 ) {
-
+      !AOP_USESDPTR(IC_LEFT(ic)) && icount <= 5 && size <= 3 &&
+      options.model == MODEL_FLAT24 )
+    {
+      if (IC_RESULT(ic)->isGptr)
+        {
+          emitcode ("mov","b,%s",aopGet(AOP (IC_LEFT (ic)), 3, FALSE, FALSE, NULL));
+        }
       switch (size) {
       case 3:
-	  emitcode ("mov","dpx,%s",aopGet(AOP (IC_LEFT (ic)), 2, FALSE, FALSE, NULL));
+          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));
+          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;
+          emitcode ("mov","dpl,%s",aopGet(AOP (IC_LEFT (ic)), 0, FALSE, FALSE, NULL));
+          break;
       }
-      while (icount--) emitcode ("inc","dptr");      
+      while (icount--) emitcode ("inc","dptr");
       return TRUE;
   }
 
@@ -3728,21 +3903,21 @@ genPlusIncr (iCode * ic)
     {
 
       if (icount > 3)
-	{
-	  MOVA (aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE, NULL));
-	  emitcode ("add", "a,#!constbyte", ((char) icount) & 0xff);
-	  aopPut (AOP (IC_RESULT (ic)), "a", 0);
-	}
+        {
+          MOVA (aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE, NULL));
+          emitcode ("add", "a,#!constbyte", ((char) icount) & 0xff);
+          aopPut (AOP (IC_RESULT (ic)), "a", 0);
+        }
       else
-	{
+        {
 
-	  _startLazyDPSEvaluation ();
-	  while (icount--)
-	    {
-	      emitcode ("inc", "%s", aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE, NULL));
-	    }
-	  _endLazyDPSEvaluation ();
-	}
+          _startLazyDPSEvaluation ();
+          while (icount--)
+            {
+              emitcode ("inc", "%s", aopGet (AOP (IC_LEFT (ic)), 0, FALSE, FALSE, NULL));
+            }
+          _endLazyDPSEvaluation ();
+        }
 
       return TRUE;
     }
@@ -3778,7 +3953,7 @@ static void
 genPlusBits (iCode * ic)
 {
   D (emitcode (";", "genPlusBits "););
-    
+
   if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY)
     {
       symbol *lbl = newiTempLabel (NULL);
@@ -3807,8 +3982,8 @@ 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, NULL),
-	      GPTRSIZE - 1);
+              aopGet (AOP (IC_LEFT (ic)), GPTRSIZE - 1, FALSE, FALSE, NULL),
+              GPTRSIZE - 1);
     }
 
   if (opIsGptr (IC_RESULT (ic)) &&
@@ -3816,8 +3991,8 @@ 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, NULL),
-	      GPTRSIZE - 1);
+            aopGet (AOP (IC_RIGHT (ic)), GPTRSIZE - 1, FALSE, FALSE, NULL),
+              GPTRSIZE - 1);
     }
 
   if (opIsGptr (IC_RESULT (ic)) &&
@@ -3827,8 +4002,8 @@ adjustArithmeticResult (iCode * ic)
       !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_RIGHT (ic))))
     {
       char buff[5];
-      SNPRINTF (buff, sizeof(buff), 
-		"#%d", pointerCode (getSpec (operandType (IC_LEFT (ic)))));
+      SNPRINTF (buff, sizeof(buff),
+                "#%d", pointerTypeToGPByte (pointerCode (getSpec (operandType (IC_LEFT (ic)))), NULL, NULL));
       aopPut (AOP (IC_RESULT (ic)), buff, GPTRSIZE - 1);
     }
 }
@@ -3840,94 +4015,112 @@ 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");
+//             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");
+//             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;
+        useDp2 = TRUE;
     }
     else
     {
-	useDp2 = FALSE;
+        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;
+        useDp2 = TRUE;
     }
     else if (AOP_USESDPTR2(IC_RIGHT(ic)))
     {
-	useDp2 = FALSE;
+        useDp2 = FALSE;
     }
     else
     {
-	if (AOP_IS_STR(IC_RESULT(ic)) && !AOP_IS_STR(IC_LEFT(ic)))
-	{
-	    useDp2 = TRUE;
-	}
-	else
-	{
-	    useDp2 = FALSE;
-	}
+        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'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;
-    }
-    
+    if (isOperandEqual(IC_LEFT(ic),IC_RESULT(ic)))
+      {
+        aopOp (IC_RESULT (ic), ic, TRUE, AOP_USESDPTR2 (IC_LEFT (ic)));
+        return TRUE;
+      }
+    if (isOperandEqual(IC_RIGHT(ic),IC_RESULT(ic)))
+      {
+//      D(emitcode(";", "aopOp3: (left | right) & result equal"););
+        aopOp(IC_RESULT(ic),ic,TRUE, AOP_USESDPTR2 (IC_RIGHT (ic)));
+        return TRUE;
+      }
+
+    // Operands may be equivalent (but not equal) if they share a spill location. If
+    // so, use the same DPTR or DPTR2.
+    if (operandsEqu (IC_LEFT(ic), IC_RESULT(ic)))
+      {
+        aopOp (IC_RESULT (ic), ic, TRUE, AOP_USESDPTR2 (IC_LEFT (ic)));
+        return TRUE;
+      }
+    if (operandsEqu (IC_RIGHT(ic), IC_RESULT(ic)))
+      {
+        aopOp (IC_RESULT (ic), ic, TRUE, AOP_USESDPTR2 (IC_RIGHT (ic)));
+        return TRUE;
+      }
+
     // 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 
+
+    // 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;
+        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;
+        return FALSE;
     }
-    
-    // or, if both dp1 & dp2 are in use and the result needs a dptr, we're out of luck    
+
+    // 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;
+        return FALSE;
     }
 
     aopOp (IC_RESULT(ic),ic,TRUE, dp1InUse);
@@ -3935,30 +4128,30 @@ bool aopOp3(iCode * ic)
     // 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.");
+        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.");
-    }    
-    
+        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, 
+// 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) \
-	    do { rc = !aopOp3(ic); } while (0)
+            do { rc = !aopOp3(ic); } while (0)
 
 // aopOp the left & right operands of an ic.
 #define AOP_OP_2(ic) \
@@ -3978,28 +4171,28 @@ bool aopOp3(iCode * ic)
 //
 // On exit from this macro, pushedSize will have been adjusted to
 // equal resultSize, and ACC may be trashed.
-#define ADJUST_PUSHED_RESULT(pushedSize, resultSize) 		\
-      /* If the pushed data is bigger than the result,		\
-       * simply discard unused bytes. Icky, but works.		\
-       */							\
-      while (pushedSize > resultSize)				\
-      {								\
-	  D (emitcode (";", "discarding unused result byte."););\
-	  emitcode ("pop", "acc");				\
-	  pushedSize--;						\
-      }								\
-      if (pushedSize < resultSize)				\
-      {								\
-	  emitcode ("clr", "a");				\
-	  /* Conversly, we haven't pushed enough here.		\
-	   * just zero-pad, and all is well.			\
-	   */							\
-	  while (pushedSize < resultSize)			\
-	  {							\
-	      emitcode("push", "acc");				\
-	      pushedSize++;					\
-	  }							\
-      }								\
+#define ADJUST_PUSHED_RESULT(pushedSize, resultSize)            \
+      /* If the pushed data is bigger than the result,          \
+       * simply discard unused bytes. Icky, but works.          \
+       */                                                       \
+      while (pushedSize > resultSize)                           \
+      {                                                         \
+          D (emitcode (";", "discarding unused result byte."););\
+          emitcode ("pop", "acc");                              \
+          pushedSize--;                                         \
+      }                                                         \
+      if (pushedSize < resultSize)                              \
+      {                                                         \
+          emitcode ("clr", "a");                                \
+          /* Conversly, we haven't pushed enough here.          \
+           * just zero-pad, and all is well.                    \
+           */                                                   \
+          while (pushedSize < resultSize)                       \
+          {                                                     \
+              emitcode("push", "acc");                          \
+              pushedSize++;                                     \
+          }                                                     \
+      }                                                         \
       assert(pushedSize == resultSize);
 
 /*-----------------------------------------------------------------*/
@@ -4020,31 +4213,31 @@ genPlus (iCode * ic)
       aopOp (IC_RIGHT (ic), ic, TRUE, FALSE);
       size = (int)floatFromVal (AOP (IC_RIGHT(ic))->aopu.aop_lit);
       if (size <= 9) {
-	  while (size--) emitcode ("inc","dptr");
+          while (size--) emitcode ("inc","dptr");
       } else {
-	  emitcode ("mov","a,dpl");
-	  emitcode ("add","a,#!constbyte",size & 0xff);
-	  emitcode ("mov","dpl,a");
-	  emitcode ("mov","a,dph");
-	  emitcode ("addc","a,#!constbyte",(size >> 8) & 0xff);
-	  emitcode ("mov","dph,a");
-	  emitcode ("mov","a,dpx");
-	  emitcode ("addc","a,#!constbyte",(size >> 16) & 0xff);
-	  emitcode ("mov","dpx,a");
+          emitcode ("mov","a,dpl");
+          emitcode ("add","a,#!constbyte",size & 0xff);
+          emitcode ("mov","dpl,a");
+          emitcode ("mov","a,dph");
+          emitcode ("addc","a,#!constbyte",(size >> 8) & 0xff);
+          emitcode ("mov","dph,a");
+          emitcode ("mov","a,dpx");
+          emitcode ("addc","a,#!constbyte",(size >> 16) & 0xff);
+          emitcode ("mov","dpx,a");
       }
       freeAsmop (IC_RIGHT (ic), NULL, ic, FALSE);
       return ;
   }
-  if ( IS_SYMOP(IC_LEFT(ic)) && 
+  if ( IS_SYMOP(IC_LEFT(ic)) &&
        OP_SYMBOL(IC_LEFT(ic))->remat &&
        isOperandInFarSpace(IC_RIGHT(ic))) {
       operand *op = IC_RIGHT(ic);
       IC_RIGHT(ic) = IC_LEFT(ic);
       IC_LEFT(ic) = op;
   }
-		
+
   AOP_OP_3_NOFATAL (ic, pushResult);
-    
+
   if (pushResult)
     {
       D (emitcode (";", "genPlus: must push result: 3 ops in far space"););
@@ -4057,57 +4250,57 @@ genPlus (iCode * ic)
          in ACC */
       if ((AOP_TYPE (IC_LEFT (ic)) == AOP_LIT)
        || ((AOP_NEEDSACC (IC_LEFT (ic))) && !(AOP_NEEDSACC (IC_RIGHT (ic))))
-	  || AOP_TYPE (IC_RIGHT (ic)) == AOP_ACC)
-	{
-	  operand *t = IC_RIGHT (ic);
-	  IC_RIGHT (ic) = IC_LEFT (ic);
-	  IC_LEFT (ic) = t;
-	  emitcode (";", "Swapped plus args.");
-	}
+          || AOP_TYPE (IC_RIGHT (ic)) == AOP_ACC)
+        {
+          operand *t = IC_RIGHT (ic);
+          IC_RIGHT (ic) = IC_LEFT (ic);
+          IC_LEFT (ic) = t;
+          emitcode (";", "Swapped plus args.");
+        }
 
       /* if both left & right are in bit
          space */
       if (AOP_TYPE (IC_LEFT (ic)) == AOP_CRY &&
-	  AOP_TYPE (IC_RIGHT (ic)) == AOP_CRY)
-	{
-	  genPlusBits (ic);
-	  goto release;
-	}
+          AOP_TYPE (IC_RIGHT (ic)) == AOP_CRY)
+        {
+          genPlusBits (ic);
+          goto release;
+        }
 
       /* if left in bit space & right literal */
       if (AOP_TYPE (IC_LEFT (ic)) == AOP_CRY &&
-	  AOP_TYPE (IC_RIGHT (ic)) == AOP_LIT)
-	{
-	  emitcode ("mov", "c,%s", AOP (IC_LEFT (ic))->aopu.aop_dir);
-	  /* if result in bit space */
-	  if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY)
-	    {
-	      if ((unsigned long) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit) != 0L)
-		emitcode ("cpl", "c");
-	      outBitC (IC_RESULT (ic));
-	    }
-	  else
-	    {
-	      size = getDataSize (IC_RESULT (ic));
-	      _startLazyDPSEvaluation ();
-	      while (size--)
-		{
-		  MOVA (aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, NULL));
-		  emitcode ("addc", "a,#0");
-		  aopPut (AOP (IC_RESULT (ic)), "a", offset++);
-		}
-	      _endLazyDPSEvaluation ();
-	    }
-	  goto release;
-	}
+          AOP_TYPE (IC_RIGHT (ic)) == AOP_LIT)
+        {
+          emitcode ("mov", "c,%s", AOP (IC_LEFT (ic))->aopu.aop_dir);
+          /* if result in bit space */
+          if (AOP_TYPE (IC_RESULT (ic)) == AOP_CRY)
+            {
+              if ((unsigned long) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit) != 0L)
+                emitcode ("cpl", "c");
+              outBitC (IC_RESULT (ic));
+            }
+          else
+            {
+              size = getDataSize (IC_RESULT (ic));
+              _startLazyDPSEvaluation ();
+              while (size--)
+                {
+                  MOVA (aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, NULL));
+                  emitcode ("addc", "a,#0");
+                  aopPut (AOP (IC_RESULT (ic)), "a", offset++);
+                }
+              _endLazyDPSEvaluation ();
+            }
+          goto release;
+        }
 
       /* if I can do an increment instead
          of add then GOOD for ME */
       if (genPlusIncr (ic) == TRUE)
-	{
-	  emitcode (";", "did genPlusIncr");
-	  goto release;
-	}
+        {
+          emitcode (";", "did genPlusIncr");
+          goto release;
+        }
 
     }
   size = getDataSize (pushResult ? IC_LEFT (ic) : IC_RESULT (ic));
@@ -4116,57 +4309,57 @@ genPlus (iCode * ic)
   while (size--)
     {
       if (AOP_TYPE(IC_LEFT(ic)) == AOP_ACC && !AOP_NEEDSACC(IC_RIGHT(ic)))
-	{
-	  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, NULL));
-	  else
-	    emitcode ("addc", "a,%s",
-		 aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, NULL));
-	}
+        {
+          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, NULL));
+          else
+            emitcode ("addc", "a,%s",
+                 aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, NULL));
+        }
       else
-	{
-	  if (AOP_TYPE(IC_LEFT(ic)) == AOP_ACC && (offset == 0))
-	  {
-	      /* right is going to use ACC or we would have taken the
-	       * above branch.
-	       */
-	      assert(AOP_NEEDSACC(IC_RIGHT(ic)));
+        {
+          if (AOP_TYPE(IC_LEFT(ic)) == AOP_ACC && (offset == 0))
+          {
+              /* right is going to use ACC or we would have taken the
+               * above branch.
+               */
+              assert(AOP_NEEDSACC(IC_RIGHT(ic)));
        TR_AP("#3");
-	      D(emitcode(";", "+ AOP_ACC special case."););
-	      emitcode("xch", "a, %s", DP2_RESULT_REG);
-	  }
-	  MOVA (aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, NULL));
-	  if (offset == 0)
-	  {
-	    if (AOP_TYPE(IC_LEFT(ic)) == AOP_ACC)
-	    {
+              D(emitcode(";", "+ AOP_ACC special case."););
+              emitcode("xch", "a, %s", DP2_RESULT_REG);
+          }
+          MOVA (aopGet (AOP (IC_RIGHT (ic)), offset, FALSE, FALSE, NULL));
+          if (offset == 0)
+          {
+            if (AOP_TYPE(IC_LEFT(ic)) == AOP_ACC)
+            {
          TR_AP("#4");
-	        emitcode("add", "a, %s", DP2_RESULT_REG); 
-	    }
-	    else
-	    {
-	    	emitcode ("add", "a,%s",
-			  aopGet (AOP(IC_LEFT(ic)), offset, FALSE, FALSE,
-				  DP2_RESULT_REG));
-	    }
+                emitcode("add", "a, %s", DP2_RESULT_REG);
+            }
+            else
+            {
+                emitcode ("add", "a,%s",
+                          aopGet (AOP(IC_LEFT(ic)), offset, FALSE, FALSE,
+                                  DP2_RESULT_REG));
+            }
+          }
+          else
+          {
+            emitcode ("addc", "a,%s",
+                  aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE,
+                          DP2_RESULT_REG));
           }
-	  else
-	  {
-	    emitcode ("addc", "a,%s",
-		  aopGet (AOP (IC_LEFT (ic)), offset, FALSE, FALSE,
-			  DP2_RESULT_REG));
-	  }
-	}
+        }
       if (!pushResult)
-	{
-	  aopPut (AOP (IC_RESULT (ic)), "a", offset);
-	}
+        {
+          aopPut (AOP (IC_RESULT (ic)), "a", offset);
+        }
       else
-	{
-	  emitcode ("push", "acc");
-	}
+        {
+          emitcode ("push", "acc");
+        }
       offset++;
     }
   _endLazyDPSEvaluation ();
@@ -4182,10 +4375,10 @@ genPlus (iCode * ic)
 
       _startLazyDPSEvaluation ();
       while (size--)
-	{
-	  emitcode ("pop", "acc");
-	  aopPut (AOP (IC_RESULT (ic)), "a", size);
-	}
+        {
+          emitcode ("pop", "acc");
+          aopPut (AOP (IC_RESULT (ic)), "a", size);
+        }
       _endLazyDPSEvaluation ();
     }
 
@@ -4220,7 +4413,7 @@ genMinusDec (iCode * ic)
   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));
+          emitcode("dec","%s",aopGet(AOP(IC_RESULT(ic)),0,FALSE,FALSE,NULL));
       }
       return TRUE;
   }
@@ -4241,79 +4434,79 @@ genMinusDec (iCode * ic)
          * jumps straight to that target.
        */
       if (ic->next && ic->next->op == GOTO
-	  && (labelRange = findLabelBackwards (ic, IC_LABEL (ic->next)->key)) != 0
-	  && labelRange <= 5)
-	{
-	  emitcode (";", "tail decrement optimized (range %d)", labelRange);
-	  tlbl = IC_LABEL (ic->next);
-	  emitTlbl = 0;
-	}
+          && (labelRange = findLabelBackwards (ic, IC_LABEL (ic->next)->key)) != 0
+          && labelRange <= 5)
+        {
+          emitcode (";", "tail decrement optimized (range %d)", labelRange);
+          tlbl = IC_LABEL (ic->next);
+          emitTlbl = 0;
+        }
       else
-	{
-	  tlbl = newiTempLabel (NULL);
-	  emitTlbl = 1;
-	}
+        {
+          tlbl = newiTempLabel (NULL);
+          emitTlbl = 1;
+        }
 
       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,#!constbyte,!tlabel", l, 0xff, tlbl->key + 100);
+          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);
+          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 (!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 ("mov", "a,#!constbyte",0xff);
-		emitcode ("cjne", "a,%s,!tlabel", l, tlbl->key + 100);
-	    }
-	    l = aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE, NULL);
-	    emitcode ("dec", "%s", l);
-	}
+        {
+            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 ("mov", "a,#!constbyte",0xff);
+                emitcode ("cjne", "a,%s,!tlabel", l, tlbl->key + 100);
+            }
+            l = aopGet (AOP (IC_RESULT (ic)), MSB24, FALSE, FALSE, NULL);
+            emitcode ("dec", "%s", l);
+        }
       if (size > 3)
-	{
-	    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 ("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 (!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 ("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);
-	}
+        {
+          emitcode ("", "!tlabeldef", tlbl->key + 100);
+        }
       return TRUE;
     }
 
@@ -4333,10 +4526,10 @@ genMinusDec (iCode * ic)
 
       _startLazyDPSEvaluation ();
       while (icount--)
-	{
-	  emitcode ("dec", "%s",
-		    aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE, NULL));
-	}
+        {
+          emitcode ("dec", "%s",
+                    aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE, NULL));
+        }
       _endLazyDPSEvaluation ();
 
       return TRUE;
@@ -4356,20 +4549,20 @@ addSign (operand * result, int offset, int sign)
     {
       _startLazyDPSEvaluation();
       if (sign)
-	{
-	  emitcode ("rlc", "a");
-	  emitcode ("subb", "a,acc");
-	  while (size--)
-	  {
-	    aopPut (AOP (result), "a", offset++);
-	  }
-	}
+        {
+          emitcode ("rlc", "a");
+          emitcode ("subb", "a,acc");
+          while (size--)
+          {
+            aopPut (AOP (result), "a", offset++);
+          }
+        }
       else
       {
-	while (size--)
-	{
-	  aopPut (AOP (result), zero, offset++);
-	}
+        while (size--)
+        {
+          aopPut (AOP (result), zero, offset++);
+        }
       }
       _endLazyDPSEvaluation();
     }
@@ -4418,23 +4611,23 @@ genMinus (iCode * ic)
 
     D (emitcode (";", "genMinus "););
 
-    AOP_OP_3_NOFATAL(ic, pushResult);	
+    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 &&
-	  AOP_TYPE (IC_RIGHT (ic)) == AOP_CRY)
-	{
-	  genMinusBits (ic);
-	  goto release;
-	}
+          AOP_TYPE (IC_RIGHT (ic)) == AOP_CRY)
+        {
+          genMinusBits (ic);
+          goto release;
+        }
 
       /* if I can do an decrement instead
          of subtract then GOOD for ME */
       if (genMinusDec (ic) == TRUE)
-	goto release;
+        goto release;
 
     }
 
@@ -4455,42 +4648,42 @@ genMinus (iCode * ic)
   _startLazyDPSEvaluation ();
   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));
-	  }
+          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));
-	      }
-	  } else {
-	      emitcode ("addc", "a,#!constbyte",
-			(unsigned int) ((lit >> (offset * 8)) & 0x0FFL));
-	  }
+          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));
+              }
+          } else {
+              emitcode ("addc", "a,#!constbyte",
+                        (unsigned int) ((lit >> (offset * 8)) & 0x0FFL));
+          }
       }
-      
+
       if (pushResult) {
-	  emitcode ("push", "acc");
+          emitcode ("push", "acc");
       } else {
-	  aopPut (AOP (IC_RESULT (ic)), "a", offset);
+          aopPut (AOP (IC_RESULT (ic)), "a", offset);
       }
       offset++;
   }
   _endLazyDPSEvaluation ();
-  
+
   if (pushResult)
     {
       aopOp (IC_RESULT (ic), ic, TRUE, FALSE);
@@ -4502,10 +4695,10 @@ genMinus (iCode * ic)
 
       _startLazyDPSEvaluation ();
       while (size--)
-	{
-	  emitcode ("pop", "acc");
-	  aopPut (AOP (IC_RESULT (ic)), "a", size);
-	}
+        {
+          emitcode ("pop", "acc");
+          aopPut (AOP (IC_RESULT (ic)), "a", size);
+        }
       _endLazyDPSEvaluation ();
     }
 
@@ -4523,9 +4716,9 @@ release:
 /*-----------------------------------------------------------------*/
 static void
 genMultbits (operand * left,
-	     operand * right,
-	     operand * result,
-	     iCode   * ic)
+             operand * right,
+             operand * result,
+             iCode   * ic)
 {
   emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
   emitcode ("anl", "c,%s", AOP (right)->aopu.aop_dir);
@@ -4539,12 +4732,14 @@ genMultbits (operand * left,
 /*-----------------------------------------------------------------*/
 static void
 genMultOneByte (operand * left,
-		operand * right,
-		operand * result,
-		iCode   * ic)
+                operand * right,
+                operand * result,
+                iCode   * ic)
 {
-  sym_link *opetype = operandType (result);
+  int size;
   symbol *lbl;
+  bool runtimeSign, compiletimeSign;
+  bool lUnsigned, rUnsigned;
 
 
   /* (if two literals: the value is computed before) */
@@ -4557,265 +4752,357 @@ genMultOneByte (operand * left,
       emitcode (";", "swapped left and right");
     }
 
-  if (SPEC_USIGN(opetype)
-      // ignore the sign of left and right, what else can we do?
-      || (SPEC_USIGN(operandType(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, NULL));
-    MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL));
-    emitcode ("mul", "ab");
-   
-    _G.accInUse++; _G.bInUse++;
-    aopOp(result, ic, TRUE, FALSE);
-      
-      if (AOP_SIZE(result)<1 || AOP_SIZE(result)>2) 
-      {
-	  // this should never happen
-	  fprintf (stderr, "size!=1||2 (%d) in %s at line:%d \n", 
-		   AOP_SIZE(result), __FILE__, lineno);
-	  exit (1);
-      }      
-      
-    aopPut (AOP (result), "a", 0);
-    _G.accInUse--; _G.bInUse--;
-    if (AOP_SIZE(result)==2) 
-    {
-      aopPut (AOP (result), "b", 1);
+  /* (if two literals: the value is computed before) */
+  /* if one literal, literal on the right */
+  if (AOP_TYPE (left) == AOP_LIT)
+    {
+      operand *t = right;
+      right = left;
+      left = t;
+      /* emitcode (";", "swapped left and right"); */
+    }
+  /* if no literal, unsigned on the right: shorter code */
+  if (   AOP_TYPE (right) != AOP_LIT
+      && SPEC_USIGN (getSpec (operandType (left))))
+    {
+      operand *t = right;
+      right = left;
+      left = t;
     }
-    return;
-  }
 
-  // we have to do a signed multiply
+  lUnsigned = SPEC_USIGN (getSpec (operandType (left)));
+  rUnsigned = SPEC_USIGN (getSpec (operandType (right)));
 
-  emitcode (";", "signed");
-  emitcode ("clr", "F0"); // reset sign flag
-  MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL));
+  if ((lUnsigned && rUnsigned)
+/* sorry, I don't know how to get size
+   without calling aopOp (result,...);
+   see Feature Request  */
+      /* || size == 1 */ ) /* no, this is not a bug; with a 1 byte result there's
+                   no need to take care about the signedness! */
+    {
+      /* just an unsigned 8 * 8 = 8 multiply
+         or 8u * 8u = 16u */
+      /* emitcode (";","unsigned"); */
+      emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE, NULL));
+      MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL));
+      emitcode ("mul", "ab");
 
-  lbl=newiTempLabel(NULL);
-  emitcode ("jnb", "acc.7,!tlabel",  lbl->key+100);
-  // left side is negative, 8-bit two's complement, this fails for -128
-  emitcode ("setb", "F0"); // set sign flag
-  emitcode ("cpl", "a");
-  emitcode ("inc", "a");
+      _G.accInUse++; _G.bInUse++;
+      aopOp (result, ic, TRUE, FALSE);
+      size = AOP_SIZE (result);
 
-  emitcode ("", "!tlabeldef", lbl->key+100);
+      if (size < 1 || size > 2)
+        {
+          /* this should never happen */
+          fprintf (stderr, "size!=1||2 (%d) in %s at line:%d \n",
+                   size, __FILE__, lineno);
+          exit (1);
+        }
 
-  /* if literal */
-  if (AOP_TYPE(right)==AOP_LIT) {
-    signed char val=(signed char)floatFromVal (AOP (right)->aopu.aop_lit);
-    /* AND literal negative */
-    if ((int) val < 0) {
-      emitcode ("cpl", "F0"); // complement sign flag
-      emitcode ("mov", "b,#!constbyte", -val);
-    } else {
-      emitcode ("mov", "b,#!constbyte", val);
+      aopPut (AOP (result), "a", 0);
+      _G.accInUse--; _G.bInUse--;
+      if (size == 2)
+        aopPut (AOP (result), "b", 1);
+      return;
     }
-  } else {
-    lbl=newiTempLabel(NULL);
-    emitcode ("mov", "b,a");
-    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
-    emitcode ("cpl", "a");
-    emitcode ("inc", "a");
-    emitcode ("", "!tlabeldef", lbl->key+100);
-  }
+
+  /* we have to do a signed multiply */
+  /* emitcode (";", "signed"); */
+
+  /* now sign adjust for both left & right */
+
+  /* let's see what's needed: */
+  /* apply negative sign during runtime */
+  runtimeSign = FALSE;
+  /* negative sign from literals */
+  compiletimeSign = FALSE;
+
+  if (!lUnsigned)
+    {
+      if (AOP_TYPE(left) == AOP_LIT)
+        {
+          /* signed literal */
+          signed char val = (char) floatFromVal (AOP (left)->aopu.aop_lit);
+          if (val < 0)
+            compiletimeSign = TRUE;
+        }
+      else
+        /* signed but not literal */
+        runtimeSign = TRUE;
+    }
+
+  if (!rUnsigned)
+    {
+      if (AOP_TYPE(right) == AOP_LIT)
+        {
+          /* signed literal */
+          signed char val = (char) floatFromVal (AOP (right)->aopu.aop_lit);
+          if (val < 0)
+            compiletimeSign ^= TRUE;
+        }
+      else
+        /* signed but not literal */
+        runtimeSign = TRUE;
+    }
+
+  /* initialize F0, which stores the runtime sign */
+  if (runtimeSign)
+    {
+      if (compiletimeSign)
+        emitcode ("setb", "F0"); /* set sign flag */
+      else
+        emitcode ("clr", "F0"); /* reset sign flag */
+    }
+
+  /* save the signs of the operands */
+  if (AOP_TYPE(right) == AOP_LIT)
+    {
+      signed char val = (char) floatFromVal (AOP (right)->aopu.aop_lit);
+
+      if (!rUnsigned && val < 0)
+        emitcode ("mov", "b,#!constbyte", -val);
+      else
+        emitcode ("mov", "b,#!constbyte", (unsigned char) val);
+    }
+  else /* ! literal */
+    {
+      if (rUnsigned)  /* emitcode (";", "signed"); */
+        emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE, NULL));
+      else
+        {
+          MOVA (aopGet (AOP (right), 0, FALSE, FALSE, NULL));
+          lbl = newiTempLabel (NULL);
+          emitcode ("jnb", "acc.7,!tlabel", lbl->key + 100);
+          emitcode ("cpl", "F0"); /* complement sign flag */
+          emitcode ("cpl", "a");  /* 2's complement */
+          emitcode ("inc", "a");
+          emitcode ("", "!tlabeldef", lbl->key + 100);
+          emitcode ("mov", "b,a");
+        }
+    }
+
+  if (AOP_TYPE(left) == AOP_LIT)
+    {
+      signed char val = (char) floatFromVal (AOP (left)->aopu.aop_lit);
+
+      if (!lUnsigned && val < 0)
+        emitcode ("mov", "a,#!constbyte", -val);
+      else
+        emitcode ("mov", "a,#!constbyte", (unsigned char) val);
+    }
+  else /* ! literal */
+    {
+      if (lUnsigned)  /* emitcode (";", "signed"); */
+
+        emitcode ("mov", "a,%s", aopGet (AOP (left), 0, FALSE, FALSE, NULL));
+      else
+        {
+          MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL));
+          lbl = newiTempLabel (NULL);
+          emitcode ("jnb", "acc.7,!tlabel", lbl->key + 100);
+          emitcode ("cpl", "F0"); /* complement sign flag */
+          emitcode ("cpl", "a");  /* 2's complement */
+          emitcode ("inc", "a");
+          emitcode ("", "!tlabeldef", lbl->key + 100);
+        }
+    }
+
+  /* now the multiplication */
   emitcode ("mul", "ab");
-    
   _G.accInUse++;_G.bInUse++;
   aopOp(result, ic, TRUE, FALSE);
-    
-  if (AOP_SIZE(result)<1 || AOP_SIZE(result)>2) 
-  {
-    // this should never happen
-      fprintf (stderr, "size!=1||2 (%d) in %s at line:%d \n", 
-	       AOP_SIZE(result), __FILE__, lineno);
+  size = AOP_SIZE (result);
+
+  if (size < 1 || size > 2)
+    {
+      /* this should never happen */
+      fprintf (stderr, "size!=1||2 (%d) in %s at line:%d \n",
+               size, __FILE__, lineno);
       exit (1);
-  }    
-    
-  lbl=newiTempLabel(NULL);
-  emitcode ("jnb", "F0,!tlabel", lbl->key+100);
-  // only ONE op was negative, we have to do a 8/16-bit two's complement
-  emitcode ("cpl", "a"); // lsb
-  if (AOP_SIZE(result)==1) {
-    emitcode ("inc", "a");
-  } else {
-    emitcode ("add", "a,#1");
-    emitcode ("xch", "a,b");
-    emitcode ("cpl", "a"); // msb
-    emitcode ("addc", "a,#0");
-    emitcode ("xch", "a,b");
-  }
+    }
 
-  emitcode ("", "!tlabeldef", lbl->key+100);
+  if (runtimeSign || compiletimeSign)
+    {
+      lbl = newiTempLabel (NULL);
+      if (runtimeSign)
+        emitcode ("jnb", "F0,!tlabel", lbl->key + 100);
+      emitcode ("cpl", "a"); /* lsb 2's complement */
+      if (size != 2)
+        emitcode ("inc", "a"); /* inc doesn't set carry flag */
+      else
+        {
+          emitcode ("add", "a,#1"); /* this sets carry flag */
+          emitcode ("xch", "a,b");
+          emitcode ("cpl", "a"); /* msb 2's complement */
+          emitcode ("addc", "a,#0");
+          emitcode ("xch", "a,b");
+        }
+      emitcode ("", "!tlabeldef", lbl->key + 100);
+    }
   aopPut (AOP (result), "a", 0);
   _G.accInUse--;_G.bInUse--;
-  if (AOP_SIZE(result)==2) {
+  if (size == 2)
     aopPut (AOP (result), "b", 1);
-  }
 }
 
 /*-----------------------------------------------------------------*/
 /* genMultTwoByte - use the DS390 MAC unit to do 16*16 multiply    */
 /*-----------------------------------------------------------------*/
-static void genMultTwoByte (operand *left, operand *right, 
-			    operand *result, iCode *ic)
-{
-	sym_link *retype = getSpec(operandType(right));
-	sym_link *letype = getSpec(operandType(left));
-	int umult = SPEC_USIGN(retype) | SPEC_USIGN(letype);
-	symbol *lbl;
-
-	if (AOP_TYPE (left) == AOP_LIT) {
-		operand *t = right;
-		right = left;
-		left = t;
-	}
-	/* save EA bit in F1 */
-	lbl = newiTempLabel(NULL);
-	emitcode ("setb","F1");
-	emitcode ("jbc","EA,!tlabel",lbl->key+100);
-	emitcode ("clr","F1");
-	emitcode("","!tlabeldef",lbl->key+100);
-
-	/* load up MB with right */
-	if (!umult) {
-		emitcode("clr","F0");
-		if (AOP_TYPE(right) == AOP_LIT) {
-			int val=(int)floatFromVal (AOP (right)->aopu.aop_lit);
-			if (val < 0) {
-				emitcode("setb","F0");
-				val = -val;
-			}
-			emitcode ("mov","mb,#!constbyte",val & 0xff);
-			emitcode ("mov","mb,#!constbyte",(val >> 8) & 0xff);		    
-		} else {
-			lbl = newiTempLabel(NULL);
-			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");
-			emitcode ("add", "a,#1");
-			emitcode ("xch", "a,b");
-			emitcode ("cpl", "a"); // msb
-			emitcode ("addc", "a,#0");
-			emitcode ("setb","F0");
-			emitcode ("","!tlabeldef",lbl->key+100);
-			emitcode ("mov","mb,b");
-			emitcode ("mov","mb,a");
-		}
-	} else {
-		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,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");
-		emitcode ("add", "a,#1");
-		emitcode ("xch", "a,b");
-		emitcode ("cpl", "a"); // msb
-		emitcode ("addc","a,#0");
-		emitcode ("jbc","F0,!tlabel",lbl->key+100);
-		emitcode ("setb","F0");
-		emitcode ("","!tlabeldef",lbl->key+100);
-		emitcode ("mov","ma,b");
-		emitcode ("mov","ma,a");
-	} else {
-		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,#!constbyte",0x80);
-	emitcode("jnz","!tlabel",lbl->key+100);
-	
-	freeAsmop (left, NULL, ic, TRUE);
-	freeAsmop (right, NULL, ic,TRUE);
-	aopOp(result, ic, TRUE, FALSE);
-
-	/* if unsigned then simple */	
-	if (umult) {
-		emitcode ("mov","a,ma");
-		if (AOP_SIZE(result) >= 4) aopPut(AOP(result),"a",3);
-		emitcode ("mov","a,ma");
-		if (AOP_SIZE(result) >= 3) aopPut(AOP(result),"a",2);
-		aopPut(AOP(result),"ma",1);
-		aopPut(AOP(result),"ma",0);
-	} else {
-		emitcode("push","ma");
-		emitcode("push","ma");
-		emitcode("push","ma");
-		MOVA("ma");
-		/* negate result if needed */
-		lbl = newiTempLabel(NULL); 	
-		emitcode("jnb","F0,!tlabel",lbl->key+100);
-		emitcode("cpl","a");
-		emitcode("add","a,#1");
-		emitcode("","!tlabeldef", lbl->key+100);
-	        if (AOP_TYPE(result) == AOP_ACC)
-	        {
-		    D(emitcode(";", "ACC special case."););
-		    /* We know result is the only live aop, and 
-		     * it's obviously not a DPTR2, so AP is available.
-		     */
-		    emitcode("mov", "%s,acc", DP2_RESULT_REG);
-	        }
-	        else
-	        {
-		    aopPut(AOP(result),"a",0);
-		}
-	    
-		emitcode("pop","acc");
-		lbl = newiTempLabel(NULL); 	
-		emitcode("jnb","F0,!tlabel",lbl->key+100);
-		emitcode("cpl","a");
-		emitcode("addc","a,#0");
-		emitcode("","!tlabeldef", lbl->key+100);
-		aopPut(AOP(result),"a",1);
-		emitcode("pop","acc");
-		if (AOP_SIZE(result) >= 3) {
-			lbl = newiTempLabel(NULL); 	
-			emitcode("jnb","F0,!tlabel",lbl->key+100);
-			emitcode("cpl","a");
-			emitcode("addc","a,#0");			
-			emitcode("","!tlabeldef", lbl->key+100);
-			aopPut(AOP(result),"a",2);
-		}
-		emitcode("pop","acc");
-		if (AOP_SIZE(result) >= 4) {
-			lbl = newiTempLabel(NULL); 	
-			emitcode("jnb","F0,!tlabel",lbl->key+100);
-			emitcode("cpl","a");
-			emitcode("addc","a,#0");			
-			emitcode("","!tlabeldef", lbl->key+100);
-			aopPut(AOP(result),"a",3);
-		}
-	        if (AOP_TYPE(result) == AOP_ACC)
-	        {
-		    /* We stashed the result away above. */
-		    emitcode("mov", "acc,%s", DP2_RESULT_REG);
-	        }	    
-		
-	}
-	freeAsmop (result, NULL, ic, TRUE);
-
-	/* restore EA bit in F1 */
-	lbl = newiTempLabel(NULL);
-	emitcode ("jnb","F1,!tlabel",lbl->key+100);
-	emitcode ("setb","EA");
-	emitcode("","!tlabeldef",lbl->key+100);
-	return ;
+static void genMultTwoByte (operand *left, operand *right,
+                            operand *result, iCode *ic)
+{
+        sym_link *retype = getSpec(operandType(right));
+        sym_link *letype = getSpec(operandType(left));
+        int umult = SPEC_USIGN(retype) | SPEC_USIGN(letype);
+        symbol *lbl;
+
+        if (AOP_TYPE (left) == AOP_LIT) {
+                operand *t = right;
+                right = left;
+                left = t;
+        }
+        /* save EA bit in F1 */
+        lbl = newiTempLabel(NULL);
+        emitcode ("setb","F1");
+        emitcode ("jbc","EA,!tlabel",lbl->key+100);
+        emitcode ("clr","F1");
+        emitcode("","!tlabeldef",lbl->key+100);
+
+        /* load up MB with right */
+        if (!umult) {
+                emitcode("clr","F0");
+                if (AOP_TYPE(right) == AOP_LIT) {
+                        int val=(int)floatFromVal (AOP (right)->aopu.aop_lit);
+                        if (val < 0) {
+                                emitcode("setb","F0");
+                                val = -val;
+                        }
+                        emitcode ("mov","mb,#!constbyte",val & 0xff);
+                        emitcode ("mov","mb,#!constbyte",(val >> 8) & 0xff);
+                } else {
+                        lbl = newiTempLabel(NULL);
+                        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");
+                        emitcode ("add", "a,#1");
+                        emitcode ("xch", "a,b");
+                        emitcode ("cpl", "a"); // msb
+                        emitcode ("addc", "a,#0");
+                        emitcode ("setb","F0");
+                        emitcode ("","!tlabeldef",lbl->key+100);
+                        emitcode ("mov","mb,b");
+                        emitcode ("mov","mb,a");
+                }
+        } else {
+                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,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");
+                emitcode ("add", "a,#1");
+                emitcode ("xch", "a,b");
+                emitcode ("cpl", "a"); // msb
+                emitcode ("addc","a,#0");
+                emitcode ("jbc","F0,!tlabel",lbl->key+100);
+                emitcode ("setb","F0");
+                emitcode ("","!tlabeldef",lbl->key+100);
+                emitcode ("mov","ma,b");
+                emitcode ("mov","ma,a");
+        } else {
+                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,#!constbyte",0x80);
+        emitcode("jnz","!tlabel",lbl->key+100);
+
+        freeAsmop (left, NULL, ic, TRUE);
+        freeAsmop (right, NULL, ic,TRUE);
+        aopOp(result, ic, TRUE, FALSE);
+
+        /* if unsigned then simple */
+        if (umult) {
+                emitcode ("mov","a,ma");
+                if (AOP_SIZE(result) >= 4) aopPut(AOP(result),"a",3);
+                emitcode ("mov","a,ma");
+                if (AOP_SIZE(result) >= 3) aopPut(AOP(result),"a",2);
+                aopPut(AOP(result),"ma",1);
+                aopPut(AOP(result),"ma",0);
+        } else {
+                emitcode("push","ma");
+                emitcode("push","ma");
+                emitcode("push","ma");
+                MOVA("ma");
+                /* negate result if needed */
+                lbl = newiTempLabel(NULL);
+                emitcode("jnb","F0,!tlabel",lbl->key+100);
+                emitcode("cpl","a");
+                emitcode("add","a,#1");
+                emitcode("","!tlabeldef", lbl->key+100);
+                if (AOP_TYPE(result) == AOP_ACC)
+                {
+                    D(emitcode(";", "ACC special case."););
+                    /* We know result is the only live aop, and
+                     * it's obviously not a DPTR2, so AP is available.
+                     */
+                    emitcode("mov", "%s,acc", DP2_RESULT_REG);
+                }
+                else
+                {
+                    aopPut(AOP(result),"a",0);
+                }
+
+                emitcode("pop","acc");
+                lbl = newiTempLabel(NULL);
+                emitcode("jnb","F0,!tlabel",lbl->key+100);
+                emitcode("cpl","a");
+                emitcode("addc","a,#0");
+                emitcode("","!tlabeldef", lbl->key+100);
+                aopPut(AOP(result),"a",1);
+                emitcode("pop","acc");
+                if (AOP_SIZE(result) >= 3) {
+                        lbl = newiTempLabel(NULL);
+                        emitcode("jnb","F0,!tlabel",lbl->key+100);
+                        emitcode("cpl","a");
+                        emitcode("addc","a,#0");
+                        emitcode("","!tlabeldef", lbl->key+100);
+                        aopPut(AOP(result),"a",2);
+                }
+                emitcode("pop","acc");
+                if (AOP_SIZE(result) >= 4) {
+                        lbl = newiTempLabel(NULL);
+                        emitcode("jnb","F0,!tlabel",lbl->key+100);
+                        emitcode("cpl","a");
+                        emitcode("addc","a,#0");
+                        emitcode("","!tlabeldef", lbl->key+100);
+                        aopPut(AOP(result),"a",3);
+                }
+                if (AOP_TYPE(result) == AOP_ACC)
+                {
+                    /* We stashed the result away above. */
+                    emitcode("mov", "acc,%s", DP2_RESULT_REG);
+                }
+
+        }
+        freeAsmop (result, NULL, ic, TRUE);
+
+        /* restore EA bit in F1 */
+        lbl = newiTempLabel(NULL);
+        emitcode ("jnb","F1,!tlabel",lbl->key+100);
+        emitcode ("setb","EA");
+        emitcode("","!tlabeldef",lbl->key+100);
+        return ;
 }
 
 /*-----------------------------------------------------------------*/
@@ -4851,9 +5138,9 @@ genMult (iCode * ic)
     }
 
   if (AOP_SIZE (left) == 2 && AOP_SIZE(right) == 2) {
-	  /* use the ds390 ARITHMETIC accel UNIT */
-	  genMultTwoByte (left, right, result, ic);
-	  return ;
+          /* use the ds390 ARITHMETIC accel UNIT */
+          genMultTwoByte (left, right, result, ic);
+          return ;
   }
   /* should have been converted to function call */
   assert (0);
@@ -4869,9 +5156,9 @@ release:
 /*-----------------------------------------------------------------*/
 static void
 genDivbits (operand * left,
-	    operand * right,
-	    operand * result,
-	    iCode   * ic)
+            operand * right,
+            operand * result,
+            iCode   * ic)
 {
 
   char *l;
@@ -4881,7 +5168,7 @@ genDivbits (operand * left,
   emitcode ("div", "ab");
   emitcode ("rrc", "a");
   aopOp(result, ic, TRUE, FALSE);
-    
+
   aopPut (AOP (result), "c", 0);
 }
 
@@ -4890,216 +5177,304 @@ genDivbits (operand * left,
 /*-----------------------------------------------------------------*/
 static void
 genDivOneByte (operand * left,
-	       operand * right,
-	       operand * result,
-	       iCode   * ic)
+               operand * right,
+               operand * result,
+               iCode   * ic)
 {
-  sym_link *opetype = operandType (result);
+  bool lUnsigned, rUnsigned;
+  bool runtimeSign, compiletimeSign;
   char *l;
   symbol *lbl;
   int size, offset;
 
   offset = 1;
+  lUnsigned = SPEC_USIGN (getSpec (operandType (left)));
+  rUnsigned = SPEC_USIGN (getSpec (operandType (right)));
+
   /* signed or unsigned */
-  if (SPEC_USIGN (opetype))
-    {
-	/* unsigned is easy */
-	LOAD_AB_FOR_DIV (left, right, l);
-	emitcode ("div", "ab");
-
-	_G.accInUse++;
-	aopOp(result, ic, TRUE, FALSE);
-	aopPut (AOP (result), "a", 0);
-	_G.accInUse--;
-
-	size = AOP_SIZE (result) - 1;
-	
-	while (size--)
-	{
-	    aopPut (AOP (result), zero, offset++);
-	}
+  if (lUnsigned && rUnsigned)
+    {
+      /* unsigned is easy */
+      LOAD_AB_FOR_DIV (left, right, l);
+      emitcode ("div", "ab");
+
+      _G.accInUse++;
+      aopOp (result, ic, TRUE, FALSE);
+      aopPut (AOP (result), "a", 0);
+      _G.accInUse--;
+
+      size = AOP_SIZE (result) - 1;
+
+      while (size--)
+        aopPut (AOP (result), zero, offset++);
       return;
     }
 
   /* signed is a little bit more difficult */
 
+  /* now sign adjust for both left & right */
+
+  /* let's see what's needed: */
+  /* apply negative sign during runtime */
+  runtimeSign = FALSE;
+  /* negative sign from literals */
+  compiletimeSign = FALSE;
+
+  if (!lUnsigned)
+    {
+      if (AOP_TYPE(left) == AOP_LIT)
+        {
+          /* signed literal */
+          signed char val = (char) floatFromVal (AOP (left)->aopu.aop_lit);
+          if (val < 0)
+            compiletimeSign = TRUE;
+        }
+      else
+        /* signed but not literal */
+        runtimeSign = TRUE;
+    }
+
+  if (!rUnsigned)
+    {
+      if (AOP_TYPE(right) == AOP_LIT)
+        {
+          /* signed literal */
+          signed char val = (char) floatFromVal (AOP (right)->aopu.aop_lit);
+          if (val < 0)
+            compiletimeSign ^= TRUE;
+        }
+      else
+        /* signed but not literal */
+        runtimeSign = TRUE;
+    }
+
+  /* initialize F0, which stores the runtime sign */
+  if (runtimeSign)
+    {
+      if (compiletimeSign)
+        emitcode ("setb", "F0"); /* set sign flag */
+      else
+        emitcode ("clr", "F0"); /* reset sign flag */
+    }
+
   /* save the signs of the operands */
-  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 */
+  if (AOP_TYPE(right) == AOP_LIT)
+    {
+      signed char val = (char) floatFromVal (AOP (right)->aopu.aop_lit);
 
-  /* now sign adjust for both left & right */
-  MOVA (aopGet (AOP (right), 0, FALSE, FALSE, NULL));
-  lbl = newiTempLabel (NULL);
-  emitcode ("jnb", "acc.7,!tlabel", (lbl->key + 100));
-  emitcode ("cpl", "a");
-  emitcode ("inc", "a");
-  emitcode ("", "!tlabeldef", (lbl->key + 100));
-  emitcode ("mov", "b,a");
+      if (!rUnsigned && val < 0)
+        emitcode ("mov", "b,#0x%02x", -val);
+      else
+        emitcode ("mov", "b,#0x%02x", (unsigned char) val);
+    }
+  else /* ! literal */
+    {
+      if (rUnsigned)
+        emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE, NULL));
+      else
+        {
+          MOVA (aopGet (AOP (right), 0, FALSE, FALSE, NULL));
+          lbl = newiTempLabel (NULL);
+          emitcode ("jnb", "acc.7,!tlabel", lbl->key + 100);
+          emitcode ("cpl", "F0"); /* complement sign flag */
+          emitcode ("cpl", "a");  /* 2's complement */
+          emitcode ("inc", "a");
+          emitcode ("", "!tlabeldef", lbl->key + 100);
+          emitcode ("mov", "b,a");
+        }
+    }
 
-  /* sign adjust left side */
-  MOVA( aopGet (AOP (left), 0, FALSE, FALSE, NULL));
+  if (AOP_TYPE(left) == AOP_LIT)
+    {
+      signed char val = (char) floatFromVal (AOP (left)->aopu.aop_lit);
 
-  lbl = newiTempLabel (NULL);
-  emitcode ("jnb", "acc.7,!tlabel", (lbl->key + 100));
-  emitcode ("cpl", "a");
-  emitcode ("inc", "a");
-  emitcode ("", "!tlabeldef", (lbl->key + 100));
+      if (!lUnsigned && val < 0)
+        emitcode ("mov", "a,#0x%02x", -val);
+      else
+        emitcode ("mov", "a,#0x%02x", (unsigned char) val);
+    }
+  else /* ! literal */
+    {
+      if (lUnsigned)
+        emitcode ("mov", "a,%s", aopGet (AOP (left), 0, FALSE, FALSE, NULL));
+      else
+        {
+          MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL));
+          lbl = newiTempLabel (NULL);
+          emitcode ("jnb", "acc.7,!tlabel", lbl->key + 100);
+          emitcode ("cpl", "F0"); /* complement sign flag */
+          emitcode ("cpl", "a");  /* 2's complement */
+          emitcode ("inc", "a");
+          emitcode ("", "!tlabeldef", lbl->key + 100);
+        }
+    }
 
   /* now the division */
   emitcode ("nop", "; workaround for DS80C390 div bug.");
   emitcode ("div", "ab");
-  /* we are interested in the lower order
-     only */
-  emitcode ("mov", "b,a");
-  lbl = newiTempLabel (NULL);
-  emitcode ("pop", "acc");
-  /* if there was an over flow we don't
-     adjust the sign of the result */
-  emitcode ("jb", "ov,!tlabel", (lbl->key + 100));
-  emitcode ("jnb", "acc.7,!tlabel", (lbl->key + 100));
-  CLRC;
-  emitcode ("clr", "a");
-  emitcode ("subb", "a,b");
-  emitcode ("mov", "b,a");
-  emitcode ("", "!tlabeldef", (lbl->key + 100));
-
-  /* now we are done */
-  _G.accInUse++;     _G.bInUse++;
-    aopOp(result, ic, TRUE, FALSE);
-    
-    aopPut (AOP (result), "b", 0);
-    
-    size = AOP_SIZE (result) - 1;
-    
-    if (size > 0)
-    {
-      emitcode ("mov", "c,b.7");
-      emitcode ("subb", "a,acc");
+
+  if (runtimeSign || compiletimeSign)
+    {
+      lbl = newiTempLabel (NULL);
+      if (runtimeSign)
+        emitcode ("jnb", "F0,!tlabel", lbl->key + 100);
+      emitcode ("cpl", "a"); /* lsb 2's complement */
+      emitcode ("inc", "a");
+      emitcode ("", "!tlabeldef", lbl->key + 100);
+
+      _G.accInUse++;     _G.bInUse++;
+      aopOp (result, ic, TRUE, FALSE);
+      size = AOP_SIZE (result) - 1;
+
+      if (size > 0)
+        {
+          /* 123 look strange, but if (OP_SYMBOL (op)->accuse == 1)
+             then the result will be in b, a */
+          emitcode ("mov", "b,a"); /* 1 */
+          /* msb is 0x00 or 0xff depending on the sign */
+          if (runtimeSign)
+            {
+              emitcode ("mov",  "c,F0");
+              emitcode ("subb", "a,acc");
+              emitcode ("xch",  "a,b"); /* 2 */
+              while (size--)
+                aopPut (AOP (result), "b", offset++); /* write msb's */
+            }
+          else /* compiletimeSign */
+            while (size--)
+              aopPut (AOP (result), "#0xff", offset++); /* write msb's */
+        }
+      aopPut (AOP (result), "a", 0); /* 3: write lsb */
     }
-    while (size--)
+  else
     {
-	aopPut (AOP (result), "a", offset++);
+      _G.accInUse++;     _G.bInUse++;
+      aopOp(result, ic, TRUE, FALSE);
+      size = AOP_SIZE (result) - 1;
+
+      aopPut (AOP (result), "a", 0);
+      while (size--)
+        aopPut (AOP (result), zero, offset++);
     }
-    _G.accInUse--;     _G.bInUse--;
+  _G.accInUse--;     _G.bInUse--;
 
 }
 
 /*-----------------------------------------------------------------*/
 /* genDivTwoByte - use the DS390 MAC unit to do 16/16 divide       */
 /*-----------------------------------------------------------------*/
-static void genDivTwoByte (operand *left, operand *right, 
-			    operand *result, iCode *ic)
-{
-	sym_link *retype = getSpec(operandType(right));
-	sym_link *letype = getSpec(operandType(left));
-	int umult = SPEC_USIGN(retype) | SPEC_USIGN(letype);
-	symbol *lbl;
-
-	/* save EA bit in F1 */
-	lbl = newiTempLabel(NULL);
-	emitcode ("setb","F1");
-	emitcode ("jbc","EA,!tlabel",lbl->key+100);
-	emitcode ("clr","F1");
-	emitcode("","!tlabeldef",lbl->key+100);
-
-	/* load up MA with left */
-	if (!umult) {
-		emitcode("clr","F0");
-		lbl = newiTempLabel(NULL);
-		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");
-		emitcode ("add", "a,#1");
-		emitcode ("xch", "a,b");
-		emitcode ("cpl", "a"); // msb
-		emitcode ("addc","a,#0");
-		emitcode ("setb","F0");
-		emitcode ("","!tlabeldef",lbl->key+100);
-		emitcode ("mov","ma,b");
-		emitcode ("mov","ma,a");
-	} else {
-		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 */
-	if (!umult) {
-		if (AOP_TYPE(right) == AOP_LIT) {
-			int val=(int)floatFromVal (AOP (right)->aopu.aop_lit);
-			if (val < 0) {
-				lbl = newiTempLabel(NULL);
-				emitcode ("jbc","F0,!tlabel",lbl->key+100);
-				emitcode("setb","F0");
-				emitcode ("","!tlabeldef",lbl->key+100);
-				val = -val;
-			} 
-			emitcode ("mov","mb,#!constbyte",val & 0xff);		    
-			emitcode ("mov","mb,#!constbyte",(val >> 8) & 0xff);
-		} else {
-			lbl = newiTempLabel(NULL);
-			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");
-			emitcode ("add", "a,#1");
-			emitcode ("xch", "a,b");
-			emitcode ("cpl", "a"); // msb
-			emitcode ("addc", "a,#0");
-			emitcode ("jbc","F0,!tlabel",lbl->key+100);
-			emitcode ("setb","F0");
-			emitcode ("","!tlabeldef",lbl->key+100);
-			emitcode ("mov","mb,b");
-			emitcode ("mov","mb,a");
-		}
-	} else {
-		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,#!constbyte",0x80);
-	emitcode("jnz","!tlabel",lbl->key+100);
-	
-	freeAsmop (left, NULL, ic, TRUE);
-	freeAsmop (right, NULL, ic,TRUE);
-	aopOp(result, ic, TRUE, FALSE);
-
-	/* if unsigned then simple */	
-	if (umult) {
-		aopPut(AOP(result),"ma",1);
-		aopPut(AOP(result),"ma",0);
-	} else {
-		emitcode("push","ma");
-		MOVA("ma");
-		/* negate result if needed */
-		lbl = newiTempLabel(NULL); 	
-		emitcode("jnb","F0,!tlabel",lbl->key+100);
-		emitcode("cpl","a");
-		emitcode("add","a,#1");
-		emitcode("","!tlabeldef", lbl->key+100);
-		aopPut(AOP(result),"a",0);
-		emitcode("pop","acc");
-		lbl = newiTempLabel(NULL); 	
-		emitcode("jnb","F0,!tlabel",lbl->key+100);
-		emitcode("cpl","a");
-		emitcode("addc","a,#0");
-		emitcode("","!tlabeldef", lbl->key+100);
-		aopPut(AOP(result),"a",1);
-	}
-	freeAsmop (result, NULL, ic, TRUE);
-	/* restore EA bit in F1 */
-	lbl = newiTempLabel(NULL);
-	emitcode ("jnb","F1,!tlabel",lbl->key+100);
-	emitcode ("setb","EA");
-	emitcode("","!tlabeldef",lbl->key+100);
-	return ;
+static void genDivTwoByte (operand *left, operand *right,
+                            operand *result, iCode *ic)
+{
+        sym_link *retype = getSpec(operandType(right));
+        sym_link *letype = getSpec(operandType(left));
+        int umult = SPEC_USIGN(retype) | SPEC_USIGN(letype);
+        symbol *lbl;
+
+        /* save EA bit in F1 */
+        lbl = newiTempLabel(NULL);
+        emitcode ("setb","F1");
+        emitcode ("jbc","EA,!tlabel",lbl->key+100);
+        emitcode ("clr","F1");
+        emitcode("","!tlabeldef",lbl->key+100);
+
+        /* load up MA with left */
+        if (!umult) {
+                emitcode("clr","F0");
+                lbl = newiTempLabel(NULL);
+                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");
+                emitcode ("add", "a,#1");
+                emitcode ("xch", "a,b");
+                emitcode ("cpl", "a"); // msb
+                emitcode ("addc","a,#0");
+                emitcode ("setb","F0");
+                emitcode ("","!tlabeldef",lbl->key+100);
+                emitcode ("mov","ma,b");
+                emitcode ("mov","ma,a");
+        } else {
+                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 */
+        if (!umult) {
+                if (AOP_TYPE(right) == AOP_LIT) {
+                        int val=(int)floatFromVal (AOP (right)->aopu.aop_lit);
+                        if (val < 0) {
+                                lbl = newiTempLabel(NULL);
+                                emitcode ("jbc","F0,!tlabel",lbl->key+100);
+                                emitcode("setb","F0");
+                                emitcode ("","!tlabeldef",lbl->key+100);
+                                val = -val;
+                        }
+                        emitcode ("mov","mb,#!constbyte",val & 0xff);
+                        emitcode ("mov","mb,#!constbyte",(val >> 8) & 0xff);
+                } else {
+                        lbl = newiTempLabel(NULL);
+                        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");
+                        emitcode ("add", "a,#1");
+                        emitcode ("xch", "a,b");
+                        emitcode ("cpl", "a"); // msb
+                        emitcode ("addc", "a,#0");
+                        emitcode ("jbc","F0,!tlabel",lbl->key+100);
+                        emitcode ("setb","F0");
+                        emitcode ("","!tlabeldef",lbl->key+100);
+                        emitcode ("mov","mb,b");
+                        emitcode ("mov","mb,a");
+                }
+        } else {
+                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,#!constbyte",0x80);
+        emitcode("jnz","!tlabel",lbl->key+100);
+
+        freeAsmop (left, NULL, ic, TRUE);
+        freeAsmop (right, NULL, ic,TRUE);
+        aopOp(result, ic, TRUE, FALSE);
+
+        /* if unsigned then simple */
+        if (umult) {
+                aopPut(AOP(result),"ma",1);
+                aopPut(AOP(result),"ma",0);
+        } else {
+                emitcode("push","ma");
+                MOVA("ma");
+                /* negate result if needed */
+                lbl = newiTempLabel(NULL);
+                emitcode("jnb","F0,!tlabel",lbl->key+100);
+                emitcode("cpl","a");
+                emitcode("add","a,#1");
+                emitcode("","!tlabeldef", lbl->key+100);
+                aopPut(AOP(result),"a",0);
+                emitcode("pop","acc");
+                lbl = newiTempLabel(NULL);
+                emitcode("jnb","F0,!tlabel",lbl->key+100);
+                emitcode("cpl","a");
+                emitcode("addc","a,#0");
+                emitcode("","!tlabeldef", lbl->key+100);
+                aopPut(AOP(result),"a",1);
+        }
+        freeAsmop (result, NULL, ic, TRUE);
+        /* restore EA bit in F1 */
+        lbl = newiTempLabel(NULL);
+        emitcode ("jnb","F1,!tlabel",lbl->key+100);
+        emitcode ("setb","EA");
+        emitcode("","!tlabeldef",lbl->key+100);
+        return ;
 }
 
 /*-----------------------------------------------------------------*/
@@ -5135,9 +5510,9 @@ genDiv (iCode * ic)
     }
 
   if (AOP_SIZE (left) == 2 && AOP_SIZE(right) == 2) {
-	  /* use the ds390 ARITHMETIC accel UNIT */
-	  genDivTwoByte (left, right, result, ic);
-	  return ;
+          /* use the ds390 ARITHMETIC accel UNIT */
+          genDivTwoByte (left, right, result, ic);
+          return ;
   }
   /* should have been converted to function call */
   assert (0);
@@ -5152,9 +5527,9 @@ release:
 /*-----------------------------------------------------------------*/
 static void
 genModbits (operand * left,
-	    operand * right,
-	    operand * result,
-	    iCode   * ic)
+            operand * right,
+            operand * result,
+            iCode   * ic)
 {
 
   char *l;
@@ -5173,165 +5548,241 @@ genModbits (operand * left,
 /*-----------------------------------------------------------------*/
 static void
 genModOneByte (operand * left,
-	       operand * right,
-	       operand * result,
-	       iCode   * ic)
+               operand * right,
+               operand * result,
+               iCode   * ic)
 {
-  sym_link *opetype = operandType (result);
+  bool lUnsigned, rUnsigned;
+  bool runtimeSign, compiletimeSign;
   char *l;
   symbol *lbl;
+  int size, offset;
+
+  offset = 1;
+  lUnsigned = SPEC_USIGN (getSpec (operandType (left)));
+  rUnsigned = SPEC_USIGN (getSpec (operandType (right)));
 
   /* signed or unsigned */
-  if (SPEC_USIGN (opetype))
+  if (lUnsigned && rUnsigned)
     {
       /* unsigned is easy */
       LOAD_AB_FOR_DIV (left, right, l);
       emitcode ("div", "ab");
-      aopOp(result, ic, TRUE, FALSE);	
+      aopOp (result, ic, TRUE, FALSE);
       aopPut (AOP (result), "b", 0);
+
+      for (size = AOP_SIZE (result) - 1; size--;)
+        aopPut (AOP (result), zero, offset++);
       return;
     }
 
   /* signed is a little bit more difficult */
 
-  /* save the signs of the operands */
-  MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL));
+  /* now sign adjust for both left & right */
 
-  emitcode ("xrl", "a,%s", aopGet (AOP (right), 0, FALSE, FALSE, FALSE));
-  emitcode ("push", "acc");	/* save it on the stack */
+  /* modulus: sign of the right operand has no influence on the result! */
+  if (AOP_TYPE(right) == AOP_LIT)
+    {
+      signed char val = (char) floatFromVal (AOP (right)->aopu.aop_lit);
 
-  /* now sign adjust for both left & right */
-  MOVA (aopGet (AOP (right), 0, FALSE, FALSE, NULL));
+      if (!rUnsigned && val < 0)
+        emitcode ("mov", "b,#0x%02x", -val);
+      else
+        emitcode ("mov", "b,#0x%02x", (unsigned char) val);
+    }
+  else /* ! literal */
+    {
+      if (rUnsigned)
+        emitcode ("mov", "b,%s", aopGet (AOP (right), 0, FALSE, FALSE, NULL));
+      else
+        {
+          MOVA (aopGet (AOP (right), 0, FALSE, FALSE, NULL));
+          lbl = newiTempLabel (NULL);
+          emitcode ("jnb", "acc.7,!tlabel", lbl->key + 100);
+          emitcode ("cpl", "a");  /* 2's complement */
+          emitcode ("inc", "a");
+          emitcode ("", "!tlabeldef", lbl->key + 100);
+          emitcode ("mov", "b,a");
+        }
+    }
 
-  lbl = newiTempLabel (NULL);
-  emitcode ("jnb", "acc.7,!tlabel", (lbl->key + 100));
-  emitcode ("cpl", "a");
-  emitcode ("inc", "a");
-  emitcode ("", "!tlabeldef", (lbl->key + 100));
-  emitcode ("mov", "b,a");
+  /* let's see what's needed: */
+  /* apply negative sign during runtime */
+  runtimeSign = FALSE;
+  /* negative sign from literals */
+  compiletimeSign = FALSE;
 
   /* sign adjust left side */
-  MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL));
+  if (AOP_TYPE(left) == AOP_LIT)
+    {
+      signed char val = (char) floatFromVal (AOP (left)->aopu.aop_lit);
 
-  lbl = newiTempLabel (NULL);
-  emitcode ("jnb", "acc.7,!tlabel", (lbl->key + 100));
-  emitcode ("cpl", "a");
-  emitcode ("inc", "a");
-  emitcode ("", "!tlabeldef", (lbl->key + 100));
+      if (!lUnsigned && val < 0)
+        {
+          compiletimeSign = TRUE; /* set sign flag */
+          emitcode ("mov", "a,#0x%02x", -val);
+        }
+      else
+        emitcode ("mov", "a,#0x%02x", (unsigned char) val);
+    }
+  else /* ! literal */
+    {
+      MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL));
 
-  /* now the multiplication */
+      if (!lUnsigned)
+        {
+          runtimeSign = TRUE;
+          emitcode ("clr", "F0"); /* clear sign flag */
+
+          lbl = newiTempLabel (NULL);
+          emitcode ("jnb", "acc.7,!tlabel", lbl->key + 100);
+          emitcode ("setb", "F0"); /* set sign flag */
+          emitcode ("cpl", "a");   /* 2's complement */
+          emitcode ("inc", "a");
+          emitcode ("", "!tlabeldef", lbl->key + 100);
+        }
+    }
+
+  /* now the modulus */
   emitcode ("nop", "; workaround for DS80C390 div bug.");
   emitcode ("div", "ab");
-  /* we are interested in the lower order
-     only */
-  lbl = newiTempLabel (NULL);
-  emitcode ("pop", "acc");
-  /* if there was an over flow we don't
-     adjust the sign of the result */
-  emitcode ("jb", "ov,!tlabel", (lbl->key + 100));
-  emitcode ("jnb", "acc.7,!tlabel", (lbl->key + 100));
-  CLRC;
-  emitcode ("clr", "a");
-  emitcode ("subb", "a,b");
-  emitcode ("mov", "b,a");
-  emitcode ("", "!tlabeldef", (lbl->key + 100));
-  
-  _G.bInUse++;
-  /* now we are done */
-  aopOp(result, ic, TRUE, FALSE);    
-  aopPut (AOP (result), "b", 0);
-  _G.bInUse--;
+
+  if (runtimeSign || compiletimeSign)
+    {
+      emitcode ("mov", "a,b");
+      lbl = newiTempLabel (NULL);
+      if (runtimeSign)
+        emitcode ("jnb", "F0,!tlabel", lbl->key + 100);
+      emitcode ("cpl", "a"); /* lsb 2's complement */
+      emitcode ("inc", "a");
+      emitcode ("", "!tlabeldef", lbl->key + 100);
+
+      _G.accInUse++;     _G.bInUse++;
+      aopOp (result, ic, TRUE, FALSE);
+      size = AOP_SIZE (result) - 1;
+
+      if (size > 0)
+        {
+          /* 123 look strange, but if (OP_SYMBOL (op)->accuse == 1)
+             then the result will be in b, a */
+          emitcode ("mov", "b,a"); /* 1 */
+          /* msb is 0x00 or 0xff depending on the sign */
+          if (runtimeSign)
+            {
+              emitcode ("mov",  "c,F0");
+              emitcode ("subb", "a,acc");
+              emitcode ("xch",  "a,b"); /* 2 */
+              while (size--)
+                aopPut (AOP (result), "b", offset++); /* write msb's */
+            }
+          else /* compiletimeSign */
+            while (size--)
+              aopPut (AOP (result), "#0xff", offset++); /* write msb's */
+        }
+      aopPut (AOP (result), "a", 0); /* 3: write lsb */
+    }
+  else
+    {
+      _G.accInUse++;     _G.bInUse++;
+      aopOp(result, ic, TRUE, FALSE);
+      size = AOP_SIZE (result) - 1;
+
+      aopPut (AOP (result), "b", 0);
+      while (size--)
+        aopPut (AOP (result), zero, offset++);
+    }
+  _G.accInUse--;     _G.bInUse--;
 
 }
 
 /*-----------------------------------------------------------------*/
 /* genModTwoByte - use the DS390 MAC unit to do 16%16 modulus      */
 /*-----------------------------------------------------------------*/
-static void genModTwoByte (operand *left, operand *right, 
-			    operand *result, iCode *ic)
-{
-	sym_link *retype = getSpec(operandType(right));
-	sym_link *letype = getSpec(operandType(left));
-	int umult = SPEC_USIGN(retype) | SPEC_USIGN(letype);
-	symbol *lbl;
-
-	/* load up MA with left */
-	/* save EA bit in F1 */
-	lbl = newiTempLabel(NULL);
-	emitcode ("setb","F1");
-	emitcode ("jbc","EA,!tlabel",lbl->key+100);
-	emitcode ("clr","F1");
-	emitcode("","!tlabeldef",lbl->key+100);
-
-	if (!umult) {
-		lbl = newiTempLabel(NULL);
-		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");
-		emitcode ("add", "a,#1");
-		emitcode ("xch", "a,b");
-		emitcode ("cpl", "a"); // msb
-		emitcode ("addc","a,#0");
-		emitcode ("","!tlabeldef",lbl->key+100);
-		emitcode ("mov","ma,b");
-		emitcode ("mov","ma,a");
-	} else {
-		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 */
-	if (!umult) {
-		if (AOP_TYPE(right) == AOP_LIT) {
-			int val=(int)floatFromVal (AOP (right)->aopu.aop_lit);
-			if (val < 0) {
-				val = -val;
-			} 
-			emitcode ("mov","mb,#!constbyte",val & 0xff);
-			emitcode ("mov","mb,#!constbyte",(val >> 8) & 0xff);		    
-		} else {
-			lbl = newiTempLabel(NULL);
-			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");
-			emitcode ("add", "a,#1");
-			emitcode ("xch", "a,b");
-			emitcode ("cpl", "a"); // msb
-			emitcode ("addc", "a,#0");
-			emitcode ("","!tlabeldef",lbl->key+100);
-			emitcode ("mov","mb,b");
-			emitcode ("mov","mb,a");
-		}
-	} else {
-		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,#!constbyte",0x80);
-	emitcode("jnz","!tlabel",lbl->key+100);
-	
-	freeAsmop (left, NULL, ic, TRUE);
-	freeAsmop (right, NULL, ic,TRUE);
-	aopOp(result, ic, TRUE, FALSE);
-
-	aopPut(AOP(result),"mb",1);
-	aopPut(AOP(result),"mb",0);
-	freeAsmop (result, NULL, ic, TRUE);
-
-	/* restore EA bit in F1 */
-	lbl = newiTempLabel(NULL);
-	emitcode ("jnb","F1,!tlabel",lbl->key+100);
-	emitcode ("setb","EA");
-	emitcode("","!tlabeldef",lbl->key+100);
-	return ;
+static void genModTwoByte (operand *left, operand *right,
+                            operand *result, iCode *ic)
+{
+        sym_link *retype = getSpec(operandType(right));
+        sym_link *letype = getSpec(operandType(left));
+        int umult = SPEC_USIGN(retype) | SPEC_USIGN(letype);
+        symbol *lbl;
+
+        /* load up MA with left */
+        /* save EA bit in F1 */
+        lbl = newiTempLabel(NULL);
+        emitcode ("setb","F1");
+        emitcode ("jbc","EA,!tlabel",lbl->key+100);
+        emitcode ("clr","F1");
+        emitcode("","!tlabeldef",lbl->key+100);
+
+        if (!umult) {
+                lbl = newiTempLabel(NULL);
+                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");
+                emitcode ("add", "a,#1");
+                emitcode ("xch", "a,b");
+                emitcode ("cpl", "a"); // msb
+                emitcode ("addc","a,#0");
+                emitcode ("","!tlabeldef",lbl->key+100);
+                emitcode ("mov","ma,b");
+                emitcode ("mov","ma,a");
+        } else {
+                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 */
+        if (!umult) {
+                if (AOP_TYPE(right) == AOP_LIT) {
+                        int val=(int)floatFromVal (AOP (right)->aopu.aop_lit);
+                        if (val < 0) {
+                                val = -val;
+                        }
+                        emitcode ("mov","mb,#!constbyte",val & 0xff);
+                        emitcode ("mov","mb,#!constbyte",(val >> 8) & 0xff);
+                } else {
+                        lbl = newiTempLabel(NULL);
+                        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");
+                        emitcode ("add", "a,#1");
+                        emitcode ("xch", "a,b");
+                        emitcode ("cpl", "a"); // msb
+                        emitcode ("addc", "a,#0");
+                        emitcode ("","!tlabeldef",lbl->key+100);
+                        emitcode ("mov","mb,b");
+                        emitcode ("mov","mb,a");
+                }
+        } else {
+                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,#!constbyte",0x80);
+        emitcode("jnz","!tlabel",lbl->key+100);
+
+        freeAsmop (left, NULL, ic, TRUE);
+        freeAsmop (right, NULL, ic,TRUE);
+        aopOp(result, ic, TRUE, FALSE);
+
+        aopPut(AOP(result),"mb",1);
+        aopPut(AOP(result),"mb",0);
+        freeAsmop (result, NULL, ic, TRUE);
+
+        /* restore EA bit in F1 */
+        lbl = newiTempLabel(NULL);
+        emitcode ("jnb","F1,!tlabel",lbl->key+100);
+        emitcode ("setb","EA");
+        emitcode("","!tlabeldef",lbl->key+100);
+        return ;
 }
 
 /*-----------------------------------------------------------------*/
@@ -5367,9 +5818,9 @@ genMod (iCode * ic)
     }
 
   if (AOP_SIZE (left) == 2 && AOP_SIZE(right) == 2) {
-	  /* use the ds390 ARITHMETIC accel UNIT */
-	  genModTwoByte (left, right, result, ic);
-	  return ;
+          /* use the ds390 ARITHMETIC accel UNIT */
+          genModTwoByte (left, right, result, ic);
+          return ;
   }
 
   /* should have been converted to function call */
@@ -5399,14 +5850,14 @@ genIfxJump (iCode * ic, char *jval)
     {
       jlbl = IC_TRUE (ic);
       inst = ((strcmp (jval, "a") == 0 ? "jz" :
-	       (strcmp (jval, "c") == 0 ? "jnc" : "jnb")));
+               (strcmp (jval, "c") == 0 ? "jnc" : "jnb")));
     }
   else
     {
       /* false label is present */
       jlbl = IC_FALSE (ic);
       inst = ((strcmp (jval, "a") == 0 ? "jnz" :
-	       (strcmp (jval, "c") == 0 ? "jc" : "jb")));
+               (strcmp (jval, "c") == 0 ? "jc" : "jb")));
     }
   if (strcmp (inst, "jb") == 0 || strcmp (inst, "jnb") == 0)
     emitcode (inst, "%s,!tlabel", jval, (tlbl->key + 100));
@@ -5424,7 +5875,7 @@ genIfxJump (iCode * ic, char *jval)
 /*-----------------------------------------------------------------*/
 static void
 genCmp (operand * left, operand * right,
-	iCode * ic, iCode * ifx, int sign)
+        iCode * ic, iCode * ifx, int sign)
 {
   int size, offset = 0;
   unsigned long lit = 0L;
@@ -5449,93 +5900,93 @@ 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 && AOP_TYPE (left) != AOP_STR))
-	{
-	  symbol *lbl = newiTempLabel (NULL);
-	  emitcode ("cjne", "%s,%s,!tlabel",
-		    aopGet (AOP (left), offset, FALSE, FALSE, NULL),
-		    aopGet (AOP (right), offset, FALSE, FALSE, NULL),
-		    lbl->key + 100);
-	  emitcode ("", "!tlabeldef", lbl->key + 100);
-	}
+      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, NULL),
+                    aopGet (AOP (right), offset, FALSE, FALSE, NULL),
+                    lbl->key + 100);
+          emitcode ("", "!tlabeldef", lbl->key + 100);
+        }
       else
-	{
-	  if (AOP_TYPE (right) == AOP_LIT)
-	    {
-	      lit = (unsigned long) floatFromVal (AOP (right)->aopu.aop_lit);
-	      /* optimize if(x < 0) or if(x >= 0) */
-	      if (lit == 0L)
-		{
-		  if (!sign)
-		    {
-		      CLRC;
-		    }
-		  else
-		    {
-		      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));
-
-		      aopOp (result, ic, FALSE, FALSE);
-
-		      if (!(AOP_TYPE (result) == AOP_CRY && AOP_SIZE (result)) && ifx)
-			{
-			  freeAsmop (result, NULL, ic, TRUE);
-			  genIfxJump (ifx, "acc.7");
-			  return;
-			}
-		      else
-			{
-			  emitcode ("rlc", "a");
-			}
-		      goto release_freedLR;
-		    }
-		  goto release;
-		}
-	    }
-	  CLRC;
-	  while (size--)
-	    {
-	      // 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,#!constbyte",0x80);
-		  if (AOP_TYPE (right) == AOP_LIT)
-		    {
-		      unsigned long lit = (unsigned long)
-		      floatFromVal (AOP (right)->aopu.aop_lit);
-		      // emitcode (";", "genCmp #3.1");
-		      emitcode ("subb", "a,#!constbyte",
-				0x80 ^ (unsigned int) ((lit >> (offset * 8)) & 0x0FFL));
-		    }
-		  else
-		    {
-		      // 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");
-		    }
-		}
-	      else
-		{
-		  const char *s;
-
-		  // emitcode (";", "genCmp #4");
-		  saveAccWarn = 0;
-		  s = aopGet (AOP (right), offset++, FALSE, FALSE, "b");
-		  saveAccWarn = DEFAULT_ACC_WARNING;
-
-		  emitcode ("subb", "a,%s", s);
-		}
-	    }
-	}
+        {
+          if (AOP_TYPE (right) == AOP_LIT)
+            {
+              lit = (unsigned long) floatFromVal (AOP (right)->aopu.aop_lit);
+              /* optimize if(x < 0) or if(x >= 0) */
+              if (lit == 0L)
+                {
+                  if (!sign)
+                    {
+                      CLRC;
+                    }
+                  else
+                    {
+                      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));
+
+                      aopOp (result, ic, FALSE, FALSE);
+
+                      if (!(AOP_TYPE (result) == AOP_CRY && AOP_SIZE (result)) && ifx)
+                        {
+                          freeAsmop (result, NULL, ic, TRUE);
+                          genIfxJump (ifx, "acc.7");
+                          return;
+                        }
+                      else
+                        {
+                          emitcode ("rlc", "a");
+                        }
+                      goto release_freedLR;
+                    }
+                  goto release;
+                }
+            }
+          CLRC;
+          while (size--)
+            {
+              // 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,#!constbyte",0x80);
+                  if (AOP_TYPE (right) == AOP_LIT)
+                    {
+                      unsigned long lit = (unsigned long)
+                      floatFromVal (AOP (right)->aopu.aop_lit);
+                      // emitcode (";", "genCmp #3.1");
+                      emitcode ("subb", "a,#!constbyte",
+                                0x80 ^ (unsigned int) ((lit >> (offset * 8)) & 0x0FFL));
+                    }
+                  else
+                    {
+                      // 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");
+                    }
+                }
+              else
+                {
+                  const char *s;
+
+                  // emitcode (";", "genCmp #4");
+                  saveAccWarn = 0;
+                  s = aopGet (AOP (right), offset++, FALSE, FALSE, "b");
+                  saveAccWarn = DEFAULT_ACC_WARNING;
+
+                  emitcode ("subb", "a,%s", s);
+                }
+            }
+        }
     }
 
 release:
@@ -5557,13 +6008,13 @@ release_freedLR:
          ifx conditional branch then generate
          code a little differently */
       if (ifx)
-	{
-	  genIfxJump (ifx, "c");
-	}
+        {
+          genIfxJump (ifx, "c");
+        }
       else
-	{
-	  outBitC (result);
-	}
+        {
+          outBitC (result);
+        }
       /* leave the result in acc */
     }
   freeAsmop (result, NULL, ic, TRUE);
@@ -5637,6 +6088,7 @@ gencjneshort (operand * left, operand * right, symbol * lbl)
      if the right is in a pointer register and left
      is not */
   if ((AOP_TYPE (left) == AOP_LIT) ||
+      (AOP_TYPE (left) == AOP_IMMD) ||
       (IS_AOP_PREG (right) && !IS_AOP_PREG (left)))
     {
       operand *t = right;
@@ -5662,45 +6114,47 @@ gencjneshort (operand * left, operand * right, symbol * lbl)
       AOP_TYPE (left) != AOP_DIR)
     {
       while (size--)
-	{
-	  MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
-	  emitcode ("cjne", "a,%s,!tlabel",
-		    aopGet (AOP (right), offset, FALSE, FALSE, NULL),
-		    lbl->key + 100);
-	  offset++;
-	}
+        {
+          MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
+          emitcode ("cjne", "a,%s,!tlabel",
+                    aopGet (AOP (right), offset, FALSE, FALSE, NULL),
+                    lbl->key + 100);
+          offset++;
+        }
     }
 
   /* if the right side is in a register or in direct space or
      if the left is a pointer register & right is not */
   else if (AOP_TYPE (right) == AOP_REG ||
-	   AOP_TYPE (right) == AOP_DIR ||
-	   (AOP_TYPE (left) == AOP_DIR && AOP_TYPE (right) == AOP_LIT) ||
-	   (IS_AOP_PREG (left) && !IS_AOP_PREG (right)))
+           AOP_TYPE (right) == AOP_DIR ||
+           AOP_TYPE (right) == AOP_LIT ||
+           AOP_TYPE (right) == AOP_IMMD ||
+           (AOP_TYPE (left) == AOP_DIR && AOP_TYPE (right) == AOP_LIT) ||
+           (IS_AOP_PREG (left) && !IS_AOP_PREG (right)))
     {
       while (size--)
-	{
-	  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, DP2_RESULT_REG),
-		      lbl->key + 100);
-	  offset++;
-	}
+        {
+          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, DP2_RESULT_REG),
+                      lbl->key + 100);
+          offset++;
+        }
     }
   else
     {
       /* right is a pointer reg need both a & b */
       while (size--)
-	{
-	  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++;
-	}
+        {
+          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++;
+        }
     }
 }
 
@@ -5749,74 +6203,74 @@ genCmpEq (iCode * ic, iCode * ifx)
       IC_LEFT (ic) = t;
     }
 
-  if (ifx &&			/* !AOP_SIZE(result) */
+  if (ifx &&                    /* !AOP_SIZE(result) */
       OP_SYMBOL (result) &&
       OP_SYMBOL (result)->regType == REG_CND)
     {
       symbol *tlbl;
       /* if they are both bit variables */
       if (AOP_TYPE (left) == AOP_CRY &&
-	  ((AOP_TYPE (right) == AOP_CRY) || (AOP_TYPE (right) == AOP_LIT)))
-	{
-	  if (AOP_TYPE (right) == AOP_LIT)
-	    {
-	      unsigned long lit = (unsigned long) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
-	      if (lit == 0L)
-		{
-		  emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
-		  emitcode ("cpl", "c");
-		}
-	      else if (lit == 1L)
-		{
-		  emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
-		}
-	      else
-		{
-		  emitcode ("clr", "c");
-		}
-	      /* AOP_TYPE(right) == AOP_CRY */
-	    }
-	  else
-	    {
-	      symbol *lbl = newiTempLabel (NULL);
-	      emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
-	      emitcode ("jb", "%s,!tlabel", AOP (right)->aopu.aop_dir, (lbl->key + 100));
-	      emitcode ("cpl", "c");
-	      emitcode ("", "!tlabeldef", (lbl->key + 100));
-	    }
-	  /* if true label then we jump if condition
-	     supplied is true */
-	  tlbl = newiTempLabel (NULL);
-	  if (IC_TRUE (ifx))
-	    {
-	      emitcode ("jnc", "!tlabel", tlbl->key + 100);
-	      emitcode ("ljmp", "!tlabel", IC_TRUE (ifx)->key + 100);
-	    }
-	  else
-	    {
-	      emitcode ("jc", "!tlabel", tlbl->key + 100);
-	      emitcode ("ljmp", "!tlabel", IC_FALSE (ifx)->key + 100);
-	    }
-	  emitcode ("", "!tlabeldef", tlbl->key + 100);
-	}
+          ((AOP_TYPE (right) == AOP_CRY) || (AOP_TYPE (right) == AOP_LIT)))
+        {
+          if (AOP_TYPE (right) == AOP_LIT)
+            {
+              unsigned long lit = (unsigned long) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
+              if (lit == 0L)
+                {
+                  emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
+                  emitcode ("cpl", "c");
+                }
+              else if (lit == 1L)
+                {
+                  emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
+                }
+              else
+                {
+                  emitcode ("clr", "c");
+                }
+              /* AOP_TYPE(right) == AOP_CRY */
+            }
+          else
+            {
+              symbol *lbl = newiTempLabel (NULL);
+              emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
+              emitcode ("jb", "%s,!tlabel", AOP (right)->aopu.aop_dir, (lbl->key + 100));
+              emitcode ("cpl", "c");
+              emitcode ("", "!tlabeldef", (lbl->key + 100));
+            }
+          /* if true label then we jump if condition
+             supplied is true */
+          tlbl = newiTempLabel (NULL);
+          if (IC_TRUE (ifx))
+            {
+              emitcode ("jnc", "!tlabel", tlbl->key + 100);
+              emitcode ("ljmp", "!tlabel", IC_TRUE (ifx)->key + 100);
+            }
+          else
+            {
+              emitcode ("jc", "!tlabel", tlbl->key + 100);
+              emitcode ("ljmp", "!tlabel", IC_FALSE (ifx)->key + 100);
+            }
+          emitcode ("", "!tlabeldef", tlbl->key + 100);
+        }
       else
-	{
-	  tlbl = newiTempLabel (NULL);
-	  gencjneshort (left, right, tlbl);
-	  if (IC_TRUE (ifx))
-	    {
-	      emitcode ("ljmp", "!tlabel", IC_TRUE (ifx)->key + 100);
-	      emitcode ("", "!tlabeldef", tlbl->key + 100);
-	    }
-	  else
-	    {
-	      symbol *lbl = newiTempLabel (NULL);
-	      emitcode ("sjmp", "!tlabel", lbl->key + 100);
-	      emitcode ("", "!tlabeldef", tlbl->key + 100);
-	      emitcode ("ljmp", "!tlabel", IC_FALSE (ifx)->key + 100);
-	      emitcode ("", "!tlabeldef", lbl->key + 100);
-	    }
-	}
+        {
+          tlbl = newiTempLabel (NULL);
+          gencjneshort (left, right, tlbl);
+          if (IC_TRUE (ifx))
+            {
+              emitcode ("ljmp", "!tlabel", IC_TRUE (ifx)->key + 100);
+              emitcode ("", "!tlabeldef", tlbl->key + 100);
+            }
+          else
+            {
+              symbol *lbl = newiTempLabel (NULL);
+              emitcode ("sjmp", "!tlabel", lbl->key + 100);
+              emitcode ("", "!tlabeldef", tlbl->key + 100);
+              emitcode ("ljmp", "!tlabel", IC_FALSE (ifx)->key + 100);
+              emitcode ("", "!tlabeldef", lbl->key + 100);
+            }
+        }
       /* mark the icode as generated */
       ifx->generated = 1;
 
@@ -5830,31 +6284,31 @@ genCmpEq (iCode * ic, iCode * ifx)
       ((AOP_TYPE (right) == AOP_CRY) || (AOP_TYPE (right) == AOP_LIT)))
     {
       if (AOP_TYPE (right) == AOP_LIT)
-	{
-	  unsigned long lit = (unsigned long) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
-	  if (lit == 0L)
-	    {
-	      emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
-	      emitcode ("cpl", "c");
-	    }
-	  else if (lit == 1L)
-	    {
-	      emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
-	    }
-	  else
-	    {
-	      emitcode ("clr", "c");
-	    }
-	  /* AOP_TYPE(right) == AOP_CRY */
-	}
+        {
+          unsigned long lit = (unsigned long) floatFromVal (AOP (IC_RIGHT (ic))->aopu.aop_lit);
+          if (lit == 0L)
+            {
+              emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
+              emitcode ("cpl", "c");
+            }
+          else if (lit == 1L)
+            {
+              emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
+            }
+          else
+            {
+              emitcode ("clr", "c");
+            }
+          /* AOP_TYPE(right) == AOP_CRY */
+        }
       else
-	{
-	  symbol *lbl = newiTempLabel (NULL);
-	  emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
-	  emitcode ("jb", "%s,!tlabel", AOP (right)->aopu.aop_dir, (lbl->key + 100));
-	  emitcode ("cpl", "c");
-	  emitcode ("", "!tlabeldef", (lbl->key + 100));
-	}
+        {
+          symbol *lbl = newiTempLabel (NULL);
+          emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
+          emitcode ("jb", "%s,!tlabel", AOP (right)->aopu.aop_dir, (lbl->key + 100));
+          emitcode ("cpl", "c");
+          emitcode ("", "!tlabeldef", (lbl->key + 100));
+        }
 
       freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
       freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
@@ -5863,15 +6317,15 @@ genCmpEq (iCode * ic, iCode * ifx)
 
       /* c = 1 if egal */
       if (AOP_TYPE (result) == AOP_CRY && AOP_SIZE (result))
-	{
-	  outBitC (result);
-	  goto release;
-	}
+        {
+          outBitC (result);
+          goto release;
+        }
       if (ifx)
-	{
-	  genIfxJump (ifx, "c");
-	  goto release;
-	}
+        {
+          genIfxJump (ifx, "c");
+          goto release;
+        }
       /* if the result is used in an arithmetic operation
          then put the result in place */
       outBitC (result);
@@ -5886,19 +6340,19 @@ genCmpEq (iCode * ic, iCode * ifx)
       aopOp (result, ic, TRUE, FALSE);
 
       if (AOP_TYPE (result) == AOP_CRY && AOP_SIZE (result))
-	{
-	  aopPut (AOP (result), "a", 0);
-	  goto release;
-	}
+        {
+          aopPut (AOP (result), "a", 0);
+          goto release;
+        }
       if (ifx)
-	{
-	  genIfxJump (ifx, "a");
-	  goto release;
-	}
+        {
+          genIfxJump (ifx, "a");
+          goto release;
+        }
       /* if the result is used in an arithmetic operation
          then put the result in place */
       if (AOP_TYPE (result) != AOP_CRY)
-	outAcc (result);
+        outAcc (result);
       /* leave the result in acc */
     }
 
@@ -5937,7 +6391,7 @@ hasInc (operand *op, iCode *ic, int osize)
   sym_link *retype = getSpec (type);
   iCode *lic = ic->next;
   int isize ;
-  
+
   /* this could from a cast, e.g.: "(char xdata *) 0x7654;" */
   if (!IS_SYMOP(op)) return NULL;
 
@@ -5948,14 +6402,14 @@ hasInc (operand *op, iCode *ic, int osize)
   while (lic) {
       /* if operand of the form op = op + <sizeof *op> */
       if (lic->op == '+' && isOperandEqual(IC_LEFT(lic),op) &&
-	  isOperandEqual(IC_RESULT(lic),op) && 
-	  isOperandLiteral(IC_RIGHT(lic)) &&
-	  operandLitValue(IC_RIGHT(lic)) == isize) {
-	  return lic;
+          isOperandEqual(IC_RESULT(lic),op) &&
+          isOperandLiteral(IC_RIGHT(lic)) &&
+          operandLitValue(IC_RIGHT(lic)) == isize) {
+          return lic;
       }
       /* if the operand used or deffed */
-      if (bitVectBitValue(OP_USES(op),lic->key) || (unsigned) lic->defKey == op->key) {
-	  return NULL;
+      if (bitVectBitValue(OP_USES(op),lic->key) || lic->defKey == op->key) {
+          return NULL;
       }
       /* if GOTO or IFX */
       if (lic->op == IFX || lic->op == GOTO || lic->op == LABEL) break;
@@ -5989,7 +6443,7 @@ genAndOp (iCode * ic)
       emitcode ("anl", "c,%s", AOP (right)->aopu.aop_dir);
       freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
       freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
-  
+
       aopOp (result,ic,FALSE, FALSE);
       outBitC (result);
     }
@@ -6002,7 +6456,7 @@ genAndOp (iCode * ic)
       emitcode ("", "!tlabeldef", tlbl->key + 100);
       freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
       freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
-  
+
       aopOp (result,ic,FALSE, FALSE);
       outBitAcc (result);
     }
@@ -6035,9 +6489,9 @@ genOrOp (iCode * ic)
       emitcode ("orl", "c,%s", AOP (right)->aopu.aop_dir);
       freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
       freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
-  
+
       aopOp (result,ic,FALSE, FALSE);
-      
+
       outBitC (result);
     }
   else
@@ -6049,9 +6503,9 @@ genOrOp (iCode * ic)
       emitcode ("", "!tlabeldef", tlbl->key + 100);
       freeAsmop (left, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
       freeAsmop (right, NULL, ic, (RESULTONSTACK (ic) ? FALSE : TRUE));
-  
+
       aopOp (result,ic,FALSE, FALSE);
-      
+
       outBitAcc (result);
     }
 
@@ -6126,7 +6580,7 @@ jmpTrueOrFalse (iCode * ic, symbol * tlbl)
 }
 
 // Generate code to perform a bit-wise logic operation
-// on two operands in far space (assumed to already have been 
+// on two operands in far space (assumed to already have been
 // aopOp'd by the AOP_OP_3_NOFATAL macro), storing the result
 // in far space. This requires pushing the result on the stack
 // then popping it into the result.
@@ -6135,28 +6589,28 @@ genFarFarLogicOp(iCode *ic, char *logicOp)
 {
       int size, resultSize, compSize;
       int offset = 0;
-      
+
       TR_AP("#5");
       D(emitcode(";", "%s special case for 3 far operands.", logicOp););
-      compSize = AOP_SIZE(IC_LEFT(ic)) < AOP_SIZE(IC_RIGHT(ic)) ? 
-      		  AOP_SIZE(IC_LEFT(ic)) : AOP_SIZE(IC_RIGHT(ic));
-      
+      compSize = AOP_SIZE(IC_LEFT(ic)) < AOP_SIZE(IC_RIGHT(ic)) ?
+                  AOP_SIZE(IC_LEFT(ic)) : AOP_SIZE(IC_RIGHT(ic));
+
       _startLazyDPSEvaluation();
       for (size = compSize; (size--); offset++)
       {
-      	  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, NULL));
-      	  
-      	  emitcode (logicOp, "a,%s", DP2_RESULT_REG);
-      	  emitcode ("push", "acc");
+          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, NULL));
+
+          emitcode (logicOp, "a,%s", DP2_RESULT_REG);
+          emitcode ("push", "acc");
       }
       _endLazyDPSEvaluation();
-     
+
       freeAsmop (IC_LEFT(ic), NULL, ic, RESULTONSTACK (ic) ? FALSE : TRUE);
       freeAsmop (IC_RIGHT(ic), NULL, ic, RESULTONSTACK (ic) ? FALSE : TRUE);
       aopOp (IC_RESULT(ic),ic,TRUE, FALSE);
-     
+
       resultSize = AOP_SIZE(IC_RESULT(ic));
 
       ADJUST_PUSHED_RESULT(compSize, resultSize);
@@ -6164,8 +6618,8 @@ genFarFarLogicOp(iCode *ic, char *logicOp)
       _startLazyDPSEvaluation();
       while (compSize--)
       {
-	  emitcode ("pop", "acc");
-	  aopPut (AOP (IC_RESULT (ic)), "a", compSize);
+          emitcode ("pop", "acc");
+          aopPut (AOP (IC_RESULT (ic)), "a", compSize);
       }
       _endLazyDPSEvaluation();
       freeAsmop(IC_RESULT (ic), NULL, ic, TRUE);
@@ -6194,20 +6648,20 @@ genAnd (iCode * ic, iCode * ifx)
   {
       genFarFarLogicOp(ic, "anl");
       return;
-  }  
+  }
 
 #ifdef DEBUG_TYPE
   emitcode ("", "; Type res[%d] = l[%d]&r[%d]",
-	    AOP_TYPE (result),
-	    AOP_TYPE (left), AOP_TYPE (right));
+            AOP_TYPE (result),
+            AOP_TYPE (left), AOP_TYPE (right));
   emitcode ("", "; Size res[%d] = l[%d]&r[%d]",
-	    AOP_SIZE (result),
-	    AOP_SIZE (left), AOP_SIZE (right));
+            AOP_SIZE (result),
+            AOP_SIZE (left), AOP_SIZE (right));
 #endif
 
   /* if left is a literal & right is not then exchange them */
   if ((AOP_TYPE (left) == AOP_LIT && AOP_TYPE (right) != AOP_LIT)
-#ifdef LOGIC_OPS_BROKEN      
+#ifdef LOGIC_OPS_BROKEN
     ||  AOP_NEEDSACC (left)
 #endif
     )
@@ -6217,7 +6671,7 @@ genAnd (iCode * ic, iCode * ifx)
       left = tmp;
     }
 
-  /* if result = right then exchange them */
+  /* if result = right then exchange left and right */
   if (sameRegs (AOP (result), AOP (right)))
     {
       operand *tmp = right;
@@ -6244,54 +6698,54 @@ genAnd (iCode * ic, iCode * ifx)
     {
       // c = bit & literal;
       if (AOP_TYPE (right) == AOP_LIT)
-	{
-	  if (lit & 1)
-	    {
-	      if (size && sameRegs (AOP (result), AOP (left)))
-		// no change
-		goto release;
-	      emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
-	    }
-	  else
-	    {
-	      // bit(result) = 0;
-	      if (size && (AOP_TYPE (result) == AOP_CRY))
-		{
-		  emitcode ("clr", "%s", AOP (result)->aopu.aop_dir);
-		  goto release;
-		}
-	      if ((AOP_TYPE (result) == AOP_CRY) && ifx)
-		{
-		  jumpIfTrue (ifx);
-		  goto release;
-		}
-	      emitcode ("clr", "c");
-	    }
-	}
+        {
+          if (lit & 1)
+            {
+              if (size && sameRegs (AOP (result), AOP (left)))
+                // no change
+                goto release;
+              emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
+            }
+          else
+            {
+              // bit(result) = 0;
+              if (size && (AOP_TYPE (result) == AOP_CRY))
+                {
+                  emitcode ("clr", "%s", AOP (result)->aopu.aop_dir);
+                  goto release;
+                }
+              if ((AOP_TYPE (result) == AOP_CRY) && ifx)
+                {
+                  jumpIfTrue (ifx);
+                  goto release;
+                }
+              emitcode ("clr", "c");
+            }
+        }
       else
-	{
-	  if (AOP_TYPE (right) == AOP_CRY)
-	    {
-	      // c = bit & bit;
-	      emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
-	      emitcode ("anl", "c,%s", AOP (left)->aopu.aop_dir);
-	    }
-	  else
-	    {
-	      // c = bit & val;
-	      MOVA (aopGet (AOP (right), 0, FALSE, FALSE, NULL));
-	      // c = lsb
-	      emitcode ("rrc", "a");
-	      emitcode ("anl", "c,%s", AOP (left)->aopu.aop_dir);
-	    }
-	}
+        {
+          if (AOP_TYPE (right) == AOP_CRY)
+            {
+              // c = bit & bit;
+              emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
+              emitcode ("anl", "c,%s", AOP (left)->aopu.aop_dir);
+            }
+          else
+            {
+              // c = bit & val;
+              MOVA (aopGet (AOP (right), 0, FALSE, FALSE, NULL));
+              // c = lsb
+              emitcode ("rrc", "a");
+              emitcode ("anl", "c,%s", AOP (left)->aopu.aop_dir);
+            }
+        }
       // bit = c
       // val = c
       if (size)
-	outBitC (result);
+        outBitC (result);
       // if(bit & ...)
       else if ((AOP_TYPE (result) == AOP_CRY) && ifx)
-	genIfxJump (ifx, "c");
+        genIfxJump (ifx, "c");
       goto release;
     }
 
@@ -6304,66 +6758,68 @@ genAnd (iCode * ic, iCode * ifx)
       int posbit = isLiteralBit (lit);
       /* left &  2^n */
       if (posbit)
-	{
-	  posbit--;
-	  MOVA (aopGet (AOP (left), posbit >> 3, FALSE, FALSE, NULL));
-	  // bit = left & 2^n
-	  if (size)
-	    emitcode ("mov", "c,acc.%d", posbit & 0x07);
-	  // if(left &  2^n)
-	  else
-	    {
-	      if (ifx)
-		{
-		  SNPRINTF (buff, sizeof(buff), 
-			    "acc.%d", posbit & 0x07);
-		  genIfxJump (ifx, buff);
-		}
-	      else 
-		  {
-		      emitcode ("anl","a,#!constbyte",1 << (posbit & 0x07));
-		  }
-	      goto release;
-	    }
-	}
+        {
+          posbit--;
+          MOVA (aopGet (AOP (left), posbit >> 3, FALSE, FALSE, NULL));
+          // bit = left & 2^n
+          if (size)
+            emitcode ("mov", "c,acc.%d", posbit & 0x07);
+          // if(left &  2^n)
+          else
+            {
+              if (ifx)
+                {
+                  SNPRINTF (buff, sizeof(buff),
+                            "acc.%d", posbit & 0x07);
+                  genIfxJump (ifx, buff);
+                }
+              else
+                  {
+                      emitcode ("anl","a,#!constbyte",1 << (posbit & 0x07));
+                  }
+              goto release;
+            }
+        }
       else
-	{
-	  symbol *tlbl = newiTempLabel (NULL);
-	  int sizel = AOP_SIZE (left);
-	  if (size)
-	    emitcode ("setb", "c");
-	  while (sizel--)
-	    {
-	      if ((bytelit = ((lit >> (offset * 8)) & 0x0FFL)) != 0x0L)
-		{
-		  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);
-		  else
-		    {
-		      if (bytelit != 0x0FFL)
-			emitcode ("anl", "a,%s",
-			  aopGet (AOP (right), offset, FALSE, TRUE, DP2_RESULT_REG));
-		      emitcode ("jnz", "!tlabel", tlbl->key + 100);
-		    }
-		}
-	      offset++;
-	    }
-	  // bit = left & literal
-	  if (size)
-	    {
-	      emitcode ("clr", "c");
-	      emitcode ("", "!tlabeldef", tlbl->key + 100);
-	    }
-	  // if(left & literal)
-	  else
-	    {
-	      if (ifx)
-		jmpTrueOrFalse (ifx, tlbl);
-	      goto release;
-	    }
-	}
+        {
+          symbol *tlbl = newiTempLabel (NULL);
+          int sizel = AOP_SIZE (left);
+          if (size)
+            emitcode ("setb", "c");
+          while (sizel--)
+            {
+              if ((bytelit = ((lit >> (offset * 8)) & 0x0FFL)) != 0x0L)
+                {
+                  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);
+                  else
+                    {
+                      if (bytelit != 0x0FFL)
+                        emitcode ("anl", "a,%s",
+                          aopGet (AOP (right), offset, FALSE, TRUE, DP2_RESULT_REG));
+                      emitcode ("jnz", "!tlabel", tlbl->key + 100);
+                    }
+                }
+              offset++;
+            }
+          // bit = left & literal
+          if (size)
+            {
+              emitcode ("clr", "c");
+              emitcode ("", "!tlabeldef", tlbl->key + 100);
+            }
+          // if(left & literal)
+          else
+            {
+              if (ifx)
+                jmpTrueOrFalse (ifx, tlbl);
+              else
+                emitcode ("", "!tlabeldef", tlbl->key + 100);
+              goto release;
+            }
+        }
       outBitC (result);
       goto release;
     }
@@ -6372,137 +6828,152 @@ genAnd (iCode * ic, iCode * ifx)
   if (sameRegs (AOP (result), AOP (left)))
     {
       for (; size--; offset++)
-	{
-	  if (AOP_TYPE (right) == AOP_LIT)
-	    {
-	      if ((bytelit = (int) ((lit >> (offset * 8)) & 0x0FFL)) == 0x0FF)
-		continue;
-	      else if (bytelit == 0)
-		aopPut (AOP (result), zero, offset);
-	      else if (IS_AOP_PREG (result))
-		{
-		  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, 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, DP2_RESULT_REG));
-	      else
-		{
-		  MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL));
-		  if (IS_AOP_PREG (result))
-		    {
-		      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, DP2_RESULT_REG));
-		}
-	    }
-	}
+        {
+          if (AOP_TYPE (right) == AOP_LIT)
+            {
+              bytelit = (int) ((lit >> (offset * 8)) & 0x0FFL);
+              if (bytelit == 0x0FF)
+                {
+                  /* dummy read of volatile operand */
+                  if (isOperandVolatile (left, FALSE))
+                    MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
+                  else
+                    continue;
+                }
+              else if (bytelit == 0)
+                {
+                  aopPut (AOP (result), zero, offset);
+                }
+              else if (IS_AOP_PREG (result))
+                {
+                  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, 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, DP2_RESULT_REG));
+              else
+                {
+                  MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL));
+                  if (IS_AOP_PREG (result))
+                    {
+                      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, DP2_RESULT_REG));
+                }
+            }
+        }
     }
   else
     {
       // left & result in different registers
       if (AOP_TYPE (result) == AOP_CRY)
-	{
-	  // result = bit
-	  // if(size), result in bit
-	  // if(!size && ifx), conditional oper: if(left & right)
-	  symbol *tlbl = newiTempLabel (NULL);
-	  int sizer = min (AOP_SIZE (left), AOP_SIZE (right));
-	  if (size)
-	    emitcode ("setb", "c");
-	  while (sizer--)
-	    {
-	      if (AOP_TYPE(right)==AOP_REG && AOP_TYPE(left)==AOP_ACC) {
-		emitcode ("anl", "a,%s",
-			  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, NULL));
-		  emitcode("anl", "a,b");
-		}else {
-		  MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL));
-		  emitcode ("anl", "a,%s",
-			    aopGet (AOP (left), offset, FALSE, FALSE, DP2_RESULT_REG));
-		}
-	      }
-	      emitcode ("jnz", "!tlabel", tlbl->key + 100);
-	      offset++;
-	    }
-	  if (size)
-	    {
-	      CLRC;
-	      emitcode ("", "!tlabeldef", tlbl->key + 100);
-	      outBitC (result);
-	    }
-	  else if (ifx)
-	    jmpTrueOrFalse (ifx, tlbl);
-	}
+        {
+          // result = bit
+          // if(size), result in bit
+          // if(!size && ifx), conditional oper: if(left & right)
+          symbol *tlbl = newiTempLabel (NULL);
+          int sizer = min (AOP_SIZE (left), AOP_SIZE (right));
+          if (size)
+            emitcode ("setb", "c");
+          while (sizer--)
+            {
+              if (AOP_TYPE(right)==AOP_REG && AOP_TYPE(left)==AOP_ACC) {
+                emitcode ("anl", "a,%s",
+                          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, NULL));
+                  emitcode("anl", "a,b");
+                }else {
+                  MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL));
+                  emitcode ("anl", "a,%s",
+                            aopGet (AOP (left), offset, FALSE, FALSE, DP2_RESULT_REG));
+                }
+              }
+              emitcode ("jnz", "!tlabel", tlbl->key + 100);
+              offset++;
+            }
+          if (size)
+            {
+              CLRC;
+              emitcode ("", "!tlabeldef", tlbl->key + 100);
+              outBitC (result);
+            }
+          else if (ifx)
+            jmpTrueOrFalse (ifx, tlbl);
+          else
+            emitcode ("", "!tlabeldef", tlbl->key + 100);
+        }
       else
-	{
-	  for (; (size--); offset++)
-	    {
-	      // normal case
-	      // result = left & right
-	      if (AOP_TYPE (right) == AOP_LIT)
-		{
-		  if ((bytelit = (int) ((lit >> (offset * 8)) & 0x0FFL)) == 0x0FF)
-		    {
-		      aopPut (AOP (result),
-			   aopGet (AOP (left), offset, FALSE, FALSE, NULL),
-			      offset);
-		      continue;
-		    }
-		  else if (bytelit == 0)
-		    {
-		      aopPut (AOP (result), zero, offset);
-		      continue;
-		    }
-		  D (emitcode (";", "better literal AND."););
-		  MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
-		  emitcode ("anl", "a, %s", aopGet (AOP (right), offset,
-						    FALSE, FALSE, DP2_RESULT_REG));
-
-		}
-	      else
-		{
-		  // faster than result <- left, anl result,right
-		  // and better if result is SFR
-		  if (AOP_TYPE (left) == AOP_ACC)
-		    {
-		      emitcode ("anl", "a,%s", 
-				aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG));
-		    }
-		  else
-		    {
-		      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, NULL));
-		      emitcode ("anl", "a,%s", rOp);
-		    }			
-		}
-	      aopPut (AOP (result), "a", offset);
-	    }
-	}
+        {
+          for (; (size--); offset++)
+            {
+              // normal case
+              // result = left & right
+              if (AOP_TYPE (right) == AOP_LIT)
+                {
+                  bytelit = (int) ((lit >> (offset * 8)) & 0x0FFL);
+                  if (bytelit == 0x0FF)
+                    {
+                      aopPut (AOP (result),
+                              aopGet (AOP (left), offset, FALSE, FALSE, NULL),
+                              offset);
+                      continue;
+                    }
+                  else if (bytelit == 0)
+                    {
+                      /* dummy read of volatile operand */
+                      if (isOperandVolatile (left, FALSE))
+                        MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
+                      aopPut (AOP (result), zero, offset);
+                      continue;
+                    }
+                  D (emitcode (";", "better literal AND."););
+                  MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
+                  emitcode ("anl", "a, %s", aopGet (AOP (right), offset,
+                                                    FALSE, FALSE, DP2_RESULT_REG));
+
+                }
+              else
+                {
+                  // faster than result <- left, anl result,right
+                  // and better if result is SFR
+                  if (AOP_TYPE (left) == AOP_ACC)
+                    {
+                      emitcode ("anl", "a,%s",
+                                aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG));
+                    }
+                  else
+                    {
+                      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, NULL));
+                      emitcode ("anl", "a,%s", rOp);
+                    }
+                }
+              aopPut (AOP (result), "a", offset);
+            }
+        }
     }
 
 release:
@@ -6521,7 +6992,8 @@ genOr (iCode * ic, iCode * ifx)
   operand *left, *right, *result;
   int size, offset = 0;
   unsigned long lit = 0L;
-  bool 	   pushResult;
+  int bytelit = 0;
+  bool     pushResult;
 
   D (emitcode (";", "genOr "););
 
@@ -6537,18 +7009,18 @@ genOr (iCode * ic, iCode * ifx)
 
 #ifdef DEBUG_TYPE
   emitcode ("", "; Type res[%d] = l[%d]&r[%d]",
-	    AOP_TYPE (result),
-	    AOP_TYPE (left), AOP_TYPE (right));
+            AOP_TYPE (result),
+            AOP_TYPE (left), AOP_TYPE (right));
   emitcode ("", "; Size res[%d] = l[%d]&r[%d]",
-	    AOP_SIZE (result),
-	    AOP_SIZE (left), AOP_SIZE (right));
+            AOP_SIZE (result),
+            AOP_SIZE (left), AOP_SIZE (right));
 #endif
 
   /* if left is a literal & right is not then exchange them */
   if ((AOP_TYPE (left) == AOP_LIT && AOP_TYPE (right) != AOP_LIT)
 #ifdef LOGIC_OPS_BROKEN
    || AOP_NEEDSACC (left) // I think this is a net loss now.
-#endif      
+#endif
       )
     {
       operand *tmp = right;
@@ -6582,66 +7054,66 @@ genOr (iCode * ic, iCode * ifx)
   if (AOP_TYPE (left) == AOP_CRY)
     {
       if (AOP_TYPE (right) == AOP_LIT)
-	{
-	  // c = bit & literal;
-	  if (lit)
-	    {
-	      // lit != 0 => result = 1
-	      if (AOP_TYPE (result) == AOP_CRY)
-		{
-		  if (size)
-		    emitcode ("setb", "%s", AOP (result)->aopu.aop_dir);
-		  else if (ifx)
-		    continueIfTrue (ifx);
-		  goto release;
-		}
-	      emitcode ("setb", "c");
-	    }
-	  else
-	    {
-	      // lit == 0 => result = left
-	      if (size && sameRegs (AOP (result), AOP (left)))
-		goto release;
-	      emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
-	    }
-	}
+        {
+          // c = bit & literal;
+          if (lit)
+            {
+              // lit != 0 => result = 1
+              if (AOP_TYPE (result) == AOP_CRY)
+                {
+                  if (size)
+                    emitcode ("setb", "%s", AOP (result)->aopu.aop_dir);
+                  else if (ifx)
+                    continueIfTrue (ifx);
+                  goto release;
+                }
+              emitcode ("setb", "c");
+            }
+          else
+            {
+              // lit == 0 => result = left
+              if (size && sameRegs (AOP (result), AOP (left)))
+                goto release;
+              emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
+            }
+        }
       else
-	{
-	  if (AOP_TYPE (right) == AOP_CRY)
-	    {
-	      // c = bit | bit;
-	      emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
-	      emitcode ("orl", "c,%s", AOP (left)->aopu.aop_dir);
-	    }
-	  else
-	    {
-	      // c = bit | val;
-	      symbol *tlbl = newiTempLabel (NULL);
-	      if (!((AOP_TYPE (result) == AOP_CRY) && ifx))
-		emitcode ("setb", "c");
-	      emitcode ("jb", "%s,!tlabel",
-			AOP (left)->aopu.aop_dir, tlbl->key + 100);
-	      toBoolean (right);
-	      emitcode ("jnz", "!tlabel", tlbl->key + 100);
-	      if ((AOP_TYPE (result) == AOP_CRY) && ifx)
-		{
-		  jmpTrueOrFalse (ifx, tlbl);
-		  goto release;
-		}
-	      else
-		{
-		  CLRC;
-		  emitcode ("", "!tlabeldef", tlbl->key + 100);
-		}
-	    }
-	}
+        {
+          if (AOP_TYPE (right) == AOP_CRY)
+            {
+              // c = bit | bit;
+              emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
+              emitcode ("orl", "c,%s", AOP (left)->aopu.aop_dir);
+            }
+          else
+            {
+              // c = bit | val;
+              symbol *tlbl = newiTempLabel (NULL);
+              if (!((AOP_TYPE (result) == AOP_CRY) && ifx))
+                emitcode ("setb", "c");
+              emitcode ("jb", "%s,!tlabel",
+                        AOP (left)->aopu.aop_dir, tlbl->key + 100);
+              toBoolean (right);
+              emitcode ("jnz", "!tlabel", tlbl->key + 100);
+              if ((AOP_TYPE (result) == AOP_CRY) && ifx)
+                {
+                  jmpTrueOrFalse (ifx, tlbl);
+                  goto release;
+                }
+              else
+                {
+                  CLRC;
+                  emitcode ("", "!tlabeldef", tlbl->key + 100);
+                }
+            }
+        }
       // bit = c
       // val = c
       if (size)
-	outBitC (result);
+        outBitC (result);
       // if(bit | ...)
       else if ((AOP_TYPE (result) == AOP_CRY) && ifx)
-	   genIfxJump (ifx, "c");
+           genIfxJump (ifx, "c");
       goto release;
     }
 
@@ -6652,33 +7124,33 @@ genOr (iCode * ic, iCode * ifx)
       (AOP_TYPE (left) != AOP_CRY))
     {
       if (lit)
-	{
-	  // result = 1
-	  if (size)
-	    emitcode ("setb", "%s", AOP (result)->aopu.aop_dir);
-	  else
-	    continueIfTrue (ifx);
-	  goto release;
-	}
+        {
+          // result = 1
+          if (size)
+            emitcode ("setb", "%s", AOP (result)->aopu.aop_dir);
+          else
+            continueIfTrue (ifx);
+          goto release;
+        }
       else
-	{
-	  // lit = 0, result = boolean(left)
-	  if (size)
-	    emitcode ("setb", "c");
-	  toBoolean (right);
-	  if (size)
-	    {
-	      symbol *tlbl = newiTempLabel (NULL);
-	      emitcode ("jnz", "!tlabel", tlbl->key + 100);
-	      CLRC;
-	      emitcode ("", "!tlabeldef", tlbl->key + 100);
-	    }
-	  else
-	    {
-	      genIfxJump (ifx, "a");
-	      goto release;
-	    }
-	}
+        {
+          // lit = 0, result = boolean(left)
+          if (size)
+            emitcode ("setb", "c");
+          toBoolean (right);
+          if (size)
+            {
+              symbol *tlbl = newiTempLabel (NULL);
+              emitcode ("jnz", "!tlabel", tlbl->key + 100);
+              CLRC;
+              emitcode ("", "!tlabeldef", tlbl->key + 100);
+            }
+          else
+            {
+              genIfxJump (ifx, "a");
+              goto release;
+            }
+        }
       outBitC (result);
       goto release;
     }
@@ -6687,140 +7159,157 @@ genOr (iCode * ic, iCode * ifx)
   if (sameRegs (AOP (result), AOP (left)))
     {
       for (; size--; offset++)
-	{
-	  if (AOP_TYPE (right) == AOP_LIT)
-	    {
-	      if (((lit >> (offset * 8)) & 0x0FFL) == 0x00L)
-		{
-		  continue;
-		}
-	      else
-		{
-		  if (IS_AOP_PREG (left))
-		    {
-		      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, NULL),
-				aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG));
-		    }
-		}
-	    }
-	  else
-	    {
-	      if (AOP_TYPE (left) == AOP_ACC)
-		{
-		  emitcode ("orl", "a,%s",
-			    aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG));
-		}
-	      else
-		{
-		  MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL));
-		  if (IS_AOP_PREG (left))
-		    {
-		      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, DP2_RESULT_REG));
-		    }
-		}
-	    }
-	}
+        {
+          if (AOP_TYPE (right) == AOP_LIT)
+            {
+              bytelit = (int)((lit >> (offset * 8)) & 0x0FFL);
+              if (bytelit == 0x00L)
+                {
+                  /* dummy read of volatile operand */
+                  if (isOperandVolatile (left, FALSE))
+                    MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
+                  else
+                    continue;
+                }
+              else if (bytelit == 0x0FF)
+                {
+                  aopPut (AOP (result), "#0xFF", offset);
+                }
+              else if (IS_AOP_PREG (left))
+                {
+                  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, NULL),
+                            aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG));
+                }
+            }
+          else
+            {
+              if (AOP_TYPE (left) == AOP_ACC)
+                {
+                  emitcode ("orl", "a,%s",
+                            aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG));
+                }
+              else
+                {
+                  MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL));
+                  if (IS_AOP_PREG (left))
+                    {
+                      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, DP2_RESULT_REG));
+                    }
+                }
+            }
+        }
     }
   else
     {
       // left & result in different registers
       if (AOP_TYPE (result) == AOP_CRY)
-	{
-	  // result = bit
-	  // if(size), result in bit
-	  // if(!size && ifx), conditional oper: if(left | right)
-	  symbol *tlbl = newiTempLabel (NULL);
-	  int sizer = max (AOP_SIZE (left), AOP_SIZE (right));
-	  if (size)
-	    emitcode ("setb", "c");
-	  while (sizer--)
-	    {
-	      if (AOP_TYPE(right)==AOP_REG && AOP_TYPE(left)==AOP_ACC) {
-		emitcode ("orl", "a,%s",
-			  aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG));
-	      } else {
-		MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL));
-		emitcode ("orl", "a,%s",
-			  aopGet (AOP (left), offset, FALSE, FALSE, DP2_RESULT_REG));
-	      }
-	      emitcode ("jnz", "!tlabel", tlbl->key + 100);
-	      offset++;
-	    }
-	  if (size)
-	    {
-	      CLRC;
-	      emitcode ("", "!tlabeldef", tlbl->key + 100);
-	      outBitC (result);
-	    }
-	  else if (ifx)
-	    jmpTrueOrFalse (ifx, tlbl);
-	}
+        {
+          // result = bit
+          // if(size), result in bit
+          // if(!size && ifx), conditional oper: if(left | right)
+          symbol *tlbl = newiTempLabel (NULL);
+          int sizer = max (AOP_SIZE (left), AOP_SIZE (right));
+          if (size)
+            emitcode ("setb", "c");
+          while (sizer--)
+            {
+              if (AOP_TYPE(right)==AOP_REG && AOP_TYPE(left)==AOP_ACC) {
+                emitcode ("orl", "a,%s",
+                          aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG));
+              } else {
+                MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL));
+                emitcode ("orl", "a,%s",
+                          aopGet (AOP (left), offset, FALSE, FALSE, DP2_RESULT_REG));
+              }
+              emitcode ("jnz", "!tlabel", tlbl->key + 100);
+              offset++;
+            }
+          if (size)
+            {
+              CLRC;
+              emitcode ("", "!tlabeldef", tlbl->key + 100);
+              outBitC (result);
+            }
+          else if (ifx)
+            jmpTrueOrFalse (ifx, tlbl);
+          else
+            emitcode ("", "!tlabeldef", tlbl->key + 100);
+        }
       else
-	{
-	    _startLazyDPSEvaluation();
-	  for (; (size--); offset++)
-	    {
-	      // normal case
-	      // result = left & right
-	      if (AOP_TYPE (right) == AOP_LIT)
-		{
-		  if (((lit >> (offset * 8)) & 0x0FFL) == 0x00L)
-		    {
-		      aopPut (AOP (result),
-			   aopGet (AOP (left), offset, FALSE, FALSE, NULL),
-			      offset);
-		      continue;
-		    }
-		  D (emitcode (";", "better literal OR."););
-		  MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
-		  emitcode ("orl", "a, %s",
-			    aopGet (AOP (right), offset,
-				    FALSE, FALSE, DP2_RESULT_REG));
-
-		}
-	      else
-		{
-		  // faster than result <- left, anl result,right
-		  // and better if result is SFR
-		  if (AOP_TYPE (left) == AOP_ACC)
-		    {
-		      emitcode ("orl", "a,%s",
-				aopGet (AOP (right), offset,
-					FALSE, FALSE, DP2_RESULT_REG));
-		    }
-		  else
-		    {
-		      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, NULL));
-		      emitcode ("orl", "a,%s", rOp);
-		    }
-		}
-	      aopPut (AOP (result), "a", offset);
-	    }
-	    _endLazyDPSEvaluation();
-	}
+        {
+            _startLazyDPSEvaluation();
+          for (; (size--); offset++)
+            {
+              // normal case
+              // result = left & right
+              if (AOP_TYPE (right) == AOP_LIT)
+                {
+                  bytelit = (int)((lit >> (offset * 8)) & 0x0FFL);
+                  if (bytelit == 0x00L)
+                    {
+                      aopPut (AOP (result),
+                              aopGet (AOP (left), offset, FALSE, FALSE, NULL),
+                              offset);
+                      continue;
+                    }
+                  else if (bytelit == 0x0FF)
+                    {
+                      /* dummy read of volatile operand */
+                      if (isOperandVolatile (left, FALSE))
+                        MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
+                      aopPut (AOP (result), "#0xFF", offset);
+                      continue;
+                    }
+                  D (emitcode (";", "better literal OR."););
+                  MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
+                  emitcode ("orl", "a, %s",
+                            aopGet (AOP (right), offset,
+                                    FALSE, FALSE, DP2_RESULT_REG));
+
+                }
+              else
+                {
+                  // faster than result <- left, anl result,right
+                  // and better if result is SFR
+                  if (AOP_TYPE (left) == AOP_ACC)
+                    {
+                      emitcode ("orl", "a,%s",
+                                aopGet (AOP (right), offset,
+                                        FALSE, FALSE, DP2_RESULT_REG));
+                    }
+                  else
+                    {
+                      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, NULL));
+                      emitcode ("orl", "a,%s", rOp);
+                    }
+                }
+              aopPut (AOP (result), "a", offset);
+            }
+            _endLazyDPSEvaluation();
+        }
     }
 
 release:
@@ -6838,6 +7327,7 @@ genXor (iCode * ic, iCode * ifx)
   operand *left, *right, *result;
   int size, offset = 0;
   unsigned long lit = 0L;
+  int bytelit = 0;
   bool pushResult;
 
   D (emitcode (";", "genXor "););
@@ -6849,21 +7339,21 @@ genXor (iCode * ic, iCode * ifx)
   {
       genFarFarLogicOp(ic, "xrl");
       return;
-  }  
+  }
 
 #ifdef DEBUG_TYPE
   emitcode ("", "; Type res[%d] = l[%d]&r[%d]",
-	    AOP_TYPE (result),
-	    AOP_TYPE (left), AOP_TYPE (right));
+            AOP_TYPE (result),
+            AOP_TYPE (left), AOP_TYPE (right));
   emitcode ("", "; Size res[%d] = l[%d]&r[%d]",
-	    AOP_SIZE (result),
-	    AOP_SIZE (left), AOP_SIZE (right));
+            AOP_SIZE (result),
+            AOP_SIZE (left), AOP_SIZE (right));
 #endif
 
   /* if left is a literal & right is not ||
      if left needs acc & right does not */
-  if ((AOP_TYPE (left) == AOP_LIT && AOP_TYPE (right) != AOP_LIT) 
-#ifdef LOGIC_OPS_BROKEN      
+  if ((AOP_TYPE (left) == AOP_LIT && AOP_TYPE (right) != AOP_LIT)
+#ifdef LOGIC_OPS_BROKEN
       || (AOP_NEEDSACC (left) && !AOP_NEEDSACC (right))
 #endif
      )
@@ -6899,227 +7389,236 @@ genXor (iCode * ic, iCode * ifx)
   if (AOP_TYPE (left) == AOP_CRY)
     {
       if (AOP_TYPE (right) == AOP_LIT)
-	{
-	  // c = bit & literal;
-	  if (lit >> 1)
-	    {
-	      // lit>>1  != 0 => result = 1
-	      if (AOP_TYPE (result) == AOP_CRY)
-		{
-		  if (size)
-		    emitcode ("setb", "%s", AOP (result)->aopu.aop_dir);
-		  else if (ifx)
-		    continueIfTrue (ifx);
-		  goto release;
-		}
-	      emitcode ("setb", "c");
-	    }
-	  else
-	    {
-	      // lit == (0 or 1)
-	      if (lit == 0)
-		{
-		  // lit == 0, result = left
-		  if (size && sameRegs (AOP (result), AOP (left)))
-		    goto release;
-		  emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
-		}
-	      else
-		{
-		  // lit == 1, result = not(left)
-		  if (size && sameRegs (AOP (result), AOP (left)))
-		    {
-		      emitcode ("cpl", "%s", AOP (result)->aopu.aop_dir);
-		      goto release;
-		    }
-		  else
-		    {
-		      emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
-		      emitcode ("cpl", "c");
-		    }
-		}
-	    }
-
-	}
+        {
+          // c = bit & literal;
+          if (lit >> 1)
+            {
+              // lit>>1  != 0 => result = 1
+              if (AOP_TYPE (result) == AOP_CRY)
+                {
+                  if (size)
+                    emitcode ("setb", "%s", AOP (result)->aopu.aop_dir);
+                  else if (ifx)
+                    continueIfTrue (ifx);
+                  goto release;
+                }
+              emitcode ("setb", "c");
+            }
+          else
+            {
+              // lit == (0 or 1)
+              if (lit == 0)
+                {
+                  // lit == 0, result = left
+                  if (size && sameRegs (AOP (result), AOP (left)))
+                    goto release;
+                  emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
+                }
+              else
+                {
+                  // lit == 1, result = not(left)
+                  if (size && sameRegs (AOP (result), AOP (left)))
+                    {
+                      emitcode ("cpl", "%s", AOP (result)->aopu.aop_dir);
+                      goto release;
+                    }
+                  else
+                    {
+                      emitcode ("mov", "c,%s", AOP (left)->aopu.aop_dir);
+                      emitcode ("cpl", "c");
+                    }
+                }
+            }
+
+        }
       else
-	{
-	  // right != literal
-	  symbol *tlbl = newiTempLabel (NULL);
-	  if (AOP_TYPE (right) == AOP_CRY)
-	    {
-	      // c = bit ^ bit;
-	      emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
-	    }
-	  else
-	    {
-	      int sizer = AOP_SIZE (right);
-	      // c = bit ^ val
-	      // if val>>1 != 0, result = 1
-	      emitcode ("setb", "c");
-	      while (sizer)
-		{
-		  MOVA (aopGet (AOP (right), sizer - 1, FALSE, FALSE, NULL));
-		  if (sizer == 1)
-		    // test the msb of the lsb
-		    emitcode ("anl", "a,#!constbyte",0xfe);
-		  emitcode ("jnz", "!tlabel", tlbl->key + 100);
-		  sizer--;
-		}
-	      // val = (0,1)
-	      emitcode ("rrc", "a");
-	    }
-	  emitcode ("jnb", "%s,!tlabel", AOP (left)->aopu.aop_dir, (tlbl->key + 100));
-	  emitcode ("cpl", "c");
-	  emitcode ("", "!tlabeldef", (tlbl->key + 100));
-	}
+        {
+          // right != literal
+          symbol *tlbl = newiTempLabel (NULL);
+          if (AOP_TYPE (right) == AOP_CRY)
+            {
+              // c = bit ^ bit;
+              emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
+            }
+          else
+            {
+              int sizer = AOP_SIZE (right);
+              // c = bit ^ val
+              // if val>>1 != 0, result = 1
+              emitcode ("setb", "c");
+              while (sizer)
+                {
+                  MOVA (aopGet (AOP (right), sizer - 1, FALSE, FALSE, NULL));
+                  if (sizer == 1)
+                    // test the msb of the lsb
+                    emitcode ("anl", "a,#!constbyte",0xfe);
+                  emitcode ("jnz", "!tlabel", tlbl->key + 100);
+                  sizer--;
+                }
+              // val = (0,1)
+              emitcode ("rrc", "a");
+            }
+          emitcode ("jnb", "%s,!tlabel", AOP (left)->aopu.aop_dir, (tlbl->key + 100));
+          emitcode ("cpl", "c");
+          emitcode ("", "!tlabeldef", (tlbl->key + 100));
+        }
       // bit = c
       // val = c
       if (size)
-	outBitC (result);
+        outBitC (result);
       // if(bit | ...)
       else if ((AOP_TYPE (result) == AOP_CRY) && ifx)
-	genIfxJump (ifx, "c");
+        genIfxJump (ifx, "c");
       goto release;
     }
 
+  /* if left is same as result */
   if (sameRegs (AOP (result), AOP (left)))
     {
-      /* if left is same as result */
       for (; size--; offset++)
-	{
-	  if (AOP_TYPE (right) == AOP_LIT)
-	    {
-	      if (((lit >> (offset * 8)) & 0x0FFL) == 0x00L)
-		continue;
-	      else if (IS_AOP_PREG (left))
-		{
-		  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, 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, DP2_RESULT_REG));
-	      else
-		{
-		  MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL));
-		  if (IS_AOP_PREG (left))
-		    {
-		      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, DP2_RESULT_REG));
-		}
-	    }
-	}
+        {
+          if (AOP_TYPE (right) == AOP_LIT)
+            {
+              bytelit = (int) ((lit >> (offset * 8)) & 0x0FFL);
+              if (bytelit == 0x00L)
+                {
+                  /* dummy read of volatile operand */
+                  if (isOperandVolatile (left, FALSE))
+                    MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
+                  else
+                    continue;
+                }
+              else if (IS_AOP_PREG (left))
+                {
+                  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, 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, DP2_RESULT_REG));
+              else
+                {
+                  MOVA (aopGet (AOP (right), offset, FALSE, FALSE, NULL));
+                  if (IS_AOP_PREG (left))
+                    {
+                      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, DP2_RESULT_REG));
+                }
+            }
+        }
     }
   else
     {
       // left & result in different registers
       if (AOP_TYPE (result) == AOP_CRY)
-	{
-	  // result = bit
-	  // if(size), result in bit
-	  // if(!size && ifx), conditional oper: if(left ^ right)
-	  symbol *tlbl = newiTempLabel (NULL);
-	  int sizer = max (AOP_SIZE (left), AOP_SIZE (right));
-	          
-	  if (size)
-	    emitcode ("setb", "c");
-	  while (sizer--)
-	    {
-	      if ((AOP_TYPE (right) == AOP_LIT) &&
-		  (((lit >> (offset * 8)) & 0x0FFL) == 0x00L))
-		{
-		  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, DP2_RESULT_REG));
-		  } else {
-		      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, NULL));
-		      emitcode ("xrl", "a,%s", rOp);		      
-		  }
-		}
-	      emitcode ("jnz", "!tlabel", tlbl->key + 100);
-	      offset++;
-	    }
-	  if (size)
-	    {
-	      CLRC;
-	      emitcode ("", "!tlabeldef", tlbl->key + 100);
-	      outBitC (result);
-	    }
-	  else if (ifx)
-	    jmpTrueOrFalse (ifx, tlbl);
-	}
+        {
+          // result = bit
+          // if(size), result in bit
+          // if(!size && ifx), conditional oper: if(left ^ right)
+          symbol *tlbl = newiTempLabel (NULL);
+          int sizer = max (AOP_SIZE (left), AOP_SIZE (right));
+
+          if (size)
+            emitcode ("setb", "c");
+          while (sizer--)
+            {
+              if ((AOP_TYPE (right) == AOP_LIT) &&
+                  (((lit >> (offset * 8)) & 0x0FFL) == 0x00L))
+                {
+                  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, DP2_RESULT_REG));
+                  } else {
+                      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, NULL));
+                      emitcode ("xrl", "a,%s", rOp);
+                  }
+                }
+              emitcode ("jnz", "!tlabel", tlbl->key + 100);
+              offset++;
+            }
+          if (size)
+            {
+              CLRC;
+              emitcode ("", "!tlabeldef", tlbl->key + 100);
+              outBitC (result);
+            }
+          else if (ifx)
+            jmpTrueOrFalse (ifx, tlbl);
+        }
       else
-	{
-	for (; (size--); offset++)
-	  {
-	    // normal case
-	    // result = left & right
-	    if (AOP_TYPE (right) == AOP_LIT)
-	      {
-		if (((lit >> (offset * 8)) & 0x0FFL) == 0x00L)
-		  {
-		    aopPut (AOP (result),
-			    aopGet (AOP (left), offset, FALSE, FALSE, NULL),
-			    offset);
-		    continue;
-		  }
-		D (emitcode (";", "better literal XOR."););
-		MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
-		emitcode ("xrl", "a, %s",
-			  aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG));
-	      }
-	    else
-	      {
-		// faster than result <- left, anl result,right
-		// and better if result is SFR
-		if (AOP_TYPE (left) == AOP_ACC)
-		  {
-		    emitcode ("xrl", "a,%s",
-			      aopGet (AOP (right), offset,
-				      FALSE, FALSE, DP2_RESULT_REG));
-		  }
-		else
-		  {
-		      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, NULL));
-		      emitcode ("xrl", "a,%s", rOp);
-		  }
-	      }
-	    aopPut (AOP (result), "a", offset);
-	  }
-	}
-	
+        {
+        for (; (size--); offset++)
+          {
+            // normal case
+            // result = left & right
+            if (AOP_TYPE (right) == AOP_LIT)
+              {
+                if (((lit >> (offset * 8)) & 0x0FFL) == 0x00L)
+                  {
+                    aopPut (AOP (result),
+                            aopGet (AOP (left), offset, FALSE, FALSE, NULL),
+                            offset);
+                    continue;
+                  }
+                D (emitcode (";", "better literal XOR."););
+                MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
+                emitcode ("xrl", "a, %s",
+                          aopGet (AOP (right), offset, FALSE, FALSE, DP2_RESULT_REG));
+              }
+            else
+              {
+                // faster than result <- left, anl result,right
+                // and better if result is SFR
+                if (AOP_TYPE (left) == AOP_ACC)
+                  {
+                    emitcode ("xrl", "a,%s",
+                              aopGet (AOP (right), offset,
+                                      FALSE, FALSE, DP2_RESULT_REG));
+                  }
+                else
+                  {
+                      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, NULL));
+                      emitcode ("xrl", "a,%s", rOp);
+                  }
+              }
+            aopPut (AOP (result), "a", offset);
+          }
+        }
+
     }
 
 release:
@@ -7148,24 +7647,24 @@ genInline (iCode * ic)
   while (*bp)
     {
       if (*bp == '\n')
-	{
-	  *bp++ = '\0';
-	  emitcode (bp1, "");
-	  bp1 = bp;
-	}
+        {
+          *bp++ = '\0';
+          emitcode (bp1, "");
+          bp1 = bp;
+        }
       else
-	{
-	  if (*bp == ':')
-	    {
-	      bp++;
-	      *bp = '\0';
-	      bp++;
-	      emitcode (bp1, "");
-	      bp1 = bp;
-	    }
-	  else
-	    bp++;
-	}
+        {
+          if (*bp == ':')
+            {
+              bp++;
+              *bp = '\0';
+              bp++;
+              emitcode (bp1, "");
+              bp1 = bp;
+            }
+          else
+            bp++;
+        }
     }
   if (bp1 != bp)
     emitcode (bp1, "");
@@ -7180,7 +7679,7 @@ static void
 genRRC (iCode * ic)
 {
   operand *left, *result;
-  int 	  size, offset;
+  int     size, offset;
 
   D (emitcode (";", "genRRC "););
 
@@ -7201,7 +7700,7 @@ genRRC (iCode * ic)
       MOVA (aopGet (AOP (left), offset, FALSE, FALSE, NULL));
       emitcode ("rrc", "a");
       if (AOP_SIZE (result) > 1)
-	aopPut (AOP (result), "a", offset--);
+        aopPut (AOP (result), "a", offset--);
     }
   _endLazyDPSEvaluation ();
 
@@ -7244,19 +7743,19 @@ genRLC (iCode * ic)
       MOVA (l);
       emitcode ("add", "a,acc");
       if (AOP_SIZE (result) > 1)
-	{
-	  aopPut (AOP (result), "a", offset++);
-	}
+        {
+          aopPut (AOP (result), "a", offset++);
+        }
 
       _startLazyDPSEvaluation ();
       while (size--)
-	{
-	  l = aopGet (AOP (left), offset, FALSE, FALSE, NULL);
-	  MOVA (l);
-	  emitcode ("rlc", "a");
-	  if (AOP_SIZE (result) > 1)
-	    aopPut (AOP (result), "a", offset++);
-	}
+        {
+          l = aopGet (AOP (left), offset, FALSE, FALSE, NULL);
+          MOVA (l);
+          emitcode ("rlc", "a");
+          if (AOP_SIZE (result) > 1)
+            aopPut (AOP (result), "a", offset++);
+        }
       _endLazyDPSEvaluation ();
     }
   /* now we need to put the carry into the
@@ -7305,13 +7804,72 @@ genGetHbit (iCode * ic)
   freeAsmop (result, NULL, ic, TRUE);
 }
 
+/*-----------------------------------------------------------------*/
+/* genSwap - generates code to swap nibbles or bytes               */
+/*-----------------------------------------------------------------*/
+static void
+genSwap (iCode * ic)
+{
+  operand *left, *result;
+
+  D(emitcode (";     genSwap",""));
+
+  left = IC_LEFT (ic);
+  result = IC_RESULT (ic);
+  aopOp (left, ic, FALSE, FALSE);
+  aopOp (result, ic, FALSE, AOP_USESDPTR(left));
+
+  _startLazyDPSEvaluation ();
+  switch (AOP_SIZE (left))
+    {
+    case 1: /* swap nibbles in byte */
+      MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL));
+      emitcode ("swap", "a");
+      aopPut (AOP (result), "a", 0);
+      break;
+    case 2: /* swap bytes in word */
+      if (AOP_TYPE(left) == AOP_REG && sameRegs(AOP(left), AOP(result)))
+        {
+          MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL));
+          aopPut (AOP (result), aopGet (AOP (left), 1, FALSE, FALSE, NULL), 0);
+          aopPut (AOP (result), "a", 1);
+        }
+      else if (operandsEqu (left, result))
+        {
+          char * reg = "a";
+          MOVA (aopGet (AOP (left), 0, FALSE, FALSE, NULL));
+          if (AOP_NEEDSACC (left) || AOP_NEEDSACC (result))
+            {
+              emitcode ("mov", "b,a");
+              reg = "b";
+              _G.bInUse=1;
+            }
+          aopPut (AOP (result), aopGet (AOP (left), 1, FALSE, FALSE, NULL), 0);
+          aopPut (AOP (result), reg, 1);
+          _G.bInUse=0;
+        }
+      else
+        {
+          aopPut (AOP (result), aopGet (AOP (left), 1, FALSE, FALSE, NULL), 0);
+          aopPut (AOP (result), aopGet (AOP (left), 0, FALSE, FALSE, NULL), 1);
+        }
+      break;
+    default:
+      wassertl(FALSE, "unsupported SWAP operand size");
+    }
+  _endLazyDPSEvaluation ();
+
+  freeAsmop (left, NULL, ic, TRUE);
+  freeAsmop (result, NULL, ic, TRUE);
+}
+
 /*-----------------------------------------------------------------*/
 /* AccRol - rotate left accumulator by known count                 */
 /*-----------------------------------------------------------------*/
 static void
 AccRol (int shCount)
 {
-  shCount &= 0x0007;		// shCount : 0..7
+  shCount &= 0x0007;            // shCount : 0..7
 
   switch (shCount)
     {
@@ -7354,19 +7912,19 @@ AccLsh (int shCount)
   if (shCount != 0)
     {
       if (shCount == 1)
-	emitcode ("add", "a,acc");
+        emitcode ("add", "a,acc");
       else if (shCount == 2)
-	{
-	  emitcode ("add", "a,acc");
-	  emitcode ("add", "a,acc");
-	}
+        {
+          emitcode ("add", "a,acc");
+          emitcode ("add", "a,acc");
+        }
       else
-	{
-	  /* rotate left accumulator */
-	  AccRol (shCount);
-	  /* and kill the lower order bits */
-	  emitcode ("anl", "a,#!constbyte", SLMask[shCount]);
-	}
+        {
+          /* rotate left accumulator */
+          AccRol (shCount);
+          /* and kill the lower order bits */
+          emitcode ("anl", "a,#!constbyte", SLMask[shCount]);
+        }
     }
 }
 
@@ -7379,17 +7937,17 @@ AccRsh (int shCount)
   if (shCount != 0)
     {
       if (shCount == 1)
-	{
-	  CLRC;
-	  emitcode ("rrc", "a");
-	}
+        {
+          CLRC;
+          emitcode ("rrc", "a");
+        }
       else
-	{
-	  /* rotate right accumulator */
-	  AccRol (8 - shCount);
-	  /* and kill the higher order bits */
-	  emitcode ("anl", "a,#!constbyte", SRMask[shCount]);
-	}
+        {
+          /* rotate right accumulator */
+          AccRol (8 - shCount);
+          /* and kill the higher order bits */
+          emitcode ("anl", "a,#!constbyte", SRMask[shCount]);
+        }
     }
 }
 
@@ -7404,29 +7962,29 @@ AccSRsh (int shCount)
   if (shCount != 0)
     {
       if (shCount == 1)
-	{
-	  emitcode ("mov", "c,acc.7");
-	  emitcode ("rrc", "a");
-	}
+        {
+          emitcode ("mov", "c,acc.7");
+          emitcode ("rrc", "a");
+        }
       else if (shCount == 2)
-	{
-	  emitcode ("mov", "c,acc.7");
-	  emitcode ("rrc", "a");
-	  emitcode ("mov", "c,acc.7");
-	  emitcode ("rrc", "a");
-	}
+        {
+          emitcode ("mov", "c,acc.7");
+          emitcode ("rrc", "a");
+          emitcode ("mov", "c,acc.7");
+          emitcode ("rrc", "a");
+        }
       else
-	{
-	  tlbl = newiTempLabel (NULL);
-	  /* rotate right accumulator */
-	  AccRol (8 - shCount);
-	  /* and kill the higher order bits */
-	  emitcode ("anl", "a,#!constbyte", SRMask[shCount]);
-	  emitcode ("jnb", "acc.%d,!tlabel", 7 - shCount, tlbl->key + 100);
-	  emitcode ("orl", "a,#!constbyte",
-		    (unsigned char) ~SRMask[shCount]);
-	  emitcode ("", "!tlabeldef", tlbl->key + 100);
-	}
+        {
+          tlbl = newiTempLabel (NULL);
+          /* rotate right accumulator */
+          AccRol (8 - shCount);
+          /* and kill the higher order bits */
+          emitcode ("anl", "a,#!constbyte", SRMask[shCount]);
+          emitcode ("jnb", "acc.%d,!tlabel", 7 - shCount, tlbl->key + 100);
+          emitcode ("orl", "a,#!constbyte",
+                    (unsigned char) ~SRMask[shCount]);
+          emitcode ("", "!tlabeldef", tlbl->key + 100);
+        }
     }
 }
 #endif
@@ -7437,8 +7995,8 @@ AccSRsh (int shCount)
 /*-----------------------------------------------------------------*/
 static void
 shiftR1Left2Result (operand * left, int offl,
-		    operand * result, int offr,
-		    int shCount, int sign)
+                    operand * result, int offr,
+                    int shCount, int sign)
 {
   MOVA (aopGet (AOP (left), offl, FALSE, FALSE, NULL));
   /* shift right accumulator */
@@ -7456,7 +8014,7 @@ shiftR1Left2Result (operand * left, int offl,
 /*-----------------------------------------------------------------*/
 static void
 shiftL1Left2Result (operand * left, int offl,
-		    operand * result, int offr, int shCount)
+                    operand * result, int offr, int shCount)
 {
   MOVA(aopGet (AOP (left), offl, FALSE, FALSE, NULL));
   /* shift left accumulator */
@@ -7471,7 +8029,7 @@ shiftL1Left2Result (operand * left, int offl,
 /*-----------------------------------------------------------------*/
 static void
 movLeft2Result (operand * left, int offl,
-		operand * result, int offr, int sign)
+                operand * result, int offr, int sign)
 {
   char *l;
   if (!sameRegs (AOP (left), AOP (result)) || (offl != offr))
@@ -7480,24 +8038,24 @@ movLeft2Result (operand * left, int offl,
 
       if (*l == '@' && (IS_AOP_PREG (result)))
       {
-	  emitcode ("mov", "a,%s", l);
-	  aopPut (AOP (result), "a", offr);
+          emitcode ("mov", "a,%s", l);
+          aopPut (AOP (result), "a", offr);
       }
       else
       {
-	  if (!sign)
-	  {
-	    aopPut (AOP (result), l, offr);
-	  }
-	  else
-	    {
-	      /* MSB sign in acc.7 ! */
-	      if (getDataSize (left) == offl + 1)
-		{
-		  emitcode ("mov", "a,%s", l);
-		  aopPut (AOP (result), "a", offr);
-		}
-	    }
+          if (!sign)
+          {
+            aopPut (AOP (result), l, offr);
+          }
+          else
+            {
+              /* MSB sign in acc.7 ! */
+              if (getDataSize (left) == offl + 1)
+                {
+                  emitcode ("mov", "a,%s", l);
+                  aopPut (AOP (result), "a", offr);
+                }
+            }
       }
   }
 }
@@ -7566,62 +8124,62 @@ AccAXLsh (char *x, int shCount)
       break;
     case 3:
     case 4:
-    case 5:			// AAAAABBB:CCCCCDDD
+    case 5:                     // AAAAABBB:CCCCCDDD
 
-      AccRol (shCount);		// BBBAAAAA:CCCCCDDD
+      AccRol (shCount);         // BBBAAAAA:CCCCCDDD
 
       emitcode ("anl", "a,#!constbyte",
-		SLMask[shCount]);	// BBB00000:CCCCCDDD
+                SLMask[shCount]);       // BBB00000:CCCCCDDD
 
-      emitcode ("xch", "a,%s", x);	// CCCCCDDD:BBB00000
+      emitcode ("xch", "a,%s", x);      // CCCCCDDD:BBB00000
 
-      AccRol (shCount);		// DDDCCCCC:BBB00000
+      AccRol (shCount);         // DDDCCCCC:BBB00000
 
-      emitcode ("xch", "a,%s", x);	// BBB00000:DDDCCCCC
+      emitcode ("xch", "a,%s", x);      // BBB00000:DDDCCCCC
 
-      emitcode ("xrl", "a,%s", x);	// (BBB^DDD)CCCCC:DDDCCCCC
+      emitcode ("xrl", "a,%s", x);      // (BBB^DDD)CCCCC:DDDCCCCC
 
-      emitcode ("xch", "a,%s", x);	// DDDCCCCC:(BBB^DDD)CCCCC
+      emitcode ("xch", "a,%s", x);      // DDDCCCCC:(BBB^DDD)CCCCC
 
       emitcode ("anl", "a,#!constbyte",
-		SLMask[shCount]);	// DDD00000:(BBB^DDD)CCCCC
+                SLMask[shCount]);       // DDD00000:(BBB^DDD)CCCCC
 
-      emitcode ("xch", "a,%s", x);	// (BBB^DDD)CCCCC:DDD00000
+      emitcode ("xch", "a,%s", x);      // (BBB^DDD)CCCCC:DDD00000
 
-      emitcode ("xrl", "a,%s", x);	// BBBCCCCC:DDD00000
+      emitcode ("xrl", "a,%s", x);      // BBBCCCCC:DDD00000
 
       break;
-    case 6:			// AAAAAABB:CCCCCCDD
+    case 6:                     // AAAAAABB:CCCCCCDD
       emitcode ("anl", "a,#!constbyte",
-		SRMask[shCount]);	// 000000BB:CCCCCCDD
-      emitcode ("mov", "c,acc.0");	// c = B
-      emitcode ("xch", "a,%s", x);	// CCCCCCDD:000000BB
+                SRMask[shCount]);       // 000000BB:CCCCCCDD
+      emitcode ("mov", "c,acc.0");      // c = B
+      emitcode ("xch", "a,%s", x);      // CCCCCCDD:000000BB
 #if 0
-      AccAXRrl1 (x);		// BCCCCCCD:D000000B
-      AccAXRrl1 (x);		// BBCCCCCC:DD000000
+      AccAXRrl1 (x);            // BCCCCCCD:D000000B
+      AccAXRrl1 (x);            // BBCCCCCC:DD000000
 #else
-      emitcode("rrc","a"); 
-      emitcode("xch","a,%s", x); 
-      emitcode("rrc","a"); 
-      emitcode("mov","c,acc.0"); //<< get correct bit 
-      emitcode("xch","a,%s", x); 
-
-      emitcode("rrc","a"); 
-      emitcode("xch","a,%s", x); 
-      emitcode("rrc","a"); 
-      emitcode("xch","a,%s", x); 
+      emitcode("rrc","a");
+      emitcode("xch","a,%s", x);
+      emitcode("rrc","a");
+      emitcode("mov","c,acc.0"); //<< get correct bit
+      emitcode("xch","a,%s", x);
+
+      emitcode("rrc","a");
+      emitcode("xch","a,%s", x);
+      emitcode("rrc","a");
+      emitcode("xch","a,%s", x);
 #endif
       break;
-    case 7:			// a:x <<= 7
+    case 7:                     // a:x <<= 7
 
       emitcode ("anl", "a,#!constbyte",
-		SRMask[shCount]);	// 0000000B:CCCCCCCD
+                SRMask[shCount]);       // 0000000B:CCCCCCCD
 
-      emitcode ("mov", "c,acc.0");	// c = B
+      emitcode ("mov", "c,acc.0");      // c = B
 
-      emitcode ("xch", "a,%s", x);	// CCCCCCCD:0000000B
+      emitcode ("xch", "a,%s", x);      // CCCCCCCD:0000000B
 
-      AccAXRrl1 (x);		// BCCCCCCC:D0000000
+      AccAXRrl1 (x);            // BCCCCCCC:D0000000
 
       break;
     default:
@@ -7644,67 +8202,67 @@ AccAXRsh (char *x, int shCount)
       break;
     case 1:
       CLRC;
-      AccAXRrl1 (x);		// 0->a:x
+      AccAXRrl1 (x);            // 0->a:x
 
       break;
     case 2:
       CLRC;
-      AccAXRrl1 (x);		// 0->a:x
+      AccAXRrl1 (x);            // 0->a:x
 
       CLRC;
-      AccAXRrl1 (x);		// 0->a:x
+      AccAXRrl1 (x);            // 0->a:x
 
       break;
     case 3:
     case 4:
-    case 5:			// AAAAABBB:CCCCCDDD = a:x
+    case 5:                     // AAAAABBB:CCCCCDDD = a:x
 
-      AccRol (8 - shCount);	// BBBAAAAA:DDDCCCCC
+      AccRol (8 - shCount);     // BBBAAAAA:DDDCCCCC
 
-      emitcode ("xch", "a,%s", x);	// CCCCCDDD:BBBAAAAA
+      emitcode ("xch", "a,%s", x);      // CCCCCDDD:BBBAAAAA
 
-      AccRol (8 - shCount);	// DDDCCCCC:BBBAAAAA
+      AccRol (8 - shCount);     // DDDCCCCC:BBBAAAAA
 
       emitcode ("anl", "a,#!constbyte",
-		SRMask[shCount]);	// 000CCCCC:BBBAAAAA
+                SRMask[shCount]);       // 000CCCCC:BBBAAAAA
 
-      emitcode ("xrl", "a,%s", x);	// BBB(CCCCC^AAAAA):BBBAAAAA
+      emitcode ("xrl", "a,%s", x);      // BBB(CCCCC^AAAAA):BBBAAAAA
 
-      emitcode ("xch", "a,%s", x);	// BBBAAAAA:BBB(CCCCC^AAAAA)
+      emitcode ("xch", "a,%s", x);      // BBBAAAAA:BBB(CCCCC^AAAAA)
 
       emitcode ("anl", "a,#!constbyte",
-		SRMask[shCount]);	// 000AAAAA:BBB(CCCCC^AAAAA)
+                SRMask[shCount]);       // 000AAAAA:BBB(CCCCC^AAAAA)
 
-      emitcode ("xch", "a,%s", x);	// BBB(CCCCC^AAAAA):000AAAAA
+      emitcode ("xch", "a,%s", x);      // BBB(CCCCC^AAAAA):000AAAAA
 
-      emitcode ("xrl", "a,%s", x);	// BBBCCCCC:000AAAAA
+      emitcode ("xrl", "a,%s", x);      // BBBCCCCC:000AAAAA
 
-      emitcode ("xch", "a,%s", x);	// 000AAAAA:BBBCCCCC
+      emitcode ("xch", "a,%s", x);      // 000AAAAA:BBBCCCCC
 
       break;
-    case 6:			// AABBBBBB:CCDDDDDD
+    case 6:                     // AABBBBBB:CCDDDDDD
 
       emitcode ("mov", "c,acc.7");
-      AccAXLrl1 (x);		// ABBBBBBC:CDDDDDDA
+      AccAXLrl1 (x);            // ABBBBBBC:CDDDDDDA
 
-      AccAXLrl1 (x);		// BBBBBBCC:DDDDDDAA
+      AccAXLrl1 (x);            // BBBBBBCC:DDDDDDAA
 
-      emitcode ("xch", "a,%s", x);	// DDDDDDAA:BBBBBBCC
+      emitcode ("xch", "a,%s", x);      // DDDDDDAA:BBBBBBCC
 
       emitcode ("anl", "a,#!constbyte",
-		SRMask[shCount]);	// 000000AA:BBBBBBCC
+                SRMask[shCount]);       // 000000AA:BBBBBBCC
 
       break;
-    case 7:			// ABBBBBBB:CDDDDDDD
+    case 7:                     // ABBBBBBB:CDDDDDDD
 
-      emitcode ("mov", "c,acc.7");	// c = A
+      emitcode ("mov", "c,acc.7");      // c = A
 
-      AccAXLrl1 (x);		// BBBBBBBC:DDDDDDDA
+      AccAXLrl1 (x);            // BBBBBBBC:DDDDDDDA
 
-      emitcode ("xch", "a,%s", x);	// DDDDDDDA:BBBBBBCC
+      emitcode ("xch", "a,%s", x);      // DDDDDDDA:BBBBBBCC
 
       emitcode ("anl", "a,#!constbyte",
-		SRMask[shCount]);	// 0000000A:BBBBBBBC
+                SRMask[shCount]);       // 0000000A:BBBBBBBC
 
       break;
     default:
@@ -7727,85 +8285,85 @@ AccAXRshS (char *x, int shCount)
       break;
     case 1:
       emitcode ("mov", "c,acc.7");
-      AccAXRrl1 (x);		// s->a:x
+      AccAXRrl1 (x);            // s->a:x
 
       break;
     case 2:
       emitcode ("mov", "c,acc.7");
-      AccAXRrl1 (x);		// s->a:x
+      AccAXRrl1 (x);            // s->a:x
 
       emitcode ("mov", "c,acc.7");
-      AccAXRrl1 (x);		// s->a:x
+      AccAXRrl1 (x);            // s->a:x
 
       break;
     case 3:
     case 4:
-    case 5:			// AAAAABBB:CCCCCDDD = a:x
+    case 5:                     // AAAAABBB:CCCCCDDD = a:x
 
       tlbl = newiTempLabel (NULL);
-      AccRol (8 - shCount);	// BBBAAAAA:CCCCCDDD
+      AccRol (8 - shCount);     // BBBAAAAA:CCCCCDDD
 
-      emitcode ("xch", "a,%s", x);	// CCCCCDDD:BBBAAAAA
+      emitcode ("xch", "a,%s", x);      // CCCCCDDD:BBBAAAAA
 
-      AccRol (8 - shCount);	// DDDCCCCC:BBBAAAAA
+      AccRol (8 - shCount);     // DDDCCCCC:BBBAAAAA
 
       emitcode ("anl", "a,#!constbyte",
-		SRMask[shCount]);	// 000CCCCC:BBBAAAAA
+                SRMask[shCount]);       // 000CCCCC:BBBAAAAA
 
-      emitcode ("xrl", "a,%s", x);	// BBB(CCCCC^AAAAA):BBBAAAAA
+      emitcode ("xrl", "a,%s", x);      // BBB(CCCCC^AAAAA):BBBAAAAA
 
-      emitcode ("xch", "a,%s", x);	// BBBAAAAA:BBB(CCCCC^AAAAA)
+      emitcode ("xch", "a,%s", x);      // BBBAAAAA:BBB(CCCCC^AAAAA)
 
       emitcode ("anl", "a,#!constbyte",
-		SRMask[shCount]);	// 000AAAAA:BBB(CCCCC^AAAAA)
+                SRMask[shCount]);       // 000AAAAA:BBB(CCCCC^AAAAA)
 
-      emitcode ("xch", "a,%s", x);	// BBB(CCCCC^AAAAA):000AAAAA
+      emitcode ("xch", "a,%s", x);      // BBB(CCCCC^AAAAA):000AAAAA
 
-      emitcode ("xrl", "a,%s", x);	// BBBCCCCC:000AAAAA
+      emitcode ("xrl", "a,%s", x);      // BBBCCCCC:000AAAAA
 
-      emitcode ("xch", "a,%s", x);	// 000SAAAA:BBBCCCCC
+      emitcode ("xch", "a,%s", x);      // 000SAAAA:BBBCCCCC
 
       emitcode ("jnb", "acc.%d,!tlabel", 7 - shCount, tlbl->key + 100);
       emitcode ("orl", "a,#!constbyte",
-		(unsigned char) ~SRMask[shCount]);	// 111AAAAA:BBBCCCCC
+                (unsigned char) ~SRMask[shCount]);      // 111AAAAA:BBBCCCCC
 
       emitcode ("", "!tlabeldef", tlbl->key + 100);
-      break;			// SSSSAAAA:BBBCCCCC
+      break;                    // SSSSAAAA:BBBCCCCC
 
-    case 6:			// AABBBBBB:CCDDDDDD
+    case 6:                     // AABBBBBB:CCDDDDDD
 
       tlbl = newiTempLabel (NULL);
       emitcode ("mov", "c,acc.7");
-      AccAXLrl1 (x);		// ABBBBBBC:CDDDDDDA
+      AccAXLrl1 (x);            // ABBBBBBC:CDDDDDDA
 
-      AccAXLrl1 (x);		// BBBBBBCC:DDDDDDAA
+      AccAXLrl1 (x);            // BBBBBBCC:DDDDDDAA
 
-      emitcode ("xch", "a,%s", x);	// DDDDDDAA:BBBBBBCC
+      emitcode ("xch", "a,%s", x);      // DDDDDDAA:BBBBBBCC
 
       emitcode ("anl", "a,#!constbyte",
-		SRMask[shCount]);	// 000000AA:BBBBBBCC
+                SRMask[shCount]);       // 000000AA:BBBBBBCC
 
       emitcode ("jnb", "acc.%d,!tlabel", 7 - shCount, tlbl->key + 100);
       emitcode ("orl", "a,#!constbyte",
-		(unsigned char) ~SRMask[shCount]);	// 111111AA:BBBBBBCC
+                (unsigned char) ~SRMask[shCount]);      // 111111AA:BBBBBBCC
 
       emitcode ("", "!tlabeldef", tlbl->key + 100);
       break;
-    case 7:			// ABBBBBBB:CDDDDDDD
+    case 7:                     // ABBBBBBB:CDDDDDDD
 
       tlbl = newiTempLabel (NULL);
-      emitcode ("mov", "c,acc.7");	// c = A
+      emitcode ("mov", "c,acc.7");      // c = A
 
-      AccAXLrl1 (x);		// BBBBBBBC:DDDDDDDA
+      AccAXLrl1 (x);            // BBBBBBBC:DDDDDDDA
 
-      emitcode ("xch", "a,%s", x);	// DDDDDDDA:BBBBBBCC
+      emitcode ("xch", "a,%s", x);      // DDDDDDDA:BBBBBBCC
 
       emitcode ("anl", "a,#!constbyte",
-		SRMask[shCount]);	// 0000000A:BBBBBBBC
+                SRMask[shCount]);       // 0000000A:BBBBBBBC
 
       emitcode ("jnb", "acc.%d,!tlabel", 7 - shCount, tlbl->key + 100);
       emitcode ("orl", "a,#!constbyte",
-		(unsigned char) ~SRMask[shCount]);	// 1111111A:BBBBBBBC
+                (unsigned char) ~SRMask[shCount]);      // 1111111A:BBBBBBBC
 
       emitcode ("", "!tlabeldef", tlbl->key + 100);
       break;
@@ -7817,11 +8375,11 @@ AccAXRshS (char *x, int shCount)
 
 #ifdef BETTER_LITERAL_SHIFT
 static void
-_loadLeftIntoAx(char 	**lsb, 
-		operand *left, 
-		operand *result,
-		int	offl,
-		int 	offr)
+_loadLeftIntoAx(char    **lsb,
+                operand *left,
+                operand *result,
+                int     offl,
+                int     offr)
 {
   // Get the initial value from left into a pair of registers.
   // MSB must be in A, LSB can be any register.
@@ -7835,29 +8393,29 @@ _loadLeftIntoAx(char 	**lsb,
   if (AOP_NEEDSACC(result))
   {
        char *leftByte;
-       
+
        _startLazyDPSEvaluation();
       if (AOP_TYPE(left) == AOP_DPTR2)
        {
            // Get MSB in A.
-       	   MOVA(aopGet(AOP(left), offl + MSB16, FALSE, FALSE, NULL));
-       	   // get LSB in DP2_RESULT_REG.
-       	   leftByte = aopGet(AOP(left), offl, FALSE, FALSE, DP2_RESULT_REG);
-       	   assert(!strcmp(leftByte, DP2_RESULT_REG));
+           MOVA(aopGet(AOP(left), offl + MSB16, FALSE, FALSE, NULL));
+           // get LSB in DP2_RESULT_REG.
+           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, NULL);
+           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, NULL);
-       	   assert(strcmp(leftByte, DP2_RESULT_REG));
-       	   MOVA(leftByte);
+           }
+           // And MSB in A.
+           leftByte = aopGet(AOP(left), offl + MSB16, FALSE, FALSE, NULL);
+           assert(strcmp(leftByte, DP2_RESULT_REG));
+           MOVA(leftByte);
        }
        _endLazyDPSEvaluation();
        *lsb = DP2_RESULT_REG;
@@ -7865,27 +8423,27 @@ _loadLeftIntoAx(char 	**lsb,
   else
   {
       if (sameRegs (AOP (result), AOP (left)) &&
-      	((offl + MSB16) == offr))
+        ((offl + MSB16) == offr))
       {
-      	  /* don't crash result[offr] */
-      	  MOVA(aopGet(AOP(left), offl, FALSE, FALSE, NULL));
-      	  emitcode ("xch", "a,%s", 
-      	  	    aopGet(AOP(left), offl + MSB16, FALSE, FALSE, DP2_RESULT_REG));
+          /* don't crash result[offr] */
+          MOVA(aopGet(AOP(left), offl, FALSE, FALSE, NULL));
+          emitcode ("xch", "a,%s",
+                    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, NULL));
+          movLeft2Result (left, offl, result, offr, 0);
+          MOVA (aopGet (AOP (left), offl + MSB16, FALSE, FALSE, NULL));
       }
       *lsb = aopGet(AOP (result), offr, FALSE, FALSE, DP2_RESULT_REG);
-      assert(strcmp(*lsb,"a"));      
+      assert(strcmp(*lsb,"a"));
   }
 }
 
 static void
-_storeAxResults(char 	*lsb,
-		operand *result,
-		int	offr)
+_storeAxResults(char    *lsb,
+                operand *result,
+                int     offr)
 {
   _startLazyDPSEvaluation();
   if (AOP_NEEDSACC(result))
@@ -7908,14 +8466,14 @@ _storeAxResults(char 	*lsb,
 /*-----------------------------------------------------------------*/
 static void
 shiftL2Left2Result (operand * left, int offl,
-		    operand * result, int offr, int shCount)
+                    operand * result, int offr, int shCount)
 {
   char *lsb;
 
   _loadLeftIntoAx(&lsb, left, result, offl, offr);
-  
+
   AccAXLsh (lsb, shCount);
-  
+
   _storeAxResults(lsb, result, offr);
 }
 #endif
@@ -7926,13 +8484,13 @@ shiftL2Left2Result (operand * left, int offl,
 /*-----------------------------------------------------------------*/
 static void
 shiftR2Left2Result (operand * left, int offl,
-		    operand * result, int offr,
-		    int shCount, int sign)
+                    operand * result, int offr,
+                    int shCount, int sign)
 {
   char *lsb;
-  
+
   _loadLeftIntoAx(&lsb, left, result, offl, offr);
-  
+
   /* a:x >> shCount (x = lsb(result)) */
   if (sign)
   {
@@ -7942,7 +8500,7 @@ shiftR2Left2Result (operand * left, int offl,
   {
     AccAXRsh(lsb, shCount);
   }
-  
+
   _storeAxResults(lsb, result, offr);
 }
 #endif
@@ -7952,14 +8510,14 @@ shiftR2Left2Result (operand * left, int offl,
 /*-----------------------------------------------------------------*/
 static void
 shiftLLeftOrResult (operand * left, int offl,
-		    operand * result, int offr, int shCount)
+                    operand * result, int offr, int shCount)
 {
   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, DP2_RESULT_REG));
+            aopGet (AOP (result), offr, FALSE, FALSE, DP2_RESULT_REG));
   /* back to result */
   aopPut (AOP (result), "a", offr);
 }
@@ -7971,14 +8529,14 @@ shiftLLeftOrResult (operand * left, int offl,
 /*-----------------------------------------------------------------*/
 static void
 shiftRLeftOrResult (operand * left, int offl,
-		    operand * result, int offr, int shCount)
+                    operand * result, int offr, int shCount)
 {
   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, DP2_RESULT_REG));
+            aopGet (AOP (result), offr, FALSE, FALSE, DP2_RESULT_REG));
   /* back to result */
   aopPut (AOP (result), "a", offr);
 }
@@ -8017,25 +8575,25 @@ genlshTwo (operand * result, operand * left, int shCount)
       _startLazyDPSEvaluation();
 
       if (size > 1)
-	{
-	  if (shCount)
-	  {
-	    _endLazyDPSEvaluation();
-	    shiftL1Left2Result (left, LSB, result, MSB16, shCount);
-      	    aopPut (AOP (result), zero, LSB);	    
-	  }
-	  else
-	  {
-	    movLeft2Result (left, LSB, result, MSB16, 0);
-	    aopPut (AOP (result), zero, LSB);
-	    _endLazyDPSEvaluation();
-	  }
-	}
-	else
-	{
-	  aopPut (AOP (result), zero, LSB);
-	  _endLazyDPSEvaluation();
-	}
+        {
+          if (shCount)
+          {
+            _endLazyDPSEvaluation();
+            shiftL1Left2Result (left, LSB, result, MSB16, shCount);
+            aopPut (AOP (result), zero, LSB);
+          }
+          else
+          {
+            movLeft2Result (left, LSB, result, MSB16, 0);
+            aopPut (AOP (result), zero, LSB);
+            _endLazyDPSEvaluation();
+          }
+        }
+        else
+        {
+          aopPut (AOP (result), zero, LSB);
+          _endLazyDPSEvaluation();
+        }
   }
 
   /*  1 <= shCount <= 7 */
@@ -8043,11 +8601,11 @@ genlshTwo (operand * result, operand * left, int shCount)
     {
       if (size == 1)
       {
-	shiftL1Left2Result (left, LSB, result, LSB, shCount);
+        shiftL1Left2Result (left, LSB, result, LSB, shCount);
       }
       else
       {
-	shiftL2Left2Result (left, LSB, result, LSB, shCount);
+        shiftL2Left2Result (left, LSB, result, LSB, shCount);
       }
     }
 }
@@ -8071,49 +8629,49 @@ shiftLLong (operand * left, operand * result, int offr)
       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, DP2_RESULT_REG));
+          size >= MSB16 + offr && offr != LSB)
+        emitcode ("xch", "a,%s",
+                  aopGet (AOP (left), LSB + offr, FALSE, FALSE, DP2_RESULT_REG));
       else
-	aopPut (AOP (result), "a", LSB + offr);
+        aopPut (AOP (result), "a", LSB + offr);
     }
 
   if (size >= MSB16 + offr)
     {
       if (!(sameRegs (AOP (result), AOP (left)) && size >= MSB16 + offr && offr != LSB))
-	{
-	  MOVA (aopGet (AOP (left), MSB16, FALSE, FALSE, TRUE));
-	}
+        {
+          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, DP2_RESULT_REG));
+          size >= MSB24 + offr && offr != LSB)
+        emitcode ("xch", "a,%s",
+                  aopGet (AOP (left), MSB16 + offr, FALSE, FALSE, DP2_RESULT_REG));
       else
-	aopPut (AOP (result), "a", MSB16 + offr);
+        aopPut (AOP (result), "a", MSB16 + offr);
     }
 
   if (size >= MSB24 + offr)
     {
       if (!(sameRegs (AOP (left), AOP (left)) && size >= MSB24 + offr && offr != LSB))
-	{
-	  MOVA (aopGet (AOP (left), MSB24, FALSE, FALSE, NULL));
-	}
+        {
+          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, DP2_RESULT_REG));
+          size >= MSB32 + offr && offr != LSB)
+        emitcode ("xch", "a,%s",
+                  aopGet (AOP (left), MSB24 + offr, FALSE, FALSE, DP2_RESULT_REG));
       else
-	aopPut (AOP (result), "a", MSB24 + offr);
+        aopPut (AOP (result), "a", MSB24 + offr);
     }
 
   if (size > MSB32 + offr)
     {
       if (!(sameRegs (AOP (result), AOP (left)) && size >= MSB32 + offr && offr != LSB))
-	{
-	  MOVA (aopGet (AOP (left), MSB32, FALSE, FALSE, NULL));
-	}
+        {
+          MOVA (aopGet (AOP (left), MSB32, FALSE, FALSE, NULL));
+        }
       emitcode ("rlc", "a");
       aopPut (AOP (result), "a", MSB32 + offr);
     }
@@ -8142,11 +8700,11 @@ genlshFour (operand * result, operand * left, int shCount)
     {
       shCount -= 24;
       if (shCount)
-	/* lowest order of left goes to the highest
-	   order of the destination */
-	shiftL1Left2Result (left, LSB, result, MSB32, shCount);
+        /* lowest order of left goes to the highest
+           order of the destination */
+        shiftL1Left2Result (left, LSB, result, MSB32, shCount);
       else
-	movLeft2Result (left, LSB, result, MSB32, 0);
+        movLeft2Result (left, LSB, result, MSB32, 0);
       aopPut (AOP (result), zero, LSB);
       aopPut (AOP (result), zero, MSB16);
       aopPut (AOP (result), zero, MSB24);
@@ -8160,12 +8718,12 @@ genlshFour (operand * result, operand * left, int shCount)
       shCount -= 16;
       /* if some more remaining */
       if (shCount)
-	shiftL2Left2Result (left, LSB, result, MSB24, shCount);
+        shiftL2Left2Result (left, LSB, result, MSB24, shCount);
       else
-	{
-	  movLeft2Result (left, MSB16, result, MSB32, 0);
-	  movLeft2Result (left, LSB, result, MSB24, 0);
-	}
+        {
+          movLeft2Result (left, MSB16, result, MSB32, 0);
+          movLeft2Result (left, LSB, result, MSB24, 0);
+        }
       aopPut (AOP (result), zero, MSB16);
       aopPut (AOP (result), zero, LSB);
       return;
@@ -8177,31 +8735,31 @@ genlshFour (operand * result, operand * left, int shCount)
       /* lower order three bytes goes to higher order  three bytes */
       shCount -= 8;
       if (size == 2)
-	{
-	  if (shCount)
-	    shiftL1Left2Result (left, LSB, result, MSB16, shCount);
-	  else
-	    movLeft2Result (left, LSB, result, MSB16, 0);
-	}
+        {
+          if (shCount)
+            shiftL1Left2Result (left, LSB, result, MSB16, shCount);
+          else
+            movLeft2Result (left, LSB, result, MSB16, 0);
+        }
       else
-	{			/* size = 4 */
-	  if (shCount == 0)
-	    {
-	      movLeft2Result (left, MSB24, result, MSB32, 0);
-	      movLeft2Result (left, MSB16, result, MSB24, 0);
-	      movLeft2Result (left, LSB, result, MSB16, 0);
-	      aopPut (AOP (result), zero, LSB);
-	    }
-	  else if (shCount == 1)
-	    shiftLLong (left, result, MSB16);
-	  else
-	    {
-	      shiftL2Left2Result (left, MSB16, result, MSB24, shCount);
-	      shiftL1Left2Result (left, LSB, result, MSB16, shCount);
-	      shiftRLeftOrResult (left, LSB, result, MSB24, 8 - shCount);
-	      aopPut (AOP (result), zero, LSB);
-	    }
-	}
+        {                       /* size = 4 */
+          if (shCount == 0)
+            {
+              movLeft2Result (left, MSB24, result, MSB32, 0);
+              movLeft2Result (left, MSB16, result, MSB24, 0);
+              movLeft2Result (left, LSB, result, MSB16, 0);
+              aopPut (AOP (result), zero, LSB);
+            }
+          else if (shCount == 1)
+            shiftLLong (left, result, MSB16);
+          else
+            {
+              shiftL2Left2Result (left, MSB16, result, MSB24, shCount);
+              shiftL1Left2Result (left, LSB, result, MSB16, shCount);
+              shiftRLeftOrResult (left, LSB, result, MSB24, 8 - shCount);
+              aopPut (AOP (result), zero, LSB);
+            }
+        }
     }
 
   /* 1 <= shCount <= 7 */
@@ -8209,7 +8767,7 @@ genlshFour (operand * result, operand * left, int shCount)
     {
       shiftLLong (left, result, LSB);
       if (shCount == 2)
-	shiftLLong (result, result, LSB);
+        shiftLLong (result, result, LSB);
     }
   /* 3 <= shCount <= 7, optimize */
   else
@@ -8227,9 +8785,9 @@ genlshFour (operand * result, operand * left, int shCount)
 /*-----------------------------------------------------------------*/
 static bool
 genLeftShiftLiteral (operand * left,
-		     operand * right,
-		     operand * result,
-		     iCode * ic)
+                     operand * right,
+                     operand * result,
+                     iCode * ic)
 {
   int shCount = (int) floatFromVal (AOP (right)->aopu.aop_lit);
   int size;
@@ -8244,7 +8802,7 @@ genLeftShiftLiteral (operand * left,
    && (size != 1)
    && (size != 2))
   {
-      D(emitcode (";", "genLeftShiftLiteral wimping out"););	
+      D(emitcode (";", "genLeftShiftLiteral wimping out"););
       return FALSE;
   }
 
@@ -8256,36 +8814,36 @@ genLeftShiftLiteral (operand * left,
 #if 0 // debug spew
   if (IS_SYMOP(left) && OP_SYMBOL(left)->aop)
   {
-  	emitcode(";", "left (%s) is %d", OP_SYMBOL(left)->rname, AOP_TYPE(left));
-  	if (!IS_TRUE_SYMOP(left) && OP_SYMBOL(left)->usl.spillLoc)
-  	{
-  	   emitcode(";", "\taka %s", OP_SYMBOL(left)->usl.spillLoc->rname);
-  	}
+        emitcode(";", "left (%s) is %d", OP_SYMBOL(left)->rname, AOP_TYPE(left));
+        if (!IS_TRUE_SYMOP(left) && OP_SYMBOL(left)->usl.spillLoc)
+        {
+           emitcode(";", "\taka %s", OP_SYMBOL(left)->usl.spillLoc->rname);
+        }
   }
   if (IS_SYMOP(result) && OP_SYMBOL(result)->aop)
   {
-  	emitcode(";", "result (%s) is %d", OP_SYMBOL(result)->rname, AOP_TYPE(result));
-  	if (!IS_TRUE_SYMOP(result) && OP_SYMBOL(result)->usl.spillLoc)
-  	{
-  	   emitcode(";", "\taka %s", OP_SYMBOL(result)->usl.spillLoc->rname);
-  	}  	
-  }  
+        emitcode(";", "result (%s) is %d", OP_SYMBOL(result)->rname, AOP_TYPE(result));
+        if (!IS_TRUE_SYMOP(result) && OP_SYMBOL(result)->usl.spillLoc)
+        {
+           emitcode(";", "\taka %s", OP_SYMBOL(result)->usl.spillLoc->rname);
+        }
+  }
 #endif
-  
+
 #if VIEW_SIZE
   emitcode ("; shift left ", "result %d, left %d", size,
-	    AOP_SIZE (left));
+            AOP_SIZE (left));
 #endif
 
   /* I suppose that the left size >= result size */
   if (shCount == 0)
   {
-  	_startLazyDPSEvaluation();
-      	while (size--)
-	{
-	  movLeft2Result (left, size, result, size, 0);
-	}
-	_endLazyDPSEvaluation();
+        _startLazyDPSEvaluation();
+        while (size--)
+        {
+          movLeft2Result (left, size, result, size, 0);
+        }
+        _endLazyDPSEvaluation();
   }
   else if (shCount >= (size * 8))
   {
@@ -8299,23 +8857,23 @@ genLeftShiftLiteral (operand * left,
   else
   {
       switch (size)
-	{
-	case 1:
-	  genlshOne (result, left, shCount);
-	  break;
-
-	case 2:
-	  genlshTwo (result, left, shCount);
-	  break;
+        {
+        case 1:
+          genlshOne (result, left, shCount);
+          break;
+
+        case 2:
+          genlshTwo (result, left, shCount);
+          break;
 #if 0
-	case 4:
-	  genlshFour (result, left, shCount);
-	  break;
+        case 4:
+          genlshFour (result, left, shCount);
+          break;
 #endif
-	default:
-	  fprintf(stderr, "*** ack! mystery literal shift!\n");	  
-	  break;
-	}
+        default:
+          fprintf(stderr, "*** ack! mystery literal shift!\n");
+          break;
+        }
     }
   freeAsmop (left, NULL, ic, TRUE);
   freeAsmop (result, NULL, ic, TRUE);
@@ -8350,7 +8908,7 @@ genLeftShift (iCode * ic)
     {
       if (genLeftShiftLiteral (left, right, result, ic))
       {
-      	return;
+        return;
       }
     }
 #endif
@@ -8368,7 +8926,7 @@ genLeftShift (iCode * ic)
        * some small improvement.
        */
        emitcode("mov", "b,#!constbyte",
-       	        ((int) floatFromVal (AOP (right)->aopu.aop_lit)) + 1);
+                ((int) floatFromVal (AOP (right)->aopu.aop_lit)) + 1);
   }
   else
   {
@@ -8389,18 +8947,18 @@ genLeftShift (iCode * ic)
       offset = 0;
       _startLazyDPSEvaluation ();
       while (size--)
-	{
-	  l = aopGet (AOP (left), offset, FALSE, TRUE, NULL);
-	  if (*l == '@' && (IS_AOP_PREG (result)))
-	    {
-
-	      emitcode ("mov", "a,%s", l);
-	      aopPut (AOP (result), "a", offset);
-	    }
-	  else
-	    aopPut (AOP (result), l, offset);
-	  offset++;
-	}
+        {
+          l = aopGet (AOP (left), offset, FALSE, TRUE, NULL);
+          if (*l == '@' && (IS_AOP_PREG (result)))
+            {
+
+              emitcode ("mov", "a,%s", l);
+              aopPut (AOP (result), "a", offset);
+            }
+          else
+            aopPut (AOP (result), l, offset);
+          offset++;
+        }
       _endLazyDPSEvaluation ();
     }
 
@@ -8454,7 +9012,7 @@ release:
 /*-----------------------------------------------------------------*/
 static void
 genrshOne (operand * result, operand * left,
-	   int shCount, int sign)
+           int shCount, int sign)
 {
   D (emitcode (";", "genrshOne"););
   shiftR1Left2Result (left, LSB, result, LSB, shCount, sign);
@@ -8467,7 +9025,7 @@ genrshOne (operand * result, operand * left,
 /*-----------------------------------------------------------------*/
 static void
 genrshTwo (operand * result, operand * left,
-	   int shCount, int sign)
+           int shCount, int sign)
 {
   D (emitcode (";", "genrshTwo"););
 
@@ -8478,12 +9036,12 @@ genrshTwo (operand * result, operand * left,
       _startLazyDPSEvaluation();
       if (shCount)
       {
-	shiftR1Left2Result (left, MSB16, result, LSB,
-			    shCount, sign);
-      }			    
+        shiftR1Left2Result (left, MSB16, result, LSB,
+                            shCount, sign);
+      }
       else
       {
-	movLeft2Result (left, MSB16, result, LSB, sign);
+        movLeft2Result (left, MSB16, result, LSB, sign);
       }
       addSign (result, MSB16, sign);
       _endLazyDPSEvaluation();
@@ -8503,7 +9061,7 @@ genrshTwo (operand * result, operand * left,
 /*-----------------------------------------------------------------*/
 static void
 shiftRLong (operand * left, int offl,
-	    operand * result, int sign)
+            operand * result, int sign)
 {
   int isSameRegs=sameRegs(AOP(left),AOP(result));
 
@@ -8513,14 +9071,14 @@ shiftRLong (operand * left, int offl,
   }
 
   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, DP2_RESULT_REG));
+                aopGet(AOP(left), MSB32, FALSE, FALSE, DP2_RESULT_REG));
     } else {
       aopPut (AOP(result), zero, MSB32);
     }
@@ -8536,7 +9094,7 @@ shiftRLong (operand * left, int offl,
 
   if (isSameRegs && offl==MSB16) {
     emitcode ("xch",
-	      "a,%s",aopGet (AOP (left), MSB24, FALSE, FALSE, DP2_RESULT_REG));
+              "a,%s",aopGet (AOP (left), MSB24, FALSE, FALSE, DP2_RESULT_REG));
   } else {
     aopPut (AOP (result), "a", MSB32);
     MOVA (aopGet (AOP (left), MSB24, FALSE, FALSE, NULL));
@@ -8545,7 +9103,7 @@ shiftRLong (operand * left, int offl,
   emitcode ("rrc", "a");
   if (isSameRegs && offl==1) {
     emitcode ("xch", "a,%s",
-	      aopGet (AOP (left), MSB16, FALSE, FALSE, DP2_RESULT_REG));
+              aopGet (AOP (left), MSB16, FALSE, FALSE, DP2_RESULT_REG));
   } else {
     aopPut (AOP (result), "a", MSB24);
     MOVA (aopGet (AOP (left), MSB16, FALSE, FALSE, NULL));
@@ -8566,7 +9124,7 @@ shiftRLong (operand * left, int offl,
 /*-----------------------------------------------------------------*/
 static void
 genrshFour (operand * result, operand * left,
-	    int shCount, int sign)
+            int shCount, int sign)
 {
   D (emitcode (";", "genrshFour"););
 
@@ -8576,9 +9134,9 @@ genrshFour (operand * result, operand * left,
       shCount -= 24;
       _startLazyDPSEvaluation();
       if (shCount)
-	shiftR1Left2Result (left, MSB32, result, LSB, shCount, sign);
+        shiftR1Left2Result (left, MSB32, result, LSB, shCount, sign);
       else
-	movLeft2Result (left, MSB32, result, LSB, sign);
+        movLeft2Result (left, MSB32, result, LSB, sign);
       addSign (result, MSB16, sign);
       _endLazyDPSEvaluation();
     }
@@ -8587,12 +9145,12 @@ genrshFour (operand * result, operand * left,
       shCount -= 16;
       _startLazyDPSEvaluation();
       if (shCount)
-	shiftR2Left2Result (left, MSB24, result, LSB, shCount, sign);
+        shiftR2Left2Result (left, MSB24, result, LSB, shCount, sign);
       else
-	{
-	  movLeft2Result (left, MSB24, result, LSB, 0);
-	  movLeft2Result (left, MSB32, result, MSB16, sign);
-	}
+        {
+          movLeft2Result (left, MSB24, result, LSB, 0);
+          movLeft2Result (left, MSB32, result, MSB16, sign);
+        }
       addSign (result, MSB24, sign);
       _endLazyDPSEvaluation();
     }
@@ -8601,41 +9159,41 @@ genrshFour (operand * result, operand * left,
       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);
-	  movLeft2Result (left, MSB24, result, MSB16, 0);
-	  movLeft2Result (left, MSB32, result, MSB24, sign);
-	  addSign (result, MSB32, sign);
-	}
+        {
+          movLeft2Result (left, MSB16, result, LSB, 0);
+          movLeft2Result (left, MSB24, result, MSB16, 0);
+          movLeft2Result (left, MSB32, result, MSB24, sign);
+          addSign (result, MSB32, sign);
+        }
       else
-	{
-	  shiftR2Left2Result (left, MSB16, result, LSB, shCount, 0);
-	  shiftLLeftOrResult (left, MSB32, result, MSB16, 8 - shCount);
-	  /* the last shift is signed */
-	  shiftR1Left2Result (left, MSB32, result, MSB24, shCount, sign);
-	  addSign (result, MSB32, sign);
-	}
-	_endLazyDPSEvaluation();
+        {
+          shiftR2Left2Result (left, MSB16, result, LSB, shCount, 0);
+          shiftLLeftOrResult (left, MSB32, result, MSB16, 8 - shCount);
+          /* the last shift is signed */
+          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);
-	  if (shCount == 2)
-	    shiftRLong (result, LSB, result, sign);
-	}
+        {
+          shiftRLong (left, LSB, result, sign);
+          if (shCount == 2)
+            shiftRLong (result, LSB, result, sign);
+        }
       else
-	{
-	  shiftR2Left2Result (left, LSB, result, LSB, shCount, 0);
-	  shiftLLeftOrResult (left, MSB24, result, MSB16, 8 - shCount);
-	  shiftR2Left2Result (left, MSB24, result, MSB24, shCount, sign);
-	}
+        {
+          shiftR2Left2Result (left, LSB, result, LSB, shCount, 0);
+          shiftLLeftOrResult (left, MSB24, result, MSB16, 8 - shCount);
+          shiftR2Left2Result (left, MSB24, result, MSB24, shCount, sign);
+        }
     }
 }
 
@@ -8645,10 +9203,10 @@ genrshFour (operand * result, operand * left,
 /*-----------------------------------------------------------------*/
 static bool
 genRightShiftLiteral (operand * left,
-		      operand * right,
-		      operand * result,
-		      iCode * ic,
-		      int sign)
+                      operand * right,
+                      operand * result,
+                      iCode * ic,
+                      int sign)
 {
   int shCount = (int) floatFromVal (AOP (right)->aopu.aop_lit);
   int size;
@@ -8664,7 +9222,7 @@ genRightShiftLiteral (operand * left,
    && (size != 2)
    && (size != 4))
   {
-      D(emitcode (";", "genRightShiftLiteral wimping out"););	
+      D(emitcode (";", "genRightShiftLiteral wimping out"););
       return FALSE;
   }
 
@@ -8675,7 +9233,7 @@ genRightShiftLiteral (operand * left,
 
 #if VIEW_SIZE
   emitcode ("; shift right ", "result %d, left %d", AOP_SIZE (result),
-	    AOP_SIZE (left));
+            AOP_SIZE (left));
 #endif
 
   /* test the LEFT size !!! */
@@ -8687,7 +9245,7 @@ genRightShiftLiteral (operand * left,
       _startLazyDPSEvaluation();
       while (size--)
       {
-	movLeft2Result (left, size, result, size, 0);
+        movLeft2Result (left, size, result, size, 0);
       }
       _endLazyDPSEvaluation();
   }
@@ -8695,34 +9253,34 @@ genRightShiftLiteral (operand * left,
     {
       if (sign)
       {
-	/* get sign in acc.7 */
-	MOVA (aopGet (AOP (left), size - 1, FALSE, FALSE, NULL));
+        /* get sign in acc.7 */
+        MOVA (aopGet (AOP (left), size - 1, FALSE, FALSE, NULL));
       }
       addSign (result, LSB, sign);
     }
   else
     {
       switch (size)
-	{
-	case 1:
-	  genrshOne (result, left, shCount, sign);
-	  break;
-
-	case 2:
-	  genrshTwo (result, left, shCount, sign);
-	  break;
+        {
+        case 1:
+          genrshOne (result, left, shCount, sign);
+          break;
+
+        case 2:
+          genrshTwo (result, left, shCount, sign);
+          break;
 #if 1
-	case 4:
-	  genrshFour (result, left, shCount, sign);
-	  break;
-#endif	  
-	default:
-	  break;
-	}
+        case 4:
+          genrshFour (result, left, shCount, sign);
+          break;
+#endif
+        default:
+          break;
+        }
     }
   freeAsmop (left, NULL, ic, TRUE);
   freeAsmop (result, NULL, ic, TRUE);
-  
+
   return TRUE;
 }
 #endif
@@ -8754,7 +9312,7 @@ genSignedRightShift (iCode * ic)
     {
       if (genRightShiftLiteral (left, right, result, ic, 1))
       {
-      	return;
+        return;
       }
     }
 #endif
@@ -8771,16 +9329,16 @@ genSignedRightShift (iCode * ic)
        * some small improvement.
        */
        emitcode("mov", "b,#!constbyte",
-       	        ((int) floatFromVal (AOP (right)->aopu.aop_lit)) + 1);
+                ((int) floatFromVal (AOP (right)->aopu.aop_lit)) + 1);
   }
   else
   {
-  	MOVB(aopGet (AOP (right), 0, FALSE, FALSE, "b"));
-  	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_USESDPTR(left)); 
+  aopOp (result, ic, FALSE, AOP_USESDPTR(left));
 
   /* now move the left to the result if they are not the
      same */
@@ -8792,18 +9350,18 @@ genSignedRightShift (iCode * ic)
       offset = 0;
       _startLazyDPSEvaluation ();
       while (size--)
-	{
-	  l = aopGet (AOP (left), offset, FALSE, TRUE, NULL);
-	  if (*l == '@' && IS_AOP_PREG (result))
-	    {
-
-	      emitcode ("mov", "a,%s", l);
-	      aopPut (AOP (result), "a", offset);
-	    }
-	  else
-	    aopPut (AOP (result), l, offset);
-	  offset++;
-	}
+        {
+          l = aopGet (AOP (left), offset, FALSE, TRUE, NULL);
+          if (*l == '@' && IS_AOP_PREG (result))
+            {
+
+              emitcode ("mov", "a,%s", l);
+              aopPut (AOP (result), "a", offset);
+            }
+          else
+            aopPut (AOP (result), l, offset);
+          offset++;
+        }
       _endLazyDPSEvaluation ();
     }
 
@@ -8858,7 +9416,7 @@ static void
 genRightShift (iCode * ic)
 {
   operand *right, *left, *result;
-  sym_link *retype;
+  sym_link *letype;
   int size, offset;
   char *l;
   symbol *tlbl, *tlbl1;
@@ -8867,9 +9425,9 @@ genRightShift (iCode * ic)
 
   /* if signed then we do it the hard way preserve the
      sign bit moving it inwards */
-  retype = getSpec (operandType (IC_RESULT (ic)));
+  letype = getSpec (operandType (IC_LEFT (ic)));
 
-  if (!SPEC_USIGN (retype))
+  if (!SPEC_USIGN (letype))
     {
       genSignedRightShift (ic);
       return;
@@ -8895,7 +9453,7 @@ genRightShift (iCode * ic)
     {
       if (genRightShiftLiteral (left, right, result, ic, 0))
       {
-      	return;
+        return;
       }
     }
 #endif
@@ -8905,7 +9463,7 @@ genRightShift (iCode * ic)
      only the lower order byte since shifting
      more that 32 bits make no sense anyway, ( the
      largest size of an object can be only 32 bits ) */
-  
+
   if (AOP_TYPE (right) == AOP_LIT)
   {
       /* Really should be handled by genRightShiftLiteral,
@@ -8913,7 +9471,7 @@ genRightShift (iCode * ic)
        * some small improvement.
        */
        emitcode("mov", "b,#!constbyte",
-       	        ((int) floatFromVal (AOP (right)->aopu.aop_lit)) + 1);
+                ((int) floatFromVal (AOP (right)->aopu.aop_lit)) + 1);
   }
   else
   {
@@ -8934,18 +9492,18 @@ genRightShift (iCode * ic)
       offset = 0;
       _startLazyDPSEvaluation ();
       while (size--)
-	{
-	  l = aopGet (AOP (left), offset, FALSE, TRUE, NULL);
-	  if (*l == '@' && IS_AOP_PREG (result))
-	    {
-
-	      emitcode ("mov", "a,%s", l);
-	      aopPut (AOP (result), "a", offset);
-	    }
-	  else
-	    aopPut (AOP (result), l, offset);
-	  offset++;
-	}
+        {
+          l = aopGet (AOP (left), offset, FALSE, TRUE, NULL);
+          if (*l == '@' && IS_AOP_PREG (result))
+            {
+
+              emitcode ("mov", "a,%s", l);
+              aopPut (AOP (result), "a", offset);
+            }
+          else
+            aopPut (AOP (result), l, offset);
+          offset++;
+        }
       _endLazyDPSEvaluation ();
     }
 
@@ -9013,7 +9571,7 @@ emitPtrByteGet (char *rname, int p_type, bool preserveAinB)
         emitcode ("mov", "b,a");
       emitcode ("movx", "a,@%s", rname);
       break;
-      
+
     case FPOINTER:
       if (preserveAinB)
         emitcode ("mov", "b,a");
@@ -9064,7 +9622,7 @@ emitPtrByteSet (char *rname, int p_type, char *src)
       MOVA (src);
       emitcode ("movx", "@%s,a", rname);
       break;
-      
+
     case FPOINTER:
       MOVA (src);
       emitcode ("movx", "@dptr,a");
@@ -9083,12 +9641,12 @@ emitPtrByteSet (char *rname, int p_type, char *src)
 static void
 genUnpackBits (operand * result, char *rname, int ptype)
 {
-  int offset = 0;	/* result byte offset */
-  int rsize;		/* result size */
-  int rlen = 0;		/* remaining bitfield length */
-  sym_link *etype;	/* bitfield type information */
-  int blen;		/* bitfield length */
-  int bstr;		/* bitfield starting bit within byte */
+  int offset = 0;       /* result byte offset */
+  int rsize;            /* result size */
+  int rlen = 0;         /* remaining bitfield length */
+  sym_link *etype;      /* bitfield type information */
+  int blen;             /* bitfield length */
+  int bstr;             /* bitfield starting bit within byte */
 
   D(emitcode (";     genUnpackBits",""));
 
@@ -9130,7 +9688,7 @@ finish:
     {
       rsize -= offset;
       while (rsize--)
-	aopPut (AOP (result), zero, offset++);
+        aopPut (AOP (result), zero, offset++);
     }
 }
 
@@ -9140,8 +9698,8 @@ finish:
 /*-----------------------------------------------------------------*/
 static void
 genDataPointerGet (operand * left,
-		   operand * result,
-		   iCode * ic)
+                   operand * result,
+                   iCode * ic)
 {
   char *l;
   char buff[256];
@@ -9154,16 +9712,16 @@ genDataPointerGet (operand * left,
   _startLazyDPSEvaluation ();
   while (size--)
     {
-	if (offset)
-	{
-	    SNPRINTF (buff, sizeof(buff), 
-		      "(%s + %d)", l + 1, offset);
-	}
-	else
-	{
-	    SNPRINTF (buff, sizeof(buff), 
-		      "%s", l + 1);
-	}
+        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 ();
@@ -9177,9 +9735,9 @@ genDataPointerGet (operand * left,
 /*-----------------------------------------------------------------*/
 static void
 genNearPointerGet (operand * left,
-		   operand * result,
-		   iCode * ic,
-		   iCode *pi)
+                   operand * result,
+                   iCode * ic,
+                   iCode *pi)
 {
   asmop *aop = NULL;
   regs *preg;
@@ -9195,12 +9753,12 @@ genNearPointerGet (operand * left,
   aopOp (left, ic, FALSE, FALSE);
 
   /* if left is rematerialisable and
-     result is not bit variable type and
+     result is not bitfield variable type and
      the left is pointer to data space i.e
      lower 128 bytes of space */
   if (AOP_TYPE (left) == AOP_IMMD &&
-      !IS_BITVAR (retype) &&
-      !IS_BITVAR (letype) &&
+      !IS_BITFIELD (retype) &&
+      !IS_BITFIELD (letype) &&
       DCL_TYPE (ltype) == POINTER)
     {
       genDataPointerGet (left, result, ic);
@@ -9215,8 +9773,8 @@ genNearPointerGet (operand * left,
       aop = newAsmop (0);
       preg = getFreePtr (ic, &aop, FALSE);
       emitcode ("mov", "%s,%s",
-		preg->name,
-		aopGet (AOP (left), 0, FALSE, TRUE, DP2_RESULT_REG));
+                preg->name,
+                aopGet (AOP (left), 0, FALSE, TRUE, DP2_RESULT_REG));
       rname = preg->name;
     }
   else
@@ -9226,7 +9784,7 @@ genNearPointerGet (operand * left,
   aopOp (result, ic, FALSE, FALSE);
 
   /* if bitfield then unpack the bits */
-  if (IS_BITVAR (retype) || IS_BITVAR (letype))
+  if (IS_BITFIELD (retype) || IS_BITFIELD (letype))
     genUnpackBits (result, rname, POINTER);
   else
     {
@@ -9235,24 +9793,24 @@ genNearPointerGet (operand * left,
       int offset = 0;
 
       while (size--)
-	{
-	  if (IS_AOP_PREG (result) || AOP_TYPE (result) == AOP_STK)
-	    {
-
-	      emitcode ("mov", "a,@%s", rname);
-	      aopPut (AOP (result), "a", offset);
-	    }
-	  else
-	    {
-	      SNPRINTF (buff, sizeof(buff), "@%s", rname);
-	      aopPut (AOP (result), buff, offset);
-	    }
-	  offset++;
-	  if (size || pi)
-	    {
-		emitcode ("inc", "%s", rname);
-	    }
-	}
+        {
+          if (IS_AOP_PREG (result) || AOP_TYPE (result) == AOP_STK)
+            {
+
+              emitcode ("mov", "a,@%s", rname);
+              aopPut (AOP (result), "a", offset);
+            }
+          else
+            {
+              SNPRINTF (buff, sizeof(buff), "@%s", rname);
+              aopPut (AOP (result), buff, offset);
+            }
+          offset++;
+          if (size || pi)
+            {
+                emitcode ("inc", "%s", rname);
+            }
+        }
     }
 
   /* now some housekeeping stuff */
@@ -9260,7 +9818,7 @@ genNearPointerGet (operand * left,
     {
       /* we had to allocate for this iCode */
       if (pi) { /* post increment present */
-	aopPut(AOP ( left ),rname,0);
+        aopPut(AOP ( left ),rname,0);
       }
       freeAsmop (NULL, aop, ic, TRUE);
     }
@@ -9272,15 +9830,15 @@ genNearPointerGet (operand * left,
          we have to point it back to where it
          belongs */
       if (AOP_SIZE (result) > 1 &&
-	  !OP_SYMBOL (left)->remat &&
-	  (OP_SYMBOL (left)->liveTo > ic->seq ||
-	   ic->depth) &&
-	  !pi)
-	{
-	  int size = AOP_SIZE (result) - 1;
-	  while (size--)
-	    emitcode ("dec", "%s", rname);
-	}
+          !OP_SYMBOL (left)->remat &&
+          (OP_SYMBOL (left)->liveTo > ic->seq ||
+           ic->depth) &&
+          !pi)
+        {
+          int size = AOP_SIZE (result) - 1;
+          while (size--)
+            emitcode ("dec", "%s", rname);
+        }
     }
 
   /* done */
@@ -9293,9 +9851,9 @@ genNearPointerGet (operand * left,
 /*-----------------------------------------------------------------*/
 static void
 genPagedPointerGet (operand * left,
-		    operand * result,
-		    iCode * ic,
-		    iCode * pi)
+                    operand * result,
+                    iCode * ic,
+                    iCode * pi)
 {
   asmop *aop = NULL;
   regs *preg;
@@ -9315,8 +9873,8 @@ genPagedPointerGet (operand * left,
       aop = newAsmop (0);
       preg = getFreePtr (ic, &aop, FALSE);
       emitcode ("mov", "%s,%s",
-		preg->name,
-		aopGet (AOP (left), 0, FALSE, TRUE, NULL));
+                preg->name,
+                aopGet (AOP (left), 0, FALSE, TRUE, NULL));
       rname = preg->name;
     }
   else
@@ -9326,7 +9884,7 @@ genPagedPointerGet (operand * left,
   aopOp (result, ic, FALSE, FALSE);
 
   /* if bitfield then unpack the bits */
-  if (IS_BITVAR (retype) || IS_BITVAR (letype))
+  if (IS_BITFIELD (retype) || IS_BITFIELD (letype))
     genUnpackBits (result, rname, PPOINTER);
   else
     {
@@ -9335,16 +9893,16 @@ genPagedPointerGet (operand * left,
       int offset = 0;
 
       while (size--)
-	{
+        {
 
-	  emitcode ("movx", "a,@%s", rname);
-	  aopPut (AOP (result), "a", offset);
+          emitcode ("movx", "a,@%s", rname);
+          aopPut (AOP (result), "a", offset);
 
-	  offset++;
+          offset++;
 
-	  if (size || pi)
-	    emitcode ("inc", "%s", rname);
-	}
+          if (size || pi)
+            emitcode ("inc", "%s", rname);
+        }
     }
 
   /* now some housekeeping stuff */
@@ -9362,15 +9920,15 @@ genPagedPointerGet (operand * left,
          we have to point it back to where it
          belongs */
       if (AOP_SIZE (result) > 1 &&
-	  !OP_SYMBOL (left)->remat &&
-	  (OP_SYMBOL (left)->liveTo > ic->seq ||
-	   ic->depth) &&
-	  !pi)
-	{
-	  int size = AOP_SIZE (result) - 1;
-	  while (size--)
-	    emitcode ("dec", "%s", rname);
-	}
+          !OP_SYMBOL (left)->remat &&
+          (OP_SYMBOL (left)->liveTo > ic->seq ||
+           ic->depth) &&
+          !pi)
+        {
+          int size = AOP_SIZE (result) - 1;
+          while (size--)
+            emitcode ("dec", "%s", rname);
+        }
     }
 
   /* done */
@@ -9383,7 +9941,7 @@ genPagedPointerGet (operand * left,
 /*-----------------------------------------------------------------*/
 static void
 genFarPointerGet (operand * left,
-		  operand * result, iCode * ic, iCode *pi)
+                  operand * result, iCode * ic, iCode *pi)
 {
     int size, offset, dopi=1;
   sym_link *retype = getSpec (operandType (result));
@@ -9398,46 +9956,46 @@ genFarPointerGet (operand * left,
     {
       /* if this is remateriazable */
       if (AOP_TYPE (left) == AOP_IMMD)
-	{
-	  emitcode ("mov", "dptr,%s", aopGet (AOP (left), 0, TRUE, FALSE, NULL));
-	}
+        {
+          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, 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, 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, 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, NULL));
-	      emitcode ("pop", "dph");
-	      emitcode ("pop", "dpl");
-	      dopi =0;
-	    }
-	  _endLazyDPSEvaluation ();
-	}
+        {
+          /* 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, 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, 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, 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, NULL));
+              emitcode ("pop", "dph");
+              emitcode ("pop", "dpl");
+              dopi =0;
+            }
+          _endLazyDPSEvaluation ();
+        }
     }
   /* so dptr know contains the address */
   aopOp (result, ic, FALSE, (AOP_INDPTRn(left) ? FALSE : TRUE));
 
   /* if bit then unpack */
-  if (IS_BITVAR (retype) || IS_BITVAR (letype)) {
+  if (IS_BITFIELD (retype) || IS_BITFIELD (letype)) {
       if (AOP_INDPTRn(left)) {
-	  genSetDPTR(AOP(left)->aopu.dptr);
+          genSetDPTR(AOP(left)->aopu.dptr);
       }
       genUnpackBits (result, "dptr", FPOINTER);
       if (AOP_INDPTRn(left)) {
-	  genSetDPTR(0);
+          genSetDPTR(0);
       }
   } else
     {
@@ -9445,55 +10003,55 @@ genFarPointerGet (operand * left,
       offset = 0;
 
       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++);
-	  }
+          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 ();
+          _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) {
       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 ();
+          _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 ((AOP_IS_STR(left) || AOP_INDPTRn(left)) && 
-	     AOP_SIZE(result) > 1 &&
-	     IS_SYMOP(left) &&
-	     (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);
+          genSetDPTR(AOP(left)->aopu.dptr);
       }
       while (size--) emitcode ("lcall","__decdptr");
       if (AOP_INDPTRn(left)) {
-	  genSetDPTR(0);
+          genSetDPTR(0);
       }
   }
 
@@ -9506,7 +10064,7 @@ genFarPointerGet (operand * left,
 /*-----------------------------------------------------------------*/
 static void
 genCodePointerGet (operand * left,
-		    operand * result, iCode * ic, iCode *pi)
+                    operand * result, iCode * ic, iCode *pi)
 {
   int size, offset, dopi=1;
   sym_link *retype = getSpec (operandType (result));
@@ -9519,106 +10077,106 @@ genCodePointerGet (operand * left,
     {
       /* if this is remateriazable */
       if (AOP_TYPE (left) == AOP_IMMD)
-	{
-	  emitcode ("mov", "dptr,%s", aopGet (AOP (left), 0, TRUE, FALSE, NULL));
-	}
+        {
+          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, 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, 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, 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, NULL));
-	      emitcode ("pop", "dph");
-	      emitcode ("pop", "dpl");
-	      dopi=0;
-	    }
-	  _endLazyDPSEvaluation ();
-	}
+        {                       /* 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, 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, 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, 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, NULL));
+              emitcode ("pop", "dph");
+              emitcode ("pop", "dpl");
+              dopi=0;
+            }
+          _endLazyDPSEvaluation ();
+        }
     }
   /* so dptr know contains the address */
   aopOp (result, ic, FALSE, (AOP_INDPTRn(left) ? FALSE : TRUE));
 
   /* if bit then unpack */
-  if (IS_BITVAR (retype)) {
+  if (IS_BITFIELD (retype)) {
       if (AOP_INDPTRn(left)) {
-	  genSetDPTR(AOP(left)->aopu.dptr);
+          genSetDPTR(AOP(left)->aopu.dptr);
       }
       genUnpackBits (result, "dptr", CPOINTER);
       if (AOP_INDPTRn(left)) {
-	  genSetDPTR(0);
+          genSetDPTR(0);
       }
   } else
     {
       size = AOP_SIZE (result);
       offset = 0;
       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++);
-	  }
+          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 ();
+          _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) {
       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 ();
+          _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_INDPTRn(left)) && 
-	     AOP_SIZE(result) > 1 &&
-	     (OP_SYMBOL (left)->liveTo > ic->seq || ic->depth)) {
-      
+  } 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);
+          genSetDPTR(AOP(left)->aopu.dptr);
       }
       while (size--) emitcode ("lcall","__decdptr");
       if (AOP_INDPTRn(left)) {
-	  genSetDPTR(0);
+          genSetDPTR(0);
       }
   }
-  
+
   freeAsmop (left, NULL, ic, TRUE);
   freeAsmop (result, NULL, ic, TRUE);
 }
@@ -9628,7 +10186,7 @@ genCodePointerGet (operand * left,
 /*-----------------------------------------------------------------*/
 static void
 genGenPointerGet (operand * left,
-		  operand * result, iCode * ic, iCode * pi)
+                  operand * result, iCode * ic, iCode * pi)
 {
   int size, offset;
   sym_link *retype = getSpec (operandType (result));
@@ -9642,32 +10200,32 @@ genGenPointerGet (operand * left,
      then we do nothing else we move the value to dptr */
   if (AOP_TYPE (left) != AOP_STR)
     {
-      /* if this is remateriazable */
+      /* if this is rematerializable */
       if (AOP_TYPE (left) == AOP_IMMD)
-	{
-	  emitcode ("mov", "dptr,%s", aopGet (AOP (left), 0, TRUE, FALSE, NULL));
-	  if (AOP(left)->aopu.aop_immd.from_cast_remat) 
-	    {
-		MOVB(aopGet(AOP (left), AOP_SIZE(left)-1, FALSE, FALSE, NULL));
-	    }
-	    else
-	    {
-		emitcode ("mov", "b,#%d", pointerCode (retype));
-	    }
-	}
+        {
+          emitcode ("mov", "dptr,%s", aopGet (AOP (left), 0, TRUE, FALSE, NULL));
+          if (AOP(left)->aopu.aop_immd.from_cast_remat)
+            {
+              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 ();
-	    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,NULL));
-		emitcode ("mov", "b,%s", aopGet (AOP(left),3,FALSE,FALSE,NULL));
-	    } else {
-		emitcode ("mov", "b,%s", aopGet (AOP(left),2,FALSE,FALSE,NULL));
-	    }
-	    _endLazyDPSEvaluation ();
-	}
+        {                       /* we need to get it byte by byte */
+          _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,NULL));
+              emitcode ("mov", "b,%s", aopGet (AOP(left),3,FALSE,FALSE,NULL));
+          } else {
+              emitcode ("mov", "b,%s", aopGet (AOP(left),2,FALSE,FALSE,NULL));
+          }
+          _endLazyDPSEvaluation ();
+        }
     }
 
   /* so dptr-b now contains the address */
@@ -9676,60 +10234,60 @@ genGenPointerGet (operand * left,
   _G.bInUse--;
 
   /* if bit then unpack */
-  if (IS_BITVAR (retype) || IS_BITVAR (letype))
+  if (IS_BITFIELD (retype) || IS_BITFIELD (letype))
   {
     genUnpackBits (result, "dptr", GPOINTER);
   }
   else
     {
-	size = AOP_SIZE (result);
-	offset = 0;
-
-	while (size--)
-	{
-	    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");
-	    }
-	}
+        size = AOP_SIZE (result);
+        offset = 0;
+
+        while (size--)
+        {
+            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);	
-    
+        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)) {
-      
+             (OP_SYMBOL (left)->liveTo > ic->seq || ic->depth)) {
+
       size = AOP_SIZE (result) - 1;
       while (size--) emitcode ("lcall","__decdptr");
   }
@@ -9768,11 +10326,12 @@ genPointerGet (iCode * ic, iCode *pi)
     }
   /* special case when cast remat */
   if (p_type == GPOINTER && OP_SYMBOL(left)->remat &&
-      IS_CAST_ICODE(OP_SYMBOL(left)->rematiCode)) {
-	  left = IC_RIGHT(OP_SYMBOL(left)->rematiCode);
-	  type = operandType (left);
-	  p_type = DCL_TYPE (type);
-  }
+      IS_CAST_ICODE(OP_SYMBOL(left)->rematiCode))
+    {
+      left = IC_RIGHT(OP_SYMBOL(left)->rematiCode);
+      type = operandType (left);
+      p_type = DCL_TYPE (type);
+    }
   /* now that we have the pointer type we assign
      the pointer values */
   switch (p_type)
@@ -9807,15 +10366,15 @@ genPointerGet (iCode * ic, iCode *pi)
 /*-----------------------------------------------------------------*/
 static void
 genPackBits (sym_link * etype,
-	     operand * right,
-	     char *rname, int p_type)
+             operand * right,
+             char *rname, int p_type)
 {
-  int offset = 0;	/* source byte offset */
-  int rlen = 0;		/* remaining bitfield length */
-  int blen;		/* bitfield length */
-  int bstr;		/* bitfield starting bit within byte */
-  int litval;		/* source literal value (if AOP_LIT) */
-  unsigned char mask;	/* bitmask within current byte */
+  int offset = 0;       /* source byte offset */
+  int rlen = 0;         /* remaining bitfield length */
+  int blen;             /* bitfield length */
+  int bstr;             /* bitfield starting bit within byte */
+  int litval;           /* source literal value (if AOP_LIT) */
+  unsigned char mask;   /* bitmask within current byte */
 
   D(emitcode (";     genPackBits",""));
 
@@ -9826,7 +10385,7 @@ genPackBits (sym_link * etype,
   if (blen < 8)
     {
       mask = ((unsigned char) (0xFF << (blen + bstr)) |
-	      (unsigned char) (0xFF >> (8 - bstr)));
+              (unsigned char) (0xFF >> (8 - bstr)));
 
       if (AOP_TYPE (right) == AOP_LIT)
         {
@@ -9866,7 +10425,7 @@ genPackBits (sym_link * etype,
               AccLsh (bstr);
               emitcode ("anl", "a,#!constbyte", (~mask) & 0xff);
 
-    	      /* transfer A to B and get next byte */
+              /* transfer A to B and get next byte */
               emitPtrByteGet (rname, p_type, TRUE);
 
               emitcode ("anl", "a,#!constbyte", mask);
@@ -9884,7 +10443,7 @@ genPackBits (sym_link * etype,
   /* all except the partial byte at the end                 */
   for (rlen=blen;rlen>=8;rlen-=8)
     {
-      emitPtrByteSet (rname, p_type, 
+      emitPtrByteSet (rname, p_type,
                       aopGet (AOP (right), offset++, FALSE, TRUE, NULL) );
       if (rlen>8)
         emitcode ("inc", "%s", rname);
@@ -9894,7 +10453,7 @@ genPackBits (sym_link * etype,
   if (rlen)
     {
       mask = (((unsigned char) -1 << rlen) & 0xff);
-      
+
       if (AOP_TYPE (right) == AOP_LIT)
         {
           /* Case with partial byte and literal source
@@ -9915,7 +10474,7 @@ genPackBits (sym_link * etype,
           MOVA (aopGet (AOP (right), offset++, FALSE, FALSE, NULL));
           emitcode ("anl", "a,#!constbyte", (~mask) & 0xff);
 
-	  /* transfer A to B and get next byte */
+          /* transfer A to B and get next byte */
           emitPtrByteGet (rname, p_type, TRUE);
 
           emitcode ("anl", "a,#!constbyte", mask);
@@ -9934,8 +10493,8 @@ genPackBits (sym_link * etype,
 /*-----------------------------------------------------------------*/
 static void
 genDataPointerSet (operand * right,
-		   operand * result,
-		   iCode * ic)
+                   operand * result,
+                   iCode * ic)
 {
   int size, offset = 0;
   char *l, buff[256];
@@ -9947,16 +10506,16 @@ genDataPointerSet (operand * right,
   while (size--)
     {
       if (offset)
-	{
-	    SNPRINTF (buff, sizeof(buff), "(%s + %d)", l + 1, offset);
-	}
+        {
+            SNPRINTF (buff, sizeof(buff), "(%s + %d)", l + 1, offset);
+        }
       else
-	{
-	    SNPRINTF (buff, sizeof(buff), "%s", l + 1);
-	}
-	
+        {
+            SNPRINTF (buff, sizeof(buff), "%s", l + 1);
+        }
+
       emitcode ("mov", "%s,%s", buff,
-		aopGet (AOP (right), offset++, FALSE, FALSE, NULL));
+                aopGet (AOP (right), offset++, FALSE, FALSE, NULL));
     }
 
   freeAsmop (right, NULL, ic, TRUE);
@@ -9968,9 +10527,9 @@ genDataPointerSet (operand * right,
 /*-----------------------------------------------------------------*/
 static void
 genNearPointerSet (operand * right,
-		   operand * result,
-		   iCode * ic,
-		   iCode * pi)
+                   operand * result,
+                   iCode * ic,
+                   iCode * pi)
 {
   asmop *aop = NULL;
   char *rname, *l;
@@ -9999,12 +10558,12 @@ genNearPointerSet (operand * right,
     {
       /* 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, NULL));
+                preg->name,
+                aopGet (AOP (result), 0, FALSE, TRUE, NULL));
       rname = preg->name;
     }
   else
@@ -10013,8 +10572,8 @@ genNearPointerSet (operand * right,
   aopOp (right, ic, FALSE, FALSE);
 
   /* if bitfield then unpack the bits */
-  if (IS_BITVAR (retype) || IS_BITVAR (letype))
-    genPackBits ((IS_BITVAR (retype) ? retype : letype), right, rname, POINTER);
+  if (IS_BITFIELD (retype) || IS_BITFIELD (letype))
+    genPackBits ((IS_BITFIELD (retype) ? retype : letype), right, rname, POINTER);
   else
     {
       /* we have can just get the values */
@@ -10022,19 +10581,19 @@ genNearPointerSet (operand * right,
       int offset = 0;
 
       while (size--)
-	{
-	  l = aopGet (AOP (right), offset, FALSE, TRUE, NULL);
-	  if (*l == '@')
-	    {
-	      MOVA (l);
-	      emitcode ("mov", "@%s,a", rname);
-	    }
-	  else
-	    emitcode ("mov", "@%s,%s", rname, l);
-	  if (size || pi)
-	    emitcode ("inc", "%s", rname);
-	  offset++;
-	}
+        {
+          l = aopGet (AOP (right), offset, FALSE, TRUE, NULL);
+          if (*l == '@')
+            {
+              MOVA (l);
+              emitcode ("mov", "@%s,a", rname);
+            }
+          else
+            emitcode ("mov", "@%s,%s", rname, l);
+          if (size || pi)
+            emitcode ("inc", "%s", rname);
+          offset++;
+        }
     }
 
   /* now some housekeeping stuff */
@@ -10052,15 +10611,15 @@ genNearPointerSet (operand * right,
          we have to point it back to where it
          belongs */
       if (AOP_SIZE (right) > 1 &&
-	  !OP_SYMBOL (result)->remat &&
-	  (OP_SYMBOL (result)->liveTo > ic->seq ||
-	   ic->depth) &&
-	  !pi)
-	{
-	  int size = AOP_SIZE (right) - 1;
-	  while (size--)
-	    emitcode ("dec", "%s", rname);
-	}
+          !OP_SYMBOL (result)->remat &&
+          (OP_SYMBOL (result)->liveTo > ic->seq ||
+           ic->depth) &&
+          !pi)
+        {
+          int size = AOP_SIZE (right) - 1;
+          while (size--)
+            emitcode ("dec", "%s", rname);
+        }
     }
 
   /* done */
@@ -10076,9 +10635,9 @@ genNearPointerSet (operand * right,
 /*-----------------------------------------------------------------*/
 static void
 genPagedPointerSet (operand * right,
-		    operand * result,
-		    iCode * ic,
-		    iCode *pi)
+                    operand * result,
+                    iCode * ic,
+                    iCode *pi)
 {
   asmop *aop = NULL;
   char *rname;
@@ -10095,12 +10654,12 @@ genPagedPointerSet (operand * right,
     {
       /* 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, NULL));
+                preg->name,
+                aopGet (AOP (result), 0, FALSE, TRUE, NULL));
       rname = preg->name;
     }
   else
@@ -10109,8 +10668,8 @@ genPagedPointerSet (operand * right,
   aopOp (right, ic, FALSE, FALSE);
 
   /* if bitfield then unpack the bits */
-  if (IS_BITVAR (retype) || IS_BITVAR (letype))
-    genPackBits ((IS_BITVAR (retype) ? retype : letype), right, rname, PPOINTER);
+  if (IS_BITFIELD (retype) || IS_BITFIELD (letype))
+    genPackBits ((IS_BITFIELD (retype) ? retype : letype), right, rname, PPOINTER);
   else
     {
       /* we have can just get the values */
@@ -10118,16 +10677,16 @@ genPagedPointerSet (operand * right,
       int offset = 0;
 
       while (size--)
-	{
-	  MOVA (aopGet (AOP (right), offset, FALSE, TRUE, NULL));
+        {
+          MOVA (aopGet (AOP (right), offset, FALSE, TRUE, NULL));
 
-	  emitcode ("movx", "@%s,a", rname);
+          emitcode ("movx", "@%s,a", rname);
 
-	  if (size || pi)
-	    emitcode ("inc", "%s", rname);
+          if (size || pi)
+            emitcode ("inc", "%s", rname);
 
-	  offset++;
-	}
+          offset++;
+        }
     }
 
   /* now some housekeeping stuff */
@@ -10145,15 +10704,15 @@ genPagedPointerSet (operand * right,
          we have to point it back to where it
          belongs */
       if (AOP_SIZE (right) > 1 &&
-	  !OP_SYMBOL (result)->remat &&
-	  (OP_SYMBOL (result)->liveTo > ic->seq ||
-	   ic->depth) &&
-	  !pi)
-	{
-	  int size = AOP_SIZE (right) - 1;
-	  while (size--)
-	    emitcode ("dec", "%s", rname);
-	}
+          !OP_SYMBOL (result)->remat &&
+          (OP_SYMBOL (result)->liveTo > ic->seq ||
+           ic->depth) &&
+          !pi)
+        {
+          int size = AOP_SIZE (right) - 1;
+          while (size--)
+            emitcode ("dec", "%s", rname);
+        }
     }
 
   /* done */
@@ -10169,7 +10728,7 @@ genPagedPointerSet (operand * right,
 /*-----------------------------------------------------------------*/
 static void
 genFarPointerSet (operand * right,
-		  operand * result, iCode * ic, iCode *pi)
+                  operand * result, iCode * ic, iCode *pi)
 {
   int size, offset, dopi=1;
   sym_link *retype = getSpec (operandType (right));
@@ -10183,103 +10742,103 @@ genFarPointerSet (operand * right,
     {
       /* if this is remateriazable */
       if (AOP_TYPE (result) == AOP_IMMD)
-	emitcode ("mov", "dptr,%s", 
-		  aopGet (AOP (result), 0, TRUE, FALSE, NULL));
+        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, 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, 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, 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, NULL));
-	      emitcode ("pop", "dph");
-	      emitcode ("pop", "dpl");
-	      dopi=0;
-	    }
-	  _endLazyDPSEvaluation ();
-	}
+        {
+          /* 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, 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, 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, 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, NULL));
+              emitcode ("pop", "dph");
+              emitcode ("pop", "dpl");
+              dopi=0;
+            }
+          _endLazyDPSEvaluation ();
+        }
     }
   /* so dptr know contains the address */
   aopOp (right, ic, FALSE, (AOP_INDPTRn(result) ? FALSE : TRUE));
 
   /* if bit then unpack */
-  if (IS_BITVAR (retype) || IS_BITVAR (letype)) {
+  if (IS_BITFIELD (retype) || IS_BITFIELD (letype)) {
       if (AOP_INDPTRn(result)) {
-	  genSetDPTR(AOP(result)->aopu.dptr);
+          genSetDPTR(AOP(result)->aopu.dptr);
       }
-      genPackBits ((IS_BITVAR (retype) ? retype : letype), right, "dptr", FPOINTER);
+      genPackBits ((IS_BITFIELD (retype) ? retype : letype), right, "dptr", FPOINTER);
       if (AOP_INDPTRn(result)) {
-	  genSetDPTR(0);
+          genSetDPTR(0);
       }
   } else {
       size = AOP_SIZE (right);
       offset = 0;
       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);
-	  }
+          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 ();
+          _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) {
       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 ();
+          _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_INDPTRn(result)) && 
-	     AOP_SIZE(right) > 1 &&
-	     (OP_SYMBOL (result)->liveTo > ic->seq || ic->depth)) {
-      
+  } 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);
-      } 
+          genSetDPTR(AOP(result)->aopu.dptr);
+      }
       while (size--) emitcode ("lcall","__decdptr");
       if (AOP_INDPTRn(result)) {
-	  genSetDPTR(0);
+          genSetDPTR(0);
       }
   }
   freeAsmop (result, NULL, ic, TRUE);
@@ -10291,7 +10850,7 @@ genFarPointerSet (operand * right,
 /*-----------------------------------------------------------------*/
 static void
 genGenPointerSet (operand * right,
-		  operand * result, iCode * ic, iCode *pi)
+                  operand * result, iCode * ic, iCode *pi)
 {
   int size, offset;
   sym_link *retype = getSpec (operandType (right));
@@ -10306,102 +10865,102 @@ genGenPointerSet (operand * right,
       _startLazyDPSEvaluation ();
       /* if this is remateriazable */
       if (AOP_TYPE (result) == AOP_IMMD)
-	{
-	  emitcode ("mov", "dptr,%s", aopGet (AOP (result), 0, TRUE, FALSE, NULL));
-	  if (AOP(result)->aopu.aop_immd.from_cast_remat) 
-	  {
-	      MOVB(aopGet(AOP (result), AOP_SIZE(result)-1, FALSE, FALSE, NULL));
-	  }
-	  else
-	  {
-	      emitcode ("mov", 
-			"b,%s + 1", aopGet (AOP (result), 0, TRUE, FALSE, NULL));
-	  }
-	}
+        {
+          emitcode ("mov", "dptr,%s", aopGet (AOP (result), 0, TRUE, FALSE, NULL));
+          if (AOP(result)->aopu.aop_immd.from_cast_remat)
+          {
+              MOVB(aopGet(AOP (result), AOP_SIZE(result)-1, FALSE, FALSE, NULL));
+          }
+          else
+          {
+              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, 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, NULL));
-	    emitcode ("mov", "b,%s", aopGet (AOP (result), 3, FALSE, FALSE, NULL));
-	  } else {
-	    emitcode ("mov", "b,%s", aopGet (AOP (result), 2, FALSE, FALSE, NULL));
-	  }
-	}
+        {                       /* we need to get it byte by byte */
+          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, NULL));
+            emitcode ("mov", "b,%s", aopGet (AOP (result), 3, FALSE, FALSE, NULL));
+          } else {
+            emitcode ("mov", "b,%s", aopGet (AOP (result), 2, FALSE, FALSE, NULL));
+          }
+        }
       _endLazyDPSEvaluation ();
     }
   /* 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))
+  if (IS_BITFIELD (retype) || IS_BITFIELD (letype))
     {
-	genPackBits ((IS_BITVAR (retype) ? retype : letype), right, "dptr", GPOINTER);
+        genPackBits ((IS_BITFIELD (retype) ? retype : letype), right, "dptr", GPOINTER);
     }
   else
     {
-	size = AOP_SIZE (right);
-	offset = 0;
-
-	_startLazyDPSEvaluation ();
-	while (size--)
-	{
-	    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));
-
-		genSetDPTR (0);
-		_flushLazyDPS ();		
-		emitcode ("lcall", "__gptrput");
-	    }
-	    
-	    if (size || (pi && AOP_TYPE (result) != AOP_IMMD))
-	    {
-		emitcode ("inc", "dptr");
-	    }
-	}
-	_endLazyDPSEvaluation ();
+        size = AOP_SIZE (right);
+        offset = 0;
+
+        _startLazyDPSEvaluation ();
+        while (size--)
+        {
+            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));
+
+                genSetDPTR (0);
+                _flushLazyDPS ();
+                emitcode ("lcall", "__gptrput");
+            }
+
+            if (size || (pi && AOP_TYPE (result) != AOP_IMMD))
+            {
+                emitcode ("inc", "dptr");
+            }
+        }
+        _endLazyDPSEvaluation ();
     }
 
   if (pi && AOP_TYPE (result) != AOP_IMMD) {
       _startLazyDPSEvaluation ();
-      
+
       aopPut (AOP(result),"dpl",0);
       aopPut (AOP(result),"dph",1);
       if (options.model == MODEL_FLAT24) {
-	  aopPut (AOP(result),"dpx",2);
-	  aopPut (AOP(result),"b",3);
+          aopPut (AOP(result),"dpx",2);
+          aopPut (AOP(result),"b",3);
       } else {
-	  aopPut (AOP(result),"b",2);
+          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)) {
-      
+             (OP_SYMBOL (result)->liveTo > ic->seq || ic->depth)) {
+
       size = AOP_SIZE (right) - 1;
       while (size--) emitcode ("lcall","__decdptr");
   }
@@ -10441,9 +11000,9 @@ genPointerSet (iCode * ic, iCode *pi)
   /* special case when cast remat */
   if (p_type == GPOINTER && OP_SYMBOL(result)->remat &&
       IS_CAST_ICODE(OP_SYMBOL(result)->rematiCode)) {
-	  result = IC_RIGHT(OP_SYMBOL(result)->rematiCode);
-	  type = operandType (result);
-	  p_type = DCL_TYPE (type);
+          result = IC_RIGHT(OP_SYMBOL(result)->rematiCode);
+          type = operandType (result);
+          p_type = DCL_TYPE (type);
   }
 
   /* now that we have the pointer type we assign
@@ -10469,8 +11028,8 @@ genPointerSet (iCode * ic, iCode *pi)
       break;
 
     default:
-      werror (E_INTERNAL_ERROR, __FILE__, __LINE__, 
-	      "genPointerSet: illegal pointer type");
+      werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
+              "genPointerSet: illegal pointer type");
     }
 
 }
@@ -10491,13 +11050,13 @@ 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);
 
@@ -10509,15 +11068,15 @@ genIfx (iCode * ic, iCode * popIc)
   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;
@@ -10541,69 +11100,69 @@ genAddrOf (iCode * ic)
      need to get the stack offset of this
      variable */
   if (sym->onStack) {
-      
+
       /* if 10 bit stack */
       if (options.stack10bit) {
-	  char buff[10];
-	  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); */
-	  if (sym->stack) {
-	      emitcode ("mov", "a,_bpx");
-	      emitcode ("add", "a,#!constbyte", ((sym->stack < 0) ? 
-					     ((char) (sym->stack - _G.nRegsSaved)) :
-					     ((char) sym->stack )) & 0xff);
-	      emitcode ("mov", "b,a");
-	      emitcode ("mov", "a,_bpx+1");
-	      
-	      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);
-	  } else {
-	      /* we can just move _bp */
-	      aopPut (AOP (IC_RESULT (ic)), "_bpx", 0);
-	      aopPut (AOP (IC_RESULT (ic)), "_bpx+1", 1);
-	      aopPut (AOP (IC_RESULT (ic)), buff, 2);
-	  }	  
+          char buff[10];
+          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); */
+          if (sym->stack) {
+              emitcode ("mov", "a,_bpx");
+              emitcode ("add", "a,#!constbyte", ((sym->stack < 0) ?
+                                             ((char) (sym->stack - _G.nRegsSaved)) :
+                                             ((char) sym->stack )) & 0xff);
+              emitcode ("mov", "b,a");
+              emitcode ("mov", "a,_bpx+1");
+
+              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);
+          } else {
+              /* we can just move _bp */
+              aopPut (AOP (IC_RESULT (ic)), "_bpx", 0);
+              aopPut (AOP (IC_RESULT (ic)), "_bpx+1", 1);
+              aopPut (AOP (IC_RESULT (ic)), buff, 2);
+          }
       } else {
-	  /* if it has an offset then we need to compute it */
-	  if (sym->stack) {
-	      emitcode ("mov", "a,_bp");
-	      emitcode ("add", "a,#!constbyte", ((char) sym->stack & 0xff));
-	      aopPut (AOP (IC_RESULT (ic)), "a", 0);
-	  } else {
-	      /* we can just move _bp */
-	      aopPut (AOP (IC_RESULT (ic)), "_bp", 0);
-	  }
-	  /* fill the result with zero */
-	  size = AOP_SIZE (IC_RESULT (ic)) - 1;
-	  
-	  
-	  if (options.stack10bit && size < (FPTRSIZE - 1)) {
-	      fprintf (stderr,
-		       "*** warning: pointer to stack var truncated.\n");
-	  }
-
-	  offset = 1;
-	  while (size--) {
-	      aopPut (AOP (IC_RESULT (ic)), zero, offset++);
-	  }      
+          /* if it has an offset then we need to compute it */
+          if (sym->stack) {
+              emitcode ("mov", "a,_bp");
+              emitcode ("add", "a,#!constbyte", ((char) sym->stack & 0xff));
+              aopPut (AOP (IC_RESULT (ic)), "a", 0);
+          } else {
+              /* we can just move _bp */
+              aopPut (AOP (IC_RESULT (ic)), "_bp", 0);
+          }
+          /* fill the result with zero */
+          size = AOP_SIZE (IC_RESULT (ic)) - 1;
+
+
+          if (options.stack10bit && size < (FPTRSIZE - 1)) {
+              fprintf (stderr,
+                       "*** warning: pointer to stack var truncated.\n");
+          }
+
+          offset = 1;
+          while (size--) {
+              aopPut (AOP (IC_RESULT (ic)), zero, offset++);
+          }
       }
       goto release;
   }
@@ -10616,27 +11175,27 @@ genAddrOf (iCode * ic)
     {
       char s[SDCC_NAME_MAX];
       if (offset) {
-	  switch (offset) {
-	  case 1:
-	      tsprintf(s, sizeof(s), "#!his",sym->rname);
-	      break;
-	  case 2:
-	      tsprintf(s, sizeof(s), "#!hihis",sym->rname);
-	      break;
-	  case 3:
-	      tsprintf(s, sizeof(s), "#!hihihis",sym->rname);
-	      break;
-	  default: /* should not need this (just in case) */
-	      SNPRINTF (s, sizeof(s), "#(%s >> %d)",
-		       sym->rname,
-		       offset * 8);
-	  }
-      } 
+          switch (offset) {
+          case 1:
+              tsprintf(s, sizeof(s), "#!his",sym->rname);
+              break;
+          case 2:
+              tsprintf(s, sizeof(s), "#!hihis",sym->rname);
+              break;
+          case 3:
+              tsprintf(s, sizeof(s), "#!hihihis",sym->rname);
+              break;
+          default: /* should not need this (just in case) */
+              SNPRINTF (s, sizeof(s), "#(%s >> %d)",
+                       sym->rname,
+                       offset * 8);
+          }
+      }
       else
       {
-	  SNPRINTF (s, sizeof(s), "#%s", sym->rname);
+          SNPRINTF (s, sizeof(s), "#%s", sym->rname);
       }
-	
+
       aopPut (AOP (IC_RESULT (ic)), s, offset++);
     }
 
@@ -10658,100 +11217,100 @@ genArrayInit (iCode * ic)
     unsigned    val, lastVal;
     sym_link    *type;
     operand     *left=IC_LEFT(ic);
-    
+
     D (emitcode (";", "genArrayInit "););
 
     aopOp (IC_LEFT(ic), ic, FALSE, FALSE);
-    
+
     if (AOP_TYPE(IC_LEFT(ic)) == AOP_IMMD)
     {
-	// Load immediate value into DPTR.
-	emitcode("mov", "dptr, %s",
-	     aopGet(AOP(IC_LEFT(ic)), 0, TRUE, FALSE, NULL));
+        // Load immediate value into DPTR.
+        emitcode("mov", "dptr, %s",
+             aopGet(AOP(IC_LEFT(ic)), 0, TRUE, FALSE, NULL));
     }
     else if (AOP_TYPE(IC_LEFT(ic)) != AOP_DPTR)
     {
 #if 0
       werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
-	      "Unexpected operand to genArrayInit.\n");
+              "Unexpected operand to genArrayInit.\n");
       exit(1);
 #else
       // a regression because of SDCCcse.c:1.52
       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, NULL));
+        emitcode ("mov", "dpx,%s", aopGet (AOP (left), 2, FALSE, FALSE, NULL));
 #endif
     }
-    
+
     type = operandType(IC_LEFT(ic));
-    
+
     if (type && type->next)
     {
-	elementSize = getSize(type->next);
+        elementSize = getSize(type->next);
     }
     else
     {
-	werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
-		                "can't determine element size in genArrayInit.\n");
-	exit(1);
+        werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
+                                "can't determine element size in genArrayInit.\n");
+        exit(1);
     }
-    
+
     iLoop = IC_ARRAYILIST(ic);
     lastVal = 0xffff;
-    
+
     while (iLoop)
     {
-	bool firstpass = TRUE;
-	
-	emitcode(";", "store %d x 0x%x to DPTR (element size %d)", 
-		 iLoop->count, (int)iLoop->literalValue, elementSize);
-	
-	ix = iLoop->count;
-	
-	while (ix)
-	{
-	    symbol *tlbl = NULL;
-	    
-	    count = ix > 256 ? 256 : ix;
-	    
-	    if (count > 1)
-	    {
-		tlbl = newiTempLabel (NULL);
-		if (firstpass || (count & 0xff))
-		{
-		    emitcode("mov", "b, #!constbyte", count & 0xff);
-		}
-		
-		emitcode ("", "!tlabeldef", tlbl->key + 100);
-	    }
-	    
-	    firstpass = FALSE;
-		
-	    for (eIndex = 0; eIndex < elementSize; eIndex++)
-	    {
-		val = (((int)iLoop->literalValue) >> (eIndex * 8)) & 0xff;
-		if (val != lastVal)
-		{
-		    emitcode("mov", "a, #!constbyte", val);
-		    lastVal = val;
-		}
-		
-		emitcode("movx", "@dptr, a");
-		emitcode("inc", "dptr");
-	    }
-	    
-	    if (count > 1)
-	    {
-		emitcode("djnz", "b, !tlabel", tlbl->key + 100);
-	    }
-	    
-	    ix -= count;
-	}
-	
-	iLoop = iLoop->next;
-    }
-    
+        bool firstpass = TRUE;
+
+        emitcode(";", "store %d x 0x%x to DPTR (element size %d)",
+                 iLoop->count, (int)iLoop->literalValue, elementSize);
+
+        ix = iLoop->count;
+
+        while (ix)
+        {
+            symbol *tlbl = NULL;
+
+            count = ix > 256 ? 256 : ix;
+
+            if (count > 1)
+            {
+                tlbl = newiTempLabel (NULL);
+                if (firstpass || (count & 0xff))
+                {
+                    emitcode("mov", "b, #!constbyte", count & 0xff);
+                }
+
+                emitcode ("", "!tlabeldef", tlbl->key + 100);
+            }
+
+            firstpass = FALSE;
+
+            for (eIndex = 0; eIndex < elementSize; eIndex++)
+            {
+                val = (((int)iLoop->literalValue) >> (eIndex * 8)) & 0xff;
+                if (val != lastVal)
+                {
+                    emitcode("mov", "a, #!constbyte", val);
+                    lastVal = val;
+                }
+
+                emitcode("movx", "@dptr, a");
+                emitcode("inc", "dptr");
+            }
+
+            if (count > 1)
+            {
+                emitcode("djnz", "b, !tlabel", tlbl->key + 100);
+            }
+
+            ix -= count;
+        }
+
+        iLoop = iLoop->next;
+    }
+
     freeAsmop (IC_LEFT(ic), NULL, ic, TRUE);
 }
 #endif
@@ -10769,7 +11328,7 @@ genFarFarAssign (operand * result, operand * right, iCode * ic)
   if (size == 1)
   {
       /* quick & easy case. */
-      D(emitcode(";","genFarFarAssign (1 byte case)"););      
+      D(emitcode(";","genFarFarAssign (1 byte case)"););
       MOVA(aopGet(AOP(right), 0, FALSE, FALSE, NULL));
       freeAsmop (right, NULL, ic, FALSE);
       /* now assign DPTR to result */
@@ -10780,27 +11339,27 @@ genFarFarAssign (operand * result, operand * right, iCode * ic)
       freeAsmop(result, NULL, ic, FALSE);
       return;
   }
-  
+
   /* See if we've got an underlying symbol to abuse. */
   if (IS_SYMOP(result) && OP_SYMBOL(result))
   {
       if (IS_TRUE_SYMOP(result))
       {
-	  rSym = OP_SYMBOL(result);
+          rSym = OP_SYMBOL(result);
       }
       else if (IS_ITEMP(result) && OP_SYMBOL(result)->isspilt && OP_SYMBOL(result)->usl.spillLoc)
       {
-	  rSym = OP_SYMBOL(result)->usl.spillLoc;
+          rSym = OP_SYMBOL(result)->usl.spillLoc;
       }
   }
-	     
+
   if (size > 1 && rSym && rSym->rname && !rSym->onStack)
   {
       /* We can use the '390 auto-toggle feature to good effect here. */
-      
+
       D(emitcode(";","genFarFarAssign (390 auto-toggle fun)"););
-      emitcode("mov", "dps,#!constbyte",0x21); 	/* Select DPTR2 & auto-toggle. */
-      emitcode ("mov", "dptr,#%s", rSym->rname); 
+      emitcode("mov", "dps,#!constbyte",0x21);  /* Select DPTR2 & auto-toggle. */
+      emitcode ("mov", "dptr,#%s", rSym->rname);
       /* DP2 = result, DP1 = right, DP1 is current. */
       while (size)
       {
@@ -10818,8 +11377,8 @@ genFarFarAssign (operand * result, operand * right, iCode * ic)
 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,#1"); 	/* Select DPTR2. */
-        emitcode ("mov", "dptr,#%s", rSym->rname); 
+        emitcode("mov", "dps,#1");      /* Select DPTR2. */
+        emitcode ("mov", "dptr,#%s", rSym->rname);
         /* DP2 = result, DP1 = right, DP1 is current. */
         while (size)
         {
@@ -10843,13 +11402,13 @@ no time to test now, so later well put in...kpb
       aopOp (result, ic, TRUE, TRUE);
 
       _startLazyDPSEvaluation ();
-      
+
       while (size--)
-	{
-	  aopPut (AOP (result),
-		  aopGet (AOP (right), offset, FALSE, FALSE, NULL), offset);
-	  offset++;
-	}
+        {
+          aopPut (AOP (result),
+                  aopGet (AOP (right), offset, FALSE, FALSE, NULL), offset);
+          offset++;
+        }
       _endLazyDPSEvaluation ();
       freeAsmop (result, NULL, ic, FALSE);
       freeAsmop (right, NULL, ic, FALSE);
@@ -10879,8 +11438,8 @@ genAssign (iCode * ic)
   aopOp (right, ic, FALSE, FALSE);
 
   emitcode (";", "genAssign: resultIsFar = %s",
-	    isOperandInFarSpace (result) ?
-	    "TRUE" : "FALSE");
+            isOperandInFarSpace (result) ?
+            "TRUE" : "FALSE");
 
   /* special case both in far space */
   if ((AOP_TYPE (right) == AOP_DPTR ||
@@ -10904,21 +11463,21 @@ genAssign (iCode * ic)
       /* if the right size is a literal then
          we know what the value is */
       if (AOP_TYPE (right) == AOP_LIT)
-	{
-	  if (((int) operandLitValue (right)))
-	    aopPut (AOP (result), one, 0);
-	  else
-	    aopPut (AOP (result), zero, 0);
-	  goto release;
-	}
+        {
+          if (((int) operandLitValue (right)))
+            aopPut (AOP (result), one, 0);
+          else
+            aopPut (AOP (result), zero, 0);
+          goto release;
+        }
 
       /* the right is also a bit variable */
       if (AOP_TYPE (right) == AOP_CRY)
-	{
-	  emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
-	  aopPut (AOP (result), "c", 0);
-	  goto release;
-	}
+        {
+          emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
+          aopPut (AOP (result), "c", 0);
+          goto release;
+        }
 
       /* we need to or */
       toBoolean (right);
@@ -10940,34 +11499,34 @@ genAssign (iCode * ic)
     {
       _startLazyDPSEvaluation ();
       while (size && ((unsigned int) (lit >> (offset * 8)) != 0))
-	{
-	  aopPut (AOP (result),
-		  aopGet (AOP (right), offset, FALSE, FALSE, NULL),
-		  offset);
-	  offset++;
-	  size--;
-	}
+        {
+          aopPut (AOP (result),
+                  aopGet (AOP (right), offset, FALSE, FALSE, NULL),
+                  offset);
+          offset++;
+          size--;
+        }
       /* And now fill the rest with zeros. */
       if (size)
-	{
-	  emitcode ("clr", "a");
-	}
+        {
+          emitcode ("clr", "a");
+        }
       while (size--)
-	{
-	  aopPut (AOP (result), "a", offset++);
-	}
+        {
+          aopPut (AOP (result), "a", offset++);
+        }
       _endLazyDPSEvaluation ();
     }
   else
     {
       _startLazyDPSEvaluation ();
       while (size--)
-	{
-	  aopPut (AOP (result),
-		  aopGet (AOP (right), offset, FALSE, FALSE, NULL),
-		  offset);
-	  offset++;
-	}
+        {
+          aopPut (AOP (result),
+                  aopGet (AOP (right), offset, FALSE, FALSE, NULL),
+                  offset);
+          offset++;
+        }
       _endLazyDPSEvaluation ();
     }
 
@@ -11026,8 +11585,8 @@ genCast (iCode * ic)
   if (operandsEqu (IC_RESULT (ic), IC_RIGHT (ic)))
     return;
 
-  aopOp (right, ic, FALSE, FALSE);
-  aopOp (result, ic, FALSE, AOP_USESDPTR(right));
+  aopOp (right, ic, FALSE, AOP_IS_STR (result));
+  aopOp (result, ic, FALSE, (AOP_TYPE(right) == AOP_DPTR));
 
   /* if the result is a bit */
   if (IS_BITVAR (OP_SYMBOL (result)->type)
@@ -11036,22 +11595,22 @@ genCast (iCode * ic)
       /* if the right size is a literal then
          we know what the value is */
       if (AOP_TYPE (right) == AOP_LIT)
-	{
-	  if (((int) operandLitValue (right)))
-	    aopPut (AOP (result), one, 0);
-	  else
-	    aopPut (AOP (result), zero, 0);
+        {
+          if (((int) operandLitValue (right)))
+            aopPut (AOP (result), one, 0);
+          else
+            aopPut (AOP (result), zero, 0);
 
-	  goto release;
-	}
+          goto release;
+        }
 
       /* the right is also a bit variable */
       if (AOP_TYPE (right) == AOP_CRY)
-	{
-	  emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
-	  aopPut (AOP (result), "c", 0);
-	  goto release;
-	}
+        {
+          emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
+          aopPut (AOP (result), "c", 0);
+          goto release;
+        }
 
       /* we need to or */
       toBoolean (right);
@@ -11065,19 +11624,19 @@ genCast (iCode * ic)
 
       /* if they are in the same place */
       if (sameRegs (AOP (right), AOP (result)))
-	goto release;
+        goto release;
 
       /* if they in different places then copy */
       size = AOP_SIZE (result);
       offset = 0;
       _startLazyDPSEvaluation ();
       while (size--)
-	{
-	  aopPut (AOP (result),
-		  aopGet (AOP (right), offset, FALSE, FALSE, NULL),
-		  offset);
-	  offset++;
-	}
+        {
+          aopPut (AOP (result),
+                  aopGet (AOP (right), offset, FALSE, FALSE, NULL),
+                  offset);
+          offset++;
+        }
       _endLazyDPSEvaluation ();
       goto release;
     }
@@ -11092,93 +11651,93 @@ genCast (iCode * ic)
 
       /* pointer to generic pointer */
       if (IS_GENPTR (ctype))
-	{
-	  if (IS_PTR (type))
-	    {
-	      p_type = DCL_TYPE (type);
-	    }
-	  else
-	    {
+        {
+          if (IS_PTR (type))
+            {
+              p_type = DCL_TYPE (type);
+            }
+          else
+            {
 #if OLD_CAST_BEHAVIOR
-	      /* KV: we are converting a non-pointer type to
-	       * a generic pointer. This (ifdef'd out) code
-	       * says that the resulting generic pointer
-	       * should have the same class as the storage
-	       * location of the non-pointer variable.
-	       *
-	       * For example, converting an int (which happens
-	       * to be stored in DATA space) to a pointer results
-	       * in a DATA generic pointer; if the original int
-	       * in XDATA space, so will be the resulting pointer.
-	       *
-	       * I don't like that behavior, and thus this change:
-	       * all such conversions will be forced to XDATA and
-	       * throw a warning. If you want some non-XDATA
-	       * type, or you want to suppress the warning, you
-	       * must go through an intermediate cast, like so:
-	       *
-	       * char _generic *gp = (char _xdata *)(intVar);
-	       */
-	      sym_link *etype = getSpec (type);
-
-	      /* we have to go by the storage class */
-	      if (SPEC_OCLS (etype) != generic)
-		{
-		  p_type = PTR_TYPE (SPEC_OCLS (etype));
-		}
-	      else
+              /* KV: we are converting a non-pointer type to
+               * a generic pointer. This (ifdef'd out) code
+               * says that the resulting generic pointer
+               * should have the same class as the storage
+               * location of the non-pointer variable.
+               *
+               * For example, converting an int (which happens
+               * to be stored in DATA space) to a pointer results
+               * in a DATA generic pointer; if the original int
+               * in XDATA space, so will be the resulting pointer.
+               *
+               * I don't like that behavior, and thus this change:
+               * all such conversions will be forced to XDATA and
+               * throw a warning. If you want some non-XDATA
+               * type, or you want to suppress the warning, you
+               * must go through an intermediate cast, like so:
+               *
+               * char _generic *gp = (char _xdata *)(intVar);
+               */
+              sym_link *etype = getSpec (type);
+
+              /* we have to go by the storage class */
+              if (SPEC_OCLS (etype) != generic)
+                {
+                  p_type = PTR_TYPE (SPEC_OCLS (etype));
+                }
+              else
 #endif
-		{
-		  /* Converting unknown class (i.e. register variable)
-		   * to generic pointer. This is not good, but
-		   * we'll make a guess (and throw a warning).
-		   */
-		  p_type = FPOINTER;
-		  werror (W_INT_TO_GEN_PTR_CAST);
-		}
-	    }
-
-	  /* the first two bytes are known */
-	  size = GPTRSIZE - 1;
-	  offset = 0;
-	  _startLazyDPSEvaluation ();
-	  while (size--)
-	    {
-	      aopPut (AOP (result),
-		      aopGet (AOP (right), offset, FALSE, FALSE, NULL),
-		      offset);
-	      offset++;
-	    }
-	  _endLazyDPSEvaluation ();
-
-	  /* the last byte depending on type */
-	    {
-		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);
-	    }
-	  goto release;
-	}
+                {
+                  /* Converting unknown class (i.e. register variable)
+                   * to generic pointer. This is not good, but
+                   * we'll make a guess (and throw a warning).
+                   */
+                  p_type = FPOINTER;
+                  werror (W_INT_TO_GEN_PTR_CAST);
+                }
+            }
+
+          /* the first two bytes are known */
+          size = GPTRSIZE - 1;
+          offset = 0;
+          _startLazyDPSEvaluation ();
+          while (size--)
+            {
+              aopPut (AOP (result),
+                      aopGet (AOP (right), offset, FALSE, FALSE, NULL),
+                      offset);
+              offset++;
+            }
+          _endLazyDPSEvaluation ();
+
+          /* the last byte depending on type */
+            {
+                int gpVal = pointerTypeToGPByte(p_type, NULL, NULL);
+                char gpValStr[10];
+
+                if (gpVal == -1)
+                {
+                    // pointerTypeToGPByte will have bitched.
+                    exit(1);
+                }
+
+                SNPRINTF(gpValStr, sizeof(gpValStr), "#0x%x", gpVal);
+                aopPut (AOP (result), gpValStr, GPTRSIZE - 1);
+            }
+          goto release;
+        }
 
       /* just copy the pointers */
       size = AOP_SIZE (result);
       offset = 0;
       _startLazyDPSEvaluation ();
       while (size--)
-	{
-	  aopPut (AOP (result),
-		  aopGet (AOP (right), offset, FALSE, FALSE, NULL),
-		  offset);
-	  offset++;
-	}
+        {
+          aopPut (AOP (result),
+                  aopGet (AOP (right), offset, FALSE, FALSE, NULL),
+                  offset);
+          offset++;
+        }
       _endLazyDPSEvaluation ();
       goto release;
     }
@@ -11192,8 +11751,8 @@ genCast (iCode * ic)
   while (size--)
     {
       aopPut (AOP (result),
-	      aopGet (AOP (right), offset, FALSE, FALSE, NULL),
-	      offset);
+              aopGet (AOP (right), offset, FALSE, FALSE, NULL),
+              offset);
       offset++;
     }
   _endLazyDPSEvaluation ();
@@ -11207,19 +11766,19 @@ genCast (iCode * ic)
   if (!IS_SPEC (rtype) || SPEC_USIGN (rtype) || AOP_TYPE (right) == AOP_CRY)
     {
       while (size--)
-	{
-	  aopPut (AOP (result), zero, offset++);
-	}
+        {
+          aopPut (AOP (result), zero, offset++);
+        }
     }
   else
     {
       /* we need to extend the sign :{ */
       MOVA (aopGet (AOP (right), AOP_SIZE (right) - 1,
-			FALSE, FALSE, NULL));
+                        FALSE, FALSE, NULL));
       emitcode ("rlc", "a");
       emitcode ("subb", "a,acc");
       while (size--)
-	aopPut (AOP (result), "a", offset++);
+        aopPut (AOP (result), "a", offset++);
     }
 
   /* we are done hurray !!!! */
@@ -11274,12 +11833,12 @@ genDjnz (iCode * ic, iCode * ifx)
        * it back after the decrement.
        */
       char *rByte = aopGet(AOP(IC_RESULT(ic)), 0, FALSE, FALSE, NULL);
-      
+
       if (strcmp(rByte, "a"))
       {
            /* Something is hopelessly wrong */
            fprintf(stderr, "*** warning: internal error at %s:%d\n",
-           	   __FILE__, __LINE__);
+                   __FILE__, __LINE__);
            /* We can just give up; the generated code will be inefficient,
             * but what the hey.
             */
@@ -11293,14 +11852,14 @@ genDjnz (iCode * ic, iCode * ifx)
   else if (IS_AOP_PREG (IC_RESULT (ic)))
     {
       emitcode ("dec", "%s",
-		aopGet (AOP (IC_RESULT (ic)), 0, FALSE, FALSE, NULL));
+                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, NULL),
-		lbl->key + 100);
+                lbl->key + 100);
     }
   emitcode ("sjmp", "!tlabel", lbl1->key + 100);
   emitcode ("", "!tlabeldef", lbl->key + 100);
@@ -11321,50 +11880,50 @@ genReceive (iCode * ic)
     int size = getSize (operandType (IC_RESULT (ic)));
     int offset = 0;
     int rb1off ;
-    
+
     D (emitcode (";", "genReceive "););
 
-    if (ic->argreg == 1) 
-    {
-	/* first parameter */
-	if (AOP_IS_STR(IC_RESULT(ic)))
-	{
-	    /* Nothing to do: it's already in the proper place. */
-	    return;
-	}
-	else
-	{
-	    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++);
-	}
+    if (ic->argreg == 1)
+    {
+        /* first parameter */
+        if (AOP_IS_STR(IC_RESULT(ic)))
+        {
+            /* Nothing to do: it's already in the proper place. */
+            return;
+        }
+        else
+        {
+            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++);
+        }
     }
     freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
 }
@@ -11381,17 +11940,17 @@ static void genMemcpyX2X( iCode *ic, int nparms, operand **parms, int fromc)
 
     /* 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);
+            if (bitVectBitValue(ic->rMask,i))
+                    rsave = bitVectSetBit(rsave,i);
     }
     rsave = bitVectIntersect(rsave,bitVectCplAnd (bitVectCopy (ic->rMask),
-						  ds390_rUmaskForOp (IC_RESULT(ic))));
+                                                  ds390_rUmaskForOp (IC_RESULT(ic))));
     savermask(rsave);
-    
+
     to = parms[0];
     from = parms[1];
     count = parms[2];
@@ -11402,7 +11961,7 @@ static void genMemcpyX2X( iCode *ic, int nparms, operand **parms, int fromc)
     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));
+        emitcode ("mov", "dpx1,%s", aopGet (AOP (from), 2, FALSE, FALSE, NULL));
     }
 
     freeAsmop (from, NULL, ic, FALSE);
@@ -11411,28 +11970,28 @@ static void genMemcpyX2X( iCode *ic, int nparms, operand **parms, int fromc)
     /* 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 ();
-	}
+        /* 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;
@@ -11440,45 +11999,45 @@ static void genMemcpyX2X( iCode *ic, int nparms, operand **parms, int fromc)
     lbl =newiTempLabel(NULL);
 
     /* now for the actual copy */
-    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_memcpyc2x_s");
-	} else {
-	    emitcode ("lcall","__bi_memcpyx2x_s");
-	}
-	freeAsmop (count, NULL, ic, FALSE);
+    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_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");
-	    emitcode ("movc", "a,@a+dptr");
-	} else 
-	    emitcode ("movx", "a,@dptr");
-	emitcode ("movx", "@dptr,a");
-	emitcode ("inc", "dptr");
-	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);
-    }
-    emitcode ("mov", "dps,#0"); 
+        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");
+            emitcode ("movc", "a,@a+dptr");
+        } else
+            emitcode ("movx", "a,@dptr");
+        emitcode ("movx", "@dptr,a");
+        emitcode ("inc", "dptr");
+        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);
+    }
+    emitcode ("mov", "dps,#0");
     _G.dptrInUse = _G.dptr1InUse = 0;
     unsavermask(rsave);
 
@@ -11496,17 +12055,17 @@ static void genMemcmpX2X( iCode *ic, int nparms, operand **parms, int fromc)
 
     /* 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);
+            if (bitVectBitValue(ic->rMask,i))
+                    rsave = bitVectSetBit(rsave,i);
     }
     rsave = bitVectIntersect(rsave,bitVectCplAnd (bitVectCopy (ic->rMask),
-						  ds390_rUmaskForOp (IC_RESULT(ic))));
+                                                  ds390_rUmaskForOp (IC_RESULT(ic))));
     savermask(rsave);
-    
+
     to = parms[0];
     from = parms[1];
     count = parms[2];
@@ -11517,7 +12076,7 @@ static void genMemcmpX2X( iCode *ic, int nparms, operand **parms, int fromc)
     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));
+        emitcode ("mov", "dpx1,%s", aopGet (AOP (from), 2, FALSE, FALSE, NULL));
     }
 
     freeAsmop (from, NULL, ic, FALSE);
@@ -11526,28 +12085,28 @@ static void genMemcmpX2X( iCode *ic, int nparms, operand **parms, int fromc)
     /* 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 ();
-	}
+        /* 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;
@@ -11556,57 +12115,57 @@ static void genMemcmpX2X( iCode *ic, int nparms, operand **parms, int fromc)
     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);
+    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, 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 ("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 ("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 ("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");      
+        symbol *lbl1 = newiTempLabel(NULL);
+
+        emitcode("push","ar0");
+        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");
+            emitcode ("movc", "a,@a+dptr");
+        } else
+            emitcode ("movx", "a,@dptr");
+        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 ("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 ("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");
     }
     _G.dptrInUse = _G.dptr1InUse = 0;
     unsavermask(rsave);
@@ -11627,17 +12186,17 @@ static void genInp( iCode *ic, int nparms, operand **parms)
 
     /* 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);
+            if (bitVectBitValue(ic->rMask,i))
+                    rsave = bitVectSetBit(rsave,i);
     }
     rsave = bitVectIntersect(rsave,bitVectCplAnd (bitVectCopy (ic->rMask),
-						  ds390_rUmaskForOp (IC_RESULT(ic))));
+                                                  ds390_rUmaskForOp (IC_RESULT(ic))));
     savermask(rsave);
-    
+
     to = parms[0];
     from = parms[1];
     count = parms[2];
@@ -11648,7 +12207,7 @@ static void genInp( iCode *ic, int nparms, operand **parms)
     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));
+        emitcode ("mov", "dpx1,%s", aopGet (AOP (from), 2, FALSE, FALSE, NULL));
     }
 
     freeAsmop (from, NULL, ic, FALSE);
@@ -11657,28 +12216,28 @@ static void genInp( iCode *ic, int nparms, operand **parms)
     /* 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 ();
-	}
+        /* 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);
 
@@ -11687,48 +12246,48 @@ static void genInp( iCode *ic, int nparms, operand **parms)
     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",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", "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);
+    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",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", "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 (";"," 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);
-	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 ("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"); 
+        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",0x1);        /* Select DPTR2 */
+        emitcode ("","!tlabeldef",lbl->key+100);
+        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 ("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);
 
@@ -11748,17 +12307,17 @@ static void genOutp( iCode *ic, int nparms, operand **parms)
 
     /* 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);
+            if (bitVectBitValue(ic->rMask,i))
+                    rsave = bitVectSetBit(rsave,i);
     }
     rsave = bitVectIntersect(rsave,bitVectCplAnd (bitVectCopy (ic->rMask),
-						  ds390_rUmaskForOp (IC_RESULT(ic))));
+                                                  ds390_rUmaskForOp (IC_RESULT(ic))));
     savermask(rsave);
-    
+
     to = parms[0];
     from = parms[1];
     count = parms[2];
@@ -11769,7 +12328,7 @@ static void genOutp( iCode *ic, int nparms, operand **parms)
     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));
+        emitcode ("mov", "dpx1,%s", aopGet (AOP (from), 2, FALSE, FALSE, NULL));
     }
 
     freeAsmop (from, NULL, ic, FALSE);
@@ -11778,28 +12337,28 @@ static void genOutp( iCode *ic, int nparms, operand **parms)
     /* 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 ();
-	}
+        /* 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);
 
@@ -11808,46 +12367,46 @@ static void genOutp( iCode *ic, int nparms, operand **parms)
     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);
+    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"); 
+        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);
 
@@ -11873,11 +12432,11 @@ static void genSwapW(iCode *ic, int nparms, operand **parms)
     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);    
+    freeAsmop (dest, NULL, ic, FALSE);
 }
 
 /*-----------------------------------------------------------------*/
@@ -11893,19 +12452,19 @@ static void genMemsetX(iCode *ic, int nparms, operand **parms)
 
     /* 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);
+            if (bitVectBitValue(ic->rMask,i))
+                    rsave = bitVectSetBit(rsave,i);
     }
     rsave = bitVectIntersect(rsave,bitVectCplAnd (bitVectCopy (ic->rMask),
-						  ds390_rUmaskForOp (IC_RESULT(ic))));
+                                                  ds390_rUmaskForOp (IC_RESULT(ic))));
     savermask(rsave);
 
     aopOp (to, ic, FALSE, FALSE);
@@ -11913,64 +12472,64 @@ static void genMemsetX(iCode *ic, int nparms, operand **parms)
     /* 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 ();
-	}
+        /* 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);    
+    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);
+    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);
+        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);
@@ -11981,37 +12540,37 @@ static void genMemsetX(iCode *ic, int nparms, operand **parms)
 /*-----------------------------------------------------------------*/
 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);
+        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);
 }
 
 /*-----------------------------------------------------------------*/
@@ -12019,87 +12578,87 @@ static void genNatLibLoadPrimitive(iCode *ic, int nparms, operand **parms,int si
 /*-----------------------------------------------------------------*/
 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);
+        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);
 }
 
 /*-----------------------------------------------------------------*/
@@ -12107,121 +12666,121 @@ static void genNatLibInstallStateBlock(iCode *ic, int nparms,
 /*-----------------------------------------------------------------*/
 static void genNatLibRemoveStateBlock(iCode *ic,int nparms,const char *name)
 {
-	bitVect *rsave ;
+        bitVect *rsave ;
 
-	assert(nparms==0);
+        assert(nparms==0);
 
-	/* save registers that need to be saved */
-	savermask(rsave = bitVectCplAnd (bitVectCopy (ic->rMask),
-					 ds390_rUmaskForOp (IC_RESULT(ic))));
+        /* 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);
+        /* 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);
+                                   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);
+                         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);
 }
 
 /*-----------------------------------------------------------------*/
@@ -12229,54 +12788,54 @@ static void genMMMalloc (iCode *ic,int nparms, operand **parms,
 /*-----------------------------------------------------------------*/
 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);
+        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);
 }
 
 /*-----------------------------------------------------------------*/
@@ -12284,45 +12843,45 @@ static void genMMDeref (iCode *ic,int nparms, operand **parms)
 /*-----------------------------------------------------------------*/
 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);
+        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);
 }
 
 /*-----------------------------------------------------------------*/
@@ -12330,98 +12889,98 @@ static void genMMUnrestrictedPersist(iCode *ic,int nparms, operand **parms)
 /*-----------------------------------------------------------------*/
 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);
+        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);
+                                  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);
 }
 
 /*-----------------------------------------------------------------*/
@@ -12429,53 +12988,53 @@ static void genSystemRTCRegisters(iCode *ic,int nparms, operand **parms,
 /*-----------------------------------------------------------------*/
 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);
+        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);
 }
 
 /*-----------------------------------------------------------------*/
@@ -12483,41 +13042,41 @@ static void genSystemThreadSleep(iCode *ic,int nparms, operand **parms, char *na
 /*-----------------------------------------------------------------*/
 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);
+        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);
 }
 
 /*-----------------------------------------------------------------*/
@@ -12525,25 +13084,25 @@ static void genSystemThreadResume(iCode *ic,int nparms, operand **parms)
 /*-----------------------------------------------------------------*/
 static void genSystemProcessResume(iCode *ic,int nparms, operand **parms)
 {
-	bitVect *rsave ;
-	operand *pid;
+        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];
 
-	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");
+        /* 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);
 
-	unsavermask(rsave);
+        emitcode ("lcall","System_ProcessResume");
+
+        unsavermask(rsave);
 }
 
 /*-----------------------------------------------------------------*/
@@ -12551,9 +13110,9 @@ static void genSystemProcessResume(iCode *ic,int nparms, operand **parms)
 /*-----------------------------------------------------------------*/
 static void genSystem (iCode *ic,int nparms,char *name)
 {
-	assert(nparms == 0);
+        assert(nparms == 0);
 
-	emitcode ("lcall","System_%s",name);
+        emitcode ("lcall","System_%s",name);
 }
 
 /*-----------------------------------------------------------------*/
@@ -12561,41 +13120,41 @@ static void genSystem (iCode *ic,int nparms,char *name)
 /*-----------------------------------------------------------------*/
 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);
+        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);
 }
 
 /*-----------------------------------------------------------------*/
@@ -12603,18 +13162,18 @@ static void genSystemPoll(iCode *ic,int nparms, operand **parms,char *name)
 /*-----------------------------------------------------------------*/
 static void genSystemGetCurrentID(iCode *ic,int nparms, operand **parms,char *name)
 {
-	assert (nparms==0);
+        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);
-		}
-	}
+        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);
+                }
+        }
 }
 
 /*-----------------------------------------------------------------*/
@@ -12623,144 +13182,229 @@ static void genSystemGetCurrentID(iCode *ic,int nparms, operand **parms,char *na
 static void
 genDummyRead (iCode * ic)
 {
-  operand *right;
+  operand *op;
   int size, offset;
 
   D(emitcode(";     genDummyRead",""));
 
-  right = IC_RIGHT (ic);
+  op = IC_RIGHT (ic);
+  if (op && IS_SYMOP (op))
+    {
+      aopOp (op, ic, FALSE, FALSE);
 
-  aopOp (right, ic, FALSE, FALSE);
+      /* if the result is a bit */
+      if (AOP_TYPE (op) == AOP_CRY)
+        emitcode ("mov", "c,%s", AOP (op)->aopu.aop_dir);
+      else
+        {
+          /* bit variables done */
+          /* general case */
+          size = AOP_SIZE (op);
+          offset = 0;
+          while (size--)
+          {
+            MOVA (aopGet (AOP (op), offset, FALSE, FALSE, FALSE));
+            offset++;
+          }
+        }
 
-  /* if the result is a bit */
-  if (AOP_TYPE (right) == AOP_CRY)
-    {
-      emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
-      goto release;
+      freeAsmop (op, NULL, ic, TRUE);
     }
 
-  /* bit variables done */
-  /* general case */
-  size = AOP_SIZE (right);
-  offset = 0;
-  while (size--)
+  op = IC_LEFT (ic);
+  if (op && IS_SYMOP (op))
     {
-      emitcode ("mov", "a,%s", aopGet (AOP (right), offset, FALSE, FALSE, FALSE));
-      offset++;
+      aopOp (op, ic, FALSE, FALSE);
+
+      /* if the result is a bit */
+      if (AOP_TYPE (op) == AOP_CRY)
+        emitcode ("mov", "c,%s", AOP (op)->aopu.aop_dir);
+      else
+        {
+          /* bit variables done */
+          /* general case */
+          size = AOP_SIZE (op);
+          offset = 0;
+          while (size--)
+          {
+            MOVA (aopGet (AOP (op), offset, FALSE, FALSE, FALSE));
+            offset++;
+          }
+        }
+
+      freeAsmop (op, NULL, ic, TRUE);
     }
 
-release:
-  freeAsmop (right, NULL, ic, TRUE);
 }
 
+/*-----------------------------------------------------------------*/
+/* genCritical - generate code for start of a critical sequence    */
+/*-----------------------------------------------------------------*/
+static void
+genCritical (iCode *ic)
+{
+  symbol *tlbl = newiTempLabel (NULL);
+
+  D(emitcode(";     genCritical",""));
+
+  if (IC_RESULT (ic))
+    aopOp (IC_RESULT (ic), ic, TRUE, FALSE);
+
+  emitcode ("setb", "c");
+  emitcode ("jbc", "ea,%05d$", (tlbl->key + 100)); /* atomic test & clear */
+  emitcode ("clr", "c");
+  emitcode ("", "%05d$:", (tlbl->key + 100));
+
+  if (IC_RESULT (ic))
+    outBitC (IC_RESULT (ic)); /* save old ea in an operand */
+  else
+    emitcode ("push", "psw"); /* save old ea via c in psw on top of stack*/
+
+  if (IC_RESULT (ic))
+    freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
+}
+
+/*-----------------------------------------------------------------*/
+/* genEndCritical - generate code for end of a critical sequence   */
+/*-----------------------------------------------------------------*/
+static void
+genEndCritical (iCode *ic)
+{
+  D(emitcode(";     genEndCritical",""));
+
+  if (IC_RIGHT (ic))
+    {
+      aopOp (IC_RIGHT (ic), ic, FALSE, FALSE);
+      if (AOP_TYPE (IC_RIGHT (ic)) == AOP_CRY)
+        {
+          emitcode ("mov", "c,%s", IC_RIGHT (ic)->aop->aopu.aop_dir);
+          emitcode ("mov", "ea,c");
+        }
+      else
+        {
+          MOVA (aopGet (AOP (IC_RIGHT (ic)), 0, FALSE, FALSE, FALSE));
+          emitcode ("rrc", "a");
+          emitcode ("mov", "ea,c");
+        }
+      freeAsmop (IC_RIGHT (ic), NULL, ic, TRUE);
+    }
+  else
+    {
+      emitcode ("pop", "psw"); /* restore ea via c in psw on top of stack */
+      emitcode ("mov", "ea,c");
+    }
+}
+
+
+
 /*-----------------------------------------------------------------*/
 /* genBuiltIn - calls the appropriate function to  generating code */
-/* for a built in function 					   */
+/* 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 ;    
+        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 ;
 }
 
 /*-----------------------------------------------------------------*/
@@ -12776,7 +13420,7 @@ gen390Code (iCode * lic)
   dptrn[1][0] = "dpl1";
   dptrn[1][1] = "dph1";
   dptrn[1][2] = "dpx1";
-  
+
   if (options.model == MODEL_FLAT24) {
     fReturnSizeDS390 = 5;
     fReturn = fReturn24;
@@ -12793,13 +13437,7 @@ gen390Code (iCode * lic)
   /* if debug information required */
   if (options.debug && currFunc)
     {
-      debugFile->writeFunction(currFunc);
-      _G.debugLine = 1;
-      if (IS_STATIC (currFunc->etype))
-	emitcode ("", "F%s$%s$0$0 ==.", moduleName, currFunc->name);
-      else
-	emitcode ("", "G$%s$0$0 ==.", currFunc->name);
-      _G.debugLine = 0;
+      debugFile->writeFunction (currFunc, lic);
     }
   /* stack pointer name */
   if (options.useXstack)
@@ -12810,231 +13448,240 @@ gen390Code (iCode * lic)
 
   for (ic = lic; ic; ic = ic->next)
     {
+      _G.current_iCode = ic;
 
       if (ic->lineno && cln != ic->lineno)
-	{
-	  if (options.debug)
-	    {
-	      _G.debugLine = 1;
-	      emitcode ("", "C$%s$%d$%d$%d ==.",
-			FileBaseName (ic->filename), ic->lineno,
-			ic->level, ic->block);
-	      _G.debugLine = 0;
-	    }
-	  if (!options.noCcodeInAsm) {
-	    emitcode ("", ";\t%s:%d: %s", ic->filename, ic->lineno, 
-		      printCLine(ic->filename, ic->lineno));
-	  }
-	  cln = ic->lineno;
-	}
+        {
+          if (options.debug)
+            {
+              debugFile->writeCLine (ic);
+            }
+          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));
+        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
          do nothing */
       if (resultRemat (ic) || ic->generated)
-	continue;
+        continue;
 
       /* depending on the operation */
       switch (ic->op)
-	{
-	case '!':
-	  genNot (ic);
-	  break;
-
-	case '~':
-	  genCpl (ic);
-	  break;
-
-	case UNARYMINUS:
-	  genUminus (ic);
-	  break;
-
-	case IPUSH:
-	  genIpush (ic);
-	  break;
-
-	case IPOP:
-	  /* IPOP happens only when trying to restore a
-	     spilt live range, if there is an ifx statement
-	     following this pop then the if statement might
-	     be using some of the registers being popped which
-	     would destory the contents of the register so
-	     we need to check for this condition and handle it */
-	  if (ic->next &&
-	      ic->next->op == IFX &&
-	      regsInCommon (IC_LEFT (ic), IC_COND (ic->next)))
-	    genIfx (ic->next, ic);
-	  else
-	    genIpop (ic);
-	  break;
-
-	case CALL:
-	  genCall (ic);
-	  break;
-
-	case PCALL:
-	  genPcall (ic);
-	  break;
-
-	case FUNCTION:
-	  genFunction (ic);
-	  break;
-
-	case ENDFUNCTION:
-	  genEndFunction (ic);
-	  break;
-
-	case RETURN:
-	  genRet (ic);
-	  break;
-
-	case LABEL:
-	  genLabel (ic);
-	  break;
-
-	case GOTO:
-	  genGoto (ic);
-	  break;
-
-	case '+':
-	  genPlus (ic);
-	  break;
-
-	case '-':
-	  if (!genDjnz (ic, ifxForOp (IC_RESULT (ic), ic)))
-	    genMinus (ic);
-	  break;
-
-	case '*':
-	  genMult (ic);
-	  break;
-
-	case '/':
-	  genDiv (ic);
-	  break;
-
-	case '%':
-	  genMod (ic);
-	  break;
-
-	case '>':
-	  genCmpGt (ic, ifxForOp (IC_RESULT (ic), ic));
-	  break;
-
-	case '<':
-	  genCmpLt (ic, ifxForOp (IC_RESULT (ic), ic));
-	  break;
-
-	case LE_OP:
-	case GE_OP:
-	case NE_OP:
-
-	  /* note these two are xlated by algebraic equivalence
-	     during parsing SDCC.y */
-	  werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
-		  "got '>=' or '<=' shouldn't have come here");
-	  break;
-
-	case EQ_OP:
-	  genCmpEq (ic, ifxForOp (IC_RESULT (ic), ic));
-	  break;
-
-	case AND_OP:
-	  genAndOp (ic);
-	  break;
-
-	case OR_OP:
-	  genOrOp (ic);
-	  break;
-
-	case '^':
-	  genXor (ic, ifxForOp (IC_RESULT (ic), ic));
-	  break;
-
-	case '|':
-	  genOr (ic, ifxForOp (IC_RESULT (ic), ic));
-	  break;
-
-	case BITWISEAND:
-	  genAnd (ic, ifxForOp (IC_RESULT (ic), ic));
-	  break;
-
-	case INLINEASM:
-	  genInline (ic);
-	  break;
-
-	case RRC:
-	  genRRC (ic);
-	  break;
-
-	case RLC:
-	  genRLC (ic);
-	  break;
-
-	case GETHBIT:
-	  genGetHbit (ic);
-	  break;
-
-	case LEFT_OP:
-	  genLeftShift (ic);
-	  break;
-
-	case RIGHT_OP:
-	  genRightShift (ic);
-	  break;
-
-	case GET_VALUE_AT_ADDRESS:
-	  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,getSize(operandType(IC_RIGHT(ic)))));
-	  else
-	    genAssign (ic);
-	  break;
-
-	case IFX:
-	  genIfx (ic, NULL);
-	  break;
-
-	case ADDRESS_OF:
-	  genAddrOf (ic);
-	  break;
-
-	case JUMPTABLE:
-	  genJumpTab (ic);
-	  break;
-
-	case CAST:
-	  genCast (ic);
-	  break;
-
-	case RECEIVE:
-	  genReceive (ic);
-	  break;
-
-	case SEND:
-	  if (ic->builtinSEND) genBuiltIn(ic);
-	  else addSet (&_G.sendSet, ic);
-	  break;
-
-	case DUMMY_READ_VOLATILE:
-	  genDummyRead (ic);
-	  break;
+        {
+        case '!':
+          genNot (ic);
+          break;
+
+        case '~':
+          genCpl (ic);
+          break;
+
+        case UNARYMINUS:
+          genUminus (ic);
+          break;
+
+        case IPUSH:
+          genIpush (ic);
+          break;
+
+        case IPOP:
+          /* IPOP happens only when trying to restore a
+             spilt live range, if there is an ifx statement
+             following this pop then the if statement might
+             be using some of the registers being popped which
+             would destory the contents of the register so
+             we need to check for this condition and handle it */
+          if (ic->next &&
+              ic->next->op == IFX &&
+              regsInCommon (IC_LEFT (ic), IC_COND (ic->next)))
+            genIfx (ic->next, ic);
+          else
+            genIpop (ic);
+          break;
+
+        case CALL:
+          genCall (ic);
+          break;
+
+        case PCALL:
+          genPcall (ic);
+          break;
+
+        case FUNCTION:
+          genFunction (ic);
+          break;
+
+        case ENDFUNCTION:
+          genEndFunction (ic);
+          break;
+
+        case RETURN:
+          genRet (ic);
+          break;
+
+        case LABEL:
+          genLabel (ic);
+          break;
+
+        case GOTO:
+          genGoto (ic);
+          break;
+
+        case '+':
+          genPlus (ic);
+          break;
+
+        case '-':
+          if (!genDjnz (ic, ifxForOp (IC_RESULT (ic), ic)))
+            genMinus (ic);
+          break;
+
+        case '*':
+          genMult (ic);
+          break;
+
+        case '/':
+          genDiv (ic);
+          break;
+
+        case '%':
+          genMod (ic);
+          break;
+
+        case '>':
+          genCmpGt (ic, ifxForOp (IC_RESULT (ic), ic));
+          break;
+
+        case '<':
+          genCmpLt (ic, ifxForOp (IC_RESULT (ic), ic));
+          break;
+
+        case LE_OP:
+        case GE_OP:
+        case NE_OP:
+
+          /* note these two are xlated by algebraic equivalence
+             during parsing SDCC.y */
+          werror (E_INTERNAL_ERROR, __FILE__, __LINE__,
+                  "got '>=' or '<=' shouldn't have come here");
+          break;
+
+        case EQ_OP:
+          genCmpEq (ic, ifxForOp (IC_RESULT (ic), ic));
+          break;
+
+        case AND_OP:
+          genAndOp (ic);
+          break;
+
+        case OR_OP:
+          genOrOp (ic);
+          break;
+
+        case '^':
+          genXor (ic, ifxForOp (IC_RESULT (ic), ic));
+          break;
+
+        case '|':
+          genOr (ic, ifxForOp (IC_RESULT (ic), ic));
+          break;
+
+        case BITWISEAND:
+          genAnd (ic, ifxForOp (IC_RESULT (ic), ic));
+          break;
+
+        case INLINEASM:
+          genInline (ic);
+          break;
+
+        case RRC:
+          genRRC (ic);
+          break;
+
+        case RLC:
+          genRLC (ic);
+          break;
+
+        case GETHBIT:
+          genGetHbit (ic);
+          break;
+
+        case LEFT_OP:
+          genLeftShift (ic);
+          break;
+
+        case RIGHT_OP:
+          genRightShift (ic);
+          break;
+
+        case GET_VALUE_AT_ADDRESS:
+          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,getSize(operandType(IC_RIGHT(ic)))));
+          else
+            genAssign (ic);
+          break;
+
+        case IFX:
+          genIfx (ic, NULL);
+          break;
+
+        case ADDRESS_OF:
+          genAddrOf (ic);
+          break;
+
+        case JUMPTABLE:
+          genJumpTab (ic);
+          break;
+
+        case CAST:
+          genCast (ic);
+          break;
+
+        case RECEIVE:
+          genReceive (ic);
+          break;
+
+        case SEND:
+          if (ic->builtinSEND) genBuiltIn(ic);
+          else addSet (&_G.sendSet, ic);
+          break;
+
+        case DUMMY_READ_VOLATILE:
+          genDummyRead (ic);
+          break;
+
+        case CRITICAL:
+          genCritical (ic);
+          break;
+
+        case ENDCRITICAL:
+          genEndCritical (ic);
+          break;
+
+        case SWAP:
+          genSwap (ic);
+          break;
 
 #if 0 // obsolete, and buggy for != xdata
-	case ARRAYINIT:
-	    genArrayInit(ic);
-	    break;
+        case ARRAYINIT:
+            genArrayInit(ic);
+            break;
 #endif
-	    
-	default:
-	  ic = ic;
-	}
+
+        default:
+          ic = ic;
+        }
     }