X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fpic%2Fgen.c;h=5cde60649d28c1d5952804004dd3270406b8e283;hb=6e626f7686758034969a8e1b468dc30f474fb598;hp=3fffd135bc0d52732305710c99fa3aa2b99c5101;hpb=affc5e817550e87639314a8c251b2921724415db;p=fw%2Fsdcc

diff --git a/src/pic/gen.c b/src/pic/gen.c
index 3fffd135..5cde6064 100644
--- a/src/pic/gen.c
+++ b/src/pic/gen.c
@@ -36,23 +36,6 @@
 #include "SDCCglobl.h"
 #include "newalloc.h"
 
-#ifdef HAVE_SYS_ISA_DEFS_H
-#include <sys/isa_defs.h>
-#else
-#ifdef HAVE_MACHINE_ENDIAN_H
-#include <machine/endian.h>
-#else
-#ifdef HAVE_ENDIAN_H
-#include <endian.h>
-#else
-#if !defined(__BORLANDC__) && !defined(_MSC_VER) && !defined(__MINGW32__) && !defined(__CYGWIN__)
-#warning "Cannot determine ENDIANESS of this machine assuming LITTLE_ENDIAN"
-#warning "If you running sdcc on an INTEL 80x86 Platform you are okay"
-#endif
-#endif
-#endif
-#endif
-
 #include "common.h"
 #include "SDCCpeeph.h"
 #include "ralloc.h"
@@ -60,8 +43,14 @@
 #include "gen.h"
 
 
+extern void genUMult8X8_16 (operand *, operand *,operand *,pCodeOpReg *);
+extern void genSMult8X8_16 (operand *, operand *,operand *,pCodeOpReg *);
+void genMult8X8_8 (operand *, operand *,operand *);
+pCode *AssembleLine(char *line);
+extern void printpBlock(FILE *of, pBlock *pb);
+
 static int labelOffset=0;
-static int debug_verbose=1;
+extern int debug_verbose;
 static int optimized_for_speed = 0;
 
 /* max_key keeps track of the largest label number used in 
@@ -71,6 +60,7 @@ static int optimized_for_speed = 0;
 static int max_key=0;
 static int GpsuedoStkPtr=0;
 
+pCodeOp *popGetImmd(char *name, unsigned int offset, int index);
 unsigned int pic14aopLiteral (value *val, int offset);
 const char *AopType(short type);
 static iCode *ifxForOp ( operand *op, iCode *ic );
@@ -86,7 +76,7 @@ static char *zero = "#0x00";
 static char *one  = "#0x01";
 static char *spname = "sp";
 
-char *fReturnpic14[] = {"FSR","dph","b","a" };
+char *fReturnpic14[] = {"temp1","temp2","temp3","temp4" };
 //char *fReturn390[] = {"dpl","dph","dpx", "b","a" };
 unsigned fReturnSizePic = 4; /* shared with ralloc.c */
 static char **fReturn = fReturnpic14;
@@ -170,6 +160,20 @@ void DEBUGpic14_AopType(int line_no, operand *left, operand *right, operand *res
 
 }
 
+void DEBUGpic14_AopTypeSign(int line_no, operand *left, operand *right, operand *result)
+{
+
+  DEBUGpic14_emitcode ("; ","line = %d, signs: result %s=%c, left %s=%c, right %s=%c",
+		       line_no,
+		       ((result) ? AopType(AOP_TYPE(result)) : "-"),
+		       ((result) ? (SPEC_USIGN(operandType(result)) ? 'u' : 's') : '-'),
+		       ((left)   ? AopType(AOP_TYPE(left)) : "-"),
+		       ((left)   ? (SPEC_USIGN(operandType(left))   ? 'u' : 's') : '-'),
+		       ((right)  ? AopType(AOP_TYPE(right)) : "-"),
+		       ((right)  ? (SPEC_USIGN(operandType(right))  ? 'u' : 's') : '-'));
+
+}
+
 void DEBUGpic14_emitcode (char *inst,char *fmt, ...)
 {
     va_list ap;
@@ -205,9 +209,9 @@ void DEBUGpic14_emitcode (char *inst,char *fmt, ...)
 }
 
 
-static void emitpLabel(int key)
+void emitpLabel(int key)
 {
-  addpCode2pBlock(pb,newpCodeLabel(key+100+labelOffset));
+  addpCode2pBlock(pb,newpCodeLabel(NULL,key+100+labelOffset));
 }
 
 void emitpcode(PIC_OPCODE poc, pCodeOp *pcop)
@@ -305,8 +309,8 @@ static regs *getFreePtr (iCode *ic, asmop **aopp, bool result)
     if (!r0iu) {
         /* push it if not already pushed */
         if (!_G.r0Pushed) {
-            pic14_emitcode ("push","%s",
-                      pic14_regWithIdx(R0_IDX)->dname);
+	  //pic14_emitcode ("push","%s",
+	  //          pic14_regWithIdx(R0_IDX)->dname);
             _G.r0Pushed++ ;
         }
         
@@ -321,8 +325,8 @@ static regs *getFreePtr (iCode *ic, asmop **aopp, bool result)
     if (!r1iu) {
         /* push it if not already pushed */
         if (!_G.r1Pushed) {
-            pic14_emitcode ("push","%s",
-                      pic14_regWithIdx(R1_IDX)->dname);
+	  //pic14_emitcode ("push","%s",
+	  //          pic14_regWithIdx(R1_IDX)->dname);
             _G.r1Pushed++ ;
         }
         
@@ -380,15 +384,17 @@ static void resolveIfx(resolvedIfx *resIfx, iCode *ifx)
   if(!resIfx) 
     return;
 
-  DEBUGpic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
+  //  DEBUGpic14_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
 
   resIfx->condition = 1;    /* assume that the ifx is true */
   resIfx->generated = 0;    /* indicate that the ifx has not been used */
 
   if(!ifx) {
     resIfx->lbl = newiTempLabel(NULL);  /* oops, there is no ifx. so create a label */
+/*
     DEBUGpic14_emitcode("; ***","%s %d null ifx creating new label key =%d",
 			__FUNCTION__,__LINE__,resIfx->lbl->key);
+*/
   } else {
     if(IC_TRUE(ifx)) {
       resIfx->lbl = IC_TRUE(ifx);
@@ -396,13 +402,15 @@ static void resolveIfx(resolvedIfx *resIfx, iCode *ifx)
       resIfx->lbl = IC_FALSE(ifx);
       resIfx->condition = 0;
     }
+/*
     if(IC_TRUE(ifx)) 
       DEBUGpic14_emitcode("; ***","ifx true is non-null");
     if(IC_FALSE(ifx)) 
       DEBUGpic14_emitcode("; ***","ifx false is non-null");
+*/
   }
 
-  DEBUGpic14_emitcode("; ***","%s lbl->key=%d, (lab offset=%d)",__FUNCTION__,resIfx->lbl->key,labelOffset);
+  //  DEBUGpic14_emitcode("; ***","%s lbl->key=%d, (lab offset=%d)",__FUNCTION__,resIfx->lbl->key,labelOffset);
 
 }
 /*-----------------------------------------------------------------*/
@@ -520,17 +528,34 @@ static asmop *aopForSym (iCode *ic,symbol *sym,bool result)
 	aop->aopu.aop_immd = Safe_calloc(1,strlen(sym->rname)+1);
         strcpy(aop->aopu.aop_immd,sym->rname);
         aop->size = FPTRSIZE; 
+	DEBUGpic14_emitcode(";","%d size = %d, name =%s",__LINE__,aop->size,sym->rname);
         return aop;
     }
 
 
     /* only remaining is far space */
     /* in which case DPTR gets the address */
+    sym->aop = aop = newAsmop(AOP_PCODE);
+
+    aop->aopu.pcop = popGetImmd(sym->rname,0,0);
+    PCOI(aop->aopu.pcop)->_const = IN_CODESPACE(space);
+    PCOI(aop->aopu.pcop)->index = 0;
+
+    DEBUGpic14_emitcode(";","%d: rname %s, val %d, const = %d",
+			__LINE__,sym->rname, 0, PCOI(aop->aopu.pcop)->_const);
+
+    allocDirReg (IC_LEFT(ic));
+
+    aop->size = FPTRSIZE; 
+/*
+    DEBUGpic14_emitcode(";","%d size = %d, name =%s",__LINE__,aop->size,sym->rname);
     sym->aop = aop = newAsmop(AOP_DPTR);
     pic14_emitcode ("mov","dptr,#%s", sym->rname);
     aop->size = getSize(sym->type);
 
     DEBUGpic14_emitcode(";","%d size = %d",__LINE__,aop->size);
+*/
+
     /* if it is in code space */
     if (IN_CODESPACE(space))
         aop->code = 1;
@@ -541,35 +566,45 @@ static asmop *aopForSym (iCode *ic,symbol *sym,bool result)
 /*-----------------------------------------------------------------*/
 /* aopForRemat - rematerialzes an object                           */
 /*-----------------------------------------------------------------*/
-static asmop *aopForRemat (symbol *sym)
-{
-    iCode *ic = sym->rematiCode;
-    asmop *aop = newAsmop(AOP_IMMD);
-    int val = 0;
-    DEBUGpic14_emitcode(";","%s %d",__FUNCTION__,__LINE__);
-    for (;;) {
-    	if (ic->op == '+')
-	    val += (int) operandLitValue(IC_RIGHT(ic));
-	else if (ic->op == '-')
-	    val -= (int) operandLitValue(IC_RIGHT(ic));
-	else
-	    break;
+static asmop *aopForRemat (operand *op) // x symbol *sym)
+{
+  symbol *sym = OP_SYMBOL(op);
+  iCode *ic = NULL;
+  asmop *aop = newAsmop(AOP_PCODE);
+  int val = 0;
+  int offset = 0;
+
+  ic = sym->rematiCode;
+
+  DEBUGpic14_emitcode(";","%s %d",__FUNCTION__,__LINE__);
+  if(IS_OP_POINTER(op)) {
+    DEBUGpic14_emitcode(";","%s %d IS_OP_POINTER",__FUNCTION__,__LINE__);
+  }
+  for (;;) {
+    if (ic->op == '+') {
+      val += (int) operandLitValue(IC_RIGHT(ic));
+    } else if (ic->op == '-') {
+      val -= (int) operandLitValue(IC_RIGHT(ic));
+    } else
+      break;
 	
-	ic = OP_SYMBOL(IC_LEFT(ic))->rematiCode;
-    }
+    ic = OP_SYMBOL(IC_LEFT(ic))->rematiCode;
+  }
 
-    if (val)
-    	sprintf(buffer,"(%s %c 0x%04x)",
-	        OP_SYMBOL(IC_LEFT(ic))->rname, 
-		val >= 0 ? '+' : '-',
-		abs(val) & 0xffff);
-    else
-	strcpy(buffer,OP_SYMBOL(IC_LEFT(ic))->rname);
+  offset = OP_SYMBOL(IC_LEFT(ic))->offset;
+  aop->aopu.pcop = popGetImmd(OP_SYMBOL(IC_LEFT(ic))->rname,0,val);
+  PCOI(aop->aopu.pcop)->_const = IS_PTR_CONST(operandType(op));
+  PCOI(aop->aopu.pcop)->index = val;
+
+  DEBUGpic14_emitcode(";","%d: rname %s, val %d, const = %d",
+		      __LINE__,OP_SYMBOL(IC_LEFT(ic))->rname,
+		      val, IS_PTR_CONST(operandType(op)));
+
+  //    DEBUGpic14_emitcode(";","aop type  %s",AopType(AOP_TYPE(IC_LEFT(ic))));
+
+  allocDirReg (IC_LEFT(ic));
 
-    //DEBUGpic14_emitcode(";","%s",buffer);
-    aop->aopu.aop_immd = Safe_calloc(1,strlen(buffer)+1);
-    strcpy(aop->aopu.aop_immd,buffer);    
-    return aop;        
+  return aop;        
 }
 
 int aopIdx (asmop *aop, int offset)
@@ -709,6 +744,12 @@ void aopOp (operand *op, iCode *ic, bool result)
         return;
     }
 
+    {
+      sym_link *type = operandType(op);
+      if(IS_PTR_CONST(type))
+	DEBUGpic14_emitcode(";","%d aop type is const pointer",__LINE__);
+    }
+
     /* if already has a asmop then continue */
     if (op->aop)
         return ;
@@ -753,9 +794,11 @@ void aopOp (operand *op, iCode *ic, bool result)
       DEBUGpic14_emitcode(";","%d",__LINE__);
         /* rematerialize it NOW */
         if (sym->remat) {
+
             sym->aop = op->aop = aop =
-                                      aopForRemat (sym);
+                                      aopForRemat (op);
             aop->size = getSize(sym->type);
+	    //DEBUGpic14_emitcode(";"," %d: size %d, %s\n",__LINE__,aop->size,aop->aopu.aop_immd);
             return;
         }
 
@@ -765,18 +808,27 @@ void aopOp (operand *op, iCode *ic, bool result)
             aop->size = getSize(sym->type);
             for ( i = 0 ; i < 2 ; i++ )
                 aop->aopu.aop_str[i] = accUse[i];
-	    DEBUGpic14_emitcode(";","%d",__LINE__);
+	    DEBUGpic14_emitcode(";","%d size=%d",__LINE__,aop->size);
             return;  
 	}
 
         if (sym->ruonly ) {
-            unsigned i;
-            aop = op->aop = sym->aop = newAsmop(AOP_STR);
-            aop->size = getSize(sym->type);
-            for ( i = 0 ; i < fReturnSizePic ; i++ )
-	      aop->aopu.aop_str[i] = fReturn[i];
-	    DEBUGpic14_emitcode(";","%d",__LINE__);
-            return;
+	  /*
+	  sym->aop = op->aop = aop = newAsmop(AOP_PCODE);
+	  aop->aopu.pcop = popGetImmd(sym->usl.spillLoc->rname,0,sym->usl.spillLoc->offset);
+	  //allocDirReg (IC_LEFT(ic));
+	  aop->size = getSize(sym->type);
+	  */
+
+	  unsigned i;
+
+	  aop = op->aop = sym->aop = newAsmop(AOP_STR);
+	  aop->size = getSize(sym->type);
+	  for ( i = 0 ; i < fReturnSizePic ; i++ )
+	    aop->aopu.aop_str[i] = fReturn[i];
+
+	  DEBUGpic14_emitcode(";","%d",__LINE__);
+	  return;
         }
 
         /* else spill location  */
@@ -784,14 +836,29 @@ void aopOp (operand *op, iCode *ic, bool result)
 	    /* force a new aop if sizes differ */
 	    sym->usl.spillLoc->aop = NULL;
 	}
-	DEBUGpic14_emitcode(";","%s %d %s",__FUNCTION__,__LINE__,sym->usl.spillLoc->rname);
-        sym->aop = op->aop = aop = 
-                                  aopForSym(ic,sym->usl.spillLoc,result);
+	DEBUGpic14_emitcode(";","%s %d %s sym->rname = %s, offset %d",
+			    __FUNCTION__,__LINE__,
+			    sym->usl.spillLoc->rname,
+			    sym->rname, sym->usl.spillLoc->offset);
+
+	sym->aop = op->aop = aop = newAsmop(AOP_PCODE);
+	//aop->aopu.pcop = popGetImmd(sym->usl.spillLoc->rname,0,sym->usl.spillLoc->offset);
+	aop->aopu.pcop = popRegFromString(sym->usl.spillLoc->rname, 
+					  getSize(sym->type), 
+					  sym->usl.spillLoc->offset);
         aop->size = getSize(sym->type);
+
         return;
     }
 
+    {
+      sym_link *type = operandType(op);
+      if(IS_PTR_CONST(type)) 
+	DEBUGpic14_emitcode(";","%d aop type is const pointer",__LINE__);
+    }
+
     /* must be in a register */
+    DEBUGpic14_emitcode(";","%d register type nRegs=%d",__LINE__,sym->nRegs);
     sym->aop = op->aop = aop = newAsmop(AOP_REG);
     aop->size = sym->nRegs;
     for ( i = 0 ; i < sym->nRegs ;i++)
@@ -980,7 +1047,6 @@ char *aopGet (asmop *aop, int offset, bool bit16, bool dname)
 	
 	
     case AOP_IMMD:
-      DEBUGpic14_emitcode(";","%d",__LINE__);
 	if (bit16) 
 	    sprintf (s,"%s",aop->aopu.aop_immd);
 	else
@@ -991,25 +1057,27 @@ char *aopGet (asmop *aop, int offset, bool bit16, bool dname)
 	    else
 		sprintf(s,"%s",
 			aop->aopu.aop_immd);
+	DEBUGpic14_emitcode(";","%d immd %s",__LINE__,s);
 	rs = Safe_calloc(1,strlen(s)+1);
 	strcpy(rs,s);   
 	return rs;
 	
     case AOP_DIR:
-	if (offset)
-	    sprintf(s,"(%s + %d)",
-		    aop->aopu.aop_dir,
-		    offset);
-	else
+      if (offset) {
+	sprintf(s,"(%s + %d)",
+		aop->aopu.aop_dir,
+		offset);
+	DEBUGpic14_emitcode(";","oops AOP_DIR did this %s\n",s);
+      } else
 	    sprintf(s,"%s",aop->aopu.aop_dir);
 	rs = Safe_calloc(1,strlen(s)+1);
 	strcpy(rs,s);   
 	return rs;
 	
     case AOP_REG:
-	if (dname) 
-	    return aop->aopu.aop_reg[offset]->dname;
-	else
+      //if (dname) 
+      //    return aop->aopu.aop_reg[offset]->dname;
+      //else
 	    return aop->aopu.aop_reg[offset]->name;
 	
     case AOP_CRY:
@@ -1027,14 +1095,30 @@ char *aopGet (asmop *aop, int offset, bool bit16, bool dname)
 	return rs;
 	
     case AOP_STR:
-        DEBUGpic14_emitcode(";","%d",__LINE__);
 	aop->coff = offset ;
 	if (strcmp(aop->aopu.aop_str[offset],"a") == 0 &&
 	    dname)
 	    return "acc";
+        DEBUGpic14_emitcode(";","%d - %s",__LINE__, aop->aopu.aop_str[offset]);
 	
 	return aop->aopu.aop_str[offset];
 	
+    case AOP_PCODE:
+      {
+	pCodeOp *pcop = aop->aopu.pcop;
+	DEBUGpic14_emitcode(";","%d: aopGet AOP_PCODE type %s",__LINE__,pCodeOpType(pcop));
+	if(pcop->name) {
+	  DEBUGpic14_emitcode(";","%s offset %d",pcop->name,PCOI(pcop)->offset);
+	  //sprintf(s,"(%s+0x%02x)", pcop->name,PCOI(aop->aopu.pcop)->offset);
+	  sprintf(s,"%s", pcop->name);
+	} else
+	  sprintf(s,"0x%02x", PCOI(aop->aopu.pcop)->offset);
+
+      }
+      rs = Safe_calloc(1,strlen(s)+1);
+      strcpy(rs,s);   
+      return rs;
+
     }
 
     werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
@@ -1042,6 +1126,34 @@ char *aopGet (asmop *aop, int offset, bool bit16, bool dname)
     exit(0);
 }
 
+
+/*-----------------------------------------------------------------*/
+/* popGetTempReg - create a new temporary pCodeOp                  */
+/*-----------------------------------------------------------------*/
+pCodeOp *popGetTempReg(void)
+{
+
+  pCodeOp *pcop;
+
+  pcop = newpCodeOp(NULL, PO_GPR_TEMP);
+  if(pcop && pcop->type == PO_GPR_TEMP && PCOR(pcop)->r) {
+    PCOR(pcop)->r->wasUsed=1;
+    PCOR(pcop)->r->isFree=0;
+  }
+
+  return pcop;
+}
+
+/*-----------------------------------------------------------------*/
+/* popGetTempReg - create a new temporary pCodeOp                  */
+/*-----------------------------------------------------------------*/
+void popReleaseTempReg(pCodeOp *pcop)
+{
+
+  if(pcop && pcop->type == PO_GPR_TEMP && PCOR(pcop)->r)
+    PCOR(pcop)->r->isFree = 1;
+
+}
 /*-----------------------------------------------------------------*/
 /* popGetLabel - create a new pCodeOp of type PO_LABEL             */
 /*-----------------------------------------------------------------*/
@@ -1053,7 +1165,7 @@ pCodeOp *popGetLabel(unsigned int key)
   if(key>max_key)
     max_key = key;
 
-  return newpCodeOpLabel(key+100+labelOffset);
+  return newpCodeOpLabel(NULL,key+100+labelOffset);
 }
 
 /*-----------------------------------------------------------------*/
@@ -1065,41 +1177,37 @@ pCodeOp *popCopyReg(pCodeOpReg *pc)
 
   pcor = Safe_calloc(1,sizeof(pCodeOpReg) );
   pcor->pcop.type = pc->pcop.type;
-  if(!(pcor->pcop.name = Safe_strdup(pc->pcop.name)))
-    fprintf(stderr,"oops %s %d",__FILE__,__LINE__);
+  if(pc->pcop.name) {
+    if(!(pcor->pcop.name = Safe_strdup(pc->pcop.name)))
+      fprintf(stderr,"oops %s %d",__FILE__,__LINE__);
+  } else
+    pcor->pcop.name = NULL;
+
   pcor->r = pc->r;
   pcor->rIdx = pc->rIdx;
+  pcor->r->wasUsed=1;
 
   //DEBUGpic14_emitcode ("; ***","%s  , copying %s, rIdx=%d",__FUNCTION__,pc->pcop.name,pc->rIdx);
 
   return PCOP(pcor);
 }
-
 /*-----------------------------------------------------------------*/
-/* popCopy - copy a pcode operator                                 */
+/* popGet - asm operator to pcode operator conversion              */
 /*-----------------------------------------------------------------*/
-pCodeOp *popCopyGPR2Bit(pCodeOp *pc, int bitval)
+pCodeOp *popGetLit(unsigned int lit)
 {
-  pCodeOp *pcop;
-
-  pcop = Safe_calloc(1,sizeof(pCodeOpBit) );
-  pcop->type = PO_BIT;
-  if(!(pcop->name = Safe_strdup(pc->name)))
-    fprintf(stderr,"oops %s %d",__FILE__,__LINE__);
-  ((pCodeOpBit *)pcop)->bit = bitval;
-
-  ((pCodeOpBit *)pcop)->inBitSpace = 0; //(pc->type == PO_BIT) ? 1 : 0;
 
-  return pcop;
+  return newpCodeOpLit(lit);
 }
 
+
 /*-----------------------------------------------------------------*/
-/* popGet - asm operator to pcode operator conversion              */
+/* popGetImmd - asm operator to pcode immediate conversion         */
 /*-----------------------------------------------------------------*/
-pCodeOp *popGetLit(unsigned int lit)
+pCodeOp *popGetImmd(char *name, unsigned int offset, int index)
 {
 
-  return newpCodeOpLit(lit);
+  return newpCodeOpImmd(name, offset,index, 0);
 }
 
 
@@ -1121,17 +1229,34 @@ pCodeOp *popGetWithString(char *str)
   return pcop;
 }
 
-pCodeOp *popRegFromString(char *str)
+/*-----------------------------------------------------------------*/
+/* popRegFromString -                                              */
+/*-----------------------------------------------------------------*/
+pCodeOp *popRegFromString(char *str, int size, int offset)
 {
 
   pCodeOp *pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
-  pcop->type = PO_GPR_REGISTER;
-
-  PCOR(pcop)->rIdx = -1;
-  PCOR(pcop)->r = NULL;
+  pcop->type = PO_DIR;
 
   DEBUGpic14_emitcode(";","%d",__LINE__);
-  pcop->name = Safe_strdup( ( (str) ? str : "BAD STRING"));
+
+  if(!str)
+    str = "BAD_STRING";
+
+  pcop->name = Safe_calloc(1,strlen(str)+1);
+  strcpy(pcop->name,str);
+
+  //pcop->name = Safe_strdup( ( (str) ? str : "BAD STRING"));
+
+  PCOR(pcop)->r = dirregWithName(pcop->name);
+  if(PCOR(pcop)->r == NULL) {
+    //fprintf(stderr,"%d - couldn't find %s in allocated registers, size =%d\n",__LINE__,aop->aopu.aop_dir,aop->size);
+    PCOR(pcop)->r = allocRegByName (pcop->name,size);
+    DEBUGpic14_emitcode(";","%d  %s   offset=%d - had to alloc by reg name",__LINE__,pcop->name,offset);
+  } else {
+    DEBUGpic14_emitcode(";","%d  %s   offset=%d",__LINE__,pcop->name,offset);
+  }
+  PCOR(pcop)->instance = offset;
 
   return pcop;
 }
@@ -1160,8 +1285,8 @@ pCodeOp *popRegFromIdx(int rIdx)
 /*-----------------------------------------------------------------*/
 pCodeOp *popGet (asmop *aop, int offset) //, bool bit16, bool dname)
 {
-    char *s = buffer ;
-    char *rs;
+  //char *s = buffer ;
+    //char *rs;
 
     pCodeOp *pcop;
 
@@ -1182,38 +1307,19 @@ pCodeOp *popGet (asmop *aop, int offset) //, bool bit16, bool dname)
     case AOP_DPTR2:
     case AOP_ACC:
         DEBUGpic14_emitcode(";8051 legacy","%d type = %s",__LINE__,AopType(aop->type));
-	//pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
-	//pcop->type = PO_SFR_REGISTER;
-
-	//PCOR(pcop)->rIdx = -1;
-	//PCOR(pcop)->r = NULL;
-	// Really nasty hack to check for temporary registers
-
-	//pcop->name = Safe_strdup("BAD_REGISTER");
-
 	return NULL;
 	
     case AOP_IMMD:
       DEBUGpic14_emitcode(";","%d",__LINE__);
-	pcop = Safe_calloc(1,sizeof(pCodeOp) );
-	pcop->type = PO_IMMEDIATE;
-	//if (bit16) 
-	//    sprintf (s,"%s",aop->aopu.aop_immd);
-	//else
-	if (offset) 
-	  sprintf(s,"(%s >> %d)",
-		  aop->aopu.aop_immd,
-		  offset*8);
-	else
-	  sprintf(s,"%s",
-		  aop->aopu.aop_immd);
-	pcop->name = Safe_calloc(1,strlen(s)+1);
-	strcpy(pcop->name,s);   
-	return pcop;
-	
+      return popGetImmd(aop->aopu.aop_immd,offset,0);
+
     case AOP_DIR:
-	pcop = Safe_calloc(1,sizeof(pCodeOp) );
+      return popRegFromString(aop->aopu.aop_dir, aop->size, offset);
+#if 0
+	pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
 	pcop->type = PO_DIR;
+
+	/*
 	if (offset)
 	    sprintf(s,"(%s + %d)",
 		    aop->aopu.aop_dir,
@@ -1222,7 +1328,21 @@ pCodeOp *popGet (asmop *aop, int offset) //, bool bit16, bool dname)
 	    sprintf(s,"%s",aop->aopu.aop_dir);
 	pcop->name = Safe_calloc(1,strlen(s)+1);
 	strcpy(pcop->name,s);   
+	*/
+	pcop->name = Safe_calloc(1,strlen(aop->aopu.aop_dir)+1);
+	strcpy(pcop->name,aop->aopu.aop_dir);   
+	PCOR(pcop)->r = dirregWithName(aop->aopu.aop_dir);
+	if(PCOR(pcop)->r == NULL) {
+	  //fprintf(stderr,"%d - couldn't find %s in allocated registers, size =%d\n",__LINE__,aop->aopu.aop_dir,aop->size);
+	  PCOR(pcop)->r = allocRegByName (aop->aopu.aop_dir,aop->size);
+	  DEBUGpic14_emitcode(";","%d  %s   offset=%d - had to alloc by reg name",__LINE__,pcop->name,offset);
+	} else {
+	  DEBUGpic14_emitcode(";","%d  %s   offset=%d",__LINE__,pcop->name,offset);
+	}
+	PCOR(pcop)->instance = offset;
+
 	return pcop;
+#endif
 	
     case AOP_REG:
       {
@@ -1231,34 +1351,46 @@ pCodeOp *popGet (asmop *aop, int offset) //, bool bit16, bool dname)
 	pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
 	PCOR(pcop)->rIdx = rIdx;
 	PCOR(pcop)->r = pic14_regWithIdx(rIdx);
+	PCOR(pcop)->r->wasUsed=1;
+	PCOR(pcop)->r->isFree=0;
+
+	PCOR(pcop)->instance = offset;
 	pcop->type = PCOR(pcop)->r->pc_type;
-	rs = aop->aopu.aop_reg[offset]->name;
+	//rs = aop->aopu.aop_reg[offset]->name;
 	//DEBUGpic14_emitcode(";","%d regiser idx = %d name =%s",__LINE__,rIdx,rs);
 	return pcop;
       }
 
     case AOP_CRY:
       pcop = newpCodeOpBit(aop->aopu.aop_dir,-1,1);
+      PCOR(pcop)->r = dirregWithName(aop->aopu.aop_dir);
+      //if(PCOR(pcop)->r == NULL)
+      //fprintf(stderr,"%d - couldn't find %s in allocated registers\n",__LINE__,aop->aopu.aop_dir);
       return pcop;
 	
     case AOP_LIT:
       return newpCodeOpLit(pic14aopLiteral (aop->aopu.aop_lit,offset));
 
     case AOP_STR:
-      DEBUGpic14_emitcode(";","%d",__LINE__);
-
-      pcop = Safe_calloc(1,sizeof(pCodeOp) );
-      pcop->type = PO_STR;
+      DEBUGpic14_emitcode(";","%d  %s",__LINE__,aop->aopu.aop_str[offset]);
+      return newpCodeOpRegFromStr(aop->aopu.aop_str[offset]);
+      /*
+      pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
+      PCOR(pcop)->r = allocRegByName(aop->aopu.aop_str[offset]);
+      PCOR(pcop)->rIdx = PCOR(pcop)->r->rIdx;
+      pcop->type = PCOR(pcop)->r->pc_type;
+      pcop->name = PCOR(pcop)->r->name;
 
-      //aop->coff = offset ;
-      //if (strcmp(aop->aopu.aop_str[offset],"a") == 0 && dname)
-      //  sprintf(s,"%s","acc");
-      //else
-      sprintf(s,"%s",aop->aopu.aop_str[offset]);
-      pcop->name = Safe_calloc(1,strlen(s)+1);
-      strcpy(pcop->name,s);   
       return pcop;
-	
+      */
+
+    case AOP_PCODE:
+      DEBUGpic14_emitcode(";","popGet AOP_PCODE (%s) %d %s",pCodeOpType(aop->aopu.pcop),
+			  __LINE__, 
+			  ((aop->aopu.pcop->name)? (aop->aopu.pcop->name) : "no name"));
+      pcop = pCodeOpCopy(aop->aopu.pcop);
+      PCOI(pcop)->offset = offset;
+      return pcop;
     }
 
     werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
@@ -1285,10 +1417,12 @@ void aopPut (asmop *aop, char *s, int offset)
     /* depending on where it is ofcourse */
     switch (aop->type) {
     case AOP_DIR:
-	if (offset)
-	    sprintf(d,"(%s + %d)",
-		    aop->aopu.aop_dir,offset);
-	else
+      if (offset) {
+	sprintf(d,"(%s + %d)",
+		aop->aopu.aop_dir,offset);
+	fprintf(stderr,"oops aopPut:AOP_DIR did this %s\n",s);
+
+      } else
 	    sprintf(d,"%s",aop->aopu.aop_dir);
 	
 	if (strcmp(d,s)) {
@@ -1297,8 +1431,15 @@ void aopPut (asmop *aop, char *s, int offset)
 	    pic14_emitcode("movf","%s,w",s);
 	  pic14_emitcode("movwf","%s",d);
 
-	  if(strcmp(s,"W"))
-	    pic14_emitcode(";BUG! should have this:movf","%s,w   %d",s,__LINE__);
+	  if(strcmp(s,"W")) {
+	    pic14_emitcode(";BUG!? should have this:movf","%s,w   %d",s,__LINE__);
+	    if(offset >= aop->size) {
+	      emitpcode(POC_CLRF,popGet(aop,offset));
+	      break;
+	    } else
+	      emitpcode(POC_MOVLW,popGetImmd(s,offset,0));
+	  }
+
 	  emitpcode(POC_MOVWF,popGet(aop,offset));
 
 
@@ -1306,8 +1447,8 @@ void aopPut (asmop *aop, char *s, int offset)
 	break;
 	
     case AOP_REG:
-	if (strcmp(aop->aopu.aop_reg[offset]->name,s) != 0 &&
-	    strcmp(aop->aopu.aop_reg[offset]->dname,s)!= 0){
+      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 ||
@@ -1323,13 +1464,16 @@ void aopPut (asmop *aop, char *s, int offset)
 	    else
 	  */
 
-	  if(strcmp(s,"W"))
+	  if(strcmp(s,"W")==0 )
 	    pic14_emitcode("movf","%s,w  ; %d",s,__LINE__);
 
 	  pic14_emitcode("movwf","%s",
 		   aop->aopu.aop_reg[offset]->name);
 
-	  if(strcmp(s,"W")) {
+	  if(strcmp(s,zero)==0) {
+	    emitpcode(POC_CLRF,popGet(aop,offset));
+
+	  } else if(strcmp(s,"W")==0) {
 	    pCodeOp *pcop = Safe_calloc(1,sizeof(pCodeOpReg) );
 	    pcop->type = PO_GPR_REGISTER;
 
@@ -1339,9 +1483,13 @@ void aopPut (asmop *aop, char *s, int offset)
 	    DEBUGpic14_emitcode(";","%d",__LINE__);
 	    pcop->name = Safe_strdup(s);
 	    emitpcode(POC_MOVFW,pcop);
+	    emitpcode(POC_MOVWF,popGet(aop,offset));
+	  } else if(strcmp(s,one)==0) {
+	    emitpcode(POC_CLRF,popGet(aop,offset));
+	    emitpcode(POC_INCF,popGet(aop,offset));
+	  } else {
+	    emitpcode(POC_MOVWF,popGet(aop,offset));
 	  }
-	  emitpcode(POC_MOVWF,popGet(aop,offset));
-
 	}
 	break;
 	
@@ -1480,6 +1628,25 @@ void aopPut (asmop *aop, char *s, int offset)
 
 }
 
+/*-----------------------------------------------------------------*/
+/* mov2w - generate either a MOVLW or MOVFW based operand type     */
+/*-----------------------------------------------------------------*/
+void mov2w (asmop *aop, int offset)
+{
+
+  if(!aop)
+    return;
+
+  DEBUGpic14_emitcode ("; ***","%s  %d  offset=%d",__FUNCTION__,__LINE__,offset);
+
+  if ( aop->type == AOP_PCODE ||
+       aop->type == AOP_LIT )
+    emitpcode(POC_MOVLW,popGet(aop,offset));
+  else
+    emitpcode(POC_MOVFW,popGet(aop,offset));
+
+}
+
 /*-----------------------------------------------------------------*/
 /* reAdjustPreg - points a register back to where it should        */
 /*-----------------------------------------------------------------*/
@@ -1682,10 +1849,14 @@ static void genNot (iCode *ic)
   DEBUGpic14_AopType(__LINE__,IC_LEFT(ic),NULL,IC_RESULT(ic));
   /* if in bit space then a special case */
   if (AOP_TYPE(IC_LEFT(ic)) == AOP_CRY) {
-    pic14_emitcode("movlw","1<<%s");
-    //pic14_emitcode("mov","c,%s",IC_LEFT(ic)->aop->aopu.aop_dir); 
-    //pic14_emitcode("cpl","c"); 
-    //pic14_outBitC(IC_RESULT(ic));
+    if (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY) {
+      emitpcode(POC_MOVLW,popGet(AOP(IC_LEFT(ic)),0));
+      emitpcode(POC_XORWF,popGet(AOP(IC_RESULT(ic)),0));
+    } else {
+      emitpcode(POC_CLRF,popGet(AOP(IC_RESULT(ic)),0));
+      emitpcode(POC_BTFSS,popGet(AOP(IC_LEFT(ic)),0));
+      emitpcode(POC_INCF,popGet(AOP(IC_RESULT(ic)),0));
+    }
     goto release;
   }
 
@@ -1721,39 +1892,42 @@ static void genNot (iCode *ic)
 /*-----------------------------------------------------------------*/
 static void genCpl (iCode *ic)
 {
-    int offset = 0;
-    int size ;
+  operand *left, *result;
+  int size, offset=0;  
 
 
-    DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-    /* assign asmOps to operand & result */
-    aopOp (IC_LEFT(ic),ic,FALSE);
-    aopOp (IC_RESULT(ic),ic,TRUE);
+  DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+  aopOp((left = IC_LEFT(ic)),ic,FALSE);
+  aopOp((result=IC_RESULT(ic)),ic,TRUE);
 
-    /* if both are in bit space then 
-    a special case */
-    if (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY &&
-        AOP_TYPE(IC_LEFT(ic)) == AOP_CRY ) { 
+  /* if both are in bit space then 
+     a special case */
+  if (AOP_TYPE(result) == AOP_CRY &&
+      AOP_TYPE(left) == AOP_CRY ) { 
 
-        pic14_emitcode("mov","c,%s",IC_LEFT(ic)->aop->aopu.aop_dir); 
-        pic14_emitcode("cpl","c"); 
-        pic14_emitcode("mov","%s,c",IC_RESULT(ic)->aop->aopu.aop_dir); 
-        goto release; 
-    } 
+    pic14_emitcode("mov","c,%s",left->aop->aopu.aop_dir); 
+    pic14_emitcode("cpl","c"); 
+    pic14_emitcode("mov","%s,c",result->aop->aopu.aop_dir); 
+    goto release; 
+  } 
 
-    size = AOP_SIZE(IC_RESULT(ic));
-    while (size--) {
-        char *l = aopGet(AOP(IC_LEFT(ic)),offset,FALSE,FALSE);
-        MOVA(l);       
-        pic14_emitcode("cpl","a");
-        aopPut(AOP(IC_RESULT(ic)),"a",offset++);
-    }
+  size = AOP_SIZE(result);
+  while (size--) {
+
+    if(AOP_TYPE(left) == AOP_ACC) 
+      emitpcode(POC_XORLW, popGetLit(0xff));
+    else
+      emitpcode(POC_COMFW,popGet(AOP(left),offset));
+
+    emitpcode(POC_MOVWF,popGet(AOP(result),offset));
+
+  }
 
 
 release:
     /* release the aops */
-    freeAsmop(IC_LEFT(ic),NULL,ic,(RESULTONSTACK(ic) ? 0 : 1));
-    freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
+    freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? 0 : 1));
+    freeAsmop(result,NULL,ic,TRUE);
 }
 
 /*-----------------------------------------------------------------*/
@@ -1891,11 +2065,11 @@ static void saveRegisters(iCode *lic)
 	pic14_emitcode("mov","%s,r0",spname);
 	if (bitVectBitValue(rsave,R0_IDX))
 	    pic14_emitcode("mov","r0,b");	    
-    } else
-	for (i = 0 ; i < pic14_nRegs ; i++) {
-	    if (bitVectBitValue(rsave,i))
-		pic14_emitcode("push","%s",pic14_regWithIdx(i)->dname);
-	}
+    }// else
+    //for (i = 0 ; i < pic14_nRegs ; i++) {
+    //    if (bitVectBitValue(rsave,i))
+    //	pic14_emitcode("push","%s",pic14_regWithIdx(i)->dname);
+    //}
 
     dtype = operandType(IC_LEFT(ic));
     if (currFunc && dtype && 
@@ -1936,11 +2110,11 @@ static void unsaveRegisters (iCode *ic)
 	pic14_emitcode("mov","%s,r0",spname);
 	if (bitVectBitValue(rsave,R0_IDX))
 	    pic14_emitcode("mov","r0,b");
-    } else
-	for (i =  pic14_nRegs ; i >= 0 ; i--) {
-	    if (bitVectBitValue(rsave,i))
-		pic14_emitcode("pop","%s",pic14_regWithIdx(i)->dname);
-	}
+    } //else
+    //for (i =  pic14_nRegs ; i >= 0 ; i--) {
+    //    if (bitVectBitValue(rsave,i))
+    //	pic14_emitcode("pop","%s",pic14_regWithIdx(i)->dname);
+    //}
 
 }  
 
@@ -1975,6 +2149,8 @@ static void assignResultValue(operand * oper)
 
   DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
 
+  DEBUGpic14_AopType(__LINE__,oper,NULL,NULL);
+
   if(!GpsuedoStkPtr) {
     /* The last byte in the assignment is in W */
     size--;
@@ -2225,7 +2401,6 @@ static void genCall (iCode *ic)
       aopOp(IC_LEFT(sic),sic,FALSE);
       size = AOP_SIZE(IC_LEFT(sic));
 
-
       while (size--) {
 	DEBUGpic14_emitcode ("; ","%d left %s",__LINE__,
 			     AopType(AOP_TYPE(IC_LEFT(sic))));
@@ -2241,13 +2416,14 @@ static void genCall (iCode *ic)
 	firstTimeThruLoop=0;
 
 	//if (strcmp(l,fReturn[offset])) {
-
-	if ( ((AOP(IC_LEFT(sic))->type) == AOP_IMMD) ||
+	mov2w (AOP(IC_LEFT(sic)),  offset);
+/*
+	if ( ((AOP(IC_LEFT(sic))->type) == AOP_PCODE) ||
 	     ((AOP(IC_LEFT(sic))->type) == AOP_LIT) )
 	  emitpcode(POC_MOVLW,popGet(AOP(IC_LEFT(sic)),offset));
 	else
 	  emitpcode(POC_MOVFW,popGet(AOP(IC_LEFT(sic)),offset));
-
+*/
 	//}
 	offset++;
       }
@@ -2420,17 +2596,17 @@ static void genPcall (iCode *ic)
 /*-----------------------------------------------------------------*/
 static int resultRemat (iCode *ic)
 {
-    DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-    if (SKIP_IC(ic) || ic->op == IFX)
-        return 0;
+  //    DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+  if (SKIP_IC(ic) || ic->op == IFX)
+    return 0;
 
-    if (IC_RESULT(ic) && IS_ITEMP(IC_RESULT(ic))) {
-        symbol *sym = OP_SYMBOL(IC_RESULT(ic));
-        if (sym->remat && !POINTER_SET(ic)) 
-            return 1;
-    }
+  if (IC_RESULT(ic) && IS_ITEMP(IC_RESULT(ic))) {
+    symbol *sym = OP_SYMBOL(IC_RESULT(ic));
+    if (sym->remat && !POINTER_SET(ic)) 
+      return 1;
+  }
 
-    return 0;
+  return 0;
 }
 
 #if defined(__BORLANDC__) || defined(_MSC_VER)
@@ -2439,13 +2615,13 @@ static int resultRemat (iCode *ic)
 #define STRCASECMP strcasecmp
 #endif
 
+#if 0
 /*-----------------------------------------------------------------*/
 /* inExcludeList - return 1 if the string is in exclude Reg list   */
 /*-----------------------------------------------------------------*/
 static bool inExcludeList(char *s)
 {
   DEBUGpic14_emitcode ("; ***","%s  %d - WARNING no code generated",__FUNCTION__,__LINE__);
-#if 0
     int i =0;
     
     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
@@ -2458,9 +2634,9 @@ static bool inExcludeList(char *s)
         STRCASECMP(s,options.excludeRegs[i]) == 0)
 	    return TRUE;
     }
-#endif
     return FALSE ;
 }
+#endif
 
 /*-----------------------------------------------------------------*/
 /* genFunction - generated code for function entry                 */
@@ -2514,7 +2690,17 @@ static void genFunction (iCode *ic)
     /* if this is an interrupt service routine then
     save acc, b, dpl, dph  */
     if (IFFUNC_ISISR(sym->type)) {
-        
+      addpCode2pBlock(pb,newpCode(POC_GOTO,newpCodeOp("END_OF_INTERRUPT+1",PO_STR)));
+      emitpcodeNULLop(POC_NOP);
+      emitpcodeNULLop(POC_NOP);
+      emitpcodeNULLop(POC_NOP);
+      emitpcode(POC_MOVWF,  popCopyReg(&pc_wsave));
+      emitpcode(POC_SWAPFW, popCopyReg(&pc_status));
+      emitpcode(POC_CLRF,   popCopyReg(&pc_status));
+      emitpcode(POC_MOVWF,  popCopyReg(&pc_ssave));
+
+      pBlockConvert2ISR(pb);
+#if 0  
 	if (!inExcludeList("acc")) 	    
 	    pic14_emitcode ("push","acc");	
 	if (!inExcludeList("b"))
@@ -2554,7 +2740,7 @@ static void genFunction (iCode *ic)
 		    for ( i = 0 ; i < sym->regsUsed->size ; i++) {
 			if (bitVectBitValue(sym->regsUsed,i) ||
                           (pic14_ptrRegReq && (i == R0_IDX || i == R1_IDX)) )
-			    pic14_emitcode("push","%s",pic14_regWithIdx(i)->dname);			    
+			  pic14_emitcode("push","junk");//"%s",pic14_regWithIdx(i)->dname);			    
 		    }
 		}
 		
@@ -2565,6 +2751,7 @@ static void genFunction (iCode *ic)
 		saverbank(0,ic,FALSE);
 	    }	    
 	}
+#endif
     } else {
 	/* if callee-save to be used for this function
 	   then save the registers being used in this function */
@@ -2577,7 +2764,7 @@ static void genFunction (iCode *ic)
 		for ( i = 0 ; i < sym->regsUsed->size ; i++) {
 		    if (bitVectBitValue(sym->regsUsed,i) ||
                       (pic14_ptrRegReq && (i == R0_IDX || i == R1_IDX)) ) {
-			pic14_emitcode("push","%s",pic14_regWithIdx(i)->dname);
+		      //pic14_emitcode("push","%s",pic14_regWithIdx(i)->dname);
 			_G.nRegsSaved++;
 		    }
 		}
@@ -2696,7 +2883,7 @@ static void genEndFunction (iCode *ic)
 		    for ( i = sym->regsUsed->size ; i >= 0 ; i--) {
 			if (bitVectBitValue(sym->regsUsed,i) ||
                           (pic14_ptrRegReq && (i == R0_IDX || i == R1_IDX)) )
-			    pic14_emitcode("pop","%s",pic14_regWithIdx(i)->dname);
+			  pic14_emitcode("pop","junk");//"%s",pic14_regWithIdx(i)->dname);
 		    }
 		}
 		
@@ -2707,7 +2894,7 @@ static void genEndFunction (iCode *ic)
 		unsaverbank(0,ic,FALSE);
 	    }	    
 	}
-
+#if 0
 	if (options.model == MODEL_FLAT24 && !inExcludeList("dpx"))
 	{
 	    if (options.stack10bit)
@@ -2730,6 +2917,7 @@ static void genEndFunction (iCode *ic)
 
         if (IFFUNC_ISCRITICAL(sym->type))
             pic14_emitcode("setb","ea");
+#endif
 
 	/* if debug then send end of function */
 /* 	if (options.debug && currFunc) { */
@@ -2746,6 +2934,16 @@ static void genEndFunction (iCode *ic)
 	}
 	
         pic14_emitcode ("reti","");
+
+	emitpcode(POC_CLRF,   popCopyReg(&pc_status));
+	emitpcode(POC_SWAPFW, popCopyReg(&pc_ssave));
+	emitpcode(POC_MOVWF,  popCopyReg(&pc_status));
+	emitpcode(POC_SWAPF,  popCopyReg(&pc_wsave));
+	emitpcode(POC_SWAPFW, popCopyReg(&pc_wsave));
+	addpCode2pBlock(pb,newpCodeLabel("END_OF_INTERRUPT",-1));
+
+	emitpcodeNULLop(POC_RETFIE);
+
     }
     else {
         if (IFFUNC_ISCRITICAL(sym->type))
@@ -2760,7 +2958,7 @@ static void genEndFunction (iCode *ic)
 		for ( i = sym->regsUsed->size ; i >= 0 ; i--) {
 		    if (bitVectBitValue(sym->regsUsed,i) ||
                       (pic14_ptrRegReq && (i == R0_IDX || i == R1_IDX)) )
-			pic14_emitcode("pop","%s",pic14_regWithIdx(i)->dname);
+		      pic14_emitcode("pop","junk");//"%s",pic14_regWithIdx(i)->dname);
 		}
 	    }
 	    
@@ -2826,7 +3024,6 @@ static void genRet (iCode *ic)
 	}
 	if(size) {
 	  emitpcode(POC_MOVWF,popRegFromIdx(offset + Gstack_base_addr));
-	  pic14_emitcode("movwf","%s",fReturn[offset]);
 	}
 	offset++;
       }
@@ -2907,85 +3104,103 @@ static void genMultOneByte (operand *left,
                             operand *right,
                             operand *result)
 {
-    sym_link *opetype = operandType(result);
-    char *l ;
-    symbol *lbl ;
-    int size,offset;
+  sym_link *opetype = operandType(result);
 
-    DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+  // symbol *lbl ;
+  int size,offset;
+
+  DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
   DEBUGpic14_AopType(__LINE__,left,right,result);
+  DEBUGpic14_AopTypeSign(__LINE__,left,right,result);
+
+  /* (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;
+  }
+
+  size = AOP_SIZE(result);
+  if(size == 1) {
+
+    if (AOP_TYPE(right) == AOP_LIT){
+      pic14_emitcode("multiply ","lit val:%s by variable %s and store in %s", 
+		     aopGet(AOP(right),0,FALSE,FALSE), 
+		     aopGet(AOP(left),0,FALSE,FALSE), 
+		     aopGet(AOP(result),0,FALSE,FALSE));
+      pic14_emitcode("call","genMultLit");
+    } else {
+      pic14_emitcode("multiply ","variable :%s by variable %s and store in %s", 
+		     aopGet(AOP(right),0,FALSE,FALSE), 
+		     aopGet(AOP(left),0,FALSE,FALSE), 
+		     aopGet(AOP(result),0,FALSE,FALSE));
+      pic14_emitcode("call","genMult8X8_8");
 
-    /* (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;
     }
+    genMult8X8_8 (left, right,result);
+
 
-    size = AOP_SIZE(result);
     /* signed or unsigned */
-    pic14_emitcode("mov","b,%s", aopGet(AOP(right),0,FALSE,FALSE));
-    l = aopGet(AOP(left),0,FALSE,FALSE);
-    MOVA(l);       
-    pic14_emitcode("mul","ab");
+    //pic14_emitcode("mov","b,%s", aopGet(AOP(right),0,FALSE,FALSE));
+    //l = aopGet(AOP(left),0,FALSE,FALSE);
+    //MOVA(l);       
+    //pic14_emitcode("mul","ab");
     /* if result size = 1, mul signed = mul unsigned */
-    aopPut(AOP(result),"a",0);
-    if (size > 1){
-        if (SPEC_USIGN(opetype)){
-            aopPut(AOP(result),"b",1);
-            if (size > 2)
-                /* for filling the MSBs */
-                pic14_emitcode("clr","a");
-        }
-        else{
-            pic14_emitcode("mov","a,b");
+    //aopPut(AOP(result),"a",0);
 
-            /* adjust the MSB if left or right neg */
+  } else {  // (size > 1)
 
-            /* if one literal */
-            if (AOP_TYPE(right) == AOP_LIT){
-                /* AND literal negative */
-                if((int) floatFromVal (AOP(right)->aopu.aop_lit) < 0){
-                    /* adjust MSB (c==0 after mul) */
-                    pic14_emitcode("subb","a,%s", aopGet(AOP(left),0,FALSE,FALSE));
-                }
-            }
-            else{
-                lbl = newiTempLabel(NULL);
-                pic14_emitcode("xch","a,%s",aopGet(AOP(right),0,FALSE,FALSE));
-                pic14_emitcode("cjne","a,#0x80,%05d_DS_", (lbl->key+100));
-                pic14_emitcode("","%05d_DS_:",(lbl->key+100));
-                pic14_emitcode("xch","a,%s",aopGet(AOP(right),0,FALSE,FALSE));
-                lbl = newiTempLabel(NULL);      
-                pic14_emitcode("jc","%05d_DS_",(lbl->key+100));          
-                pic14_emitcode("subb","a,%s", aopGet(AOP(left),0,FALSE,FALSE));
-                pic14_emitcode("","%05d_DS_:",(lbl->key+100));
-            }
+    pic14_emitcode("multiply (size>1) ","variable :%s by variable %s and store in %s", 
+		   aopGet(AOP(right),0,FALSE,FALSE), 
+		   aopGet(AOP(left),0,FALSE,FALSE), 
+		   aopGet(AOP(result),0,FALSE,FALSE));
 
-            lbl = newiTempLabel(NULL);
-            pic14_emitcode("xch","a,%s",aopGet(AOP(left),0,FALSE,FALSE));
-            pic14_emitcode("cjne","a,#0x80,%05d_DS_", (lbl->key+100));
-            pic14_emitcode("","%05d_DS_:",(lbl->key+100));
-            pic14_emitcode("xch","a,%s",aopGet(AOP(left),0,FALSE,FALSE));
-            lbl = newiTempLabel(NULL);      
-            pic14_emitcode("jc","%05d_DS_",(lbl->key+100));          
-            pic14_emitcode("subb","a,%s", aopGet(AOP(right),0,FALSE,FALSE));
-            pic14_emitcode("","%05d_DS_:",(lbl->key+100));
+    if (SPEC_USIGN(opetype)){
+      pic14_emitcode("multiply ","unsigned result. size = %d",AOP_SIZE(result));
+      genUMult8X8_16 (left, right, result, NULL);
 
-            aopPut(AOP(result),"a",1);
-            if(size > 2){
-                /* get the sign */
-                pic14_emitcode("rlc","a");
-                pic14_emitcode("subb","a,acc");
-            }
-        }
-        size -= 2;   
-        offset = 2;
-        if (size > 0)
-            while (size--)
-                aopPut(AOP(result),"a",offset++);
+      if (size > 2) {
+	/* for filling the MSBs */
+	emitpcode(POC_CLRF,  popGet(AOP(result),2));
+	emitpcode(POC_CLRF,  popGet(AOP(result),3));
+      }
+    }
+    else{
+      pic14_emitcode("multiply ","signed result. size = %d",AOP_SIZE(result));
+
+      pic14_emitcode("mov","a,b");
+
+      /* adjust the MSB if left or right neg */
+
+      /* if one literal */
+      if (AOP_TYPE(right) == AOP_LIT){
+	pic14_emitcode("multiply ","right is a lit");
+	/* AND literal negative */
+	if((int) floatFromVal (AOP(right)->aopu.aop_lit) < 0){
+	  /* adjust MSB (c==0 after mul) */
+	  pic14_emitcode("subb","a,%s", aopGet(AOP(left),0,FALSE,FALSE));
+	}
+      }
+      else{
+	genSMult8X8_16 (left, right, result, NULL);
+      }
+
+      if(size > 2){
+	pic14_emitcode("multiply ","size is greater than 2, so propogate sign");
+	/* get the sign */
+	pic14_emitcode("rlc","a");
+	pic14_emitcode("subb","a,acc");
+      }
     }
+
+    size -= 2;   
+    offset = 2;
+    if (size > 0)
+      while (size--)
+	pic14_emitcode("multiply ","size is way greater than 2, so propogate sign");
+    //aopPut(AOP(result),"a",offset++);
+  }
 }
 
 /*-----------------------------------------------------------------*/
@@ -3020,8 +3235,10 @@ static void genMult (iCode *ic)
         goto release ;
     }
 
-    /* should have been converted to function call */       
-    assert(0) ;
+    pic14_emitcode("multiply ","sizes are greater than 2... need to insert proper algor.");
+
+    /* should have been converted to function call */
+    //assert(0) ;
 
 release :
     freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
@@ -3426,12 +3643,12 @@ static void genSkipc(resolvedIfx *rifx)
 /*-----------------------------------------------------------------*/
 /* genSkipz2                                                       */
 /*-----------------------------------------------------------------*/
-static void genSkipz2(resolvedIfx *rifx)
+static void genSkipz2(resolvedIfx *rifx, int invert_condition)
 {
   if(!rifx)
     return;
 
-  if(rifx->condition)
+  if( (rifx->condition ^ invert_condition) & 1)
     emitSKPZ;
   else
     emitSKPNZ;
@@ -3517,18 +3734,46 @@ static int genChkZeroes(operand *op, int lit,  int size)
 static void genCmp (operand *left,operand *right,
                     operand *result, iCode *ifx, int sign)
 {
-  int size, offset = 0 ;
+  int size; //, offset = 0 ;
   unsigned long lit = 0L,i = 0;
-  resolvedIfx rIfx;
-
+  resolvedIfx rFalseIfx;
+  //  resolvedIfx rTrueIfx;
+  symbol *truelbl;
   DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+/*
   if(ifx) {
-  DEBUGpic14_emitcode ("; ***","true ifx is %s",((IC_TRUE(ifx) == NULL) ? "false" : "true"));
-  DEBUGpic14_emitcode ("; ***","false ifx is %s",((IC_FALSE(ifx) == NULL) ? "false" : "true"));
+    DEBUGpic14_emitcode ("; ***","true ifx is %s",((IC_TRUE(ifx) == NULL) ? "false" : "true"));
+    DEBUGpic14_emitcode ("; ***","false ifx is %s",((IC_FALSE(ifx) == NULL) ? "false" : "true"));
   }
+*/
 
-  resolveIfx(&rIfx,ifx);
+  resolveIfx(&rFalseIfx,ifx);
+  truelbl  = newiTempLabel(NULL);
+  size = max(AOP_SIZE(left),AOP_SIZE(right));
+
+  DEBUGpic14_AopType(__LINE__,left,right,result);
+
+#define _swapp
 
+  /* if literal is on the right then swap with left */
+  if ((AOP_TYPE(right) == AOP_LIT)) {
+    operand *tmp = right ;
+    unsigned long mask = (0x100 << (8*(size-1))) - 1;
+    lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
+#ifdef _swapp
+
+    lit = (lit - 1) & mask;
+    right = left;
+    left = tmp;
+    rFalseIfx.condition ^= 1;
+#endif
+
+  } else if ((AOP_TYPE(left) == AOP_LIT)) {
+    lit = (unsigned long)floatFromVal(AOP(left)->aopu.aop_lit);
+  }
+
+
+  //if(IC_TRUE(ifx) == NULL)
   /* if left & right are bit variables */
   if (AOP_TYPE(left) == AOP_CRY &&
       AOP_TYPE(right) == AOP_CRY ) {
@@ -3538,493 +3783,617 @@ static void genCmp (operand *left,operand *right,
     /* subtract right from left if at the
        end the carry flag is set then we know that
        left is greater than 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 )){
-      symbol *lbl  = newiTempLabel(NULL);
-      pic14_emitcode("cjne","%s,%s,%05d_DS_",
-	       aopGet(AOP(left),offset,FALSE,FALSE),
-	       aopGet(AOP(right),offset,FALSE,FALSE),
-	       lbl->key+100);
-      pic14_emitcode("","%05d_DS_:",lbl->key+100);
-    } else {
 
-      symbol *lbl  = newiTempLabel(NULL);
-      int emitFinalCheck=1;
-      symbol *truelbl  = newiTempLabel(NULL);
+    //    {
 
+    symbol *lbl  = newiTempLabel(NULL);
 
-      if(AOP_TYPE(right) == AOP_LIT) {
+#ifndef _swapp
+    if(AOP_TYPE(right) == AOP_LIT) {
 
-	lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
+      //lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
 
-	DEBUGpic14_emitcode(";right lit","lit = 0x%x,sign=%d",lit,sign);
+      DEBUGpic14_emitcode(";right lit","lit = 0x%x,sign=%d",lit,sign);
 
-	/* special cases */
+      /* special cases */
 
-	if(lit == 0) {
+      if(lit == 0) {
 
-	  if(sign != 0) 
-	    genSkipCond(&rIfx,left,size-1,7);
-	  else 
-	    /* no need to compare to 0...*/
-	    /* NOTE: this is a de-generate compare that most certainly 
-	     *       creates some dead code. */
-	    emitpcode(POC_GOTO,popGetLabel(rIfx.lbl->key));
+	if(sign != 0) 
+	  genSkipCond(&rFalseIfx,left,size-1,7);
+	else 
+	  /* no need to compare to 0...*/
+	  /* NOTE: this is a de-generate compare that most certainly 
+	   *       creates some dead code. */
+	  emitpcode(POC_GOTO,popGetLabel(rFalseIfx.lbl->key));
 
-	  if(ifx) ifx->generated = 1;
-	  return;
+	if(ifx) ifx->generated = 1;
+	return;
 
-	}
-	size--;
+      }
+      size--;
 
-	if(size == 0) {
-	  //i = (lit >> (size*8)) & 0xff;
-	  DEBUGpic14_emitcode(";right lit","line = %d",__LINE__);
+      if(size == 0) {
+	//i = (lit >> (size*8)) & 0xff;
+	DEBUGpic14_emitcode(";right lit","line = %d",__LINE__);
 	
-	  emitpcode(POC_MOVFW, popGet(AOP(left),size));
-
-	  i = ((0-lit) & 0xff);
-	  if(sign) {
-	    if( i == 0x81) { 
-	      /* lit is 0x7f, all signed chars are less than
-	       * this except for 0x7f itself */
-	      emitpcode(POC_XORLW, popGetLit(0x7f));
-	      genSkipz2(&rIfx);
-	    } else {
-	      emitpcode(POC_ADDLW, popGetLit(0x80));
-	      emitpcode(POC_ADDLW, popGetLit(i^0x80));
-	      genSkipc(&rIfx);
-	    }
+	emitpcode(POC_MOVFW, popGet(AOP(left),size));
 
+	i = ((0-lit) & 0xff);
+	if(sign) {
+	  if( i == 0x81) { 
+	    /* lit is 0x7f, all signed chars are less than
+	     * this except for 0x7f itself */
+	    emitpcode(POC_XORLW, popGetLit(0x7f));
+	    genSkipz2(&rFalseIfx,0);
 	  } else {
-	    emitpcode(POC_ADDLW, popGetLit(i));
-	    genSkipc(&rIfx);
-
+	    emitpcode(POC_ADDLW, popGetLit(0x80));
+	    emitpcode(POC_ADDLW, popGetLit(i^0x80));
+	    genSkipc(&rFalseIfx);
 	  }
 
-	  if(ifx) ifx->generated = 1;
-	  return;
+	} else {
+	  if(lit == 1) {
+	    genSkipz2(&rFalseIfx,1);
+	  } else {
+	    emitpcode(POC_ADDLW, popGetLit(i));
+	    genSkipc(&rFalseIfx);
+	  }
 	}
 
-	/* chars are out of the way. now do ints and longs */
+	if(ifx) ifx->generated = 1;
+	return;
+      }
+
+      /* chars are out of the way. now do ints and longs */
 
 
-	DEBUGpic14_emitcode(";right lit","line = %d",__LINE__);
+      DEBUGpic14_emitcode(";right lit","line = %d",__LINE__);
 	
-	/* special cases */
+      /* special cases */
 
-	if(sign) {
+      if(sign) {
 
-	  if(lit == 0) {
-	    genSkipCond(&rIfx,left,size,7);
-	    if(ifx) ifx->generated = 1;
-	    return;
-	  }
+	if(lit == 0) {
+	  genSkipCond(&rFalseIfx,left,size,7);
+	  if(ifx) ifx->generated = 1;
+	  return;
+	}
 
-	  if(lit <0x100) {
-	    DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
+	if(lit <0x100) {
+	  DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
+
+	  //rFalseIfx.condition ^= 1;
+	  //genSkipCond(&rFalseIfx,left,size,7);
+	  //rFalseIfx.condition ^= 1;
 
-	    emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),size,FALSE,FALSE),7,0));
+	  emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),size,FALSE,FALSE),7,0));
+	  if(rFalseIfx.condition)
+	    emitpcode(POC_GOTO,  popGetLabel(rFalseIfx.lbl->key));
+	  else
 	    emitpcode(POC_GOTO,  popGetLabel(truelbl->key));
-	    emitpcode(POC_MOVLW, popGetLit(0x100-lit));
-	    emitpcode(POC_ADDFW, popGet(AOP(left),0));
-	    emitpcode(POC_MOVFW, popGet(AOP(left),1));
 
-	    while(size > 1)
-	      emitpcode(POC_IORFW, popGet(AOP(left),size--));
+	  emitpcode(POC_MOVLW, popGetLit(0x100-lit));
+	  emitpcode(POC_ADDFW, popGet(AOP(left),0));
+	  emitpcode(POC_MOVFW, popGet(AOP(left),1));
 
-	    emitSKPNZ;
+	  while(size > 1)
+	    emitpcode(POC_IORFW, popGet(AOP(left),size--));
 
-	    genSkipc(&rIfx);
-	    emitpLabel(truelbl->key);
-	    if(ifx) ifx->generated = 1;
-	    return;
+	  if(rFalseIfx.condition) {
+	    emitSKPZ;
+	    emitpcode(POC_GOTO,  popGetLabel(truelbl->key));
 
+	  } else {
+	    emitSKPNZ;
 	  }
 
-	  if(size == 1) {
-
-	    if( (lit & 0xff) == 0) {
-	      /* lower byte is zero */
-	      DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
-	      i = ((lit >> 8) & 0xff) ^0x80;
-	      emitpcode(POC_MOVFW, popGet(AOP(left),size));
-	      emitpcode(POC_ADDLW, popGetLit( 0x80));
-	      emitpcode(POC_ADDLW, popGetLit(0x100-i));
-	      genSkipc(&rIfx);
+	  genSkipc(&rFalseIfx);
+	  emitpLabel(truelbl->key);
+	  if(ifx) ifx->generated = 1;
+	  return;
 
+	}
 
-	      if(ifx) ifx->generated = 1;
-	      return;
+	if(size == 1) {
 
-	    }
-	  } else {
-	    /* Special cases for signed longs */
-	    if( (lit & 0xffffff) == 0) {
-	      /* lower byte is zero */
-	      DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
-	      i = ((lit >> 8*3) & 0xff) ^0x80;
-	      emitpcode(POC_MOVFW, popGet(AOP(left),size));
-	      emitpcode(POC_ADDLW, popGetLit( 0x80));
-	      emitpcode(POC_ADDLW, popGetLit(0x100-i));
-	      genSkipc(&rIfx);
+	  if( (lit & 0xff) == 0) {
+	    /* lower byte is zero */
+	    DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
+	    i = ((lit >> 8) & 0xff) ^0x80;
+	    emitpcode(POC_MOVFW, popGet(AOP(left),size));
+	    emitpcode(POC_ADDLW, popGetLit( 0x80));
+	    emitpcode(POC_ADDLW, popGetLit(0x100-i));
+	    genSkipc(&rFalseIfx);
 
 
-	      if(ifx) ifx->generated = 1;
-	      return;
+	    if(ifx) ifx->generated = 1;
+	    return;
 
-	    }
+	  }
+	} else {
+	  /* Special cases for signed longs */
+	  if( (lit & 0xffffff) == 0) {
+	    /* lower byte is zero */
+	    DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
+	    i = ((lit >> 8*3) & 0xff) ^0x80;
+	    emitpcode(POC_MOVFW, popGet(AOP(left),size));
+	    emitpcode(POC_ADDLW, popGetLit( 0x80));
+	    emitpcode(POC_ADDLW, popGetLit(0x100-i));
+	    genSkipc(&rFalseIfx);
 
-#if 0
-	    if( lit < 0x10000) {
-	      /* upper word is zero */
-	      DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
 
-	      emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),size,FALSE,FALSE),7,0));
-	      emitpcode(POC_GOTO,  popGetLabel(truelbl->key));
+	    if(ifx) ifx->generated = 1;
+	    return;
 
-	      emitpcode(POC_MOVLW, popGetLit((lit >> (1*8)) & 0xff));
-	      emitpcode(POC_SUBFW, popGet(AOP(left),1));
-	      emitpcode(POC_MOVLW, popGetLit((lit & 0xff));
-	      emitSKPNZ;
-	      emitpcode(POC_SUBFW, popGet(AOP(left),0));
+	  }
 
-	      emitpcode(POC_IORFW, popGet(AOP(left),2));
-	      emitpcode(POC_IORFW, popGet(AOP(left),3));
+	}
 
-	      emitSKPNZ;
 
-	      genSkipc(&rIfx);
-	      emitpLabel(truelbl->key);
-	      if(ifx) ifx->generated = 1;
-	      return;
+	if(lit & (0x80 << (size*8))) {
+	  /* lit is negative */
+	  DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
 
-	    }
-#endif
+	  //genSkipCond(&rFalseIfx,left,size,7);
 
-	  }
+	  emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(left),size,FALSE,FALSE),7,0));
 
+	  if(rFalseIfx.condition)
+	    emitpcode(POC_GOTO,  popGetLabel(truelbl->key));
+	  else
+	    emitpcode(POC_GOTO,  popGetLabel(rFalseIfx.lbl->key));
 
-	  if(lit & (0x80 << (size*8))) {
-	    /* lit is negative */
-	    DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
 
-	    genSkipCond(&rIfx,left,size,7);
-	  } else {
-	    /* lit is positive */
-	    DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
-	    emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),size,FALSE,FALSE),7,0));
+	} else {
+	  /* lit is positive */
+	  DEBUGpic14_emitcode(";right lit","line = %d signed compare to 0x%x",__LINE__,lit);
+	  emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),size,FALSE,FALSE),7,0));
+	  if(rFalseIfx.condition)
+	    emitpcode(POC_GOTO,  popGetLabel(rFalseIfx.lbl->key));
+	  else
 	    emitpcode(POC_GOTO,  popGetLabel(truelbl->key));
 
-	  }
+	}
 
-	  /*
-	    This works, but is only good for ints.
-	    It also requires a "known zero" register.
-	    emitpcode(POC_MOVLW, popGetLit(mlit & 0xff));
-	    emitpcode(POC_ADDFW, popGet(AOP(left),0));
-	    emitpcode(POC_RLFW,  popCopyReg(&pc_kzero));
-	    emitpcode(POC_ADDLW, popGetLit( ((mlit>>8) & 0xff)));
-	    emitpcode(POC_ADDFW, popGet(AOP(left),1));
-	    genSkipc(&rIfx);
+	/*
+	  This works, but is only good for ints.
+	  It also requires a "known zero" register.
+	  emitpcode(POC_MOVLW, popGetLit(mlit & 0xff));
+	  emitpcode(POC_ADDFW, popGet(AOP(left),0));
+	  emitpcode(POC_RLFW,  popCopyReg(&pc_kzero));
+	  emitpcode(POC_ADDLW, popGetLit( ((mlit>>8) & 0xff)));
+	  emitpcode(POC_ADDFW, popGet(AOP(left),1));
+	  genSkipc(&rFalseIfx);
 
-	    emitpLabel(truelbl->key);
-	    if(ifx) ifx->generated = 1;
-	    return;
-	  **/
+	  emitpLabel(truelbl->key);
+	  if(ifx) ifx->generated = 1;
+	  return;
+	**/
 	  
-	  /* There are no more special cases, so perform a general compare */
+	/* There are no more special cases, so perform a general compare */
   
+	emitpcode(POC_MOVLW, popGetLit((lit >> (size*8)) & 0xff));
+	emitpcode(POC_SUBFW, popGet(AOP(left),size));
+
+	while(size--) {
+
 	  emitpcode(POC_MOVLW, popGetLit((lit >> (size*8)) & 0xff));
+	  emitSKPNZ;
 	  emitpcode(POC_SUBFW, popGet(AOP(left),size));
+	}
+	//rFalseIfx.condition ^= 1;
+	genSkipc(&rFalseIfx);
 
-	  while(size--) {
+	emitpLabel(truelbl->key);
 
-	    emitpcode(POC_MOVLW, popGetLit((lit >> (size*8)) & 0xff));
-	    emitSKPNZ;
-	    emitpcode(POC_SUBFW, popGet(AOP(left),size));
-	  }
+	if(ifx) ifx->generated = 1;
+	return;
 
-	  genSkipc(&rIfx);
 
-	  emitpLabel(truelbl->key);
+      }
 
-	  if(ifx) ifx->generated = 1;
-	  return;
 
+      /* sign is out of the way. So now do an unsigned compare */
+      DEBUGpic14_emitcode(";right lit","line = %d unsigned compare to 0x%x",__LINE__,lit);
 
-	}
 
+      /* General case - compare to an unsigned literal on the right.*/
+
+      i = (lit >> (size*8)) & 0xff;
+      emitpcode(POC_MOVLW, popGetLit(i));
+      emitpcode(POC_SUBFW, popGet(AOP(left),size));
+      while(size--) {
+	i = (lit >> (size*8)) & 0xff;
 
-	/* sign is out of the way. So now do an unsigned compare */
-	DEBUGpic14_emitcode(";right lit","line = %d unsigned compare to 0x%x",__LINE__,lit);
+	if(i) {
+	  emitpcode(POC_MOVLW, popGetLit(i));
+	  emitSKPNZ;
+	  emitpcode(POC_SUBFW, popGet(AOP(left),size));
+	} else {
+	  /* this byte of the lit is zero, 
+	   *if it's not the last then OR in the variable */
+	  if(size)
+	    emitpcode(POC_IORFW, popGet(AOP(left),size));
+	}
+      }
 
 
-	//genChkZeroes(left)
+      emitpLabel(lbl->key);
+      //if(emitFinalCheck)
+      genSkipc(&rFalseIfx);
+      if(sign)
+	emitpLabel(truelbl->key);
 
-	/* General case - compare to an unsigned literal on the right.*/
+      if(ifx) ifx->generated = 1;
+      return;
 
-	i = (lit >> (size*8)) & 0xff;
-	emitpcode(POC_MOVLW, popGetLit(i));
-	emitpcode(POC_SUBFW, popGet(AOP(left),size));
-	while(size--) {
-	  i = (lit >> (size*8)) & 0xff;
 
-	  if(i) {
-	    emitpcode(POC_MOVLW, popGetLit(i));
-	    emitSKPNZ;
-	    emitpcode(POC_SUBFW, popGet(AOP(left),size));
-	  } else {
-	    /* this byte of the lit is zero, 
-	     *if it's not the last then OR in the variable */
-	    if(size)
-	      emitpcode(POC_IORFW, popGet(AOP(left),size));
-	  }
-	}
+    }
+#endif  // _swapp
 
+    if(AOP_TYPE(left) == AOP_LIT) {
+      //symbol *lbl = newiTempLabel(NULL);
 
-	emitpLabel(lbl->key);
-	if(emitFinalCheck)
-	  genSkipc(&rIfx);
-	if(sign)
-	  emitpLabel(truelbl->key);
+      //EXPERIMENTAL lit = (unsigned long)(floatFromVal(AOP(left)->aopu.aop_lit));
 
-	if(ifx) ifx->generated = 1;
-	return;
 
+      DEBUGpic14_emitcode(";left lit","lit = 0x%x,sign=%d",lit,sign);
 
-      }
+      /* Special cases */
+      if((lit == 0) && (sign == 0)){
 
-      if(AOP_TYPE(left) == AOP_LIT) {
-	//symbol *lbl = newiTempLabel(NULL);
-	unsigned long mlit;
-	lit = (unsigned long)(floatFromVal(AOP(left)->aopu.aop_lit));
-	mlit = -lit;
+	size--;
+	emitpcode(POC_MOVFW, popGet(AOP(right),size));
+	while(size) 
+	  emitpcode(POC_IORFW, popGet(AOP(right),--size));
 
-	DEBUGpic14_emitcode(";left lit","lit = %d,sign=%d",lit,sign);
+	genSkipz2(&rFalseIfx,0);
+	if(ifx) ifx->generated = 1;
+	return;
+      }
 
+      if(size==1) {
 	/* Special cases */
-	if((lit == 0) && (sign == 0)){
-
-	  size--;
-	  emitpcode(POC_MOVFW, popGet(AOP(right),size));
-	  while(size) 
-	    emitpcode(POC_IORFW, popGet(AOP(right),--size));
+	lit &= 0xff;
+	if(((lit == 0xff) && !sign) || ((lit==0x7f) && sign)) {
+	  /* degenerate compare can never be true */
+	  if(rFalseIfx.condition == 0)
+	    emitpcode(POC_GOTO,popGetLabel(rFalseIfx.lbl->key));
 
-	  //rIfx.condition ^= 1;
-	  genSkipz2(&rIfx);
 	  if(ifx) ifx->generated = 1;
 	  return;
 	}
 
-	if(size==1) {
-	  /* Special cases */
-	  lit &= 0xff;
-	  if(((lit == 0xff) && !sign) || ((lit==0x7f) && sign)) {
-	    /* degenerate compare can never be true */
-	    emitpcode(POC_GOTO,popGetLabel(rIfx.lbl->key));
-	    if(ifx) ifx->generated = 1;
-	    return;
-	  }
+	if(sign) {
+	  /* signed comparisons to a literal byte */
 
-	  if(sign) {
-	    if((lit+1)&0xff) {
-	      emitpcode(POC_MOVFW, popGet(AOP(right),0));
-	      emitpcode(POC_ADDLW, popGetLit(0x80));
-	      emitpcode(POC_ADDLW, popGetLit(((-(lit+1)) & 0xff) ^ 0x80));
-	      rIfx.condition ^= 1;
-	      genSkipc(&rIfx);
-	    } else {
-	      rIfx.condition ^= 1;
-	      genSkipCond(&rIfx,right,0,7);
-	    }
-	    
-	  } else {
-	    if(lit & 0xff) {
-	      emitpcode(POC_MOVLW, popGetLit((lit+1) & 0xff));
-	      emitpcode(POC_SUBFW, popGet(AOP(right),0));
-	      DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-	      rIfx.condition ^= 1;
-	      genSkipc(&rIfx);
-	    } else { 
-	      emitpcode(POC_MOVFW, popGet(AOP(right),0));
-	      genSkipz2(&rIfx);
-	    }
-	  }
+	  int lp1 = (lit+1) & 0xff;
 
+	  DEBUGpic14_emitcode(";left lit","line = %d lit = 0x%x",__LINE__,lit);
+	  switch (lp1) {
+	  case 0:
+	    rFalseIfx.condition ^= 1;
+	    genSkipCond(&rFalseIfx,right,0,7);
+	    break;
+	  case 0x7f:
+	    emitpcode(POC_MOVFW, popGet(AOP(right),0));
+	    emitpcode(POC_XORLW, popGetLit(0x7f));
+	    genSkipz2(&rFalseIfx,1);
+	    break;
+	  default:
+	    emitpcode(POC_MOVFW, popGet(AOP(right),0));
+	    emitpcode(POC_ADDLW, popGetLit(0x80));
+	    emitpcode(POC_ADDLW, popGetLit(((-(lit+1)) & 0xff) ^ 0x80));
+	    rFalseIfx.condition ^= 1;
+	    genSkipc(&rFalseIfx);
+	    break;
+	  }
 	  if(ifx) ifx->generated = 1;
-	  return;
-
 	} else {
+	  /* unsigned comparisons to a literal byte */
 
-	  /* Size is greater than 1 */
+	  switch(lit & 0xff ) {
+	  case 0:
+	    emitpcode(POC_MOVFW, popGet(AOP(right),0));
+	    genSkipz2(&rFalseIfx,0);
+	    if(ifx) ifx->generated = 1;
+	    break;
+	  case 0x7f:
+	    rFalseIfx.condition ^= 1;
+	    genSkipCond(&rFalseIfx,right,0,7);
+	    if(ifx) ifx->generated = 1;
+	    break;
 
+	  default:
+	    emitpcode(POC_MOVLW, popGetLit((lit+1) & 0xff));
+	    emitpcode(POC_SUBFW, popGet(AOP(right),0));
+	    DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+	    rFalseIfx.condition ^= 1;
+	    if (AOP_TYPE(result) == AOP_CRY) {
+	      genSkipc(&rFalseIfx);
+	      if(ifx) ifx->generated = 1;
+	    } else {
+	      DEBUGpic14_emitcode ("; ***","%s  %d RFIfx.cond=%d",__FUNCTION__,__LINE__, rFalseIfx.condition);
+	      emitpcode(POC_CLRF, popGet(AOP(result),0));
+	      emitpcode(POC_RLF, popGet(AOP(result),0));
+	      emitpcode(POC_MOVLW, popGetLit(0x01));
+	      emitpcode(POC_XORWF, popGet(AOP(result),0));
+	    }	      
+	    break;
+	  }
+	}
 
+	//goto check_carry;
+	return;
 
-	  if(sign) {
-	    int lp1 = lit+1;
+      } else {
 
-	    size--;
+	/* Size is greater than 1 */
 
-	    if(lp1 == 0) {
-	      /* this means lit = 0xffffffff, or -1 */
+	if(sign) {
+	  int lp1 = lit+1;
 
+	  size--;
 
-	      DEBUGpic14_emitcode(";left lit = -1","line = %d ",__LINE__);
-	      rIfx.condition ^= 1;
-	      genSkipCond(&rIfx,right,size,7);
-	      if(ifx) ifx->generated = 1;
-	      return;
-	    }
+	  if(lp1 == 0) {
+	    /* this means lit = 0xffffffff, or -1 */
 
-	    if(lit == 0) {
-	      int s = size;
-	      emitpcode(POC_MOVFW, popGet(AOP(right),size));
-	      while(size--)
-		emitpcode(POC_IORFW, popGet(AOP(right),size));
 
-	      emitSKPZ;
-	      rIfx.condition ^= 1;
-	      genSkipCond(&rIfx,right,s,7);
-	      if(ifx) ifx->generated = 1;
-	      return;
-	    }
+	    DEBUGpic14_emitcode(";left lit = -1","line = %d ",__LINE__);
+	    rFalseIfx.condition ^= 1;
+	    genSkipCond(&rFalseIfx,right,size,7);
+	    if(ifx) ifx->generated = 1;
+	    return;
+	  }
 
+	  if(lit == 0) {
+	    int s = size;
 
-	    if(lit & (0x80 << (size*8))) {
-	      /* Lit is less than zero */
-	      DEBUGpic14_emitcode(";left lit","line = %d  0x%x is less than 0",__LINE__,lit);
-	      emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(right),size,FALSE,FALSE),7,0));
+	    if(rFalseIfx.condition) {
+	      emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),size,FALSE,FALSE),7,0));
 	      emitpcode(POC_GOTO,  popGetLabel(truelbl->key));
+	    }
 
-	    } else {
-	      /* Lit is greater than or equal to zero */
-	      DEBUGpic14_emitcode(";left lit","line = %d  0x%x is greater than 0",__LINE__,lit);
-	      rIfx.condition ^= 1;
-	      genSkipCond(&rIfx,right,size,7);
-	      rIfx.condition ^= 1;
+	    emitpcode(POC_MOVFW, popGet(AOP(right),size));
+	    while(size--)
+	      emitpcode(POC_IORFW, popGet(AOP(right),size));
 
+
+	    emitSKPZ;
+	    if(rFalseIfx.condition) {
+	      emitpcode(POC_GOTO,  popGetLabel(rFalseIfx.lbl->key));
+	      emitpLabel(truelbl->key);
+	    }else {
+	      rFalseIfx.condition ^= 1;
+	      genSkipCond(&rFalseIfx,right,s,7);
 	    }
-	    emitpcode(POC_MOVLW, popGetLit((lp1 >> (size*8)) & 0xff));
-	    emitpcode(POC_SUBFW, popGet(AOP(right),size));
 
-	    while(size--) {
+	    if(ifx) ifx->generated = 1;
+	    return;
+	  }
 
-	      emitpcode(POC_MOVLW, popGetLit((lp1 >> (size*8)) & 0xff));
-	      emitSKPNZ;
-	      emitpcode(POC_SUBFW, popGet(AOP(right),size));
-	    }
-	    rIfx.condition ^= 1;
-	    genSkipc(&rIfx);
+	  if((size == 1) &&  (0 == (lp1&0xff))) {
+	    /* lower byte of signed word is zero */
+	    DEBUGpic14_emitcode(";left lit","line = %d  0x%x+1 low byte is zero",__LINE__,lit);
+	    i = ((lp1 >> 8) & 0xff) ^0x80;
+	    emitpcode(POC_MOVFW, popGet(AOP(right),size));
+	    emitpcode(POC_ADDLW, popGetLit( 0x80));
+	    emitpcode(POC_ADDLW, popGetLit(0x100-i));
+	    rFalseIfx.condition ^= 1;
+	    genSkipc(&rFalseIfx);
 
-	    emitpLabel(truelbl->key);
 
 	    if(ifx) ifx->generated = 1;
 	    return;
+	  }
 
-	  } else {
-	    /* Unsigned compare for sizes greater than 1 */
+	  if(lit & (0x80 << (size*8))) {
+	    /* Lit is less than zero */
+	    DEBUGpic14_emitcode(";left lit","line = %d  0x%x is less than 0",__LINE__,lit);
+	    //rFalseIfx.condition ^= 1;
+	    //genSkipCond(&rFalseIfx,left,size,7);
+	    //rFalseIfx.condition ^= 1;
+	    emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(right),size,FALSE,FALSE),7,0));
+	    //emitpcode(POC_GOTO,  popGetLabel(truelbl->key));
+
+	    if(rFalseIfx.condition)
+	      emitpcode(POC_GOTO,  popGetLabel(rFalseIfx.lbl->key));
+	    else
+	      emitpcode(POC_GOTO,  popGetLabel(truelbl->key));
 
-	    while(size--) {
-	      i = (lit >> (size*8)) & 0xff;
 
+	  } else {
+	    /* Lit is greater than or equal to zero */
+	    DEBUGpic14_emitcode(";left lit","line = %d  0x%x is greater than 0",__LINE__,lit);
+	    //rFalseIfx.condition ^= 1;
+	    //genSkipCond(&rFalseIfx,right,size,7);
+	    //rFalseIfx.condition ^= 1;
 
-	      if(size) {
-		DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-		emitpcode(POC_MOVLW, popGetLit(i&0xff));
-		emitpcode(POC_SUBFW, popGet(AOP(right),size));
-		emitSKPZ;
-		emitpcode(POC_GOTO,  popGetLabel(lbl->key));
-	      } else {
-		DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-		emitpcode(POC_MOVLW, popGetLit((i+1)&0xff));
-		emitpcode(POC_SUBFW, popGet(AOP(right),size));
+	    //emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),size,FALSE,FALSE),7,0));
+	    //emitpcode(POC_GOTO,  popGetLabel(rFalseIfx.lbl->key));
 
-	      }
+	    emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(right),size,FALSE,FALSE),7,0));
+	    if(rFalseIfx.condition)
+	      emitpcode(POC_GOTO,  popGetLabel(truelbl->key));
+	    else
+	      emitpcode(POC_GOTO,  popGetLabel(rFalseIfx.lbl->key));
+
+	  }
+
+
+	  emitpcode(POC_MOVLW, popGetLit((lp1 >> (size*8)) & 0xff));
+	  emitpcode(POC_SUBFW, popGet(AOP(right),size));
+
+	  while(size--) {
+
+	    emitpcode(POC_MOVLW, popGetLit((lp1 >> (size*8)) & 0xff));
+	    emitSKPNZ;
+	    emitpcode(POC_SUBFW, popGet(AOP(right),size));
+	  }
+	  rFalseIfx.condition ^= 1;
+	  //rFalseIfx.condition = 1;
+	  genSkipc(&rFalseIfx);
+
+	  emitpLabel(truelbl->key);
+
+	  if(ifx) ifx->generated = 1;
+	  return;
+	  // end of if (sign)
+	} else {
+
+	  /* compare word or long to an unsigned literal on the right.*/
+
+
+	  size--;
+	  if(lit < 0xff) {
+	    DEBUGpic14_emitcode ("; ***","%s  %d lit =0x%x < 0xff",__FUNCTION__,__LINE__,lit);
+	    switch (lit) {
+	    case 0:
+	      break; /* handled above */
+/*
+	    case 0xff:
+	      emitpcode(POC_MOVFW, popGet(AOP(right),size));
+	      while(size--)
+		emitpcode(POC_IORFW, popGet(AOP(right),size));
+	      genSkipz2(&rFalseIfx,0);
+	      break;
+*/
+	    default:
+	      emitpcode(POC_MOVFW, popGet(AOP(right),size));
+	      while(--size)
+		emitpcode(POC_IORFW, popGet(AOP(right),size));
+
+	      emitSKPZ;
+	      if(rFalseIfx.condition)
+		emitpcode(POC_GOTO,  popGetLabel(rFalseIfx.lbl->key));
+	      else
+		emitpcode(POC_GOTO,  popGetLabel(truelbl->key));
+
+
+	      emitpcode(POC_MOVLW, popGetLit(lit+1));
+	      emitpcode(POC_SUBFW, popGet(AOP(right),0));
+
+	      rFalseIfx.condition ^= 1;
+	      genSkipc(&rFalseIfx);
 	    }
 
-	    DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+	    emitpLabel(truelbl->key);
+
+	    if(ifx) ifx->generated = 1;
+	    return;
+	  }
 
-	    emitpLabel(lbl->key);
 
-	    rIfx.condition ^= 1;
-	    genSkipc(&rIfx);
+	  lit++;
+	  DEBUGpic14_emitcode ("; ***","%s  %d lit =0x%x",__FUNCTION__,__LINE__,lit);
+	  i = (lit >> (size*8)) & 0xff;
+
+	  emitpcode(POC_MOVLW, popGetLit(i));
+	  emitpcode(POC_SUBFW, popGet(AOP(right),size));
+
+	  while(size--) {
+	    i = (lit >> (size*8)) & 0xff;
 
+	    if(i) {
+	      emitpcode(POC_MOVLW, popGetLit(i));
+	      emitSKPNZ;
+	      emitpcode(POC_SUBFW, popGet(AOP(right),size));
+	    } else {
+	      /* this byte of the lit is zero, 
+	       *if it's not the last then OR in the variable */
+	      if(size)
+		emitpcode(POC_IORFW, popGet(AOP(right),size));
+	    }
 	  }
+
+
+	  emitpLabel(lbl->key);
+
+	  rFalseIfx.condition ^= 1;
+	  genSkipc(&rFalseIfx);
+	}
+
 	if(sign)
 	  emitpLabel(truelbl->key);
 	if(ifx) ifx->generated = 1;
 	return;
-	}
       }
-      /* Compare two variables */
-
-      DEBUGpic14_emitcode(";sign","%d",sign);
+    }
+    /* Compare two variables */
 
-      size--;
-      if(sign) {
-	/* Sigh. thus sucks... */
-	if(size) {
-	  emitpcode(POC_MOVFW, popGet(AOP(left),size));
-	  emitpcode(POC_MOVWF, popRegFromIdx(Gstack_base_addr));
-	  emitpcode(POC_MOVLW, popGetLit(0x80));
-	  emitpcode(POC_XORWF, popRegFromIdx(Gstack_base_addr));
-	  emitpcode(POC_XORFW, popGet(AOP(right),size));
-	  emitpcode(POC_SUBFW, popRegFromIdx(Gstack_base_addr));
-	} else {
-	  /* Signed char comparison */
-	  /* Special thanks to Nikolai Golovchenko for this snippet */
-	  emitpcode(POC_MOVFW, popGet(AOP(right),0));
-	  emitpcode(POC_SUBFW, popGet(AOP(left),0));
-	  emitpcode(POC_RRFW,  popGet(AOP(left),0)); /* could be any register */
-	  emitpcode(POC_XORFW, popGet(AOP(left),0));
-	  emitpcode(POC_XORFW, popGet(AOP(right),0));
-	  emitpcode(POC_ADDLW, popGetLit(0x80));
-
-	  DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-	  genSkipc(&rIfx);
-	  
-	  if(ifx) ifx->generated = 1;
-	  return;
-	}
+    DEBUGpic14_emitcode(";sign","%d",sign);
 
+    size--;
+    if(sign) {
+      /* Sigh. thus sucks... */
+      if(size) {
+	emitpcode(POC_MOVFW, popGet(AOP(left),size));
+	emitpcode(POC_MOVWF, popRegFromIdx(Gstack_base_addr));
+	emitpcode(POC_MOVLW, popGetLit(0x80));
+	emitpcode(POC_XORWF, popRegFromIdx(Gstack_base_addr));
+	emitpcode(POC_XORFW, popGet(AOP(right),size));
+	emitpcode(POC_SUBFW, popRegFromIdx(Gstack_base_addr));
       } else {
+	/* Signed char comparison */
+	/* Special thanks to Nikolai Golovchenko for this snippet */
+	emitpcode(POC_MOVFW, popGet(AOP(right),0));
+	emitpcode(POC_SUBFW, popGet(AOP(left),0));
+	emitpcode(POC_RRFW,  popGet(AOP(left),0)); /* could be any register */
+	emitpcode(POC_XORFW, popGet(AOP(left),0));
+	emitpcode(POC_XORFW, popGet(AOP(right),0));
+	emitpcode(POC_ADDLW, popGetLit(0x80));
 
-	emitpcode(POC_MOVFW, popGet(AOP(right),size));
-	emitpcode(POC_SUBFW, popGet(AOP(left),size));
+	DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+	genSkipc(&rFalseIfx);
+	  
+	if(ifx) ifx->generated = 1;
+	return;
       }
 
+    } else {
 
-      /* The rest of the bytes of a multi-byte compare */
-      while (size) {
-
-	emitSKPZ;
-	emitpcode(POC_GOTO,  popGetLabel(lbl->key));
-	size--;
+      emitpcode(POC_MOVFW, popGet(AOP(right),size));
+      emitpcode(POC_SUBFW, popGet(AOP(left),size));
+    }
 
-	emitpcode(POC_MOVFW, popGet(AOP(right),size));
-	emitpcode(POC_SUBFW, popGet(AOP(left),size));
 
+    /* The rest of the bytes of a multi-byte compare */
+    while (size) {
 
-      }
+      emitSKPZ;
+      emitpcode(POC_GOTO,  popGetLabel(lbl->key));
+      size--;
 
-      emitpLabel(lbl->key);
+      emitpcode(POC_MOVFW, popGet(AOP(right),size));
+      emitpcode(POC_SUBFW, popGet(AOP(left),size));
 
-      DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-      genSkipc(&rIfx);
-      if(ifx) ifx->generated = 1;
-      return;
 
     }
+
+    emitpLabel(lbl->key);
+
+    DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+    if ((AOP_TYPE(result) == AOP_CRY && AOP_SIZE(result)) || 
+	(AOP_TYPE(result) == AOP_REG)) {
+      emitpcode(POC_CLRF, popGet(AOP(result),0));
+      emitpcode(POC_RLF, popGet(AOP(result),0));
+    } else {
+      genSkipc(&rFalseIfx);
+    }	      
+    //genSkipc(&rFalseIfx);
+    if(ifx) ifx->generated = 1;
+
+    return;
+
   }
 
-  //release:
+  // check_carry:
   if (AOP_TYPE(result) == AOP_CRY && AOP_SIZE(result)) {
+    DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
     pic14_outBitC(result);
   } else {
+    DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
     /* if the result is used in the next
        ifx conditional branch then generate
        code a little differently */
@@ -4154,13 +4523,16 @@ static void gencjne(operand *left, operand *right, operand *result, iCode *ifx)
 {
   int size = max(AOP_SIZE(left),AOP_SIZE(right));
   int offset = 0;
+  int res_offset = 0;  /* the result may be a different size then left or right */
+  int res_size = AOP_SIZE(result);
   resolvedIfx rIfx;
   symbol *lbl;
 
   unsigned long lit = 0L;
   DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-  DEBUGpic14_AopType(__LINE__,left,right,NULL);
-
+  DEBUGpic14_AopType(__LINE__,left,right,result);
+  if(result)
+    DEBUGpic14_emitcode ("; ***","%s  %d result is not null",__FUNCTION__,__LINE__);
   resolveIfx(&rIfx,ifx);
   lbl =  newiTempLabel(NULL);
 
@@ -4198,6 +4570,8 @@ static void gencjne(operand *left, operand *right, operand *result, iCode *ifx)
 	emitSKPNZ;
 	emitpcode(POC_GOTO,popGetLabel(lbl->key));
 	offset++;
+	if(res_offset < res_size-1)
+	  res_offset++;
 	lit >>= 8;
       }
       break;
@@ -4210,71 +4584,90 @@ static void gencjne(operand *left, operand *right, operand *result, iCode *ifx)
 	   AOP_TYPE(right) == AOP_DIR || 
 	   (AOP_TYPE(left) == AOP_DIR && AOP_TYPE(right) == AOP_LIT) ||
 	   (IS_AOP_PREG(left) && !IS_AOP_PREG(right))) {
-    switch(size) {
-    case 2:
-      genc16bit2lit(left, lit, 0);
-      emitSKPNZ;
-      emitpcode(POC_GOTO,popGetLabel(lbl->key));
-      break;
-    default:
-      while (size--) {
-	int emit_skip=1;
-	if((AOP_TYPE(left) == AOP_DIR) && 
-	   ((AOP_TYPE(right) == AOP_REG) || (AOP_TYPE(right) == AOP_DIR))) {
+    //int lbl_key = (rIfx.condition) ? rIfx.lbl->key : lbl->key;
+    int lbl_key = lbl->key;
+
+    if(result) {
+      emitpcode(POC_CLRF,popGet(AOP(result),res_offset));
+      //emitpcode(POC_INCF,popGet(AOP(result),res_offset));
+    }else {
+      DEBUGpic14_emitcode ("; ***","%s  %d -- ERROR",__FUNCTION__,__LINE__);
+      fprintf(stderr, "%s  %d error - expecting result to be non_null\n",
+	      __FUNCTION__,__LINE__);
+      return;
+    }
 
-	  emitpcode(POC_MOVFW,popGet(AOP(left),offset));
-	  emitpcode(POC_XORFW,popGet(AOP(right),offset));
+/*     switch(size) { */
+/*     case 2: */
+/*       genc16bit2lit(left, lit, 0); */
+/*       emitSKPNZ; */
+/*       emitpcode(POC_GOTO,popGetLabel(lbl->key)); */
+/*       break; */
+/*     default: */
+    while (size--) {
+      int emit_skip=1;
+      if((AOP_TYPE(left) == AOP_DIR) && 
+	 ((AOP_TYPE(right) == AOP_REG) || (AOP_TYPE(right) == AOP_DIR))) {
+
+	emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+	emitpcode(POC_XORFW,popGet(AOP(right),offset));
 
-	} else if((AOP_TYPE(left) == AOP_DIR) && (AOP_TYPE(right) == AOP_LIT)){
+      } else if((AOP_TYPE(left) == AOP_DIR) && (AOP_TYPE(right) == AOP_LIT)){
 	    
-	  switch (lit & 0xff) {
-	  case 0:
-	    emitpcode(POC_MOVFW,popGet(AOP(left),offset));
-	    break;
-	  case 1:
-	    emitpcode(POC_DECFSZ,popGet(AOP(left),offset));
-	    emitpcode(POC_GOTO,popGetLabel(lbl->key));
-	    emit_skip=0;
-	    break;
-	  case 0xff:
-	    emitpcode(POC_INCFSZ,popGet(AOP(left),offset));
-	    emitpcode(POC_GOTO,popGetLabel(lbl->key));
-	    emit_skip=0;
-	    break;
-	  default:
-	    emitpcode(POC_MOVFW,popGet(AOP(left),offset));
-	    emitpcode(POC_XORLW,popGetLit(lit & 0xff));
-	  }
-	  lit >>= 8;
+	switch (lit & 0xff) {
+	case 0:
+	  emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+	  break;
+	case 1:
+	  emitpcode(POC_DECFSZW,popGet(AOP(left),offset));
+	  emitpcode(POC_INCF,popGet(AOP(result),res_offset));
+	  //emitpcode(POC_GOTO,popGetLabel(lbl->key));
+	  emit_skip=0;
+	  break;
+	case 0xff:
+	  emitpcode(POC_INCFSZW,popGet(AOP(left),offset));
+	  //emitpcode(POC_INCF,popGet(AOP(result),res_offset));
+	  //emitpcode(POC_INCFSZW,popGet(AOP(left),offset));
+	  emitpcode(POC_GOTO,popGetLabel(lbl_key));
+	  emit_skip=0;
+	  break;
+	default:
+	  emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+	  emitpcode(POC_XORLW,popGetLit(lit & 0xff));
+	}
+	lit >>= 8;
 
+      } else {
+	emitpcode(POC_MOVF,popGet(AOP(left),offset));
+      }
+      if(emit_skip) {
+	if(AOP_TYPE(result) == AOP_CRY) {
+	  pic14_emitcode(";***","%s  %d",__FUNCTION__,__LINE__);
+	  if(rIfx.condition)
+	    emitSKPNZ;
+	  else
+	    emitSKPZ;
+	  emitpcode(POC_GOTO,popGetLabel(rIfx.lbl->key));
 	} else {
-	  emitpcode(POC_MOVF,popGet(AOP(left),offset));
-	}
-	if(emit_skip) {
-	  if(AOP_TYPE(result) == AOP_CRY) {
-	    pic14_emitcode(";***","%s  %d",__FUNCTION__,__LINE__);
-	    if(rIfx.condition)
-	      emitSKPNZ;
-	    else
-	      emitSKPZ;
-	    emitpcode(POC_GOTO,popGetLabel(rIfx.lbl->key));
-	  } else {
-	    /* fix me. probably need to check result size too */
-	    emitpcode(POC_CLRF,popGet(AOP(result),0));
-	    if(rIfx.condition)
-	      emitSKPNZ;
-	    else
-	      emitSKPZ;
-	    emitpcode(POC_INCF,popGet(AOP(result),0));
-	  }
-	  if(ifx)
-	    ifx->generated=1;
+	  /* fix me. probably need to check result size too */
+	  //emitpcode(POC_CLRF,popGet(AOP(result),0));
+	  if(rIfx.condition)
+	    emitSKPZ;
+	  else
+	    emitSKPNZ;
+	  emitpcode(POC_GOTO,popGetLabel(lbl_key));
+	  //emitpcode(POC_INCF,popGet(AOP(result),res_offset));
 	}
-	emit_skip++;
-	offset++;
+	if(ifx)
+	  ifx->generated=1;
       }
-      break;
+      emit_skip++;
+      offset++;
+      if(res_offset < res_size-1)
+	res_offset++;
     }
+/*       break; */
+/*     } */
   } else if(AOP_TYPE(right) == AOP_REG &&
 	    AOP_TYPE(left) != AOP_DIR){
 
@@ -4288,6 +4681,8 @@ static void gencjne(operand *left, operand *right, operand *result, iCode *ifx)
 	emitSKPZ;
       emitpcode(POC_GOTO,popGetLabel(rIfx.lbl->key));
       offset++;
+      if(res_offset < res_size-1)
+	res_offset++;
     }
       
   }else{
@@ -4301,8 +4696,15 @@ static void gencjne(operand *left, operand *right, operand *result, iCode *ifx)
       offset++;
     }
   }
+
+  emitpcode(POC_INCF,popGet(AOP(result),res_offset));
+  if(!rIfx.condition)
+    emitpcode(POC_GOTO,popGetLabel(rIfx.lbl->key));
+
   emitpLabel(lbl->key);
 
+  DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+
   if(ifx)
     ifx->generated = 1;
 }
@@ -4399,6 +4801,19 @@ static void genCmpEq (iCode *ic, iCode *ifx)
                 pic14_emitcode("ljmp","%05d_DS_",IC_FALSE(ifx)->key+100);
             }
             pic14_emitcode("","%05d_DS_:",tlbl->key+100+labelOffset);
+
+	    {
+	      /* left and right are both bit variables, result is carry */
+	      resolvedIfx rIfx;
+	      
+	      resolveIfx(&rIfx,ifx);
+
+	      emitpcode(POC_MOVLW,popGet(AOP(left),0));
+	      emitpcode(POC_ANDFW,popGet(AOP(left),0));
+	      emitpcode(POC_BTFSC,popGet(AOP(right),0));
+	      emitpcode(POC_ANDLW,popGet(AOP(left),0));
+	      genSkipz2(&rIfx,0);
+	    }
         } else {
 
 	  /* They're not both bit variables. Is the right a literal? */
@@ -4576,6 +4991,7 @@ static void genCmpEq (iCode *ic, iCode *ifx)
         pic14_outBitC(result);
     } else {
       
+      DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
       gencjne(left,right,result,ifx);
 /*
       if(ifx) 
@@ -4662,7 +5078,7 @@ static iCode *ifxForOp ( operand *op, iCode *ic )
 static void genAndOp (iCode *ic)
 {
     operand *left,*right, *result;
-    symbol *tlbl;
+/*     symbol *tlbl; */
 
     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
     /* note here that && operations that are in an
@@ -4672,20 +5088,26 @@ static void genAndOp (iCode *ic)
     aopOp((right=IC_RIGHT(ic)),ic,FALSE);
     aopOp((result=IC_RESULT(ic)),ic,FALSE);
 
+    DEBUGpic14_AopType(__LINE__,left,right,result);
+
+    emitpcode(POC_MOVFW,popGet(AOP(left),0));
+    emitpcode(POC_ANDFW,popGet(AOP(right),0));
+    emitpcode(POC_MOVWF,popGet(AOP(result),0));
+
     /* if both are bit variables */
-    if (AOP_TYPE(left) == AOP_CRY &&
-        AOP_TYPE(right) == AOP_CRY ) {
-        pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir);
-        pic14_emitcode("anl","c,%s",AOP(right)->aopu.aop_dir);
-        pic14_outBitC(result);
-    } else {
-        tlbl = newiTempLabel(NULL);
-        pic14_toBoolean(left);    
-        pic14_emitcode("jz","%05d_DS_",tlbl->key+100);
-        pic14_toBoolean(right);
-        pic14_emitcode("","%05d_DS_:",tlbl->key+100);
-        pic14_outBitAcc(result);
-    }
+/*     if (AOP_TYPE(left) == AOP_CRY && */
+/*         AOP_TYPE(right) == AOP_CRY ) { */
+/*         pic14_emitcode("mov","c,%s",AOP(left)->aopu.aop_dir); */
+/*         pic14_emitcode("anl","c,%s",AOP(right)->aopu.aop_dir); */
+/*         pic14_outBitC(result); */
+/*     } else { */
+/*         tlbl = newiTempLabel(NULL); */
+/*         pic14_toBoolean(left);     */
+/*         pic14_emitcode("jz","%05d_DS_",tlbl->key+100); */
+/*         pic14_toBoolean(right); */
+/*         pic14_emitcode("","%05d_DS_:",tlbl->key+100); */
+/*         pic14_outBitAcc(result); */
+/*     } */
 
     freeAsmop(left,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
     freeAsmop(right,NULL,ic,(RESULTONSTACK(ic) ? FALSE : TRUE));
@@ -5050,22 +5472,28 @@ static void genAnd (iCode *ic, iCode *ifx)
 	    emitpcode(POC_CLRF,popGet(AOP(result),offset));
 	    break;
 	  case 0xff:
-	    pic14_emitcode("movf","%s,w",
-			   aopGet(AOP(left),offset,FALSE,FALSE));
-	    pic14_emitcode("movwf","%s",
-			   aopGet(AOP(result),offset,FALSE,FALSE));
-	    emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+	    if(AOP_TYPE(left) != AOP_ACC) {
+	      pic14_emitcode("movf","%s,w",
+			     aopGet(AOP(left),offset,FALSE,FALSE));
+	      pic14_emitcode("movwf","%s",
+			     aopGet(AOP(result),offset,FALSE,FALSE));
+	      emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+	    }
 	    emitpcode(POC_MOVWF,popGet(AOP(result),offset));
 	    break;
 	  default:
-	    pic14_emitcode("movlw","0x%x",t);
-	    pic14_emitcode("andwf","%s,w",
-			   aopGet(AOP(left),offset,FALSE,FALSE));
-	    pic14_emitcode("movwf","%s",
-			   aopGet(AOP(result),offset,FALSE,FALSE));
+	    if(AOP_TYPE(left) == AOP_ACC) {
+	      emitpcode(POC_ANDLW, popGetLit(t));
+	    } else {
+	      pic14_emitcode("movlw","0x%x",t);
+	      pic14_emitcode("andwf","%s,w",
+			     aopGet(AOP(left),offset,FALSE,FALSE));
+	      pic14_emitcode("movwf","%s",
+			     aopGet(AOP(result),offset,FALSE,FALSE));
 	      
-	    emitpcode(POC_MOVLW, popGetLit(t));
-	    emitpcode(POC_ANDFW,popGet(AOP(left),offset));
+	      emitpcode(POC_MOVLW, popGetLit(t));
+	      emitpcode(POC_ANDFW,popGet(AOP(left),offset));
+	    }
 	    emitpcode(POC_MOVWF,popGet(AOP(result),offset));
 	  }
 	  continue;
@@ -5351,25 +5779,20 @@ static void genOr (iCode *ic, iCode *ifx)
 	    int t = (lit >> (offset*8)) & 0x0FFL;
 	    switch(t) { 
 	    case 0x00:
-	      emitpcode(POC_MOVFW,  popGet(AOP(left),offset));
+	      if (AOP_TYPE(left) != AOP_ACC) {
+		emitpcode(POC_MOVFW,  popGet(AOP(left),offset));
+	      }
 	      emitpcode(POC_MOVWF,  popGet(AOP(result),offset));
 
-	      pic14_emitcode("movf","%s,w",
-		       aopGet(AOP(left),offset,FALSE,FALSE));
-	      pic14_emitcode("movwf","%s",
-		       aopGet(AOP(result),offset,FALSE,FALSE));
 	      break;
 	    default:
-	      emitpcode(POC_MOVLW,  popGetLit(t));
-	      emitpcode(POC_IORFW,  popGet(AOP(left),offset));
-	      emitpcode(POC_MOVWF,  popGet(AOP(result),offset));
-
-	      pic14_emitcode("movlw","0x%x",t);
-	      pic14_emitcode("iorwf","%s,w",
-		       aopGet(AOP(left),offset,FALSE,FALSE));
-	      pic14_emitcode("movwf","%s",
-		       aopGet(AOP(result),offset,FALSE,FALSE));
-	      
+	      if (AOP_TYPE(left) == AOP_ACC) {
+		emitpcode(POC_IORLW,  popGetLit(t));
+	      } else {
+		emitpcode(POC_MOVLW,  popGetLit(t));
+		emitpcode(POC_IORFW,  popGet(AOP(left),offset));
+	      }
+	      emitpcode(POC_MOVWF,  popGet(AOP(result),offset));	      
 	    }
 	    continue;
 	  }
@@ -5450,7 +5873,8 @@ static void genXor (iCode *ic, iCode *ifx)
 	// lit>>1  != 0 => result = 1
 	if(AOP_TYPE(result) == AOP_CRY){
 	  if(size)
-	    pic14_emitcode("setb","%s",AOP(result)->aopu.aop_dir);
+	    {emitpcode(POC_BSF,  popGet(AOP(result),offset));
+	    pic14_emitcode("setb","%s",AOP(result)->aopu.aop_dir);}
 	  else if(ifx)
 	    continueIfTrue(ifx);
 	  goto release;
@@ -5466,6 +5890,8 @@ static void genXor (iCode *ic, iCode *ifx)
 	} else{
 	  // lit == 1, result = not(left)
 	  if(size && pic14_sameRegs(AOP(result),AOP(left))){
+	    emitpcode(POC_MOVLW,  popGet(AOP(result),offset));
+	    emitpcode(POC_XORWF,  popGet(AOP(result),offset));
 	    pic14_emitcode("cpl","%s",AOP(result)->aopu.aop_dir);
 	    goto release;
 	  } else {
@@ -5583,7 +6009,9 @@ static void genXor (iCode *ic, iCode *ifx)
 	int t = (lit >> (offset*8)) & 0x0FFL;
 	switch(t) { 
 	case 0x00:
-	  emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+	  if (AOP_TYPE(left) != AOP_ACC) {
+	    emitpcode(POC_MOVFW,popGet(AOP(left),offset));
+	  }
 	  emitpcode(POC_MOVWF,popGet(AOP(result),offset));
 	  pic14_emitcode("movf","%s,w",
 			 aopGet(AOP(left),offset,FALSE,FALSE));
@@ -5591,16 +6019,20 @@ static void genXor (iCode *ic, iCode *ifx)
 			 aopGet(AOP(result),offset,FALSE,FALSE));
 	  break;
 	case 0xff:
-	  emitpcode(POC_COMFW,popGet(AOP(left),offset));
+	  if (AOP_TYPE(left) == AOP_ACC) {
+	    emitpcode(POC_XORLW, popGetLit(t));
+	  } else {
+	    emitpcode(POC_COMFW,popGet(AOP(left),offset));
+	  }
 	  emitpcode(POC_MOVWF,popGet(AOP(result),offset));
-	  pic14_emitcode("comf","%s,w",
-			 aopGet(AOP(left),offset,FALSE,FALSE));
-	  pic14_emitcode("movwf","%s",
-			 aopGet(AOP(result),offset,FALSE,FALSE));
 	  break;
 	default:
-	  emitpcode(POC_MOVLW, popGetLit(t));
-	  emitpcode(POC_XORFW,popGet(AOP(left),offset));
+	  if (AOP_TYPE(left) == AOP_ACC) {
+	    emitpcode(POC_XORLW, popGetLit(t));
+	  } else {
+	    emitpcode(POC_MOVLW, popGetLit(t));
+	    emitpcode(POC_XORFW,popGet(AOP(left),offset));
+	  }
 	  emitpcode(POC_MOVWF,popGet(AOP(result),offset));
 	  pic14_emitcode("movlw","0x%x",t);
 	  pic14_emitcode("xorwf","%s,w",
@@ -5654,7 +6086,9 @@ static void genInline (iCode *ic)
     while (*bp) {
         if (*bp == '\n') {
             *bp++ = '\0';
-            pic14_emitcode(bp1,"");
+
+	    if(*bp1)
+	      addpCode2pBlock(pb,AssembleLine(bp1));
             bp1 = bp;
         } else {
             if (*bp == ':') {
@@ -5667,9 +6101,11 @@ static void genInline (iCode *ic)
                 bp++;
         }
     }
-    if (bp1 != bp)
-        pic14_emitcode(bp1,"");
-    /*     pic14_emitcode("",buffer); */
+    if ((bp1 != bp) && *bp1)
+      addpCode2pBlock(pb,AssembleLine(bp1));
+
+    Safe_free(buffer);
+
     _G.inLine -= (!options.asmpeep);
 }
 
@@ -5909,7 +6345,7 @@ static void shiftR1Left2ResultSigned (operand *left, int offl,
 
   DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
 
-  same = (left == result) || (AOP(left) == AOP(result));
+  same = ((left == result) || (AOP(left) == AOP(result))) && (offl == offr);
 
   switch(shCount) {
   case 1:
@@ -5922,47 +6358,128 @@ static void shiftR1Left2ResultSigned (operand *left, int offl,
     }
 
     break;
+  case 2:
 
-  default:
-    break;
-  }
-}
-
-/*-----------------------------------------------------------------*/
-/* shiftR1Left2Result - shift right one byte from left to result   */
-/*-----------------------------------------------------------------*/
-static void shiftR1Left2Result (operand *left, int offl,
-                                operand *result, int offr,
-                                int shCount, int sign)
-{
-  int same;
-
-  DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-
-  same = ((left == result) || (AOP(left) == AOP(result))) && (offl == offr);
-
-  /* Copy the msb into the carry if signed. */
-  if(sign) {
-    shiftR1Left2ResultSigned(left,offl,result,offr,shCount);
-    return;
-  }
-
-
-
-  switch(shCount) {
-  case 1:
-    emitCLRC;
+    emitpcode(POC_RLFW, popGet(AOP(left),offl));
     if(same) 
       emitpcode(POC_RRF, popGet(AOP(result),offr));
     else {
       emitpcode(POC_RRFW, popGet(AOP(left),offl));
       emitpcode(POC_MOVWF, popGet(AOP(result),offr));
     }
+    emitpcode(POC_RLFW, popGet(AOP(result),offr));
+    emitpcode(POC_RRF,  popGet(AOP(result),offr));
+
     break;
-  case 2:
-    emitCLRC;
-    if(same) {
-      emitpcode(POC_RRF, popGet(AOP(result),offr));
+
+  case 3:
+    if(same)
+      emitpcode(POC_SWAPF, popGet(AOP(result),offr));
+    else {
+      emitpcode(POC_SWAPFW, popGet(AOP(left),offl));
+      emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+    }
+
+    emitpcode(POC_RLFW,  popGet(AOP(result),offr));
+    emitpcode(POC_RLFW,  popGet(AOP(result),offr));
+    emitpcode(POC_ANDLW, popGetLit(0x1f));
+
+    emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(result),offr,FALSE,FALSE),3,0));
+    emitpcode(POC_IORLW, popGetLit(0xe0));
+
+    emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+    break;
+
+  case 4:
+    emitpcode(POC_SWAPFW, popGet(AOP(left),offl));
+    emitpcode(POC_ANDLW,  popGetLit(0x0f));
+    emitpcode(POC_BTFSC,  newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),7,0));
+    emitpcode(POC_IORLW,  popGetLit(0xf0));
+    emitpcode(POC_MOVWF,  popGet(AOP(result),offr));
+    break;
+  case 5:
+    if(same) {
+      emitpcode(POC_SWAPF,  popGet(AOP(result),offr));
+    } else {
+      emitpcode(POC_SWAPFW,  popGet(AOP(left),offl));
+      emitpcode(POC_MOVWF,  popGet(AOP(result),offr));
+    }
+    emitpcode(POC_RRFW,   popGet(AOP(result),offr));
+    emitpcode(POC_ANDLW,  popGetLit(0x07));
+    emitpcode(POC_BTFSC,  newpCodeOpBit(aopGet(AOP(result),offr,FALSE,FALSE),3,0));
+    emitpcode(POC_IORLW,  popGetLit(0xf8));
+    emitpcode(POC_MOVWF,  popGet(AOP(result),offr));
+    break;
+
+  case 6:
+    if(same) {
+      emitpcode(POC_MOVLW, popGetLit(0x00));
+      emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),7,0));
+      emitpcode(POC_MOVLW, popGetLit(0xfe));
+      emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),6,0));
+      emitpcode(POC_IORLW, popGetLit(0x01));
+      emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+    } else {
+      emitpcode(POC_CLRF,  popGet(AOP(result),offr));
+      emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),7,0));
+      emitpcode(POC_DECF,  popGet(AOP(result),offr));
+      emitpcode(POC_BTFSS, newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),6,0));
+      emitpcode(POC_BCF,   newpCodeOpBit(aopGet(AOP(result),offr,FALSE,FALSE),0,0));
+    }
+    break;
+
+  case 7:
+    if(same) {
+      emitpcode(POC_MOVLW, popGetLit(0x00));
+      emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),LSB,FALSE,FALSE),7,0));
+      emitpcode(POC_MOVLW, popGetLit(0xff));
+      emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+    } else {
+      emitpcode(POC_CLRF,  popGet(AOP(result),offr));
+      emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),offl,FALSE,FALSE),7,0));
+      emitpcode(POC_DECF,  popGet(AOP(result),offr));
+    }
+
+  default:
+    break;
+  }
+}
+
+/*-----------------------------------------------------------------*/
+/* shiftR1Left2Result - shift right one byte from left to result   */
+/*-----------------------------------------------------------------*/
+static void shiftR1Left2Result (operand *left, int offl,
+                                operand *result, int offr,
+                                int shCount, int sign)
+{
+  int same;
+
+  DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+
+  same = ((left == result) || (AOP(left) == AOP(result))) && (offl == offr);
+
+  /* Copy the msb into the carry if signed. */
+  if(sign) {
+    shiftR1Left2ResultSigned(left,offl,result,offr,shCount);
+    return;
+  }
+
+
+
+  switch(shCount) {
+  case 1:
+    emitCLRC;
+    if(same) 
+      emitpcode(POC_RRF, popGet(AOP(result),offr));
+    else {
+      emitpcode(POC_RRFW, popGet(AOP(left),offl));
+      emitpcode(POC_MOVWF, popGet(AOP(result),offr));
+    }
+    break;
+  case 2:
+    emitCLRC;
+    if(same) {
+      emitpcode(POC_RRF, popGet(AOP(result),offr));
     } else {
       emitpcode(POC_RRFW, popGet(AOP(left),offl));
       emitpcode(POC_MOVWF, popGet(AOP(result),offr));
@@ -5972,7 +6489,7 @@ static void shiftR1Left2Result (operand *left, int offl,
 
     break;
   case 3:
-    if(same) 
+    if(same)
       emitpcode(POC_SWAPF, popGet(AOP(result),offr));
     else {
       emitpcode(POC_SWAPFW, popGet(AOP(left),offl));
@@ -6019,19 +6536,6 @@ static void shiftR1Left2Result (operand *left, int offl,
   default:
     break;
   }
-
-
-#if 0
-    
-  MOVA(aopGet(AOP(left),offl,FALSE,FALSE));
-
-  /* shift right accumulator */
-  if(sign)
-    AccSRsh(shCount);
-  else
-    AccRsh(shCount);
-  aopPut(AOP(result),"a",offr);
-#endif
 }
 
 /*-----------------------------------------------------------------*/
@@ -6111,31 +6615,21 @@ static void shiftL1Left2Result (operand *left, int offl,
 /* movLeft2Result - move byte from left to result                  */
 /*-----------------------------------------------------------------*/
 static void movLeft2Result (operand *left, int offl,
-                            operand *result, int offr, int sign)
+                            operand *result, int offr)
 {
-    char *l;
-    DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-    if(!pic14_sameRegs(AOP(left),AOP(result)) || (offl != offr)){
-        l = aopGet(AOP(left),offl,FALSE,FALSE);
+  char *l;
+  DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+  if(!pic14_sameRegs(AOP(left),AOP(result)) || (offl != offr)){
+    l = aopGet(AOP(left),offl,FALSE,FALSE);
 
-        if (*l == '@' && (IS_AOP_PREG(result))) {
-            pic14_emitcode("mov","a,%s",l);
-            aopPut(AOP(result),"a",offr);
-        } else {
-	  if(!sign) {
-	    emitpcode(POC_MOVFW, popGet(AOP(left),offl));
-	    emitpcode(POC_MOVWF, popGet(AOP(result),offr));
-
-	    //aopPut(AOP(result),l,offr);
-	  }else{
-                /* MSB sign in acc.7 ! */
-                if(pic14_getDataSize(left) == offl+1){
-                    pic14_emitcode("mov","a,%s",l);
-                    aopPut(AOP(result),"a",offr);
-                }
-            }
-        }
+    if (*l == '@' && (IS_AOP_PREG(result))) {
+      pic14_emitcode("mov","a,%s",l);
+      aopPut(AOP(result),"a",offr);
+    } else {
+      emitpcode(POC_MOVFW, popGet(AOP(left),offl));
+      emitpcode(POC_MOVWF, popGet(AOP(result),offr));
     }
+  }
 }
 
 /*-----------------------------------------------------------------*/
@@ -6282,10 +6776,12 @@ static void shiftR2Left2Result (operand *left, int offl,
     /* don't crash result[offr] */
     MOVA(aopGet(AOP(left),offl,FALSE,FALSE));
     pic14_emitcode("xch","a,%s", aopGet(AOP(left),offl+MSB16,FALSE,FALSE));
-  } else {
-    movLeft2Result(left,offl, result, offr, 0);
+  }
+/* else {
+    movLeft2Result(left,offl, result, offr);
     MOVA(aopGet(AOP(left),offl+MSB16,FALSE,FALSE));
   }
+*/
   /* a:x >> shCount (x = lsb(result))*/
 /*
   if(sign)
@@ -6299,12 +6795,15 @@ static void shiftR2Left2Result (operand *left, int offl,
   case 1:
   case 2:
   case 3:
-    emitCLRC;
+    if(sign)
+      emitpcode(POC_RLFW,popGet(AOP(result),offr+MSB16));
+    else
+      emitCLRC;
+
     if(same) {
       emitpcode(POC_RRF,popGet(AOP(result),offr+MSB16));
       emitpcode(POC_RRF,popGet(AOP(result),offr));
     } else {
-
       emitpcode(POC_RRFW, popGet(AOP(left),offl+MSB16));
       emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
       emitpcode(POC_RRFW, popGet(AOP(left),offl));
@@ -6312,7 +6811,10 @@ static void shiftR2Left2Result (operand *left, int offl,
     }
 
     while(--shCount) {
-      emitCLRC;
+      if(sign)
+	emitpcode(POC_RLFW,popGet(AOP(result),offr+MSB16));
+      else
+	emitCLRC;
       emitpcode(POC_RRF,popGet(AOP(result),offr+MSB16));
       emitpcode(POC_RRF,popGet(AOP(result),offr));
     }
@@ -6330,11 +6832,11 @@ static void shiftR2Left2Result (operand *left, int offl,
       emitpcode(POC_XORWF, popGet(AOP(result),offr+MSB16));
       emitpcode(POC_ADDWF, popGet(AOP(result),offr));
     } else {
-      emitpcode(POC_SWAPF, popGet(AOP(left),offl));
+      emitpcode(POC_SWAPFW,popGet(AOP(left),offl));
       emitpcode(POC_ANDLW, popGetLit(0x0f));
       emitpcode(POC_MOVWF, popGet(AOP(result),offr));
 
-      emitpcode(POC_SWAPF, popGet(AOP(left),offl+MSB16));
+      emitpcode(POC_SWAPFW,popGet(AOP(left),offl+MSB16));
       emitpcode(POC_MOVWF, popGet(AOP(result),offr+MSB16));
       emitpcode(POC_ANDLW, popGetLit(0xf0));
       emitpcode(POC_XORWF, popGet(AOP(result),offr+MSB16));
@@ -6346,6 +6848,13 @@ static void shiftR2Left2Result (operand *left, int offl,
       emitpcode(POC_RRF, popGet(AOP(result),offr));
     }
 
+    if(sign) {
+      emitpcode(POC_MOVLW, popGetLit(0xf0 + (shCount-4)*8 ));
+      emitpcode(POC_BTFSC, 
+		newpCodeOpBit(aopGet(AOP(result),offr+MSB16,FALSE,FALSE),7-shCount,0));
+      emitpcode(POC_ADDWF, popGet(AOP(result),offr+MSB16));
+    }
+
     break;
 
   case 6:
@@ -6358,6 +6867,11 @@ static void shiftR2Left2Result (operand *left, int offl,
       emitpcode(POC_RLF,  popGet(AOP(result),offr+MSB16));
       emitpcode(POC_RLFW, popGet(AOP(result),offr));
       emitpcode(POC_ANDLW,popGetLit(0x03));
+      if(sign) {
+	emitpcode(POC_BTFSC, 
+		  newpCodeOpBit(aopGet(AOP(result),offr+MSB16,FALSE,FALSE),1,0));
+	emitpcode(POC_IORLW,popGetLit(0xfc));
+      }
       emitpcode(POC_XORFW,popGet(AOP(result),offr+MSB16));
       emitpcode(POC_XORWF,popGet(AOP(result),offr+MSB16));
       emitpcode(POC_XORFW,popGet(AOP(result),offr+MSB16));
@@ -6365,13 +6879,21 @@ static void shiftR2Left2Result (operand *left, int offl,
     } else {
       emitpcode(POC_RLFW, popGet(AOP(left),offl));
       emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
-      emitpcode(POC_RLFW, popGet(AOP(result),offl+MSB16));
+      emitpcode(POC_RLFW, popGet(AOP(left),offl+MSB16));
       emitpcode(POC_MOVWF,popGet(AOP(result),offr));
       emitpcode(POC_RLF,  popGet(AOP(result),offr+MSB16));
       emitpcode(POC_RLF,  popGet(AOP(result),offr));
-      emitpcode(POC_RLFW, popGet(AOP(result),offr));
+      emitpcode(POC_RLFW, popGet(AOP(result),offr+MSB16));
       emitpcode(POC_ANDLW,popGetLit(0x03));
-      emitpcode(POC_MOVWF,popGet(AOP(result),offr));
+      if(sign) {
+	emitpcode(POC_BTFSC, 
+		  newpCodeOpBit(aopGet(AOP(result),offr+MSB16,FALSE,FALSE),0,0));
+	emitpcode(POC_IORLW,popGetLit(0xfc));
+      }
+      emitpcode(POC_MOVWF,popGet(AOP(result),offr+MSB16));
+      //emitpcode(POC_RLF,  popGet(AOP(result),offr));
+
+	
     }
 
     break;
@@ -6380,7 +6902,11 @@ static void shiftR2Left2Result (operand *left, int offl,
     emitpcode(POC_RLFW, popGet(AOP(left),offl+MSB16));
     emitpcode(POC_MOVWF,popGet(AOP(result),offr));
     emitpcode(POC_CLRF, popGet(AOP(result),offr+MSB16));
-    emitpcode(POC_RLF,  popGet(AOP(result),offr+MSB16));
+    if(sign) {
+      emitSKPNC;
+      emitpcode(POC_DECF, popGet(AOP(result),offr+MSB16));
+    } else 
+      emitpcode(POC_RLF,  popGet(AOP(result),offr+MSB16));
   }
 }
 
@@ -6444,7 +6970,7 @@ static void genlshTwo (operand *result,operand *left, int shCount)
             if (shCount)
                 shiftL1Left2Result(left, LSB, result, MSB16, shCount);
             else 
-                movLeft2Result(left, LSB, result, MSB16, 0);
+                movLeft2Result(left, LSB, result, MSB16);
         }
 	emitpcode(POC_CLRF,popGet(AOP(result),LSB));
     }
@@ -6538,7 +7064,7 @@ static void genlshFour (operand *result, operand *left, int shCount)
             order of the destination */
             shiftL1Left2Result(left, LSB, result, MSB32, shCount);
         else
-            movLeft2Result(left, LSB, result, MSB32, 0);
+            movLeft2Result(left, LSB, result, MSB32);
         aopPut(AOP(result),zero,LSB);
         aopPut(AOP(result),zero,MSB16);
         aopPut(AOP(result),zero,MSB32);
@@ -6553,8 +7079,8 @@ static void genlshFour (operand *result, operand *left, int shCount)
         if (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);
+            movLeft2Result(left, LSB, result, MSB24);
         }
         aopPut(AOP(result),zero,MSB16);
         aopPut(AOP(result),zero,LSB);
@@ -6569,13 +7095,13 @@ static void genlshFour (operand *result, operand *left, int shCount)
             if(shCount)
                 shiftL1Left2Result(left, LSB, result, MSB16, shCount);
             else
-                movLeft2Result(left, LSB, result, MSB16, 0);
+                movLeft2Result(left, LSB, result, MSB16);
         }
         else{   /* size = 4 */
             if(shCount == 0){
-                movLeft2Result(left, MSB24, result, MSB32, 0);
-                movLeft2Result(left, MSB16, result, MSB24, 0);
-                movLeft2Result(left, LSB, result, MSB16, 0);
+                movLeft2Result(left, MSB24, result, MSB32);
+                movLeft2Result(left, MSB16, result, MSB24);
+                movLeft2Result(left, LSB, result, MSB16);
                 aopPut(AOP(result),zero,LSB);
             }
             else if(shCount == 1)
@@ -6630,7 +7156,7 @@ static void genLeftShiftLiteral (operand *left,
     /* I suppose that the left size >= result size */
     if(shCount == 0){
         while(size--){
-            movLeft2Result(left, size, result, size, 0);
+            movLeft2Result(left, size, result, size);
         }
     }
 
@@ -6657,123 +7183,201 @@ static void genLeftShiftLiteral (operand *left,
     freeAsmop(result,NULL,ic,TRUE);
 }
 
+/*-----------------------------------------------------------------*
+ * genMultiAsm - repeat assembly instruction for size of register.
+ * if endian == 1, then the high byte (i.e base address + size of 
+ * register) is used first else the low byte is used first;
+ *-----------------------------------------------------------------*/
+static void genMultiAsm( PIC_OPCODE poc, operand *reg, int size, int endian)
+{
+
+  int offset = 0;
+
+  DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+
+  if(!reg)
+    return;
+
+  if(!endian) {
+    endian = 1;
+  } else {
+    endian = -1;
+    offset = size-1;
+  }
+
+  while(size--) {
+    emitpcode(poc,    popGet(AOP(reg),offset));
+    offset += endian;
+  }
+
+}
 /*-----------------------------------------------------------------*/
 /* genLeftShift - generates code for left shifting                 */
 /*-----------------------------------------------------------------*/
 static void genLeftShift (iCode *ic)
 {
-    operand *left,*right, *result;
-    int size, offset;
-    char *l;
-    symbol *tlbl , *tlbl1;
+  operand *left,*right, *result;
+  int size, offset;
+  char *l;
+  symbol *tlbl , *tlbl1;
+  pCodeOp *pctemp;
 
-    DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+  DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
 
-    right = IC_RIGHT(ic);
-    left  = IC_LEFT(ic);
-    result = IC_RESULT(ic);
+  right = IC_RIGHT(ic);
+  left  = IC_LEFT(ic);
+  result = IC_RESULT(ic);
 
-    aopOp(right,ic,FALSE);
+  aopOp(right,ic,FALSE);
 
-    /* if the shift count is known then do it 
-    as efficiently as possible */
-    if (AOP_TYPE(right) == AOP_LIT) {
-        genLeftShiftLiteral (left,right,result,ic);
-        return ;
-    }
+  /* if the shift count is known then do it 
+     as efficiently as possible */
+  if (AOP_TYPE(right) == AOP_LIT) {
+    genLeftShiftLiteral (left,right,result,ic);
+    return ;
+  }
 
-    /* shift count is unknown then we have to form 
-    a loop get the loop count in B : Note: we take
-    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 ) */  
+  /* shift count is unknown then we have to form 
+     a loop get the loop count in B : Note: we take
+     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 ) */  
 
     
-    aopOp(left,ic,FALSE);
-    aopOp(result,ic,FALSE);
+  aopOp(left,ic,FALSE);
+  aopOp(result,ic,FALSE);
 
-    /* now move the left to the result if they are not the
-    same */
-    if (!pic14_sameRegs(AOP(left),AOP(result)) && 
-        AOP_SIZE(result) > 1) {
+  /* now move the left to the result if they are not the
+     same */
+  if (!pic14_sameRegs(AOP(left),AOP(result)) && 
+      AOP_SIZE(result) > 1) {
 
-        size = AOP_SIZE(result);
-        offset=0;
-        while (size--) {
-            l = aopGet(AOP(left),offset,FALSE,TRUE);
-            if (*l == '@' && (IS_AOP_PREG(result))) {
+    size = AOP_SIZE(result);
+    offset=0;
+    while (size--) {
+      l = aopGet(AOP(left),offset,FALSE,TRUE);
+      if (*l == '@' && (IS_AOP_PREG(result))) {
 
-                pic14_emitcode("mov","a,%s",l);
-                aopPut(AOP(result),"a",offset);
-            } else
-                aopPut(AOP(result),l,offset);
-            offset++;
-        }
+	pic14_emitcode("mov","a,%s",l);
+	aopPut(AOP(result),"a",offset);
+      } else {
+	emitpcode(POC_MOVFW,  popGet(AOP(left),offset));
+	emitpcode(POC_MOVWF,  popGet(AOP(result),offset));
+	//aopPut(AOP(result),l,offset);
+      }
+      offset++;
     }
+  }
 
-    size = AOP_SIZE(result);
+  size = AOP_SIZE(result);
 
-    /* if it is only one byte then */
-    if (size == 1) {
-      if(optimized_for_speed) {
-	emitpcode(POC_SWAPFW, popGet(AOP(left),0));
-	emitpcode(POC_ANDLW,  popGetLit(0xf0));
-	emitpcode(POC_BTFSS,  newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),2,0));
+  /* if it is only one byte then */
+  if (size == 1) {
+    if(optimized_for_speed) {
+      emitpcode(POC_SWAPFW, popGet(AOP(left),0));
+      emitpcode(POC_ANDLW,  popGetLit(0xf0));
+      emitpcode(POC_BTFSS,  newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),2,0));
+      emitpcode(POC_MOVFW,  popGet(AOP(left),0));
+      emitpcode(POC_MOVWF,  popGet(AOP(result),0));
+      emitpcode(POC_BTFSS,  newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),0,0));
+      emitpcode(POC_ADDWF,  popGet(AOP(result),0));
+      emitpcode(POC_RLFW,   popGet(AOP(result),0));
+      emitpcode(POC_ANDLW,  popGetLit(0xfe));
+      emitpcode(POC_ADDFW,  popGet(AOP(result),0));
+      emitpcode(POC_BTFSC,  newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),1,0));
+      emitpcode(POC_ADDWF,  popGet(AOP(result),0));
+    } else {
+
+      tlbl = newiTempLabel(NULL);
+      if (!pic14_sameRegs(AOP(left),AOP(result))) {
 	emitpcode(POC_MOVFW,  popGet(AOP(left),0));
 	emitpcode(POC_MOVWF,  popGet(AOP(result),0));
-	emitpcode(POC_BTFSS,  newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),0,0));
-	emitpcode(POC_ADDWF,  popGet(AOP(result),0));
-	emitpcode(POC_RLFW,   popGet(AOP(result),0));
-	emitpcode(POC_ANDLW,  popGetLit(0xfe));
-	emitpcode(POC_ADDFW,  popGet(AOP(result),0));
-	emitpcode(POC_BTFSC,  newpCodeOpBit(aopGet(AOP(right),0,FALSE,FALSE),1,0));
-	emitpcode(POC_ADDWF,  popGet(AOP(result),0));
-      } else {
-
-	tlbl = newiTempLabel(NULL);
-	if (!pic14_sameRegs(AOP(left),AOP(result))) {
-	  emitpcode(POC_MOVFW,  popGet(AOP(left),0));
-	  emitpcode(POC_MOVWF,  popGet(AOP(result),0));
-	}
-
-	emitpcode(POC_COMFW,  popGet(AOP(right),0));
-	emitpcode(POC_RRF,    popGet(AOP(result),0));
-	emitpLabel(tlbl->key);
-	emitpcode(POC_RLF,    popGet(AOP(result),0));
-	emitpcode(POC_ADDLW,  popGetLit(1));
-	emitSKPC;
-	emitpcode(POC_GOTO,popGetLabel(tlbl->key));
       }
-      goto release ;
+
+      emitpcode(POC_COMFW,  popGet(AOP(right),0));
+      emitpcode(POC_RRF,    popGet(AOP(result),0));
+      emitpLabel(tlbl->key);
+      emitpcode(POC_RLF,    popGet(AOP(result),0));
+      emitpcode(POC_ADDLW,  popGetLit(1));
+      emitSKPC;
+      emitpcode(POC_GOTO,popGetLabel(tlbl->key));
     }
+    goto release ;
+  }
     
+  if (pic14_sameRegs(AOP(left),AOP(result))) {
 
     tlbl = newiTempLabel(NULL);
-    offset = 0 ;   
-    tlbl1 = newiTempLabel(NULL);
+    emitpcode(POC_COMFW,  popGet(AOP(right),0));
+    genMultiAsm(POC_RRF, result, size,1);
+    emitpLabel(tlbl->key);
+    genMultiAsm(POC_RLF, result, size,0);
+    emitpcode(POC_ADDLW,  popGetLit(1));
+    emitSKPC;
+    emitpcode(POC_GOTO,popGetLabel(tlbl->key));
+    goto release;
+  }
+
+  //tlbl = newiTempLabel(NULL);
+  //offset = 0 ;   
+  //tlbl1 = newiTempLabel(NULL);
 
-    reAdjustPreg(AOP(result));    
+  //reAdjustPreg(AOP(result));    
     
-    pic14_emitcode("sjmp","%05d_DS_",tlbl1->key+100); 
-    pic14_emitcode("","%05d_DS_:",tlbl->key+100);    
-    l = aopGet(AOP(result),offset,FALSE,FALSE);
-    MOVA(l);
-    pic14_emitcode("add","a,acc");         
-    aopPut(AOP(result),"a",offset++);
-    while (--size) {
-        l = aopGet(AOP(result),offset,FALSE,FALSE);
-        MOVA(l);
-        pic14_emitcode("rlc","a");         
-        aopPut(AOP(result),"a",offset++);
-    }
-    reAdjustPreg(AOP(result));
+  //pic14_emitcode("sjmp","%05d_DS_",tlbl1->key+100); 
+  //pic14_emitcode("","%05d_DS_:",tlbl->key+100);    
+  //l = aopGet(AOP(result),offset,FALSE,FALSE);
+  //MOVA(l);
+  //pic14_emitcode("add","a,acc");         
+  //aopPut(AOP(result),"a",offset++);
+  //while (--size) {
+  //  l = aopGet(AOP(result),offset,FALSE,FALSE);
+  //  MOVA(l);
+  //  pic14_emitcode("rlc","a");         
+  //  aopPut(AOP(result),"a",offset++);
+  //}
+  //reAdjustPreg(AOP(result));
+
+  //pic14_emitcode("","%05d_DS_:",tlbl1->key+100);
+  //pic14_emitcode("djnz","b,%05d_DS_",tlbl->key+100);
 
-    pic14_emitcode("","%05d_DS_:",tlbl1->key+100);
-    pic14_emitcode("djnz","b,%05d_DS_",tlbl->key+100);
-release:
-    freeAsmop (right,NULL,ic,TRUE);
-    freeAsmop(left,NULL,ic,TRUE);
-    freeAsmop(result,NULL,ic,TRUE);
+
+  tlbl = newiTempLabel(NULL);
+  tlbl1= newiTempLabel(NULL);
+
+  size = AOP_SIZE(result);
+  offset = 1;
+
+  pctemp = popGetTempReg();  /* grab a temporary working register. */
+
+  emitpcode(POC_MOVFW, popGet(AOP(right),0));
+
+  /* offset should be 0, 1 or 3 */
+  emitpcode(POC_ANDLW, popGetLit(0x07 + ((offset&3) << 3)));
+  emitSKPNZ;
+  emitpcode(POC_GOTO,  popGetLabel(tlbl1->key));
+
+  emitpcode(POC_MOVWF, pctemp);
+
+
+  emitpLabel(tlbl->key);
+
+  emitCLRC;
+  emitpcode(POC_RLF,  popGet(AOP(result),0));
+  while(--size)
+    emitpcode(POC_RLF,   popGet(AOP(result),offset++));
+
+  emitpcode(POC_DECFSZ,  pctemp);
+  emitpcode(POC_GOTO,popGetLabel(tlbl->key));
+  emitpLabel(tlbl1->key);
+
+  popReleaseTempReg(pctemp);
+
+
+ release:
+  freeAsmop (right,NULL,ic,TRUE);
+  freeAsmop(left,NULL,ic,TRUE);
+  freeAsmop(result,NULL,ic,TRUE);
 }
 
 /*-----------------------------------------------------------------*/
@@ -6792,25 +7396,27 @@ static void genrshOne (operand *result, operand *left,
 static void genrshTwo (operand *result,operand *left,
                        int shCount, int sign)
 {
-    DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-    /* if shCount >= 8 */
-    if (shCount >= 8) {
-        shCount -= 8 ;
-        if (shCount)
-            shiftR1Left2Result(left, MSB16, result, LSB,
-                               shCount, sign);
-        else 
-            movLeft2Result(left, MSB16, result, LSB, sign);
-	if(sign)
-	  addSign(result, MSB16, sign);
-	else
-	  emitpcode(POC_CLRF,popGet(AOP(result),MSB16));
+  DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+  /* if shCount >= 8 */
+  if (shCount >= 8) {
+    shCount -= 8 ;
+    if (shCount)
+      shiftR1Left2Result(left, MSB16, result, LSB,
+			 shCount, sign);
+    else
+      movLeft2Result(left, MSB16, result, LSB);
 
+    emitpcode(POC_CLRF,popGet(AOP(result),MSB16));
+
+    if(sign) {
+      emitpcode(POC_BTFSC,newpCodeOpBit(aopGet(AOP(left),LSB,FALSE,FALSE),7,0));
+      emitpcode(POC_DECF, popGet(AOP(result),MSB16));
     }
+  }
 
-    /*  1 <= shCount <= 7 */
-    else
-        shiftR2Left2Result(left, LSB, result, LSB, shCount, sign); 
+  /*  1 <= shCount <= 7 */
+  else
+    shiftR2Left2Result(left, LSB, result, LSB, shCount, sign); 
 }
 
 /*-----------------------------------------------------------------*/
@@ -6853,56 +7459,57 @@ static void shiftRLong (operand *left, int offl,
 static void genrshFour (operand *result, operand *left,
                         int shCount, int sign)
 {
-    DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-    /* if shifting more that 3 bytes */
-    if(shCount >= 24 ) {
-        shCount -= 24;
-        if(shCount)
-            shiftR1Left2Result(left, MSB32, result, LSB, shCount, sign);
-        else
-            movLeft2Result(left, MSB32, result, LSB, sign);
-        addSign(result, MSB16, sign);
+  DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+  /* if shifting more that 3 bytes */
+  if(shCount >= 24 ) {
+    shCount -= 24;
+    if(shCount)
+      shiftR1Left2Result(left, MSB32, result, LSB, shCount, sign);
+    else
+      movLeft2Result(left, MSB32, result, LSB);
+
+    addSign(result, MSB16, sign);
+  }
+  else if(shCount >= 16){
+    shCount -= 16;
+    if(shCount)
+      shiftR2Left2Result(left, MSB24, result, LSB, shCount, sign);
+    else{
+      movLeft2Result(left, MSB24, result, LSB);
+      movLeft2Result(left, MSB32, result, MSB16);
     }
-    else if(shCount >= 16){
-        shCount -= 16;
-        if(shCount)
-            shiftR2Left2Result(left, MSB24, result, LSB, shCount, sign);
-        else{
-            movLeft2Result(left, MSB24, result, LSB, 0);
-            movLeft2Result(left, MSB32, result, MSB16, sign);
-        }
-        addSign(result, MSB24, sign);
+    addSign(result, MSB24, sign);
+  }
+  else if(shCount >= 8){
+    shCount -= 8;
+    if(shCount == 1)
+      shiftRLong(left, MSB16, result, sign);
+    else if(shCount == 0){
+      movLeft2Result(left, MSB16, result, LSB);
+      movLeft2Result(left, MSB24, result, MSB16);
+      movLeft2Result(left, MSB32, result, MSB24);
+      addSign(result, MSB32, sign);
     }
-    else if(shCount >= 8){
-        shCount -= 8;
-        if(shCount == 1)
-            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);
-        }
-        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);
-        }
+    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);
     }
-    else{   /* 1 <= shCount <= 7 */
-        if(shCount <= 2){
-            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);
-        }
+  }
+  else{   /* 1 <= shCount <= 7 */
+    if(shCount <= 2){
+      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);
     }
+  }
 }
 
 /*-----------------------------------------------------------------*/
@@ -6914,55 +7521,75 @@ static void genRightShiftLiteral (operand *left,
                                   iCode *ic,
                                   int sign)
 {    
-    int shCount = (int) floatFromVal (AOP(right)->aopu.aop_lit);
-    int size;
+  int shCount = (int) floatFromVal (AOP(right)->aopu.aop_lit);
+  int lsize,res_size;
 
-    DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-    freeAsmop(right,NULL,ic,TRUE);
+  DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+  freeAsmop(right,NULL,ic,TRUE);
 
-    aopOp(left,ic,FALSE);
-    aopOp(result,ic,FALSE);
+  aopOp(left,ic,FALSE);
+  aopOp(result,ic,FALSE);
 
 #if VIEW_SIZE
-    pic14_emitcode("; shift right ","result %d, left %d",AOP_SIZE(result),
-             AOP_SIZE(left));
+  pic14_emitcode("; shift right ","result %d, left %d",AOP_SIZE(result),
+		 AOP_SIZE(left));
 #endif
 
-    size = pic14_getDataSize(left);
-    /* test the LEFT size !!! */
+  lsize = pic14_getDataSize(left);
+  res_size = pic14_getDataSize(result);
+  /* test the LEFT size !!! */
 
-    /* I suppose that the left size >= result size */
-    if(shCount == 0){
-        size = pic14_getDataSize(result);
-        while(size--)
-            movLeft2Result(left, size, result, size, 0);
-    }
+  /* I suppose that the left size >= result size */
+  if(shCount == 0){
+    while(res_size--)
+      movLeft2Result(left, lsize, result, res_size);
+  }
 
-    else if(shCount >= (size * 8)){
-        if(sign)
-            /* get sign in acc.7 */
-            MOVA(aopGet(AOP(left),size-1,FALSE,FALSE));
-        addSign(result, LSB, sign);
-    } else{
-        switch (size) {
-            case 1:
-                genrshOne (result,left,shCount,sign);
-                break;
+  else if(shCount >= (lsize * 8)){
 
-            case 2:
-                genrshTwo (result,left,shCount,sign);
-                break;
+    if(res_size == 1) {
+      emitpcode(POC_CLRF, popGet(AOP(result),LSB));
+      if(sign) {
+	emitpcode(POC_BTFSC,newpCodeOpBit(aopGet(AOP(left),lsize-1,FALSE,FALSE),7,0));
+	emitpcode(POC_DECF, popGet(AOP(result),LSB));
+      }
+    } else {
 
-            case 4:
-                genrshFour (result,left,shCount,sign);
-                break;
-            default :
-                break;
-        }
+      if(sign) {
+	emitpcode(POC_MOVLW, popGetLit(0));
+	emitpcode(POC_BTFSC, newpCodeOpBit(aopGet(AOP(left),lsize-1,FALSE,FALSE),7,0));
+	emitpcode(POC_MOVLW, popGetLit(0xff));
+	while(res_size--)
+	  emitpcode(POC_MOVWF, popGet(AOP(result),res_size));
+
+      } else {
+
+	while(res_size--)
+	  emitpcode(POC_CLRF, popGet(AOP(result),res_size));
+      }
+    }
+  } else {
+
+    switch (res_size) {
+    case 1:
+      genrshOne (result,left,shCount,sign);
+      break;
+
+    case 2:
+      genrshTwo (result,left,shCount,sign);
+      break;
 
-        freeAsmop(left,NULL,ic,TRUE);
-        freeAsmop(result,NULL,ic,TRUE);
+    case 4:
+      genrshFour (result,left,shCount,sign);
+      break;
+    default :
+      break;
     }
+
+  }
+
+  freeAsmop(left,NULL,ic,TRUE);
+  freeAsmop(result,NULL,ic,TRUE);
 }
 
 /*-----------------------------------------------------------------*/
@@ -6970,97 +7597,140 @@ static void genRightShiftLiteral (operand *left,
 /*-----------------------------------------------------------------*/
 static void genSignedRightShift (iCode *ic)
 {
-    operand *right, *left, *result;
-    int size, offset;
-    char *l;
-    symbol *tlbl, *tlbl1 ;
+  operand *right, *left, *result;
+  int size, offset;
+  //  char *l;
+  symbol *tlbl, *tlbl1 ;
+  pCodeOp *pctemp;
 
-    /* we do it the hard way put the shift count in b
-    and loop thru preserving the sign */
-    DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+  //same = ((left == result) || (AOP(left) == AOP(result))) && (offl == offr);
 
-    right = IC_RIGHT(ic);
-    left  = IC_LEFT(ic);
-    result = IC_RESULT(ic);
+  /* we do it the hard way put the shift count in b
+     and loop thru preserving the sign */
+  DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
 
-    aopOp(right,ic,FALSE);  
+  right = IC_RIGHT(ic);
+  left  = IC_LEFT(ic);
+  result = IC_RESULT(ic);
+
+  aopOp(right,ic,FALSE);  
+  aopOp(left,ic,FALSE);
+  aopOp(result,ic,FALSE);
 
 
-    if ( AOP_TYPE(right) == AOP_LIT) {
-	genRightShiftLiteral (left,right,result,ic,1);
-	return ;
+  if ( AOP_TYPE(right) == AOP_LIT) {
+    genRightShiftLiteral (left,right,result,ic,1);
+    return ;
+  }
+  /* shift count is unknown then we have to form 
+     a loop get the loop count in B : Note: we take
+     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 ) */  
+
+  //pic14_emitcode("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE));
+  //pic14_emitcode("inc","b");
+  //freeAsmop (right,NULL,ic,TRUE);
+  //aopOp(left,ic,FALSE);
+  //aopOp(result,ic,FALSE);
+
+  /* now move the left to the result if they are not the
+     same */
+  if (!pic14_sameRegs(AOP(left),AOP(result)) && 
+      AOP_SIZE(result) > 1) {
+
+    size = AOP_SIZE(result);
+    offset=0;
+    while (size--) { 
+      /*
+	l = aopGet(AOP(left),offset,FALSE,TRUE);
+	if (*l == '@' && IS_AOP_PREG(result)) {
+
+	pic14_emitcode("mov","a,%s",l);
+	aopPut(AOP(result),"a",offset);
+	} else
+	aopPut(AOP(result),l,offset);
+      */
+      emitpcode(POC_MOVFW,  popGet(AOP(left),offset));
+      emitpcode(POC_MOVWF,  popGet(AOP(result),offset));
+
+      offset++;
     }
-        /* shift count is unknown then we have to form 
-       a loop get the loop count in B : Note: we take
-       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 ) */  
+  }
 
-    pic14_emitcode("mov","b,%s",aopGet(AOP(right),0,FALSE,FALSE));
-    pic14_emitcode("inc","b");
-    freeAsmop (right,NULL,ic,TRUE);
-    aopOp(left,ic,FALSE);
-    aopOp(result,ic,FALSE);
+  /* mov the highest order bit to OVR */    
+  tlbl = newiTempLabel(NULL);
+  tlbl1= newiTempLabel(NULL);
 
-    /* now move the left to the result if they are not the
-    same */
-    if (!pic14_sameRegs(AOP(left),AOP(result)) && 
-        AOP_SIZE(result) > 1) {
+  size = AOP_SIZE(result);
+  offset = size - 1;
 
-        size = AOP_SIZE(result);
-        offset=0;
-        while (size--) {
-            l = aopGet(AOP(left),offset,FALSE,TRUE);
-            if (*l == '@' && IS_AOP_PREG(result)) {
+  pctemp = popGetTempReg();  /* grab a temporary working register. */
 
-                pic14_emitcode("mov","a,%s",l);
-                aopPut(AOP(result),"a",offset);
-            } else
-                aopPut(AOP(result),l,offset);
-            offset++;
-        }
-    }
+  emitpcode(POC_MOVFW, popGet(AOP(right),0));
 
-    /* mov the highest order bit to OVR */    
-    tlbl = newiTempLabel(NULL);
-    tlbl1= newiTempLabel(NULL);
+  /* offset should be 0, 1 or 3 */
+  emitpcode(POC_ANDLW, popGetLit(0x07 + ((offset&3) << 3)));
+  emitSKPNZ;
+  emitpcode(POC_GOTO,  popGetLabel(tlbl1->key));
 
-    size = AOP_SIZE(result);
-    offset = size - 1;
-    pic14_emitcode("mov","a,%s",aopGet(AOP(left),offset,FALSE,FALSE));
-    pic14_emitcode("rlc","a");
-    pic14_emitcode("mov","ov,c");
-    /* if it is only one byte then */
-    if (size == 1) {
-        l = aopGet(AOP(left),0,FALSE,FALSE);
-        MOVA(l);
-	pic14_emitcode("sjmp","%05d_DS_",tlbl1->key+100);
-        pic14_emitcode("","%05d_DS_:",tlbl->key+100);
-        pic14_emitcode("mov","c,ov");
-        pic14_emitcode("rrc","a");
-	pic14_emitcode("","%05d_DS_:",tlbl1->key+100);
-        pic14_emitcode("djnz","b,%05d_DS_",tlbl->key+100);
-        aopPut(AOP(result),"a",0);
-        goto release ;
-    }
+  emitpcode(POC_MOVWF, pctemp);
 
-    reAdjustPreg(AOP(result));
+
+  emitpLabel(tlbl->key);
+
+  emitpcode(POC_RLFW,  popGet(AOP(result),offset));
+  emitpcode(POC_RRF,   popGet(AOP(result),offset));
+
+  while(--size) {
+    emitpcode(POC_RRF,   popGet(AOP(result),--offset));
+  }
+
+  emitpcode(POC_DECFSZ,  pctemp);
+  emitpcode(POC_GOTO,popGetLabel(tlbl->key));
+  emitpLabel(tlbl1->key);
+
+  popReleaseTempReg(pctemp);
+#if 0
+  size = AOP_SIZE(result);
+  offset = size - 1;
+  pic14_emitcode("mov","a,%s",aopGet(AOP(left),offset,FALSE,FALSE));
+  pic14_emitcode("rlc","a");
+  pic14_emitcode("mov","ov,c");
+  /* if it is only one byte then */
+  if (size == 1) {
+    l = aopGet(AOP(left),0,FALSE,FALSE);
+    MOVA(l);
     pic14_emitcode("sjmp","%05d_DS_",tlbl1->key+100);
-    pic14_emitcode("","%05d_DS_:",tlbl->key+100);    
-    pic14_emitcode("mov","c,ov");
-    while (size--) {
-        l = aopGet(AOP(result),offset,FALSE,FALSE);
-        MOVA(l);
-        pic14_emitcode("rrc","a");         
-        aopPut(AOP(result),"a",offset--);
-    }
-    reAdjustPreg(AOP(result));
+    pic14_emitcode("","%05d_DS_:",tlbl->key+100);
+    pic14_emitcode("mov","c,ov");
+    pic14_emitcode("rrc","a");
     pic14_emitcode("","%05d_DS_:",tlbl1->key+100);
     pic14_emitcode("djnz","b,%05d_DS_",tlbl->key+100);
+    aopPut(AOP(result),"a",0);
+    goto release ;
+  }
 
-release:
-    freeAsmop(left,NULL,ic,TRUE);
-    freeAsmop(result,NULL,ic,TRUE);
+  reAdjustPreg(AOP(result));
+  pic14_emitcode("sjmp","%05d_DS_",tlbl1->key+100);
+  pic14_emitcode("","%05d_DS_:",tlbl->key+100);    
+  pic14_emitcode("mov","c,ov");
+  while (size--) {
+    l = aopGet(AOP(result),offset,FALSE,FALSE);
+    MOVA(l);
+    pic14_emitcode("rrc","a");         
+    aopPut(AOP(result),"a",offset--);
+  }
+  reAdjustPreg(AOP(result));
+  pic14_emitcode("","%05d_DS_:",tlbl1->key+100);
+  pic14_emitcode("djnz","b,%05d_DS_",tlbl->key+100);
+
+ release:
+#endif
+
+  freeAsmop(left,NULL,ic,TRUE);
+  freeAsmop(result,NULL,ic,TRUE);
+  freeAsmop(right,NULL,ic,TRUE);
 }
 
 /*-----------------------------------------------------------------*/
@@ -7141,32 +7811,22 @@ static void genRightShift (iCode *ic)
 
     /* if it is only one byte then */
     if (size == 1) {
-/*
-        l = aopGet(AOP(left),0,FALSE,FALSE);
-        MOVA(l);
-	pic14_emitcode("sjmp","%05d_DS_",tlbl1->key+100);
-        pic14_emitcode("","%05d_DS_:",tlbl->key+100);
-        CLRC;
-        pic14_emitcode("rrc","a");
-	pic14_emitcode("","%05d_DS_:",tlbl1->key+100);
-        pic14_emitcode("djnz","b,%05d_DS_",tlbl->key+100);
-        aopPut(AOP(result),"a",0);
-*/
-	tlbl = newiTempLabel(NULL);
-	if (!pic14_sameRegs(AOP(left),AOP(result))) {
-	  emitpcode(POC_MOVFW,  popGet(AOP(left),0));
-	  emitpcode(POC_MOVWF,  popGet(AOP(result),0));
-	}
 
-	emitpcode(POC_COMFW,  popGet(AOP(right),0));
-	emitpcode(POC_RLF,    popGet(AOP(result),0));
-	emitpLabel(tlbl->key);
-	emitpcode(POC_RRF,    popGet(AOP(result),0));
-	emitpcode(POC_ADDLW,  popGetLit(1));
-	emitSKPC;
-	emitpcode(POC_GOTO,popGetLabel(tlbl->key));
+      tlbl = newiTempLabel(NULL);
+      if (!pic14_sameRegs(AOP(left),AOP(result))) {
+	emitpcode(POC_MOVFW,  popGet(AOP(left),0));
+	emitpcode(POC_MOVWF,  popGet(AOP(result),0));
+      }
 
-        goto release ;
+      emitpcode(POC_COMFW,  popGet(AOP(right),0));
+      emitpcode(POC_RLF,    popGet(AOP(result),0));
+      emitpLabel(tlbl->key);
+      emitpcode(POC_RRF,    popGet(AOP(result),0));
+      emitpcode(POC_ADDLW,  popGetLit(1));
+      emitSKPC;
+      emitpcode(POC_GOTO,popGetLabel(tlbl->key));
+
+      goto release ;
     }
 
     reAdjustPreg(AOP(result));
@@ -7296,7 +7956,7 @@ static void genUnpackBits (operand *result, char *rname, int ptype)
     return ;
 }
 
-
+#if 0
 /*-----------------------------------------------------------------*/
 /* genDataPointerGet - generates code when ptr offset is known     */
 /*-----------------------------------------------------------------*/
@@ -7317,6 +7977,8 @@ static void genDataPointerGet (operand *left,
 
   aopOp(result,ic,TRUE);
 
+  DEBUGpic14_AopType(__LINE__,left,NULL,result);
+
   emitpcode(POC_MOVFW, popGet(AOP(left),0));
 
   size = AOP_SIZE(result);
@@ -7329,7 +7991,7 @@ static void genDataPointerGet (operand *left,
   freeAsmop(left,NULL,ic,TRUE);
   freeAsmop(result,NULL,ic,TRUE);
 }
-
+#endif
 /*-----------------------------------------------------------------*/
 /* genNearPointerGet - pic14_emitcode for near pointer fetch             */
 /*-----------------------------------------------------------------*/
@@ -7338,11 +8000,11 @@ static void genNearPointerGet (operand *left,
 			       iCode *ic)
 {
     asmop *aop = NULL;
-    regs *preg = NULL ;
+    //regs *preg = NULL ;
     char *rname ;
     sym_link *rtype, *retype;
     sym_link *ltype = operandType(left);    
-    char buffer[80];
+    //char buffer[80];
 
     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
 
@@ -7355,10 +8017,10 @@ static void genNearPointerGet (operand *left,
        result is not bit variable type and
        the left is pointer to data space i.e
        lower 128 bytes of space */
-    if (AOP_TYPE(left) == AOP_IMMD &&
+    if (AOP_TYPE(left) == AOP_PCODE &&  //AOP_TYPE(left) == AOP_IMMD &&
 	!IS_BITVAR(retype)         &&
 	DCL_TYPE(ltype) == POINTER) {
-	genDataPointerGet (left,result,ic);
+      //genDataPointerGet (left,result,ic);
 	return ;
     }
     
@@ -7369,16 +8031,18 @@ static void genNearPointerGet (operand *left,
     if (!AOP_INPREG(AOP(left))) {
 	/* otherwise get a free pointer register */
     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+/*
 	aop = newAsmop(0);
 	preg = getFreePtr(ic,&aop,FALSE);
 	pic14_emitcode("mov","%s,%s",
 		preg->name,
 		aopGet(AOP(left),0,FALSE,TRUE));
 	rname = preg->name ;
+*/
+    rname ="BAD";
     } else
 	rname = aopGet(AOP(left),0,FALSE,FALSE);
     
-    freeAsmop(left,NULL,ic,TRUE);
     aopOp (result,ic,FALSE);
     
       /* if bitfield then unpack the bits */
@@ -7386,10 +8050,20 @@ static void genNearPointerGet (operand *left,
 	genUnpackBits (result,rname,POINTER);
     else {
 	/* we have can just get the values */
-	int size = AOP_SIZE(result);
-	int offset = 0 ;	
+      int size = AOP_SIZE(result);
+      int offset = 0 ;	
 	
-    DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+      DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+
+      emitpcode(POC_MOVFW,popGet(AOP(left),0));
+      emitpcode(POC_MOVWF,popCopyReg(&pc_fsr));
+      while(size--) {
+	emitpcode(POC_MOVFW,popCopyReg(&pc_indf));
+	emitpcode(POC_MOVWF,popGet(AOP(result),offset++));
+	if(size)
+	  emitpcode(POC_INCF,popCopyReg(&pc_fsr));
+      }
+/*
 	while (size--) {
 	    if (IS_AOP_PREG(result) || AOP_TYPE(result) == AOP_STK ) {
 
@@ -7403,6 +8077,7 @@ static void genNearPointerGet (operand *left,
 	    if (size)
 		pic14_emitcode("inc","%s",rname);
 	}
+*/
     }
 
     /* now some housekeeping stuff */
@@ -7428,6 +8103,7 @@ static void genNearPointerGet (operand *left,
     }
 
     /* done */
+    freeAsmop(left,NULL,ic,TRUE);
     freeAsmop(result,NULL,ic,TRUE);
      
 }
@@ -7562,11 +8238,11 @@ static void genFarPointerGet (operand *left,
 
     freeAsmop(result,NULL,ic,TRUE);
 }
-
+#if 0
 /*-----------------------------------------------------------------*/
-/* pic14_emitcodePointerGet - gget value from code space                  */
+/* genCodePointerGet - get value from code space                  */
 /*-----------------------------------------------------------------*/
-static void pic14_emitcodePointerGet (operand *left,
+static void genCodePointerGet (operand *left,
                                 operand *result, iCode *ic)
 {
     int size, offset ;
@@ -7613,7 +8289,7 @@ static void pic14_emitcodePointerGet (operand *left,
 
     freeAsmop(result,NULL,ic,TRUE);
 }
-
+#endif
 /*-----------------------------------------------------------------*/
 /* genGenPointerGet - gget value from generic pointer space        */
 /*-----------------------------------------------------------------*/
@@ -7632,7 +8308,7 @@ static void genGenPointerGet (operand *left,
 
   /* if the operand is already in dptr 
      then we do nothing else we move the value to dptr */
-  if (AOP_TYPE(left) != AOP_STR) {
+  //  if (AOP_TYPE(left) != AOP_STR) {
     /* if this is remateriazable */
     if (AOP_TYPE(left) == AOP_IMMD) {
       pic14_emitcode("mov","dptr,%s",aopGet(AOP(left),0,TRUE,FALSE));
@@ -7654,12 +8330,12 @@ static void genGenPointerGet (operand *left,
       }
       goto release;
     }
-  }
+    //}
   /* so dptr know contains the address */
 
   /* if bit then unpack */
-  if (IS_BITVAR(retype)) 
-    genUnpackBits(result,"dptr",GPOINTER);
+  //if (IS_BITVAR(retype)) 
+  //  genUnpackBits(result,"dptr",GPOINTER);
 
  release:
   freeAsmop(left,NULL,ic,TRUE);
@@ -7667,6 +8343,46 @@ static void genGenPointerGet (operand *left,
 
 }
 
+/*-----------------------------------------------------------------*/
+/* genConstPointerGet - get value from const generic pointer space */
+/*-----------------------------------------------------------------*/
+static void genConstPointerGet (operand *left,
+				operand *result, iCode *ic)
+{
+  //sym_link *retype = getSpec(operandType(result));
+  symbol *albl = newiTempLabel(NULL);
+  symbol *blbl = newiTempLabel(NULL);
+  PIC_OPCODE poc;
+
+  DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+  aopOp(left,ic,FALSE);
+  aopOp(result,ic,FALSE);
+
+
+  DEBUGpic14_AopType(__LINE__,left,NULL,result);
+
+  DEBUGpic14_emitcode ("; "," %d getting const pointer",__LINE__);
+
+  emitpcode(POC_CALL,popGetLabel(albl->key));
+  emitpcode(POC_GOTO,popGetLabel(blbl->key));
+  emitpLabel(albl->key);
+
+  poc = ( (AOP_TYPE(left) == AOP_PCODE) ? POC_MOVLW : POC_MOVFW);
+    
+  emitpcode(poc,popGet(AOP(left),1));
+  emitpcode(POC_MOVWF,popCopyReg(&pc_pclath));
+  emitpcode(poc,popGet(AOP(left),0));
+  emitpcode(POC_MOVWF,popCopyReg(&pc_pcl));
+
+  emitpLabel(blbl->key);
+
+  emitpcode(POC_MOVWF,popGet(AOP(result),0));
+
+
+  freeAsmop(left,NULL,ic,TRUE);
+  freeAsmop(result,NULL,ic,TRUE);
+
+}
 /*-----------------------------------------------------------------*/
 /* genPointerGet - generate code for pointer get                   */
 /*-----------------------------------------------------------------*/
@@ -7685,6 +8401,10 @@ static void genPointerGet (iCode *ic)
     move it to the correct pointer register */
     type = operandType(left);
     etype = getSpec(type);
+
+    if (IS_PTR_CONST(type))
+      DEBUGpic14_emitcode ("; ***","%d - const pointer",__LINE__);
+
     /* if left is of type of pointer then it is simple */
     if (IS_PTR(type) && !IS_FUNC(type->next)) 
         p_type = DCL_TYPE(type);
@@ -7692,19 +8412,26 @@ static void genPointerGet (iCode *ic)
 	/* we have to go by the storage class */
 	p_type = PTR_TYPE(SPEC_OCLS(etype));
 
-/* 	if (SPEC_OCLS(etype)->codesp ) { */
-/* 	    p_type = CPOINTER ;	 */
-/* 	} */
-/* 	else */
-/* 	    if (SPEC_OCLS(etype)->fmap && !SPEC_OCLS(etype)->paged) */
-/* 		p_type = FPOINTER ; */
-/* 	    else */
-/* 		if (SPEC_OCLS(etype)->fmap && SPEC_OCLS(etype)->paged) */
+	DEBUGpic14_emitcode ("; ***","%d - resolve pointer by storage class",__LINE__);
+
+	if (SPEC_OCLS(etype)->codesp ) {
+	  DEBUGpic14_emitcode ("; ***","%d - cpointer",__LINE__);
+	  //p_type = CPOINTER ;	
+	}
+	else
+	    if (SPEC_OCLS(etype)->fmap && !SPEC_OCLS(etype)->paged)
+	      DEBUGpic14_emitcode ("; ***","%d - fpointer",__LINE__);
+	       /*p_type = FPOINTER ;*/ 
+	    else
+		if (SPEC_OCLS(etype)->fmap && SPEC_OCLS(etype)->paged)
+		  DEBUGpic14_emitcode ("; ***","%d - ppointer",__LINE__);
 /* 		    p_type = PPOINTER; */
-/* 		else */
-/* 		    if (SPEC_OCLS(etype) == idata ) */
+		else
+		    if (SPEC_OCLS(etype) == idata )
+		      DEBUGpic14_emitcode ("; ***","%d - ipointer",__LINE__);
 /* 			p_type = IPOINTER; */
-/* 		    else */
+		    else
+		      DEBUGpic14_emitcode ("; ***","%d - pointer",__LINE__);
 /* 			p_type = POINTER ; */
     }
 
@@ -7726,12 +8453,16 @@ static void genPointerGet (iCode *ic)
 	break;
 
     case CPOINTER:
-	pic14_emitcodePointerGet (left,result,ic);
+	genConstPointerGet (left,result,ic);
+	//pic14_emitcodePointerGet (left,result,ic);
 	break;
 
     case GPOINTER:
+      if (IS_PTR_CONST(type))
+	genConstPointerGet (left,result,ic);
+      else
 	genGenPointerGet (left,result,ic);
-	break;
+      break;
     }
 
 }
@@ -7908,12 +8639,21 @@ static void genDataPointerSet(operand *right,
     
     l = aopGet(AOP(result),0,FALSE,TRUE);
     size = AOP_SIZE(right);
+/*
+    if ( AOP_TYPE(result) == AOP_PCODE) {
+      fprintf(stderr,"genDataPointerSet   %s, %d\n",
+	      AOP(result)->aopu.pcop->name,
+	      PCOI(AOP(result)->aopu.pcop)->offset);
+    }
+*/
+
     // tsd, was l+1 - the underline `_' prefix was being stripped
     while (size--) {
-	if (offset)
-	    sprintf(buffer,"(%s + %d)",l,offset);
-	else
-	    sprintf(buffer,"%s",l);
+      if (offset) {
+	sprintf(buffer,"(%s + %d)",l,offset);
+	fprintf(stderr,"oops  %s\n",buffer);
+      } else
+	sprintf(buffer,"%s",l);
 
 	if (AOP_TYPE(right) == AOP_LIT) {
 	  unsigned int lit = (unsigned int) floatFromVal (AOP(IC_RIGHT(ic))->aopu.aop_lit);
@@ -7923,18 +8663,21 @@ static void genDataPointerSet(operand *right,
 	    pic14_emitcode("movwf","%s",buffer);
 
 	    emitpcode(POC_MOVLW, popGetLit(lit&0xff));
-	    emitpcode(POC_MOVWF, popRegFromString(buffer));
+	    //emitpcode(POC_MOVWF, popRegFromString(buffer));
+	    emitpcode(POC_MOVWF, popGet(AOP(result),0));
 
 	  } else {
 	    pic14_emitcode("clrf","%s",buffer);
-	    emitpcode(POC_CLRF, popRegFromString(buffer));
+	    //emitpcode(POC_CLRF, popRegFromString(buffer));
+	    emitpcode(POC_CLRF, popGet(AOP(result),0));
 	  }
 	}else {
 	  pic14_emitcode("movf","%s,w",aopGet(AOP(right),offset,FALSE,FALSE));
 	  pic14_emitcode("movwf","%s",buffer);
 
 	  emitpcode(POC_MOVFW, popGet(AOP(right),offset));
-	  emitpcode(POC_MOVWF, popRegFromString(buffer));
+	  //emitpcode(POC_MOVWF, popRegFromString(buffer));
+	  emitpcode(POC_MOVWF, popGet(AOP(result),0));
 
 	}
 
@@ -7952,116 +8695,124 @@ static void genNearPointerSet (operand *right,
                                operand *result, 
                                iCode *ic)
 {
-    asmop *aop = NULL;
-    char *l;
-    sym_link *retype;
-    sym_link *ptype = operandType(result);
+  asmop *aop = NULL;
+  char *l;
+  sym_link *retype;
+  sym_link *ptype = operandType(result);
 
     
-    DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-    retype= getSpec(operandType(right));
+  DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+  retype= getSpec(operandType(right));
+
+  aopOp(result,ic,FALSE);
 
-    aopOp(result,ic,FALSE);
     
-    /* if the result is rematerializable &
-       in data space & not a bit variable */
-    if (AOP_TYPE(result) == AOP_IMMD &&
-	DCL_TYPE(ptype) == POINTER   &&
-	!IS_BITVAR(retype)) {
-	genDataPointerSet (right,result,ic);
-	return;
-    }
+  /* if the result is rematerializable &
+     in data space & not a bit variable */
+  //if (AOP_TYPE(result) == AOP_IMMD &&
+  if (AOP_TYPE(result) == AOP_PCODE &&  //AOP_TYPE(result) == AOP_IMMD &&
+      DCL_TYPE(ptype) == POINTER   &&
+      !IS_BITVAR(retype)) {
+    genDataPointerSet (right,result,ic);
+    freeAsmop(result,NULL,ic,TRUE);
+    return;
+  }
+
+  DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+  aopOp(right,ic,FALSE);
+  DEBUGpic14_AopType(__LINE__,NULL,right,result);
 
+  /* if the value is already in a pointer register
+     then don't need anything more */
+  if (!AOP_INPREG(AOP(result))) {
+    /* otherwise get a free pointer register */
+    //aop = newAsmop(0);
+    //preg = getFreePtr(ic,&aop,FALSE);
     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+    //pic14_emitcode("mov","%s,%s",
+    //         preg->name,
+    //         aopGet(AOP(result),0,FALSE,TRUE));
+    //rname = preg->name ;
+    //pic14_emitcode("movwf","fsr");
+    emitpcode(POC_MOVFW, popGet(AOP(result),0));
+    emitpcode(POC_MOVWF, popCopyReg(&pc_fsr));
+    emitpcode(POC_MOVFW, popGet(AOP(right),0));
+    emitpcode(POC_MOVWF, popCopyReg(&pc_indf));
+    goto release;
 
-    /* if the value is already in a pointer register
-    then don't need anything more */
-    if (!AOP_INPREG(AOP(result))) {
-        /* otherwise get a free pointer register */
-        //aop = newAsmop(0);
-        //preg = getFreePtr(ic,&aop,FALSE);
-	DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-	//pic14_emitcode("mov","%s,%s",
-        //         preg->name,
-        //         aopGet(AOP(result),0,FALSE,TRUE));
-        //rname = preg->name ;
-	pic14_emitcode("movwf","fsr");
-    }// else
-    //   rname = aopGet(AOP(result),0,FALSE,FALSE);
+  }// else
+  //   rname = aopGet(AOP(result),0,FALSE,FALSE);
 
-    freeAsmop(result,NULL,ic,TRUE);
-    aopOp (right,ic,FALSE);
-    DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
 
-    /* if bitfield then unpack the bits */
-    if (IS_BITVAR(retype)) {
-      werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
-	     "The programmer is obviously confused");
-      //genPackBits (retype,right,rname,POINTER);
-      exit(1);
-    }
-    else {
-        /* we have can just get the values */
-        int size = AOP_SIZE(right);
-        int offset = 0 ;    
+  /* if bitfield then unpack the bits */
+  if (IS_BITVAR(retype)) {
+    werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
+	   "The programmer is obviously confused");
+    //genPackBits (retype,right,rname,POINTER);
+    exit(1);
+  }
+  else {
+    /* we have can just get the values */
+    int size = AOP_SIZE(right);
+    int offset = 0 ;    
 
     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-        while (size--) {
-            l = aopGet(AOP(right),offset,FALSE,TRUE);
-            if (*l == '@' ) {
-	      //MOVA(l);
-	      //pic14_emitcode("mov","@%s,a",rname);
-	      pic14_emitcode("movf","indf,w ;1");
-            } else {
+    while (size--) {
+      l = aopGet(AOP(right),offset,FALSE,TRUE);
+      if (*l == '@' ) {
+	//MOVA(l);
+	//pic14_emitcode("mov","@%s,a",rname);
+	pic14_emitcode("movf","indf,w ;1");
+      } else {
 
-	      if (AOP_TYPE(right) == AOP_LIT) {
-		unsigned int lit = (unsigned int) floatFromVal (AOP(IC_RIGHT(ic))->aopu.aop_lit);
-		if(lit) {
-		  pic14_emitcode("movlw","%s",l);
-		  pic14_emitcode("movwf","indf ;2");
-		} else 
-		  pic14_emitcode("clrf","indf");
-	      }else {
-		pic14_emitcode("movf","%s,w",l);
-		pic14_emitcode("movwf","indf ;2");
-	      }
-	    //pic14_emitcode("mov","@%s,%s",rname,l);
-	    }
-            if (size)
-	      pic14_emitcode("incf","fsr,f ;3");
-	    //pic14_emitcode("inc","%s",rname);
-            offset++;
-        }
+	if (AOP_TYPE(right) == AOP_LIT) {
+	  unsigned int lit = (unsigned int) floatFromVal (AOP(IC_RIGHT(ic))->aopu.aop_lit);
+	  if(lit) {
+	    pic14_emitcode("movlw","%s",l);
+	    pic14_emitcode("movwf","indf ;2");
+	  } else 
+	    pic14_emitcode("clrf","indf");
+	}else {
+	  pic14_emitcode("movf","%s,w",l);
+	  pic14_emitcode("movwf","indf ;2");
+	}
+	//pic14_emitcode("mov","@%s,%s",rname,l);
+      }
+      if (size)
+	pic14_emitcode("incf","fsr,f ;3");
+      //pic14_emitcode("inc","%s",rname);
+      offset++;
     }
+  }
 
+  DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+  /* now some housekeeping stuff */
+  if (aop) {
+    /* we had to allocate for this iCode */
+    freeAsmop(NULL,aop,ic,TRUE);
+  } else { 
+    /* we did not allocate which means left
+       already in a pointer register, then
+       if size > 0 && this could be used again
+       we have to point it back to where it 
+       belongs */
     DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-    /* now some housekeeping stuff */
-    if (aop) {
-        /* we had to allocate for this iCode */
-        freeAsmop(NULL,aop,ic,TRUE);
-    } else { 
-        /* we did not allocate which means left
-        already in a pointer register, then
-        if size > 0 && this could be used again
-        we have to point it back to where it 
-        belongs */
-    DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-        if (AOP_SIZE(right) > 1 &&
-            !OP_SYMBOL(result)->remat &&
-            ( OP_SYMBOL(result)->liveTo > ic->seq ||
-              ic->depth )) {
-            int size = AOP_SIZE(right) - 1;
-            while (size--)
-	      pic14_emitcode("decf","fsr,f");
-	      //pic14_emitcode("dec","%s",rname);
-        }
+    if (AOP_SIZE(right) > 1 &&
+	!OP_SYMBOL(result)->remat &&
+	( OP_SYMBOL(result)->liveTo > ic->seq ||
+	  ic->depth )) {
+      int size = AOP_SIZE(right) - 1;
+      while (size--)
+	pic14_emitcode("decf","fsr,f");
+      //pic14_emitcode("dec","%s",rname);
     }
+  }
 
-    DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-    /* done */
-    freeAsmop(right,NULL,ic,TRUE);
-
-
+  DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+  /* done */
+ release:
+  freeAsmop(right,NULL,ic,TRUE);
+  freeAsmop(result,NULL,ic,TRUE);
 }
 
 /*-----------------------------------------------------------------*/
@@ -8228,9 +8979,17 @@ static void genGenPointerSet (operand *right,
       /* hack hack! see if this the FSR. If so don't load W */
       if(AOP_TYPE(right) != AOP_ACC) {
 
+
 	emitpcode(POC_MOVFW,popGet(AOP(result),0));
 	emitpcode(POC_MOVWF,popCopyReg(&pc_fsr));
 
+	if(AOP_SIZE(result) > 1) {
+	  emitpcode(POC_BCF,  popCopyGPR2Bit(PCOP(&pc_status),PIC_IRP_BIT));
+	  emitpcode(POC_BTFSC,newpCodeOpBit(aopGet(AOP(result),1,FALSE,FALSE),0,0));
+	  emitpcode(POC_BSF,  popCopyGPR2Bit(PCOP(&pc_status),PIC_IRP_BIT));
+
+	}
+
 	//if(size==2)
 	//emitpcode(POC_DECF,popCopyReg(&pc_fsr));
 	//if(size==4) {
@@ -8271,16 +9030,21 @@ static void genGenPointerSet (operand *right,
     size = AOP_SIZE(right);
     offset = 0 ;
 
-    while (--size) {
-      //char *l = aopGet(AOP(right),offset++,FALSE,FALSE);
-      if(size)
-	pic14_emitcode("incf","fsr,f");
-      pic14_emitcode("movf","%s,w",aopGet(AOP(right),offset++,FALSE,FALSE));
-      pic14_emitcode("movwf","indf");
-      //MOVA(l);
-      //DEBUGpic14_emitcode(";lcall","__gptrput");
-      //if (size)
-      //    pic14_emitcode("inc","dptr");
+  DEBUGpic14_emitcode ("; ***","%s  %d size=%d",__FUNCTION__,__LINE__,size);
+
+    while (size--) {
+
+      emitpcode(POC_MOVFW,popGet(AOP(result),offset));
+      emitpcode(POC_MOVWF,popCopyReg(&pc_fsr));
+
+      if (AOP_TYPE(right) == AOP_LIT) 
+	emitpcode(POC_MOVLW, popGet(AOP(right),offset));
+      else
+	emitpcode(POC_MOVFW, popGet(AOP(right),offset));
+
+      emitpcode(POC_MOVWF,popCopyReg(&pc_indf));
+
+      offset++;
     }
   }
 
@@ -8351,8 +9115,11 @@ static void genPointerSet (iCode *ic)
     case GPOINTER:
 	genGenPointerSet (right,result,ic);
 	break;
-    }
 
+    default:
+      werror (E_INTERNAL_ERROR, __FILE__, __LINE__, 
+	      "genPointerSet: illegal pointer type");
+    }
 }
 
 /*-----------------------------------------------------------------*/
@@ -8400,9 +9167,8 @@ static void genIfx (iCode *ic, iCode *popIc)
 /*-----------------------------------------------------------------*/
 static void genAddrOf (iCode *ic)
 {
-  //symbol *sym = OP_SYMBOL(IC_LEFT(ic));
   operand *right, *result, *left;
-  //int size, offset ;
+  int size, offset ;
 
   DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
 
@@ -8415,28 +9181,15 @@ static void genAddrOf (iCode *ic)
 
   DEBUGpic14_AopType(__LINE__,left,right,result);
 
-  emitpcode(POC_MOVLW, popGet(AOP(left),0));
-  emitpcode(POC_MOVWF, popGet(AOP(result),0));
-
-#if 0
-  /* object not on stack then we need the name */
   size = AOP_SIZE(IC_RESULT(ic));
   offset = 0;
 
   while (size--) {
-    char s[SDCC_NAME_MAX];
-    if (offset) 
-      sprintf(s,"#(%s >> %d)",
-	      sym->rname,
-	      offset*8);
-    else
-      sprintf(s,"#%s",sym->rname);
-    aopPut(AOP(IC_RESULT(ic)),s,offset++);
+    emitpcode(POC_MOVLW, popGet(AOP(left),offset));
+    emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+    offset++;
   }
-#endif
 
-
-  //  freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
   freeAsmop(left,NULL,ic,FALSE);
   freeAsmop(result,NULL,ic,TRUE);
 
@@ -8779,6 +9532,7 @@ static void genCast (iCode *ic)
 {
     operand *result = IC_RESULT(ic);
     sym_link *ctype = operandType(IC_LEFT(ic));
+    sym_link *rtype = operandType(IC_RIGHT(ic));
     operand *right = IC_RIGHT(ic);
     int size, offset ;
 
@@ -8796,6 +9550,7 @@ static void genCast (iCode *ic)
     if (AOP_TYPE(result) == AOP_CRY) {
         /* if the right size is a literal then
         we know what the value is */
+      DEBUGpic14_emitcode("; ***","%s  %d",__FUNCTION__,__LINE__);
         if (AOP_TYPE(right) == AOP_LIT) {
 
 	  emitpcode(  ( ((int) operandLitValue(right)) ? POC_BSF : POC_BCF),
@@ -8842,6 +9597,8 @@ static void genCast (iCode *ic)
       int offset = 1;
       size = AOP_SIZE(result);
 
+      DEBUGpic14_emitcode("; ***","%s  %d",__FUNCTION__,__LINE__);
+
       emitpcode(POC_CLRF,   popGet(AOP(result),0));
       emitpcode(POC_BTFSC,  popGet(AOP(right),0));
       emitpcode(POC_INCF,   popGet(AOP(result),0));
@@ -8856,19 +9613,40 @@ static void genCast (iCode *ic)
     if (AOP_SIZE(result) <= AOP_SIZE(right)) {
 
         /* if they are in the same place */
-        if (pic14_sameRegs(AOP(right),AOP(result)))
-            goto release;
+      if (pic14_sameRegs(AOP(right),AOP(result)))
+	goto release;
+
+      DEBUGpic14_emitcode("; ***","%s  %d",__FUNCTION__,__LINE__);
+      if (IS_PTR_CONST(rtype))
+	DEBUGpic14_emitcode ("; ***","%d - right is const pointer",__LINE__);
+      if (IS_PTR_CONST(operandType(IC_RESULT(ic))))
+	DEBUGpic14_emitcode ("; ***","%d - result is const pointer",__LINE__);
+
+      if ((AOP_TYPE(right) == AOP_PCODE) && AOP(right)->aopu.pcop->type == PO_IMMEDIATE) {
+	emitpcode(POC_MOVLW, popGet(AOP(right),0));
+	emitpcode(POC_MOVWF, popGet(AOP(result),0));
+	emitpcode(POC_MOVLW, popGet(AOP(right),1));
+	emitpcode(POC_MOVWF, popGet(AOP(result),1));
+        if(AOP_SIZE(result) <2)
+	  fprintf(stderr,"%d -- result is not big enough to hold a ptr\n",__LINE__);
+
+      } else {
 
         /* if they in different places then copy */
         size = AOP_SIZE(result);
         offset = 0 ;
         while (size--) {
-            aopPut(AOP(result),
-                   aopGet(AOP(right),offset,FALSE,FALSE),
-                   offset);
-            offset++;
+	  emitpcode(POC_MOVFW, popGet(AOP(right),offset));
+	  emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+
+	  //aopPut(AOP(result),
+	  // aopGet(AOP(right),offset,FALSE,FALSE),
+	  // offset);
+
+	  offset++;
         }
-        goto release;
+      }
+      goto release;
     }
 
 
@@ -8878,6 +9656,7 @@ static void genCast (iCode *ic)
 	int p_type;
 	sym_link *type = operandType(right);
 	sym_link *etype = getSpec(type);
+      DEBUGpic14_emitcode("; ***","%s  %d - pointer cast",__FUNCTION__,__LINE__);
 
 	/* pointer to generic pointer */
 	if (IS_GENPTR(ctype)) {
@@ -8905,27 +9684,41 @@ static void genCast (iCode *ic)
 	    }
 		
 	    /* the first two bytes are known */
+      DEBUGpic14_emitcode("; ***","%s  %d - pointer cast2",__FUNCTION__,__LINE__);
 	    size = GPTRSIZE - 1; 
 	    offset = 0 ;
 	    while (size--) {
-		aopPut(AOP(result),
-		       aopGet(AOP(right),offset,FALSE,FALSE),
-		       offset);
-		offset++;
+	      if(offset < AOP_SIZE(right)) {
+      DEBUGpic14_emitcode("; ***","%s  %d - pointer cast3",__FUNCTION__,__LINE__);
+		if ((AOP_TYPE(right) == AOP_PCODE) && 
+		    AOP(right)->aopu.pcop->type == PO_IMMEDIATE) {
+		  emitpcode(POC_MOVLW, popGet(AOP(right),offset));
+		  emitpcode(POC_MOVWF, popGet(AOP(result),offset));
+		} else { 
+		  aopPut(AOP(result),
+			 aopGet(AOP(right),offset,FALSE,FALSE),
+			 offset);
+		}
+	      } else 
+		emitpcode(POC_CLRF,popGet(AOP(result),offset));
+	      offset++;
 	    }
 	    /* the last byte depending on type */
 	    switch (p_type) {
 	    case IPOINTER:
 	    case POINTER:
-		l = zero;
+		emitpcode(POC_CLRF,popGet(AOP(result),GPTRSIZE - 1));
 		break;
 	    case FPOINTER:
+	      pic14_emitcode(";BUG!? ","%d",__LINE__);
 		l = one;
 		break;
 	    case CPOINTER:
+	      pic14_emitcode(";BUG!? ","%d",__LINE__);
 		l = "#0x02";
 		break;				
 	    case PPOINTER:
+	      pic14_emitcode(";BUG!? ","%d",__LINE__);
 		l = "#0x03";
 		break;
 		
@@ -8935,7 +9728,7 @@ static void genCast (iCode *ic)
 		       "got unknown pointer type");
 		exit(1);
 	    }
-	    aopPut(AOP(result),l, GPTRSIZE - 1);	    
+	    //aopPut(AOP(result),l, GPTRSIZE - 1);	    
 	    goto release ;
 	}
 	
@@ -8961,6 +9754,7 @@ static void genCast (iCode *ic)
     if(genMixedOperation(ic))
       goto release;
 
+    DEBUGpic14_emitcode("; ***","%s  %d",__FUNCTION__,__LINE__);
     
     /* we move to result for the size of source */
     size = AOP_SIZE(right);
@@ -8974,7 +9768,7 @@ static void genCast (iCode *ic)
     /* now depending on the sign of the destination */
     size = AOP_SIZE(result) - AOP_SIZE(right);
     /* if unsigned or not an integral type */
-    if (SPEC_USIGN(ctype) || !IS_SPEC(ctype)) {
+    if (SPEC_USIGN(rtype) || !IS_SPEC(rtype)) {
       while (size--)
 	emitpcode(POC_CLRF,   popGet(AOP(result),offset++));
     } else {
@@ -9073,35 +9867,35 @@ static int genDjnz (iCode *ic, iCode *ifx)
 /*-----------------------------------------------------------------*/
 static void genReceive (iCode *ic)
 {    
-    DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+  DEBUGpic14_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
 
-    if (isOperandInFarSpace(IC_RESULT(ic)) && 
-	( OP_SYMBOL(IC_RESULT(ic))->isspilt ||
-	  IS_TRUE_SYMOP(IC_RESULT(ic))) ) {
+  if (isOperandInFarSpace(IC_RESULT(ic)) && 
+      ( OP_SYMBOL(IC_RESULT(ic))->isspilt ||
+	IS_TRUE_SYMOP(IC_RESULT(ic))) ) {
 
-	int size = getSize(operandType(IC_RESULT(ic)));
-	int offset =  fReturnSizePic - size;
-	while (size--) {
-	    pic14_emitcode ("push","%s", (strcmp(fReturn[fReturnSizePic - offset - 1],"a") ?
+    int size = getSize(operandType(IC_RESULT(ic)));
+    int offset =  fReturnSizePic - size;
+    while (size--) {
+      pic14_emitcode ("push","%s", (strcmp(fReturn[fReturnSizePic - offset - 1],"a") ?
 				    fReturn[fReturnSizePic - offset - 1] : "acc"));
-	    offset++;
-	}
-	aopOp(IC_RESULT(ic),ic,FALSE);  
-	size = AOP_SIZE(IC_RESULT(ic));
-	offset = 0;
-	while (size--) {
-	    pic14_emitcode ("pop","acc");
-	    aopPut (AOP(IC_RESULT(ic)),"a",offset++);
-	}
-	
-    } else {
-	_G.accInUse++;
-	aopOp(IC_RESULT(ic),ic,FALSE);  
-	_G.accInUse--;
-	assignResultValue(IC_RESULT(ic));	
+      offset++;
     }
+    aopOp(IC_RESULT(ic),ic,FALSE);  
+    size = AOP_SIZE(IC_RESULT(ic));
+    offset = 0;
+    while (size--) {
+      pic14_emitcode ("pop","acc");
+      aopPut (AOP(IC_RESULT(ic)),"a",offset++);
+    }
+	
+  } else {
+    _G.accInUse++;
+    aopOp(IC_RESULT(ic),ic,FALSE);  
+    _G.accInUse--;
+    assignResultValue(IC_RESULT(ic));	
+  }
 
-    freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
+  freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);
 }
 
 /*-----------------------------------------------------------------*/
@@ -9127,18 +9921,19 @@ void genpic14Code (iCode *lic)
     addpBlock(pb);
 
     /* if debug information required */
-/*     if (options.debug && currFunc) { */
-    if (currFunc) {
-	cdbSymbol(currFunc,cdbFile,FALSE,TRUE);
+    if (options.debug && currFunc) { 
+      if (currFunc) {
+	debugFile->writeFunction(currFunc);
 	_G.debugLine = 1;
 	if (IS_STATIC(currFunc->etype)) {
-	    pic14_emitcode("",";F%s$%s$0$0     %d",moduleName,currFunc->name,__LINE__);
-	    //addpCode2pBlock(pb,newpCodeLabel(moduleName,currFunc->name));
+	  pic14_emitcode("",";F%s$%s$0$0     %d",moduleName,currFunc->name,__LINE__);
+	  //addpCode2pBlock(pb,newpCodeLabel(moduleName,currFunc->name));
 	} else {
-	    pic14_emitcode("",";G$%s$0$0   %d",currFunc->name,__LINE__);
-	    //addpCode2pBlock(pb,newpCodeLabel(NULL,currFunc->name));
+	  pic14_emitcode("",";G$%s$0$0   %d",currFunc->name,__LINE__);
+	  //addpCode2pBlock(pb,newpCodeLabel(NULL,currFunc->name));
 	}
 	_G.debugLine = 0;
+      }
     }
 
 
@@ -9153,9 +9948,23 @@ void genpic14Code (iCode *lic)
 			 ic->level,ic->block);
 		_G.debugLine = 0;
 	    }
-	    pic14_emitcode("#CSRC","%s %d",FileBaseName(ic->filename),ic->lineno);
+	    /*
+	      pic14_emitcode("#CSRC","%s %d",FileBaseName(ic->filename),ic->lineno);
+	      pic14_emitcode ("", ";\t%s:%d: %s", ic->filename, ic->lineno, 
+	      printCLine(ic->filename, ic->lineno));
+	    */
+	    if (!options.noCcodeInAsm) {
+	      addpCode2pBlock(pb,
+			      newpCodeCSource(ic->lineno, 
+					      ic->filename, 
+					      printCLine(ic->filename, ic->lineno)));
+	    }
+
 	    cln = ic->lineno ;
 	}
+
+	// if you want printILine too, look at ../mcs51/gen.c, i don't understand this :)
+
 	/* if the result is marked as
 	   spilt and rematerializable or code for
 	   this has already been generated then
@@ -9355,14 +10164,15 @@ void genpic14Code (iCode *lic)
     /* now we are ready to call the 
        peep hole optimizer */
     if (!options.nopeep) {
-      printf("peep hole optimizing\n");
-	peepHole (&lineHead);
+      peepHole (&lineHead);
     }
     /* now do the actual printing */
     printLine (lineHead,codeOutFile);
 
-    printf("printing pBlock\n\n");
+#ifdef PCODE_DEBUG
+    DFPRINTF((stderr,"printing pBlock\n\n"));
     printpBlock(stdout,pb);
+#endif
 
     return;
 }