X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fpic16%2Fgen.c;h=9ca5da162e096bafd4aa27b0db89616edd9d4ece;hb=195ee3f3ee25ce2c5f2a59fbd2779c4cb80527c3;hp=efc10964894e0fccf037dba2e32ea089b2e88cbd;hpb=d8d57b14292e9492ba158e60a4c4354f199a9684;p=fw%2Fsdcc

diff --git a/src/pic16/gen.c b/src/pic16/gen.c
index efc10964..9ca5da16 100644
--- a/src/pic16/gen.c
+++ b/src/pic16/gen.c
@@ -1,4 +1,4 @@
-/*-------------------------------------------------------------------------
+ /*-------------------------------------------------------------------------
  gen.c - source file for code generation for pic16
 
   Written By -  Sandeep Dutta . sandeep.dutta@usa.net (1998)
@@ -6,7 +6,8 @@
   Bug Fixes  -  Wojciech Stryjewski  wstryj1@tiger.lsu.edu (1999 v2.1.9a)
   PIC port   -  Scott Dattalo scott@dattalo.com (2000)
   PIC16 port -  Martin Dubuc m.dubuc@rogers.com (2002)
-             -  Vangelis Rokas vrokas@otenet.gr (2003,2004)
+             -  Vangelis Rokas vrokas@otenet.gr (2003,2004,2005)
+  Bug Fixes  -  Raphael Neider rneider@web.de (2004,2005)
   
   This program is free software; you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published by the
@@ -47,6 +48,17 @@
 #include "device.h"
 #include "main.h"
 
+/* Set the following to 1 to enable the slower/bigger
+ * but more robust generic shifting routine (which also
+ * operates correctly with negative shift values). */
+#define USE_GENERIC_SIGNED_SHIFT 1
+
+/* Set the following to 1 to enable the new
+ * stripped down genCmp version.
+ * This version should be easier to understand,
+ * more reliable and (sigh) slighly slower. */
+#define USE_SIMPLE_GENCMP 1
+
 extern void pic16_genUMult8X8_16 (operand *, operand *,operand *,pCodeOpReg *);
 extern void pic16_genSMult8X8_16 (operand *, operand *,operand *,pCodeOpReg *);
 void pic16_genMult8X8_8 (operand *, operand *,operand *);
@@ -57,8 +69,6 @@ extern void pic16_printpBlock(FILE *of, pBlock *pb);
 static asmop *newAsmop (short type);
 static pCodeOp *pic16_popRegFromString(char *str, int size, int offset, operand *op);
 extern pCode *pic16_newpCodeAsmDir(char *asdir, char *argfmt, ...);
-static void mov2w (asmop *aop, int offset);
-static void mov2f(asmop *dst, asmop *src, int offset);
 static void mov2fp(pCodeOp *dst, asmop *src, int offset);
 static pCodeOp *pic16_popRegFromIdx(int rIdx);
 
@@ -66,12 +76,16 @@ static pCodeOp *pic16_popRegFromIdx(int rIdx);
 
 int pic16_labelOffset=0;
 extern int pic16_debug_verbose;
+#if !(USE_GENERIC_SIGNED_SHIFT)
 static int optimized_for_speed = 0;
+#endif
 /*
   hack hack
 
 */
 
+extern set *externs;
+
 /* max_key keeps track of the largest label number used in 
    a function. This is then used to adjust the label offset
    for the next function.
@@ -94,6 +108,11 @@ static bool is_LitAOp(asmop *aop);
 
 #define BYTEofLONG(l,b) ( (l>> (b<<3)) & 0xff)
 
+/* set the following macro to 1 to enable passing the
+ * first byte of functions parameters via WREG */
+#define USE_WREG_IN_FUNC_PARAMS	0
+
+
 /* this is the down and dirty file with all kinds of 
    kludgy & hacky stuff. This is what it is all about
    CODE GENERATION for a specific MCU . some of the
@@ -116,6 +135,7 @@ static char *one  = "#0x01";
  
 
 char *fReturnpic16[] = {"WREG", "PRODL", "PRODH", "FSR0L" };
+int fReturnIdx[] = {IDX_WREG, IDX_PRODL, IDX_PRODH, IDX_FSR0L };
 unsigned pic16_fReturnSizePic = 4; /* shared with ralloc.c */
 static char **fReturn = fReturnpic16;
 
@@ -134,23 +154,15 @@ static struct {
     short ipushRegs;
     set *sendSet;
     set *stackRegSet;
-    int interruptvector;
     int usefastretfie;
-    bitVect *fregsUsed;
+    bitVect *fregsUsed;			/* registers used in function */
+    bitVect *sregsAlloc;
+    set *sregsAllocSet;			/* registers used to store stack variables */
     int stack_lat;			/* stack offset latency */
     int resDirect;
+    int useWreg;			/* flag when WREG is used to pass function parameter */
 } _G;
 
-/* Resolved ifx structure. This structure stores information
-   about an iCode ifx that makes it easier to generate code.
-*/
-typedef struct resolvedIfx {
-  symbol *lbl;     /* pointer to a label */
-  int condition;   /* true or false ifx */
-  int generated;   /* set true when the code associated with the ifx
-		    * is generated */
-} resolvedIfx;
-
 extern int pic16_ptrRegReq ;
 extern int pic16_nRegs;
 extern FILE *codeOutFile;
@@ -175,7 +187,7 @@ static  pBlock *pb;
 /*   return y;                                                     */
 /* return -1;                                                      */
 /*-----------------------------------------------------------------*/
-static int my_powof2 (unsigned long num)
+int pic16_my_powof2 (unsigned long num)
 {
   if(num) {
     if( (num & (num-1)) == 0) {
@@ -222,7 +234,7 @@ void pic16_emitpcomment (char *fmt, ...)
 {
     va_list ap;
     char lb[INITIAL_INLINEASM];  
-    char *lbp = lb;
+    unsigned char *lbp = lb;
 
     va_start(ap,fmt);   
 
@@ -248,7 +260,7 @@ void DEBUGpic16_emitcode (char *inst,char *fmt, ...)
 {
     va_list ap;
     char lb[INITIAL_INLINEASM];  
-    char *lbp = lb;
+    unsigned char *lbp = lb;
 
     if(!pic16_debug_verbose)
       return;
@@ -279,6 +291,8 @@ void DEBUGpic16_emitcode (char *inst,char *fmt, ...)
 //	fprintf(stderr, "%s\n", lb);
 }
 
+
+
 void pic16_emitpLabel(int key)
 {
   pic16_addpCode2pBlock(pb,pic16_newpCodeLabel(NULL,key+100+pic16_labelOffset));
@@ -289,17 +303,25 @@ void pic16_emitpLabelFORCE(int key)
   pic16_addpCode2pBlock(pb,pic16_newpCodeLabelFORCE(NULL,key+100+pic16_labelOffset));
 }
 
-void pic16_emitpcode(PIC_OPCODE poc, pCodeOp *pcop)
+/* gen.h defines a macro pic16_emitpcode that allows for debug information to be inserted on demand
+ * NEVER call pic16_emitpcode_real directly, please... */
+void pic16_emitpcode_real(PIC_OPCODE poc, pCodeOp *pcop)
 {
 
   if(pcop)
     pic16_addpCode2pBlock(pb,pic16_newpCode(poc,pcop));
   else
     DEBUGpic16_emitcode(";","%s  ignoring NULL pcop",__FUNCTION__);
-    
-//    fprintf(stderr, "%s\n", pcop->name);
 }
 
+void pic16_emitpinfo(INFO_TYPE itype, pCodeOp *pcop)
+{
+  if(pcop)
+    pic16_addpCode2pBlock(pb, pic16_newpCodeInfo(itype, pcop));
+  else
+    DEBUGpic16_emitcode(";","%s  ignoring NULL pcop",__FUNCTION__);
+}
+  
 void pic16_emitpcodeNULLop(PIC_OPCODE poc)
 {
 
@@ -318,7 +340,7 @@ void pic16_emitcode (char *inst,char *fmt, ...)
 {
     va_list ap;
     char lb[INITIAL_INLINEASM];  
-    char *lbp = lb;
+    unsigned char *lbp = lb;
 
     va_start(ap,fmt);   
 
@@ -537,8 +559,9 @@ static void genSetDPTR(int n)
 /*-----------------------------------------------------------------*/
 static void resolveIfx(resolvedIfx *resIfx, iCode *ifx)
 {
-
-  DEBUGpic16_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
+  FENTRY2;
+  
+//  DEBUGpic16_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
 
   if(!resIfx) 
     return;
@@ -565,9 +588,13 @@ static void resolveIfx(resolvedIfx *resIfx, iCode *ifx)
 
 #if 1
     if(IC_TRUE(ifx)) 
-      DEBUGpic16_emitcode("; ***","ifx true is non-null");
+      DEBUGpic16_emitcode("; +++","ifx true is non-null");
+    else
+      DEBUGpic16_emitcode("; +++","ifx true is null");
     if(IC_FALSE(ifx)) 
-      DEBUGpic16_emitcode("; ***","ifx false is non-null");
+      DEBUGpic16_emitcode("; +++","ifx false is non-null");
+    else
+      DEBUGpic16_emitcode("; +++","ifx false is null");
 #endif
   }
 
@@ -595,8 +622,8 @@ static asmop *aopForSym (iCode *ic, operand *op, bool result)
     asmop *aop;
     memmap *space= SPEC_OCLS(sym->etype);
 
-    DEBUGpic16_emitcode("; ***","%s %d",__FUNCTION__,__LINE__);
-
+    FENTRY2;
+    
     _G.resDirect = 0;	/* clear flag that instructs the result is loaded directly from aopForSym */
     
 //    sym = OP_SYMBOL(op);
@@ -615,11 +642,29 @@ static asmop *aopForSym (iCode *ic, operand *op, bool result)
     }
 #endif
 
+
+#if 0
+    if(sym->iaccess) {
+      if(space->paged) {
+        fprintf(stderr, "%s:%d symbol %s points to paged data\n", __FILE__, __LINE__, sym->name);
+
+        sym->aop = aop = newAsmop (AOP_PAGED);
+        aop->aopu.aop_dir = sym->rname ;
+        aop->size = getSize(sym->type);
+	DEBUGpic16_emitcode(";","%d sym->rname = %s, size = %d",__LINE__,sym->rname,aop->size);
+	pic16_allocDirReg( IC_LEFT(ic) );
+        return aop;
+      }
+      assert( 0 );
+    }
+#endif
+    
 #if 1
     /* assign depending on the storage class */
     /* if it is on the stack or indirectly addressable */
     /* space we need to assign either r0 or r1 to it   */    
-    if (sym->onStack || sym->iaccess) {
+    if (sym->onStack)	// || sym->iaccess)
+    {
       pCodeOp *pcop[4];
       int i;
       
@@ -633,26 +678,35 @@ static asmop *aopForSym (iCode *ic, operand *op, bool result)
         aop->size = getSize(sym->type);
 
 
-        DEBUGpic16_emitcode("; +++", "%s:%d", __FILE__, __LINE__);
-        pic16_DumpAop("aopForSym", AOP( IC_RESULT(ic) ));
-        if((ic->op == '=') && IC_RESULT(ic) && AOP( IC_RESULT(ic) )
-          && (AOP_TYPE(IC_RESULT(ic)) == AOP_REG) ) {
+        DEBUGpic16_emitcode("; +++ ", "%s:%d\top = %s", __FILE__, __LINE__, pic16_decodeOp(ic->op));
+        if((ic->op == '=' /*|| ic->op == CAST*/) && IC_RESULT(ic) && AOP( IC_RESULT(ic) )
+          && (AOP_TYPE(IC_RESULT(ic)) == AOP_REG)) {
+//          pic16_DumpAop("aopForSym", AOP( IC_RESULT(ic) ));
           
           for(i=0;i<aop->size;i++)
             aop->aopu.stk.pop[i] = pcop[i] = pic16_popRegFromIdx( AOP(IC_RESULT(ic))->aopu.aop_reg[i]->rIdx);
             _G.resDirect = 1;	/* notify that result will be loaded directly from aopForSym */
         } else
+        if(1 && ic->op == SEND) {
+
+          /* if SEND do the send here */
+          _G.resDirect = 1;
+        } else {
           for(i=0;i<aop->size;i++) {
-            aop->aopu.stk.pop[i] = pcop[i] = pic16_popGetTempRegCond( _G.fregsUsed, 0 );
-            _G.fregsUsed = bitVectSetBit(_G.fregsUsed, PCOR(pcop[i])->r->rIdx);
+            aop->aopu.stk.pop[i] = pcop[i] = pic16_popGetTempRegCond(_G.fregsUsed, _G.sregsAlloc, 0 );
+            _G.sregsAlloc = bitVectSetBit(_G.sregsAlloc, PCOR(pcop[i])->r->rIdx);
           }
+        }
 
 
 //        fprintf(stderr, "%s:%d\t%s\tsym size %d\n", __FILE__, __LINE__, __FUNCTION__, aop->size);
 
 #if 1
 	DEBUGpic16_emitcode(";","%d sym->rname = %s, size = %d stack = %d",__LINE__,sym->rname,aop->size, sym->stack);
-	
+
+	// we do not need to load the value if it is to be defined...
+	if (result) return aop;
+
 	if(_G.accInUse) {
 		pic16_pushpCodeOp( pic16_popCopyReg(&pic16_pc_wreg) );
 	}
@@ -660,11 +714,28 @@ static asmop *aopForSym (iCode *ic, operand *op, bool result)
 	for(i=0;i<aop->size;i++) {
 
 	  /* initialise for stack access via frame pointer */
-	  pic16_emitpcode(POC_MOVLW, pic16_popGetLit(sym->stack + i + _G.stack_lat));
-
-	  pic16_emitpcode(POC_MOVFF, pic16_popGet2p(
-	                  pic16_popCopyReg(&pic16_pc_plusw2), pcop[i]));
-        }
+          // operands on stack are accessible via "FSR2 + index" with index
+          // starting at 2 for arguments and growing from 0 downwards for
+          // local variables (index == 0 is not assigned so we add one here)
+	  {
+	    int soffs = sym->stack;
+	    if (soffs <= 0) {
+	      assert (soffs < 0);
+	      soffs++;
+	    } // if
+
+            if(1 && ic->op == SEND) {
+              pic16_emitpcode(POC_MOVLW, pic16_popGetLit(soffs + aop->size - i - 1 /*+ _G.stack_lat*/));
+              pic16_emitpcode(POC_MOVFF, pic16_popGet2p(
+                    pic16_popCopyReg( pic16_frame_plusw ),
+                    pic16_popCopyReg(pic16_stack_postdec )));
+            } else {
+              pic16_emitpcode(POC_MOVLW, pic16_popGetLit(soffs + i /*+ _G.stack_lat*/));
+              pic16_emitpcode(POC_MOVFF, pic16_popGet2p(
+	          pic16_popCopyReg( pic16_frame_plusw ), pcop[i]));
+            }
+	  }
+	}
 	
 	if(_G.accInUse) {
 		pic16_poppCodeOp( pic16_popCopyReg(&pic16_pc_wreg) );
@@ -737,6 +808,23 @@ static asmop *aopForSym (iCode *ic, operand *op, bool result)
     	return aop;
     }
 #endif
+
+#if 1
+    /* special case for a function */
+    if (IS_FUNC(sym->type)) {   
+        sym->aop = aop = newAsmop(AOP_PCODE);
+        //_ALLOC_ATOMIC(aop->aopu.aop_immd,strlen(sym->rname)+1);
+	aop->aopu.pcop = pic16_popGetImmd(sym->rname, 0, 0);
+	PCOI(aop->aopu.pcop)->_const = IN_CODESPACE(space);
+	PCOI(aop->aopu.pcop)->index = 0;
+        aop->size = FPTRSIZE; 
+	DEBUGpic16_emitcode(";","%d size = %d, name =%s",__LINE__,aop->size,sym->rname);
+        return aop;
+    }
+#endif
+
+
+
     //DEBUGpic16_emitcode(";","%d",__LINE__);
     /* if in bit space */
     if (IN_BITSPACE(space)) {
@@ -756,7 +844,8 @@ static asmop *aopForSym (iCode *ic, operand *op, bool result)
         return aop;
     }
 
-    if (IN_FARSPACE(space)) {
+
+    if (IN_FARSPACE(space) && !IN_CODESPACE(space)) {
         sym->aop = aop = newAsmop (AOP_DIR);
         aop->aopu.aop_dir = sym->rname ;
         aop->size = getSize(sym->type);
@@ -765,22 +854,8 @@ static asmop *aopForSym (iCode *ic, operand *op, bool result)
         return aop;
     }
 
-#if 0												// patch 14
-    /* special case for a function */
-    if (IS_FUNC(sym->type)) {   
-        sym->aop = aop = newAsmop(AOP_IMMD);    
-        //_ALLOC_ATOMIC(aop->aopu.aop_immd,strlen(sym->rname)+1);
-	aop->aopu.aop_immd = Safe_calloc(1,strlen(sym->rname)+1);
-        strcpy(aop->aopu.aop_immd,sym->rname);
-        aop->size = FPTRSIZE; 
-	DEBUGpic16_emitcode(";","%d size = %d, name =%s",__LINE__,aop->size,sym->rname);
-        return aop;
-    }
-#endif												// patch 14
-
 
     /* only remaining is far space */
-    /* in which case DPTR gets the address */
     sym->aop = aop = newAsmop(AOP_PCODE);
 
 /* change the next if to 1 to revert to good old immediate code */
@@ -806,11 +881,15 @@ static asmop *aopForSym (iCode *ic, operand *op, bool result)
 		aop->size = PTRSIZE;
 	else if(IN_CODESPACE( space ) || IN_FARSPACE( space ))
 		aop->size = FPTRSIZE;
-	else if(IC_LEFT(ic)) aop->size = AOP_SIZE( IC_LEFT(ic) );
-	else if(IC_RIGHT(ic)) aop->size = AOP_SIZE( IC_RIGHT(ic) );
+	else if(IC_LEFT(ic) && AOP(IC_LEFT(ic))) aop->size = AOP_SIZE( IC_LEFT(ic) );
+	else if(IC_RIGHT(ic) && AOP(IC_RIGHT(ic))) aop->size = AOP_SIZE( IC_RIGHT(ic) );
 	else if(sym->onStack) {
 	        aop->size = PTRSIZE;
         } else {
+          if(SPEC_SCLS(sym->etype) == S_PDATA) {
+            fprintf(stderr, "%s: %d symbol in PDATA space\n", __FILE__, __LINE__);
+            aop->size = FPTRSIZE;
+          } else
 		assert( 0 );
 	}
 
@@ -836,11 +915,10 @@ static asmop *aopForRemat (operand *op) // x symbol *sym)
   int offset = 0;
   int viaimmd=0;
 
-
+    FENTRY2;
+    
 	ic = sym->rematiCode;
 
-	DEBUGpic16_emitcode(";","%s %d",__FUNCTION__,__LINE__);
-	
 	if(IS_OP_POINTER(op)) {
 		DEBUGpic16_emitcode(";","%s %d IS_OP_POINTER",__FUNCTION__,__LINE__);
 	}
@@ -869,7 +947,7 @@ static asmop *aopForRemat (operand *op) // x symbol *sym)
 	if(IN_CODESPACE( SPEC_OCLS( OP_SYM_ETYPE(refop)))
 		|| viaimmd) {
 
-		DEBUGpic16_emitcode(";", "%s:%d immediate", __FILE__, __LINE__);
+		DEBUGpic16_emitcode(";", "%s:%d immediate, size: %d", __FILE__, __LINE__, getSize( sym->type ));
 
 		aop->aopu.pcop = pic16_popGetImmd(OP_SYMBOL(IC_LEFT(ic))->rname, 0, val);
 
@@ -880,12 +958,15 @@ static asmop *aopForRemat (operand *op) // x symbol *sym)
 #endif
 
 		PCOI(aop->aopu.pcop)->index = val;
+		
+		aop->size = getSize( sym->type );
 	} else {
-		DEBUGpic16_emitcode(";", "%s:%d dir", __FILE__, __LINE__);
+		DEBUGpic16_emitcode(";", "%s:%d dir size: %d", __FILE__, __LINE__,  getSize( OP_SYMBOL( IC_LEFT(ic))->type));
 
 		aop->aopu.pcop = pic16_popRegFromString(OP_SYMBOL(IC_LEFT(ic))->rname,
 				getSize( OP_SYMBOL( IC_LEFT(ic))->type), val, op);
-//		aop->size = AOP_SIZE( IC_LEFT(ic) );
+
+		aop->size = getSize( OP_SYMBOL( IC_LEFT(ic))->type );
 	}
 
 
@@ -1021,10 +1102,12 @@ bool pic16_sameRegs (asmop *aop1, asmop *aop2 )
         aop2->type != AOP_REG )
         return FALSE ;
 
+    /* This is a bit too restrictive if one is a subset of the other...
     if (aop1->size != aop2->size )
         return FALSE ;
+    */
 
-    for (i = 0 ; i < aop1->size ; i++ ) {
+    for (i = 0 ; i < min(aop1->size, aop2->size) ; i++ ) {
 //        if(aop1->aopu.aop_reg[i]->type != aop2->aopu.aop_reg[i]->type)return FALSE;
 
 //        if(aop1->aopu.aop_reg[i]->type == AOP_REG)
@@ -1061,7 +1144,7 @@ void pic16_aopOp (operand *op, iCode *ic, bool result)
     if (!op)
         return ;
 
-//	DEBUGpic16_emitcode(";","%s %d",__FUNCTION__, __LINE__);
+    DEBUGpic16_emitcode(";","%s %d",__FUNCTION__, __LINE__);
 
     /* if this a literal */
     if (IS_OP_LITERAL(op)) {
@@ -1109,7 +1192,7 @@ void pic16_aopOp (operand *op, iCode *ic, bool result)
 
     sym = OP_SYMBOL(op);
 
-	DEBUGpic16_emitcode("; ***", "%d: symbol name = %s", __LINE__, sym->name);
+    DEBUGpic16_emitcode("; ***", "%d: symbol name = %s, regType = %d", __LINE__, sym->name, sym->regType);
     /* if the type is a conditional */
     if (sym->regType == REG_CND) {
         aop = op->aop = sym->aop = newAsmop(AOP_CRY);
@@ -1122,13 +1205,14 @@ void pic16_aopOp (operand *op, iCode *ic, bool result)
     b) has a spill location */
     if (sym->isspilt || sym->nRegs == 0) {
 
+//      debugf3("symbol %s\tisspilt: %d\tnRegs: %d\n", sym->rname, sym->isspilt, sym->nRegs);
       DEBUGpic16_emitcode(";","%d",__LINE__);
         /* rematerialize it NOW */
         if (sym->remat) {
 
             sym->aop = op->aop = aop = aopForRemat (op);
-            aop->size = getSize(sym->type);
-	    //DEBUGpic16_emitcode(";"," %d: size %d, %s\n",__LINE__,aop->size,aop->aopu.aop_immd);
+//            aop->size = getSize(sym->type);
+//	    DEBUGpic16_emitcode(";"," %d: size %d, %s\n",__LINE__,aop->size,aop->aopu.aop_immd);
             return;
         }
 
@@ -1148,7 +1232,7 @@ void pic16_aopOp (operand *op, iCode *ic, bool result)
 #endif
 
 #if 1
-        if (sym->ruonly ) {
+        if (sym->ruonly) {
 	  /*
 	  sym->aop = op->aop = aop = newAsmop(AOP_PCODE);
 	  aop->aopu.pcop = pic16_popGetImmd(sym->usl.spillLoc->rname,0,sym->usl.spillLoc->offset);
@@ -1158,10 +1242,10 @@ void pic16_aopOp (operand *op, iCode *ic, bool result)
 
 	  unsigned i;
 
-	  aop = op->aop = sym->aop = newAsmop(AOP_STR);
+	  aop = op->aop = sym->aop = newAsmop(AOP_REG);
 	  aop->size = getSize(sym->type);
 	  for ( i = 0 ; i < pic16_fReturnSizePic ; i++ )
-	    aop->aopu.aop_str[i] = fReturn[i];
+	    aop->aopu.aop_reg[i] = PCOR(pic16_popRegFromIdx( fReturnIdx[i] ))->r;
 
 	  DEBUGpic16_emitcode(";","%d",__LINE__);
 	  return;
@@ -1182,9 +1266,16 @@ void pic16_aopOp (operand *op, iCode *ic, bool result)
 
 	sym->aop = op->aop = aop = newAsmop(AOP_PCODE);
 	//aop->aopu.pcop = pic16_popGetImmd(sym->usl.spillLoc->rname,0,sym->usl.spillLoc->offset);
-	aop->aopu.pcop = pic16_popRegFromString(sym->usl.spillLoc->rname, 
-					  getSize(sym->type), 
-					  sym->usl.spillLoc->offset, op);
+	if (sym->usl.spillLoc && sym->usl.spillLoc->rname) {
+	  aop->aopu.pcop = pic16_popRegFromString(sym->usl.spillLoc->rname, 
+						  getSize(sym->type), 
+						  sym->usl.spillLoc->offset, op);
+	} else {
+	  fprintf (stderr, "%s:%d called for a spillLocation -- assigning WREG instead --- CHECK!\n", __FUNCTION__, __LINE__);
+	  pic16_emitpcomment (";!!! %s:%d called for a spillLocation -- assigning WREG instead --- CHECK", __FUNCTION__, __LINE__);
+	  assert (getSize(sym->type) <= 1);
+	  aop->aopu.pcop = pic16_popCopyReg (&pic16_pc_wreg);
+	}
         aop->size = getSize(sym->type);
 
         return;
@@ -1274,21 +1365,33 @@ void pic16_freeAsmop (operand *op, asmop *aaop, iCode *ic, bool pop)
 
               /* we must store the result on stack */
               if((op == IC_RESULT(ic)) && RESULTONSTA(ic)) {
+                // operands on stack are accessible via "FSR2 + index" with index
+                // starting at 2 for arguments and growing from 0 downwards for
+                // local variables (index == 0 is not assigned so we add one here)
+                int soffs = OP_SYMBOL(IC_RESULT(ic))->stack;
+                if (soffs <= 0) {
+                  assert (soffs < 0);
+                  soffs++;
+                } // if
                 if(_G.accInUse)pic16_pushpCodeOp( pic16_popCopyReg(&pic16_pc_wreg) );
                 for(i=0;i<aop->size;i++) {
-                  /* initialise for stack access via frame pointer */
-                  pic16_emitpcode(POC_MOVLW, pic16_popGetLit(OP_SYMBOL(IC_RESULT(ic))->stack + i + _G.stack_lat));
-
-                  pic16_emitpcode(POC_MOVFF, pic16_popGet2p(
-                        aop->aopu.stk.pop[i], pic16_popCopyReg(&pic16_pc_plusw2)));
-                }
+		  /* initialise for stack access via frame pointer */
+		  pic16_emitpcode(POC_MOVLW, pic16_popGetLit(soffs + i /*+ _G.stack_lat*/));
+		  pic16_emitpcode(POC_MOVFF, pic16_popGet2p(
+                        aop->aopu.stk.pop[i], pic16_popCopyReg(pic16_frame_plusw)));
+		}
 	
                 if(_G.accInUse)pic16_poppCodeOp( pic16_popCopyReg(&pic16_pc_wreg) );
               }
 
               if(!_G.resDirect) {
-                for(i=0;i<aop->size;i++)
+                for(i=0;i<aop->size;i++) {
                   PCOR(aop->aopu.stk.pop[i] )->r->isFree = 1;
+
+                  if(bitVectBitValue(_G.sregsAlloc, PCOR(aop->aopu.stk.pop[i])->r->rIdx))
+                      bitVectUnSetBit(_G.sregsAlloc, PCOR(aop->aopu.stk.pop[i])->r->rIdx);
+                }
+                  
               }
               _G.resDirect = 0;
           }
@@ -1454,16 +1557,21 @@ char *pic16_aopGet (asmop *aop, int offset, bool bit16, bool dname)
 	return (rs);
 
     case AOP_LIT:
-	sprintf(s,"0x%02x", pic16aopLiteral (aop->aopu.aop_lit,offset));
+	sprintf(s,"0X%02x", pic16aopLiteral (aop->aopu.aop_lit,offset));
 	rs = Safe_calloc(1,strlen(s)+1);
 	strcpy(rs,s);   
 	return rs;
 	
     case AOP_STR:
 	aop->coff = offset ;
-	if (strcmp(aop->aopu.aop_str[offset],"a") == 0 &&
-	    dname)
-	    return "acc";
+
+//	if (strcmp(aop->aopu.aop_str[offset],"a") == 0 &&
+//	    dname)
+//	    return "acc";
+        if(!strcmp(aop->aopu.aop_str[offset], "WREG")) {
+          aop->type = AOP_ACC;
+          return Safe_strdup("WREG");
+        }
         DEBUGpic16_emitcode(";","%d - %s",__LINE__, aop->aopu.aop_str[offset]);
 	
 	return aop->aopu.aop_str[offset];
@@ -1475,7 +1583,11 @@ char *pic16_aopGet (asmop *aop, int offset, bool bit16, bool dname)
 	if(pcop->name) {
 	  DEBUGpic16_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);
+	  if (offset) {
+	    sprintf(s,"(%s + %d)", pic16_get_op (pcop, NULL, 0), offset);
+	  } else {
+	    sprintf(s,"%s", pic16_get_op (pcop, NULL, 0));
+	  }
 	} else
 	  sprintf(s,"0x%02x", PCOI(aop->aopu.pcop)->offset);
 
@@ -1484,6 +1596,21 @@ char *pic16_aopGet (asmop *aop, int offset, bool bit16, bool dname)
       strcpy(rs,s);   
       return rs;
 
+#if 0
+    case AOP_PAGED:
+      DEBUGpic16_emitcode(";","oops AOP_PAGED did this %s\n",s);
+      if (offset) {
+	sprintf(s,"(%s + %d)",
+		aop->aopu.aop_dir,
+		offset);
+      } else
+	    sprintf(s,"%s",aop->aopu.aop_dir);
+      DEBUGpic16_emitcode(";","oops AOP_PAGED did this %s\n",s);
+      rs = Safe_calloc(1,strlen(s)+1);
+      strcpy(rs,s);   
+      return rs;
+#endif
+
     case AOP_STA:
         rs = Safe_strdup(PCOR(aop->aopu.stk.pop[offset])->r->name);
         return (rs);
@@ -1525,7 +1652,7 @@ pCodeOp *pic16_popGetTempReg(int lock)
 
 //    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
     if(_TempReg_lock) {
-      werror(W_POSSBUG2, __FILE__, __LINE__);
+//      werror(W_POSSBUG2, __FILE__, __LINE__);
     }
     
     _TempReg_lock += lock;
@@ -1548,18 +1675,20 @@ pCodeOp *pic16_popGetTempReg(int lock)
 }
 
 /*-----------------------------------------------------------------*/
-/* pic16_popGetTempRegCond - create a new temporary pCodeOp, but   */
-/*                            don't save if inside v               */
+/* pic16_popGetTempRegCond - create a new temporary pCodeOp which  */
+/*                           is not part of f, but don't save if   */
+/*                           inside v                              */
 /*-----------------------------------------------------------------*/
-pCodeOp *pic16_popGetTempRegCond(bitVect *v, int lock)
+pCodeOp *pic16_popGetTempRegCond(bitVect *f, bitVect *v, int lock)
 {
-  pCodeOp *pcop;
+  pCodeOp *pcop=NULL;
   symbol *cfunc;
+  int i;
 
 //    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
 
     if(_TempReg_lock) {
-      werror(W_POSSBUG2, __FILE__, __LINE__);
+//      werror(W_POSSBUG2, __FILE__, __LINE__);
     }
 
     _TempReg_lock += lock;
@@ -1567,15 +1696,58 @@ pCodeOp *pic16_popGetTempRegCond(bitVect *v, int lock)
     cfunc = currFunc;
     currFunc = NULL;
 
-    pcop = pic16_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;
+    i = bitVectFirstBit(f);
+    while(i < 128) {
 
-      if(!bitVectBitValue(v, PCOR(pcop)->r->rIdx)) {
-      /* push value on stack */
-        pic16_pushpCodeOp( pic16_pCodeOpCopy(pcop) );
+      /* bypass registers that are used by function */
+      if(!bitVectBitValue(f, i)) {
+      
+        /* bypass registers that are already allocated for stack access */
+        if(!bitVectBitValue(v, i))  {
+        
+//          debugf("getting register rIdx = %d\n", i);
+          /* ok, get the operand */
+          pcop = pic16_newpCodeOpReg( i );
+    
+          /* should never by NULL */
+          assert( pcop != NULL );
+
+          
+          /* sanity check */
+          if(pcop && pcop->type == PO_GPR_TEMP && PCOR(pcop)->r) {
+            int found=0;
+            
+              PCOR(pcop)->r->wasUsed=1;
+              PCOR(pcop)->r->isFree=0;
+
+
+              {
+                regs *sr;
+              
+                  for(sr=setFirstItem(_G.sregsAllocSet);sr;sr=setNextItem(_G.sregsAllocSet)) {
+
+                    if(sr->rIdx == PCOR(pcop)->r->rIdx) {
+                      /* already used in previous steps, break */
+                      found=1;          
+                      break;
+                    }
+                  }
+              }
+
+              /* caller takes care of the following */
+//              bitVectSetBit(v, i);
+
+              if(!found) {
+                /* push value on stack */
+                pic16_pushpCodeOp( pic16_pCodeOpCopy(pcop) );
+                addSet(&_G.sregsAllocSet, PCOR(pcop)->r);
+              }
+          
+            break;
+          }
+        }
       }
+      i++;
     }
 
     currFunc = cfunc;
@@ -1595,6 +1767,7 @@ void pic16_popReleaseTempReg(pCodeOp *pcop, int lock)
 
   if(pcop && pcop->type == PO_GPR_TEMP && PCOR(pcop)->r) {
     PCOR(pcop)->r->isFree = 1;
+
     pic16_poppCodeOp( pic16_pCodeOpCopy(pcop) );
   }
 }
@@ -1620,16 +1793,20 @@ pCodeOp *pic16_popCopyReg(pCodeOpReg *pc)
   pCodeOpReg *pcor;
 
   pcor = Safe_calloc(1,sizeof(pCodeOpReg) );
-  pcor->pcop.type = pc->pcop.type;
+  memcpy (pcor, pc, sizeof (pCodeOpReg));
+  pcor->r->wasUsed = 1;
+  
+  //pcor->pcop.type = pc->pcop.type;
   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;
+  //pcor->r = pc->r;
+  //pcor->rIdx = pc->rIdx;
+  //pcor->r->wasUsed=1;
+  //pcor->instance = pc->instance;
 
 //  DEBUGpic16_emitcode ("; ***","%s  , copying %s, rIdx=%d",__FUNCTION__,pc->pcop.name,pc->rIdx);
 
@@ -1806,7 +1983,7 @@ pCodeOp *pic16_popGet (asmop *aop, int offset) //, bool bit16, bool dname)
   char *rs;
   pCodeOp *pcop;
 
-    //DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+    FENTRY2;
     /* offset is greater than
     size then zero */
 
@@ -1881,9 +2058,17 @@ pCodeOp *pic16_popGet (asmop *aop, int offset) //, bool bit16, bool dname)
       DEBUGpic16_emitcode(";","%d\tAOP_DIR", __LINE__);
       return pic16_popRegFromString(aop->aopu.aop_dir, aop->size, offset, NULL);
 	
+#if 0
+    case AOP_PAGED:
+      DEBUGpic16_emitcode(";","%d\tAOP_DIR", __LINE__);
+      return pic16_popRegFromString(aop->aopu.aop_dir, aop->size, offset, NULL);
+#endif
+
     case AOP_REG:
       {
-	int rIdx = aop->aopu.aop_reg[offset]->rIdx;
+	int rIdx;
+	assert (aop && aop->aopu.aop_reg[offset] != NULL);
+	rIdx = aop->aopu.aop_reg[offset]->rIdx;
 
 	DEBUGpic16_emitcode(";","%d\tAOP_REG", __LINE__);
 	
@@ -1896,8 +2081,10 @@ pCodeOp *pic16_popGet (asmop *aop, int offset) //, bool bit16, bool dname)
 
 	PCOR(pcop)->instance = offset;
 	pcop->type = PCOR(pcop)->r->pc_type;
+	
+	DEBUGpic16_emitcode(";*+*", "%d\tAOP_REG type = %s", __LINE__, dumpPicOptype(pcop->type));
 	rs = aop->aopu.aop_reg[offset]->name;
-	DEBUGpic16_emitcode(";","%d regiser idx = %d name = %s",__LINE__,rIdx,rs);
+	DEBUGpic16_emitcode(";","%d register idx = %d name = %s",__LINE__,rIdx,rs);
 	return pcop;
       }
 
@@ -1905,6 +2092,7 @@ pCodeOp *pic16_popGet (asmop *aop, int offset) //, bool bit16, bool dname)
 	DEBUGpic16_emitcode(";","%d\tAOP_CRY", __LINE__);
 
       pcop = pic16_newpCodeOpBit(aop->aopu.aop_dir,-1,1, PO_GPR_REGISTER);
+      PCOR(pcop)->instance = offset;
       PCOR(pcop)->r = pic16_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);
@@ -1933,16 +2121,16 @@ pCodeOp *pic16_popGet (asmop *aop, int offset) //, bool bit16, bool dname)
 			  __LINE__, 
 			  ((aop->aopu.pcop->name)? (aop->aopu.pcop->name) : "no name"), offset);
       pcop = pic16_pCodeOpCopy(aop->aopu.pcop);
-#if 1
-	switch( aop->aopu.pcop->type ) {
-		case PO_DIR: PCOR(pcop)->instance += offset; break; // patch 8
-		case PO_IMMEDIATE: PCOI(pcop)->offset = offset; break;
-		default:
-			assert( 0 );	/* should never reach here */;
-	}
-#else
-      PCOI(pcop)->offset = offset;
-#endif
+      switch( aop->aopu.pcop->type ) {
+        case PO_DIR: PCOR(pcop)->instance += offset; break;
+        case PO_IMMEDIATE: PCOI(pcop)->offset = offset; break;
+        case PO_WREG:
+            assert (offset==0);
+            break;
+        default:
+	  fprintf (stderr, "%s: unhandled aop->aopu.pcop->type %d\n", __FUNCTION__, aop->aopu.pcop->type);
+          assert( 0 );	/* should never reach here */;
+      }
       return pcop;
     }
 
@@ -2185,9 +2373,9 @@ void pic16_aopPut (asmop *aop, char *s, int offset)
 }
 
 /*-----------------------------------------------------------------*/
-/* mov2w - generate either a MOVLW or MOVFW based operand type     */
+/* pic16_mov2w - generate either a MOVLW or MOVFW based operand type     */
 /*-----------------------------------------------------------------*/
-static void mov2w (asmop *aop, int offset)
+void pic16_mov2w (asmop *aop, int offset)
 {
   DEBUGpic16_emitcode ("; ***","%s  %d  offset=%d",__FUNCTION__,__LINE__,offset);
 
@@ -2197,7 +2385,7 @@ static void mov2w (asmop *aop, int offset)
     pic16_emitpcode(POC_MOVFW,pic16_popGet(aop,offset));
 }
 
-static void mov2f(asmop *dst, asmop *src, int offset)
+void pic16_mov2f(asmop *dst, asmop *src, int offset)
 {
   if(is_LitAOp(src)) {
     pic16_emitpcode(POC_MOVLW, pic16_popGet(src, offset));
@@ -2219,18 +2407,39 @@ static void mov2fp(pCodeOp *dst, asmop *src, int offset)
   }
 }
 
+void pic16_testStackOverflow(void)
+{
+#define	GSTACK_TEST_NAME	"_gstack_test"
+
+  pic16_emitpcode(POC_CALL, pic16_popGetWithString( GSTACK_TEST_NAME ));
+  
+  {
+    symbol *sym;
+
+      sym = newSymbol( GSTACK_TEST_NAME , 0 );
+      sprintf(sym->rname, "%s%s", port->fun_prefix, GSTACK_TEST_NAME);
+//      strcpy(sym->rname, GSTACK_TEST_NAME);
+      checkAddSym(&externs, sym);
+  }
+
+}
 
 /* push pcop into stack */
 void pic16_pushpCodeOp(pCodeOp *pcop)
 {
 //	DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-	pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pcop, pic16_popCopyReg(&pic16_pc_postdec1)));
+  pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pcop, pic16_popCopyReg( pic16_stack_postdec )));	//&pic16_pc_postdec1)));
+  if(pic16_options.gstack)
+    pic16_testStackOverflow();
+    
 }
 
 /* pop pcop from stack */
 void pic16_poppCodeOp(pCodeOp *pcop)
 {
-	pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popCopyReg(&pic16_pc_preinc1), pcop));
+  pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popCopyReg( pic16_stack_preinc ), pcop));
+  if(pic16_options.gstack)
+    pic16_testStackOverflow();
 }
 
 
@@ -2239,8 +2448,10 @@ void pic16_poppCodeOp(pCodeOp *pcop)
 /*-----------------------------------------------------------------*/
 void pushw(void)
 {
-        DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-	pic16_emitpcode(POC_MOVWF, pic16_popCopyReg(&pic16_pc_postdec1));
+  DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+  pic16_emitpcode(POC_MOVWF, pic16_popCopyReg( pic16_stack_postdec ));
+  if(pic16_options.gstack)
+    pic16_testStackOverflow();
 }
 
                 
@@ -2249,8 +2460,18 @@ void pushw(void)
 /*-----------------------------------------------------------------*/
 void pushaop(asmop *aop, int offset)
 {
-        DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-        pic16_emitpcode(POC_MOVFF, pic16_popCombine2(PCOR(pic16_popGet(aop, offset)), &pic16_pc_postdec1, 0));
+  DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+
+  if(is_LitAOp(aop)) {
+    pic16_emitpcode(POC_MOVLW, pic16_popGet(aop, offset));
+    pic16_emitpcode(POC_MOVWF, pic16_popCopyReg( pic16_stack_postdec ));
+  } else {
+    pic16_emitpcode(POC_MOVFF,
+      pic16_popGet2p(pic16_popGet(aop, offset), pic16_popCopyReg( pic16_stack_postdec )));
+  }
+
+  if(pic16_options.gstack)
+    pic16_testStackOverflow();
 }
 
 /*-----------------------------------------------------------------*/
@@ -2258,22 +2479,27 @@ void pushaop(asmop *aop, int offset)
 /*-----------------------------------------------------------------*/
 void popaop(asmop *aop, int offset)
 {
-	DEBUGpic16_emitcode("; ***", "%s  %d", __FUNCTION__, __LINE__);
-	pic16_emitpcode(POC_MOVFF, pic16_popCombine2(&pic16_pc_preinc1, PCOR(pic16_popGet(aop, offset)), 0));
+  DEBUGpic16_emitcode("; ***", "%s  %d", __FUNCTION__, __LINE__);
+  pic16_emitpcode(POC_MOVFF, pic16_popCombine2(pic16_stack_preinc, PCOR(pic16_popGet(aop, offset)), 0));
+  if(pic16_options.gstack)
+    pic16_testStackOverflow();
 }
 
 void popaopidx(asmop *aop, int offset, int index)
 {
   int ofs=1;
 
-        DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
 
-	if(STACK_MODEL_LARGE)ofs++;
+    if(STACK_MODEL_LARGE)ofs++;
 
-	pic16_emitpcode(POC_MOVLW, pic16_popGetLit(index + ofs));
-        pic16_emitpcode(POC_MOVFF, pic16_popCombine2(&pic16_pc_plusw2, PCOR(pic16_popGet(aop, offset)), 0));
+    pic16_emitpcode(POC_MOVLW, pic16_popGetLit(index + ofs));
+    pic16_emitpcode(POC_MOVFF, pic16_popCombine2(pic16_frame_plusw, PCOR(pic16_popGet(aop, offset)), 0));
+    if(pic16_options.gstack)
+      pic16_testStackOverflow();
 }
 
+#if !(USE_GENERIC_SIGNED_SHIFT)
 /*-----------------------------------------------------------------*/
 /* reAdjustPreg - points a register back to where it should        */
 /*-----------------------------------------------------------------*/
@@ -2312,7 +2538,7 @@ static void reAdjustPreg (asmop *aop)
     }   
 
 }
-
+#endif
 
 #if 0
 /*-----------------------------------------------------------------*/
@@ -2394,6 +2620,7 @@ void pic16_outBitC(operand *result)
   int i;
 
     DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+
     /* if the result is bit */
     if (AOP_TYPE(result) == AOP_CRY) {
 	fprintf(stderr, "%s:%d: pic16 port warning: unsupported case\n", __FILE__, __LINE__);
@@ -2405,12 +2632,31 @@ void pic16_outBitC(operand *result)
 		pic16_emitpcode(POC_CLRF, pic16_popGet(AOP(result), i));
 	}
 	pic16_emitpcode(POC_RLCF, pic16_popGet(AOP(result), 0));
-	
-/*
-        pic16_emitcode("clr","a  ; %d", __LINE__);
-        pic16_emitcode("rlc","a");
-        pic16_outAcc(result);
-*/
+    }
+}
+
+/*-----------------------------------------------------------------*/
+/* pic16_outBitOp - output a bit from Op                           */
+/*                 Move to result the value of set/clr op -- VR    */
+/*-----------------------------------------------------------------*/
+void pic16_outBitOp(operand *result, pCodeOp *pcop)
+{
+  int i;
+
+    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+
+    /* if the result is bit */
+    if (AOP_TYPE(result) == AOP_CRY) {
+	fprintf(stderr, "%s:%d: pic16 port warning: unsupported case\n", __FILE__, __LINE__);
+        pic16_aopPut(AOP(result),"c",0);
+    } else {
+
+	i = AOP_SIZE(result);
+	while(i--) {
+		pic16_emitpcode(POC_CLRF, pic16_popGet(AOP(result), i));
+	}
+        pic16_emitpcode(POC_RRCF, pcop);	  
+	pic16_emitpcode(POC_RLCF, pic16_popGet(AOP(result), 0));
     }
 }
 
@@ -2442,7 +2688,7 @@ static void pic16_genNot (iCode *ic)
   symbol *tlbl;
   int size;
 
-  DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+  FENTRY;
   /* assign asmOps to operand & result */
   pic16_aopOp (IC_LEFT(ic),ic,FALSE);
   pic16_aopOp (IC_RESULT(ic),ic,TRUE);
@@ -2489,11 +2735,10 @@ static void pic16_genNot (iCode *ic)
 /*-----------------------------------------------------------------*/
 static void pic16_genCpl (iCode *ic)
 {
-    int offset = 0;
-    int size ;
-
+  int offset = 0;
+  int size ;
 
-    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+    FENTRY;
     /* assign asmOps to operand & result */
     pic16_aopOp (IC_LEFT(ic),ic,FALSE);
     pic16_aopOp (IC_RESULT(ic),ic,TRUE);
@@ -2540,26 +2785,20 @@ release:
 /*-----------------------------------------------------------------*/
 static void genUminusFloat(operand *op,operand *result)
 {
-    int size ,offset =0 ;
-    char *l;
-
-    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+  int size ,offset =0 ;
+  
+    FENTRY;
     /* for this we just need to flip the 
     first it then copy the rest in place */
-    size = AOP_SIZE(op) - 1;
-    l = pic16_aopGet(AOP(op),3,FALSE,FALSE);
-
-    MOVA(l);    
-
-    pic16_emitcode("cpl","acc.7");
-    pic16_aopPut(AOP(result),"a",3);    
+    size = AOP_SIZE(op);
 
     while(size--) {
-        pic16_aopPut(AOP(result),
-               pic16_aopGet(AOP(op),offset,FALSE,FALSE),
-               offset);
-        offset++;
-    }          
+      pic16_mov2f(AOP(result), AOP(op), offset);
+      offset++;
+    }
+    
+    /* toggle the MSB's highest bit */
+    pic16_emitpcode(POC_BTG, pic16_popCopyGPR2Bit(pic16_popGet(AOP(result), offset-1), 7));
 }
 
 /*-----------------------------------------------------------------*/
@@ -2569,55 +2808,72 @@ static void genUminus (iCode *ic)
 {
   int size, i;
   sym_link *optype, *rtype;
+  symbol *label;
+  int needLabel=0;
 
-	DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-	
-	/* assign asmops */
-	pic16_aopOp(IC_LEFT(ic),ic,FALSE);
-	pic16_aopOp(IC_RESULT(ic),ic,TRUE);
-
-	/* if both in bit space then special case */
-	if (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY
-		&& AOP_TYPE(IC_LEFT(ic)) == AOP_CRY ) { 
-
-		pic16_emitpcode(POC_BCF,   pic16_popGet(AOP(IC_RESULT(ic)),0));
-		pic16_emitpcode(POC_BTFSS, pic16_popGet(AOP(IC_LEFT(ic)),0));
-		pic16_emitpcode(POC_BSF,   pic16_popGet(AOP(IC_RESULT(ic)),0));
-		
-		goto release; 
-	} 
+    FENTRY;	
+    
+    /* assign asmops */
+    pic16_aopOp(IC_LEFT(ic),ic,FALSE);
+    pic16_aopOp(IC_RESULT(ic),ic,TRUE);
 
-	optype = operandType(IC_LEFT(ic));
-	rtype = operandType(IC_RESULT(ic));
+    /* if both in bit space then special case */
+    if (AOP_TYPE(IC_RESULT(ic)) == AOP_CRY
+      && AOP_TYPE(IC_LEFT(ic)) == AOP_CRY ) { 
+        
+        pic16_emitpcode(POC_BCF,   pic16_popGet(AOP(IC_RESULT(ic)),0));
+        pic16_emitpcode(POC_BTFSS, pic16_popGet(AOP(IC_LEFT(ic)),0));
+        pic16_emitpcode(POC_BSF,   pic16_popGet(AOP(IC_RESULT(ic)),0));
+        goto release; 
+    } 
 
-	/* if float then do float stuff */
-	if (IS_FLOAT(optype)) {
-		genUminusFloat(IC_LEFT(ic),IC_RESULT(ic));
-		goto release;
-	}
+    optype = operandType(IC_LEFT(ic));
+    rtype = operandType(IC_RESULT(ic));
 
-	/* otherwise subtract from zero by taking the 2's complement */
-	size = AOP_SIZE(IC_LEFT(ic));
 
-	for(i=0; i<size; i++) {
-		if (pic16_sameRegs(AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic))) )
-			pic16_emitpcode(POC_COMF,  pic16_popGet(AOP(IC_LEFT(ic)),i));
-		else {
-			pic16_emitpcode(POC_COMFW, pic16_popGet(AOP(IC_LEFT(ic)),i));
-			pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(IC_RESULT(ic)),i));
-		}
-	}
+    /* if float then do float stuff */
+    if (IS_FLOAT(optype) || IS_FIXED(optype)) {
+      if(IS_FIXED(optype))
+        debugf("implement fixed16x16 type\n", 0);
+	
+	genUminusFloat(IC_LEFT(ic),IC_RESULT(ic));
+	goto release;
+    }
 
-	pic16_emitpcode(POC_INCF,  pic16_popGet(AOP(IC_RESULT(ic)),0));
-	for(i=1; i<size; i++) {
-		emitSKPNZ;
-		pic16_emitpcode(POC_INCF,  pic16_popGet(AOP(IC_RESULT(ic)),i));
-	}
+    /* otherwise subtract from zero by taking the 2's complement */
+    size = AOP_SIZE(IC_LEFT(ic));
+    label = newiTempLabel ( NULL );
+    
+    if (pic16_sameRegs (AOP(IC_LEFT(ic)), AOP(IC_RESULT(ic)))) {
+      for (i=size-1; i > 0; i--) {
+        pic16_emitpcode (POC_COMF, pic16_popGet (AOP(IC_LEFT(ic)), i));
+      } // for
+      pic16_emitpcode (POC_NEGF, pic16_popGet (AOP(IC_LEFT(ic)), 0));
+      for (i=1; i < size; i++) {
+        if (i == size - 1) { emitSKPNZ; } else { pic16_emitpcode (POC_BNZ, pic16_popGetLabel (label->key)); needLabel++; }
+        pic16_emitpcode (POC_INCF, pic16_popGet (AOP(IC_LEFT(ic)), i));
+      } // for
+    } else {
+      for (i=size-1; i >= 0; i--) {
+        pic16_emitpcode (POC_COMFW, pic16_popGet (AOP(IC_LEFT(ic)), i));
+	pic16_emitpcode (POC_MOVWF, pic16_popGet (AOP(IC_RESULT(ic)), i));
+      } // for
+      if (size > 1) {
+        for (i=0; i < size-2; i++) {
+          pic16_emitpcode (POC_INCF, pic16_popGet (AOP(IC_RESULT(ic)),i));
+          pic16_emitpcode (POC_BNZ, pic16_popGetLabel (label->key)); needLabel++;
+	} // for
+        pic16_emitpcode (POC_INFSNZ, pic16_popGet (AOP(IC_RESULT(ic)), size-2));
+      } // if
+      pic16_emitpcode (POC_INCF, pic16_popGet(AOP(IC_RESULT(ic)), size-1));
+    }
+    if (needLabel)
+      pic16_emitpLabel (label->key);
 
 release:
-	/* release the aops */
-	pic16_freeAsmop(IC_LEFT(ic),NULL,ic,(RESULTONSTACK(ic) ? 0 : 1));
-	pic16_freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);    
+    /* release the aops */
+    pic16_freeAsmop(IC_LEFT(ic),NULL,ic,(RESULTONSTACK(ic) ? 0 : 1));
+    pic16_freeAsmop(IC_RESULT(ic),NULL,ic,TRUE);    
 }
 
 #if 0
@@ -2747,7 +3003,7 @@ static void pushSide(operand * oper, int size)
 
 void pic16_loadFromReturn(operand *op, int offset, pCodeOp *src)
 {
-  if(AOP(op)->aopu.pcop->type == PO_IMMEDIATE) {
+  if((AOP(op)->type == AOP_PCODE) && (AOP(op)->aopu.pcop->type == PO_IMMEDIATE)) {
     pic16_emitpcode(POC_MOVFW, src);
     pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(op), offset));
   } else {
@@ -2759,14 +3015,15 @@ void pic16_loadFromReturn(operand *op, int offset, pCodeOp *src)
 
 /*-----------------------------------------------------------------*/
 /* assignResultValue - assign results to oper, rescall==1 is       */
-/*                     called from genCall() or genPCall()         */
+/*                     called from genCall() or genPcall()         */
 /*-----------------------------------------------------------------*/
 static void assignResultValue(operand * oper, int rescall)
 {
   int size = AOP_SIZE(oper);
   int offset=0;
   
-    DEBUGpic16_emitcode ("; ***","%s  %d rescall:%d size:%d",__FUNCTION__,__LINE__,rescall,size); // patch 14
+    FENTRY2;
+//    DEBUGpic16_emitcode ("; ***","%s  %d rescall:%d size:%d",__FUNCTION__,__LINE__,rescall,size); // patch 14
     DEBUGpic16_pic16_AopType(__LINE__,oper,NULL,NULL);
 
     if(rescall) {
@@ -2798,6 +3055,7 @@ static void assignResultValue(operand * oper, int rescall)
         /* >32-bits, result on stack, and FSR0 points to beginning.
 	 * Fix stack when done */
 	/* FIXME FIXME */
+//	debugf("WARNING: Possible bug when returning more than 4-bytes\n");
 	while (size--) {
 //	    DEBUGpic16_emitcode("; ", "POC_MOVLW %d", GpsuedoStkPtr);
 //          DEBUGpic16_emitcode("; ", "POC_MOVFW PLUSW2");
@@ -2808,53 +3066,59 @@ static void assignResultValue(operand * oper, int rescall)
 			
 	/* fix stack */
 	pic16_emitpcode(POC_MOVLW, pic16_popGetLit( AOP_SIZE(oper) ));
-	pic16_emitpcode(POC_ADDWF, pic16_popCopyReg( &pic16_pc_fsr1l ));
+	pic16_emitpcode(POC_ADDWF, pic16_popCopyReg( pic16_stackpnt_lo ));	//&pic16_pc_fsr1l ));
 	if(STACK_MODEL_LARGE) {
 	  emitSKPNC;
-	  pic16_emitpcode(POC_INCF, pic16_popCopyReg( &pic16_pc_fsr1h ));
+	  pic16_emitpcode(POC_INCF, pic16_popCopyReg( pic16_stackpnt_hi ));	//&pic16_pc_fsr1h ));
 	}
       }			
     } else {
       int areg = 0;		/* matching argument register */
       
+//      debugf("_G.useWreg = %d\tGpsuedoStkPtr = %d\n", _G.useWreg, GpsuedoStkPtr);
       areg = SPEC_ARGREG( OP_SYM_ETYPE( oper ) ) - 1;
-      /* its called from genReceive (probably) */
-      if(!GpsuedoStkPtr) {
+
+
+      /* its called from genReceive (probably) -- VR */
+      /* I hope this code will not be called from somewhere else in the future! 
+       * We manually set the pseudo stack pointer in genReceive. - dw
+       */
+      if(!GpsuedoStkPtr && _G.useWreg) {
 //        DEBUGpic16_emitcode("; ", "pop %d", GpsuedoStkPtr);
+
         /* The last byte in the assignment is in W */
         if(areg <= GpsuedoStkPtr) {
           size--;
           pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(oper), offset /*size*/));
           offset++;
+//          debugf("receive from WREG\n", 0);
         }
-	GpsuedoStkPtr++;
-	_G.stack_lat = AOP_SIZE(oper)-1;
+	GpsuedoStkPtr++; /* otherwise the calculation below fails (-_G.useWreg) */
       }
+//      GpsuedoStkPtr++;
+      _G.stack_lat = AOP_SIZE(oper)-1;
 
       while (size) {
-//        DEBUGpic16_emitcode("; ", "POC_MOVLW %d", GpsuedoStkPtr);
-//        DEBUGpic16_emitcode("; ", "POC_MOVFW PLUSW2");
-        if(areg <= GpsuedoStkPtr) {
-          size--;
-          popaopidx(AOP(oper), offset, GpsuedoStkPtr);
-          offset++;
-        }
-	GpsuedoStkPtr++;
+        size--;
+        GpsuedoStkPtr++;
+        popaopidx(AOP(oper), offset, GpsuedoStkPtr - _G.useWreg);
+//        debugf("receive from STACK\n", 0);
+        offset++;
       }
     }
 }
 
 
 /*-----------------------------------------------------------------*/
-/* genIpush - genrate code for pushing this gets a little complex  */
+/* genIpush - generate code for pushing this gets a little complex */
 /*-----------------------------------------------------------------*/
 static void genIpush (iCode *ic)
 {
 //  int size, offset=0;
 
+  FENTRY;
   DEBUGpic16_emitcode ("; ***","%s  %d - WARNING no code generated",__FUNCTION__,__LINE__);
 
-
   if(ic->parmPush) {
     pic16_aopOp(IC_LEFT(ic), ic, FALSE );
 
@@ -2901,6 +3165,7 @@ static void genIpush (iCode *ic)
 /*-----------------------------------------------------------------*/
 static void genIpop (iCode *ic)
 {
+  FENTRY;
   DEBUGpic16_emitcode ("; ***","%s  %d - WARNING no code generated",__FUNCTION__,__LINE__);
 #if 0
     int size,offset ;
@@ -3020,6 +3285,17 @@ static void saverbank (int bank, iCode *ic, bool pushPsw)
 #endif	/* 0 */
 
 
+static int wparamCmp(void *p1, void *p2)
+{
+  return (!strcmp((char *)p1, (char *)p2));
+}
+
+int inWparamList(char *s)
+{
+  return isinSetWith(wparamList, s, wparamCmp);
+} 
+
+
 /*-----------------------------------------------------------------*/
 /* genCall - generates a call statement                            */
 /*-----------------------------------------------------------------*/
@@ -3028,9 +3304,10 @@ static void genCall (iCode *ic)
   sym_link *ftype;   
   int stackParms=0;
   int use_wreg=0;
+  int inwparam=0;
   char *fname;
   
-    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+    FENTRY;
 
     ftype = OP_SYM_TYPE(IC_LEFT(ic));
     /* if caller saves & we have not saved then */
@@ -3041,6 +3318,7 @@ static void genCall (iCode *ic)
 //	stackParms = psuedoStkPtr;
 //	fprintf(stderr, "%s:%d ic parmBytes = %d\n", __FILE__, __LINE__, ic->parmBytes);
     fname = OP_SYMBOL(IC_LEFT(ic))->rname[0]?OP_SYMBOL(IC_LEFT(ic))->rname:OP_SYMBOL(IC_LEFT(ic))->name;
+    inwparam = (inWparamList(OP_SYMBOL(IC_LEFT(ic))->name)) || (FUNC_ISWPARAM(OP_SYM_TYPE(IC_LEFT(ic))));
 
 #if 0
     gpsimDebug_StackDump(__FILE__, __LINE__, fname );
@@ -3053,63 +3331,76 @@ static void genCall (iCode *ic)
       int firstTimeThruLoop = 1;
 
 
-#if 1
         /* reverse sendSet if function is not reentrant */
         if(!IFFUNC_ISREENT(ftype))
           _G.sendSet = reverseSet(_G.sendSet);
-#endif
 
 	/* First figure how many parameters are getting passed */
-
-/*	do we really need to know this ? -- VR 
-	for (sic = setFirstItem(_G.sendSet) ; sic ; sic = setNextItem(_G.sendSet)) {
-	  pic16_aopOp(IC_LEFT(sic),sic,FALSE);
-          psuedoStkPtr += AOP_SIZE(IC_LEFT(sic));
-          pic16_freeAsmop (IC_LEFT(sic),NULL,sic,FALSE);
-        }
-*/
-
-
-//        stackParms = psuedoStkPtr;
         stackParms = 0;
         use_wreg = 0;
         
         for (sic = setFirstItem(_G.sendSet) ; sic ; sic = setNextItem(_G.sendSet)) {
-          int size, offset = 0;
+          int size;
+//          int offset = 0;
 
             pic16_aopOp(IC_LEFT(sic),sic,FALSE);
             size = AOP_SIZE(IC_LEFT(sic));
 
             stackParms += size;
 
-            while (size--) {
-              DEBUGpic16_emitcode ("; ","%d left %s",__LINE__,
-                    pic16_AopType(AOP_TYPE(IC_LEFT(sic))));
-              DEBUGpic16_emitcode("; ", "push %d", psuedoStkPtr-1);
+            /* pass the last byte through WREG */
+            if(inwparam) {
 
-              if(!firstTimeThruLoop) {
-                /* If this is not the first time we've been through the loop
-                 * then we need to save the parameter in a temporary
-                 * register. The last byte of the last parameter is
-                 * passed in W. */
+              while (size--) {
+                DEBUGpic16_emitcode ("; ","%d left %s",__LINE__,
+                      pic16_AopType(AOP_TYPE(IC_LEFT(sic))));
+                DEBUGpic16_emitcode("; ", "push %d", psuedoStkPtr-1);
 
-                pushw();
-//                --psuedoStkPtr;		// sanity check
-              }
+                if(!firstTimeThruLoop) {
+                  /* If this is not the first time we've been through the loop
+                   * then we need to save the parameter in a temporary
+                   * register. The last byte of the last parameter is
+                   * passed in W. */
+
+                  pushw();
+//                  --psuedoStkPtr;		// sanity check
+                  use_wreg = 1;
+                }
                 
-              firstTimeThruLoop=0;
+                firstTimeThruLoop=0;
 
-              mov2w (AOP(IC_LEFT(sic)), size);
+                pic16_mov2w (AOP(IC_LEFT(sic)), size);
 
-              offset++;
+//                offset++;
+              }
+            } else {
+              /* all arguments are passed via stack */
+              use_wreg = 0;
+
+              while (size--) {
+                DEBUGpic16_emitcode ("; ","%d left %s",__LINE__,
+                      pic16_AopType(AOP_TYPE(IC_LEFT(sic))));
+                DEBUGpic16_emitcode("; ", "push %d", psuedoStkPtr-1);
+
+//                pushaop(AOP(IC_LEFT(sic)), size);
+                pic16_mov2w (AOP(IC_LEFT(sic)), size);
+
+                if(!_G.resDirect)
+                  pushw();
+              }
             }
+
             pic16_freeAsmop (IC_LEFT(sic),NULL,sic,TRUE);
           }
 
-          /* save last parameter to stack if functions has varargs */
-          if(IFFUNC_HASVARARGS(ftype))pushw();
-          else use_wreg = 1;		/* last parameter in WREG */
-          
+          if(inwparam) {
+            if(IFFUNC_HASVARARGS(ftype) || IFFUNC_ISREENT(ftype)) {
+              pushw();	/* save last parameter to stack if functions has varargs */
+              use_wreg = 0;
+            } else
+              use_wreg = 1;
+          } else use_wreg = 0;
+
           _G.stackRegSet = _G.sendSet;
           _G.sendSet = NULL;
     }
@@ -3118,6 +3409,7 @@ static void genCall (iCode *ic)
     pic16_emitpcode(POC_CALL,pic16_popGetWithString(fname));
 
     GpsuedoStkPtr=0;
+    
     /* if we need to assign a result value */
     if ((IS_ITEMP(IC_RESULT(ic))
           && (OP_SYMBOL(IC_RESULT(ic))->nRegs
@@ -3141,13 +3433,17 @@ static void genCall (iCode *ic)
     }
       
     stackParms -= use_wreg;
-      
+    
     if(stackParms>0) {
-      pic16_emitpcode(POC_MOVLW, pic16_popGetLit(stackParms));
-      pic16_emitpcode(POC_ADDWF, pic16_popCopyReg( &pic16_pc_fsr1l ));
+      if(stackParms == 1) {
+        pic16_emitpcode(POC_INCF, pic16_popCopyReg(pic16_stackpnt_lo ));	//&pic16_pc_fsr1l));
+      } else {
+        pic16_emitpcode(POC_MOVLW, pic16_popGetLit(stackParms));
+        pic16_emitpcode(POC_ADDWF, pic16_popCopyReg( pic16_stackpnt_lo ));	//&pic16_pc_fsr1l ));
+      }
       if(STACK_MODEL_LARGE) {
         emitSKPNC;
-        pic16_emitpcode(POC_INCF, pic16_popCopyReg( &pic16_pc_fsr1h ));
+        pic16_emitpcode(POC_INCF, pic16_popCopyReg( pic16_stackpnt_hi ));	//&pic16_pc_fsr1h ));
       }
     }
 
@@ -3177,84 +3473,48 @@ static void genCall (iCode *ic)
 /*-----------------------------------------------------------------*/
 static void genPcall (iCode *ic)
 {
-  sym_link *ftype;
+  sym_link *ftype, *fntype;
   int stackParms=0;
   symbol *retlbl = newiTempLabel(NULL);
   pCodeOp *pcop_lbl = pic16_popGetLabel(retlbl->key);
-  int use_wreg=0;
   
-    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+    FENTRY;
 
     ftype = OP_SYM_TYPE(IC_LEFT(ic));
-    
+    fntype = operandType( IC_LEFT(ic) )->next;
+
     /* if send set is not empty the assign */
     if (_G.sendSet) {
       iCode *sic;
       int psuedoStkPtr=-1; 
-      int firstTimeThruLoop = 1;
-
-      /* For the Pic port, there is no data stack.
-       * So parameters passed to functions are stored
-       * in registers. (The pCode optimizer will get
-       * rid of most of these :). */
 
-
-#if 1
       /* reverse sendSet if function is not reentrant */
-      if(!IFFUNC_ISREENT(ftype))
+      if(!IFFUNC_ISREENT(fntype))
         _G.sendSet = reverseSet(_G.sendSet);
-#endif
 
-      /* First figure how many parameters are getting passed */
-#if 0
-      for (sic = setFirstItem(_G.sendSet) ; sic ; sic = setNextItem(_G.sendSet)) {
-        pic16_aopOp(IC_LEFT(sic),sic,FALSE);
-        psuedoStkPtr += AOP_SIZE(IC_LEFT(sic));
-        pic16_freeAsmop (IC_LEFT(sic),NULL,sic,FALSE);
-      }
-#endif
-
-//      stackParms = psuedoStkPtr;
       stackParms = 0;
-
+      
       for (sic = setFirstItem(_G.sendSet) ; sic ; sic = setNextItem(_G.sendSet)) {
-        int size, offset = 0;
+        int size;
 
           pic16_aopOp(IC_LEFT(sic),sic,FALSE);
           size = AOP_SIZE(IC_LEFT(sic));
           stackParms += size;
 
+          /* all parameters are passed via stack, since WREG is clobbered
+           * by the calling sequence */
           while (size--) {
             DEBUGpic16_emitcode ("; ","%d left %s",__LINE__,
             pic16_AopType(AOP_TYPE(IC_LEFT(sic))));
             DEBUGpic16_emitcode("; ", "push %d", psuedoStkPtr-1);
 
-            if(!firstTimeThruLoop) {
-              /* If this is not the first time we've been through the loop
-               * then we need to save the parameter in a temporary
-               * register. The last byte of the last parameter is
-               * passed in W. */
-
-              pushw();
-              --psuedoStkPtr;		// sanity check
-            }
-			
-            firstTimeThruLoop=0;
-
-            mov2w (AOP(IC_LEFT(sic)), size);
-
-            offset++;
+            pic16_mov2w (AOP(IC_LEFT(sic)), size);
+            pushw();
           }
 
-
           pic16_freeAsmop (IC_LEFT(sic),NULL,sic,TRUE);
       }
 
-      if(IFFUNC_HASVARARGS(ftype))
-        pushw();
-      else
-        use_wreg = 1;		/* last parameter in WREG */
-
       _G.stackRegSet = _G.sendSet;
       _G.sendSet = NULL;
     }
@@ -3264,6 +3524,11 @@ static void genPcall (iCode *ic)
     // push return address
     // push $ on return stack, then replace with retlbl
 
+    /* Thanks to Thorsten Klose for pointing out that the following
+     * snippet should be interrupt safe */
+    pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popCopyReg(&pic16_pc_intcon), pic16_popCopyReg(&pic16_pc_postdec1)));
+    pic16_emitpcode(POC_BCF, pic16_popCopyGPR2Bit(pic16_popCopyReg(&pic16_pc_intcon), 7));
+
     pic16_emitpcodeNULLop(POC_PUSH);
 
     pic16_emitpcode(POC_MOVLW, pic16_popGetImmd(pcop_lbl->name, 0, 0));
@@ -3272,7 +3537,12 @@ static void genPcall (iCode *ic)
     pic16_emitpcode(POC_MOVWF, pic16_popCopyReg(&pic16_pc_tosh));
     pic16_emitpcode(POC_MOVLW, pic16_popGetImmd(pcop_lbl->name, 2, 0));
     pic16_emitpcode(POC_MOVWF, pic16_popCopyReg(&pic16_pc_tosu));
-  
+
+
+    /* restore interrupt control register */
+    pic16_emitpcode(POC_MOVFW, pic16_popCopyReg(&pic16_pc_preinc1));
+    pic16_emitpcode(POC_MOVWF, pic16_popCopyReg(&pic16_pc_intcon));
+
     /* make the call by writing the pointer into pc */
     pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(IC_LEFT(ic)),2), pic16_popCopyReg(&pic16_pc_pclatu)));
     pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(IC_LEFT(ic)),1), pic16_popCopyReg(&pic16_pc_pclath)));
@@ -3306,15 +3576,14 @@ static void genPcall (iCode *ic)
       pic16_freeAsmop(IC_RESULT(ic),NULL, ic,TRUE);
     }
 
-    stackParms -= use_wreg;
+//    stackParms -= use_wreg;
     
     if(stackParms>0) {
       pic16_emitpcode(POC_MOVLW, pic16_popGetLit(stackParms));
-      pic16_emitpcode(POC_ADDWF, pic16_popCopyReg( &pic16_pc_fsr1l ));
+      pic16_emitpcode(POC_ADDWF, pic16_popCopyReg( pic16_stackpnt_lo ));
       if(STACK_MODEL_LARGE) {
-        /* this implies that stackParms < 256 !!! -- VR */
         emitSKPNC;
-        pic16_emitpcode(POC_INCF, pic16_popCopyReg( &pic16_pc_fsr1h ));
+        pic16_emitpcode(POC_INCF, pic16_popCopyReg( pic16_stackpnt_hi ));
       }
     }
 }
@@ -3374,269 +3643,205 @@ static void genFunction (iCode *ic)
   symbol *sym;
   sym_link *ftype;
   
-	DEBUGpic16_emitcode ("; ***","%s  %d curr label offset=%dprevious max_key=%d ",__FUNCTION__,__LINE__,pic16_labelOffset,max_key);
+    FENTRY;
+    DEBUGpic16_emitcode ("; ***","%s  %d curr label offset=%dprevious max_key=%d ",__FUNCTION__,__LINE__,pic16_labelOffset,max_key);
 
-	pic16_labelOffset += (max_key+4);
-	max_key=0;
-	GpsuedoStkPtr=0;
-	_G.nRegsSaved = 0;
+    pic16_labelOffset += (max_key+4);
+    max_key=0;
+    GpsuedoStkPtr=0;
+    _G.nRegsSaved = 0;
 	
-	ftype = operandType(IC_LEFT(ic));
-	sym = OP_SYMBOL(IC_LEFT(ic));
-
-	if(IFFUNC_ISISR(sym->type /*ftype*/)) {
-		/* create an absolute section at the interrupt vector:
-		 * that is 0x0008 for interrupt 1 (high), 0x0018 interrupt 2 (low) */
-	  symbol *asym;
-	  char asymname[128];
-	  pBlock *apb;
-
-		{
-		  int i, found=-1;
-
-			sym = OP_SYMBOL( IC_LEFT(ic));
-			for(i=0;i<=2;i++) {
-				if(interrupts[i]->name
-					&& !STRCASECMP(interrupts[i]->name, sym->name)) {
-					found = i;
-					break;
-				}
-			}
-			
-			if(found == -1) {
-				fprintf(stderr, "PIC16 port: %s:%d: interrupt function but cannot locate symbol (%s)\n",
-					__FILE__, __LINE__, sym->name);
-				assert( 0 );
-			}
-			_G.interruptvector = found;
-		}
+    ftype = operandType(IC_LEFT(ic));
+    sym = OP_SYMBOL(IC_LEFT(ic));
 
-		sprintf(asymname, "ivec_%d_%s", _G.interruptvector, sym->name);
-		asym = newSymbol(asymname, 0);
+    if(IFFUNC_ISISR(sym->type /*ftype*/)) {
+      /* create an absolute section at the interrupt vector:
+       * that is 0x0008 for interrupt 1 (high), 0x0018 interrupt 2 (low) */
+      symbol *asym;
+      char asymname[128];
+      pBlock *apb;
 
-		apb = pic16_newpCodeChain(NULL, 'A', pic16_newpCodeCharP("; Starting pCode block for absolute section"));
-		pic16_addpBlock( apb );
+//        debugf("interrupt number: %hhi\n", FUNC_INTNO(sym->type));
 
-		pic16_addpCode2pBlock(apb,
-			pic16_newpCodeCharP(";-----------------------------------------"));
-
-
-		pic16_addpCode2pBlock(apb, pic16_newpCodeFunction(moduleName, asym->name));
-
-		pic16_addpCode2pBlock(apb,
-			pic16_newpCode(POC_GOTO, pic16_popGetWithString( sym->rname )));
+        if(FUNC_INTNO(sym->type) == INTNO_UNSPEC)
+          sprintf(asymname, "ivec_%s", sym->name);
+        else
+          sprintf(asymname, "ivec_0x%x_%s", FUNC_INTNO(sym->type), sym->name);
+  
+        /* when an interrupt is declared as naked, do not emit the special
+         * wrapper segment at vector address. The user should take care for
+         * this instead. -- VR */
+
+        if(!IFFUNC_ISNAKED(ftype) && (FUNC_INTNO(sym->type) != INTNO_UNSPEC)) {
+          asym = newSymbol(asymname, 0);
+          apb = pic16_newpCodeChain(NULL, 'A', pic16_newpCodeCharP("; Starting pCode block for absolute section"));
+          pic16_addpBlock( apb );
+
+          pic16_addpCode2pBlock(apb, pic16_newpCodeCharP(";-----------------------------------------"));
+          pic16_addpCode2pBlock(apb, pic16_newpCodeFunction(moduleName, asym->name));
+          //pic16_addpCode2pBlock(apb, pic16_newpCode(POC_GOTO, pic16_popGetWithString( sym->rname )));
+          //pic16_addpCode2pBlock(apb, pic16_newpCode(POC_GOTO, pic16_newpCodeOpLabel (sym->rname, 0)));
+	  pic16_addpCode2pBlock(apb, pic16_newpCodeAsmDir ("GOTO", "%s", sym->rname)); /* this suppresses a warning in LinkFlow */
 		
-		/* mark the end of this tiny function */
-		pic16_addpCode2pBlock(apb,pic16_newpCodeFunction(NULL,NULL));
-
-		{
-		  absSym *abSym;
-
-			abSym = Safe_calloc(1, sizeof(absSym));
-			abSym->name = Safe_strdup( asymname );
-
-			switch( _G.interruptvector ) {
-				case 0: abSym->address = 0x000000; break;
-				case 1: abSym->address = 0x000008; break;
-				case 2: abSym->address = 0x000018; break;
-			}
-
-			/* relocate interrupt vectors if needed */
-			abSym->address += pic16_options.ivt_loc;
-
-			addSet(&absSymSet, abSym);
-		}
-	}
-
-
-	/* create the function header */
-	pic16_emitcode(";","-----------------------------------------");
-	pic16_emitcode(";"," function %s",sym->name);
-	pic16_emitcode(";","-----------------------------------------");
-
-	pic16_emitcode("","%s:",sym->rname);
-	pic16_addpCode2pBlock(pb,pic16_newpCodeFunction(moduleName,sym->rname));
-
+          /* mark the end of this tiny function */
+          pic16_addpCode2pBlock(apb,pic16_newpCodeFunction(NULL,NULL));
+        } else {
+          sprintf(asymname, "%s", sym->rname);
+        }
 
 	{
-	  absSym *ab;
+	  absSym *abSym;
 
-		for(ab = setFirstItem(absSymSet); ab; ab = setNextItem(absSymSet))
-			if(!strcmp(ab->name, sym->name)) {
-				pic16_pBlockConvert2Absolute(pb);
-				break;
-			}
+	    abSym = Safe_calloc(1, sizeof(absSym));
+	    strcpy(abSym->name, asymname);
 
-	}
+	    switch( FUNC_INTNO(sym->type) ) {
+	      case 0: abSym->address = 0x000000; break;
+              case 1: abSym->address = 0x000008; break;
+              case 2: abSym->address = 0x000018; break;
+              
+              default:
+//                fprintf(stderr, "no interrupt number is given\n");
+                abSym->address = -1; break;
+            }
 
+            /* relocate interrupt vectors if needed */
+            if(abSym->address != -1)
+              abSym->address += pic16_options.ivt_loc;
 
-	if(IFFUNC_ISNAKED(ftype)) {
-		DEBUGpic16_emitcode("; ***", "_naked function, no prologue");
-		return;
-	}
-	
-	/* if critical function then turn interrupts off */
-	if (IFFUNC_ISCRITICAL(ftype)) {
-	  //pic16_emitcode("clr","ea");
+            addSet(&absSymSet, abSym);
         }
+    }
 
-        _G.fregsUsed = sym->regsUsed;
-
-	/* if this is an interrupt service routine then
-	 * save acc, b, dpl, dph  */
-	if (IFFUNC_ISISR(sym->type)) {
-	  int i;
-
-	        _G.usefastretfie = 1;	/* use shadow registers by default */
-		/* an ISR should save: WREG, STATUS, BSR, PRODL, PRODH, FSR0L, FSR0H */
-		if(!(_G.interruptvector == 1)) {
-
-			/* do not save WREG,STATUS,BSR for high priority interrupts
-			 * because they are stored in the hardware shadow registers already */
-			_G.usefastretfie = 0;
-			pic16_pushpCodeOp( pic16_popCopyReg( &pic16_pc_wreg ));
-			pic16_pushpCodeOp( pic16_popCopyReg( &pic16_pc_status ));
-			pic16_pushpCodeOp( pic16_popCopyReg( &pic16_pc_bsr ));
-		}
-
-
-                /* these should really be optimized somehow, because not all
-                 * interrupt handlers modify them */
-		pic16_pushpCodeOp( pic16_popCopyReg( &pic16_pc_prodl ));
-		pic16_pushpCodeOp( pic16_popCopyReg( &pic16_pc_prodh ));
-		pic16_pushpCodeOp( pic16_popCopyReg( &pic16_pc_fsr0l ));
-		pic16_pushpCodeOp( pic16_popCopyReg( &pic16_pc_fsr0h ));
-
-//                pic16_pBlockConvert2ISR(pb);
-                
-		/* if any registers used */
-		if (sym->regsUsed) {
-			/* save the registers used */
-			DEBUGpic16_emitcode("; **", "Saving used registers in stack");
-			for ( i = 0 ; i < sym->regsUsed->size ; i++) {
-				if (bitVectBitValue(sym->regsUsed,i)) {
-#if 0
-					fprintf(stderr, "%s:%d function %s uses register %s\n",
-							__FILE__, __LINE__, OP_SYMBOL(IC_LEFT(ic))->name,
-							pic16_regWithIdx(i)->name);
-#endif
-
-					pic16_pushpCodeOp( pic16_popRegFromIdx(i) );
-					_G.nRegsSaved++;
-
-					if(!pic16_regWithIdx(i)->wasUsed) {
-						fprintf(stderr, "%s:%d register %s is used in function but was wasUsed = 0d\n",
-							__FILE__, __LINE__, pic16_regWithIdx(i)->name);
+    /* create the function header */
+    pic16_emitcode(";","-----------------------------------------");
+    pic16_emitcode(";"," function %s",sym->name);
+    pic16_emitcode(";","-----------------------------------------");
 
-						pic16_regWithIdx(i)->wasUsed = 1;
-					}
-				}
-			}
-		}
-	} else {
-		/* emit code to setup stack frame if user enabled,
-		 * and function is not main() */
-	 
-//		fprintf(stderr, "function name: %s\n", sym->name);
-		if(strcmp(sym->name, "main")) {
- 			if(/*!options.ommitFramePtr || sym->regsUsed*/1) {
-			/* setup the stack frame */
-				pic16_emitpcode(POC_MOVFF, pic16_popCombine2( &pic16_pc_fsr2l, &pic16_pc_postdec1, 0));
-				pic16_emitpcode(POC_MOVFF, pic16_popCombine2( &pic16_pc_fsr1l, &pic16_pc_fsr2l, 0));
-				if(STACK_MODEL_LARGE)
-					pic16_emitpcode(POC_MOVFF, pic16_popCombine2( &pic16_pc_fsr1h, &pic16_pc_fsr2h, 0));
-			}
-		}
+    pic16_emitcode("","%s:",sym->rname);
+    pic16_addpCode2pBlock(pb,pic16_newpCodeFunction(moduleName,sym->rname));
 
-		/* if callee-save to be used for this function
-		* then save the registers being used in this function */
-//		if (IFFUNC_CALLEESAVES(sym->type))
-		{
-		  int i;
+    {
+      absSym *ab;
 
-//			fprintf(stderr, "%s:%d function sym->regsUsed= %d\n", __FILE__, __LINE__, sym->regsUsed->size);
+        for(ab = setFirstItem(absSymSet); ab; ab = setNextItem(absSymSet)) {
+          if(!strcmp(ab->name, sym->rname)) {
+            pic16_pBlockConvert2Absolute(pb);
+            break;
+          }
+        }
+    }
 
-//			pic16_emitpcomment("entry regsUsed: %d\n", sym->regsUsed?sym->regsUsed->size:-1);
+    if(IFFUNC_ISNAKED(ftype)) {
+      DEBUGpic16_emitcode("; ***", "_naked function, no prologue");
+      return;
+    }
+	
+    /* if critical function then turn interrupts off */
+    if (IFFUNC_ISCRITICAL(ftype)) {
+      //pic16_emitcode("clr","ea");
+    }
 
-			/* if any registers used */
-			if (sym->regsUsed) {
-				/* save the registers used */
-				DEBUGpic16_emitcode("; **", "Saving used registers in stack");
-				for ( i = 0 ; i < sym->regsUsed->size ; i++) {
-					if (bitVectBitValue(sym->regsUsed,i)) {
+    currFunc = sym;		/* update the currFunc symbol */
+    _G.fregsUsed = sym->regsUsed;
+    _G.sregsAlloc = newBitVect(128);
+    
 
-#if 0
-						fprintf(stderr, "%s:%d function %s uses register %s (wasUsed: %d, %p)\n",
-								__FILE__, __LINE__, OP_SYMBOL(IC_LEFT(ic))->name,
-								pic16_regWithIdx(i)->name,
-								pic16_regWithIdx(i)->wasUsed,
-								pic16_regWithIdx(i));
-#endif
+    /* if this is an interrupt service routine then
+     * save wreg, status, bsr, prodl, prodh, fsr0l, fsr0h */
+    if (IFFUNC_ISISR(sym->type)) {
+        _G.usefastretfie = 1;	/* use shadow registers by default */
+        
+        /* an ISR should save: WREG, STATUS, BSR, PRODL, PRODH, FSR0L, FSR0H */
+        if(!FUNC_ISSHADOWREGS(sym->type)) {
+          /* do not save WREG,STATUS,BSR for high priority interrupts
+           * because they are stored in the hardware shadow registers already */
+          _G.usefastretfie = 0;
+          pic16_pushpCodeOp( pic16_popCopyReg( &pic16_pc_wreg ));
+          pic16_pushpCodeOp( pic16_popCopyReg( &pic16_pc_status ));
+          pic16_pushpCodeOp( pic16_popCopyReg( &pic16_pc_bsr ));
+        }
 
-						pic16_pushpCodeOp( pic16_popRegFromIdx(i) );
+        /* these should really be optimized somehow, because not all
+         * interrupt handlers modify them */
+        pic16_pushpCodeOp( pic16_popCopyReg( &pic16_pc_prodl ));
+        pic16_pushpCodeOp( pic16_popCopyReg( &pic16_pc_prodh ));
+        pic16_pushpCodeOp( pic16_popCopyReg( &pic16_pc_fsr0l ));
+        pic16_pushpCodeOp( pic16_popCopyReg( &pic16_pc_fsr0h ));
+        
+//        pic16_pBlockConvert2ISR(pb);
+    }
 
-//						pic16_emitpcode(POC_MOVFF, pic16_popCombine2(
-//							PCOR(pic16_popCopyReg( PCOR(pic16_popRegFromIdx(i)))),
-//							&pic16_pc_postdec1, 0));
+    /* emit code to setup stack frame if user enabled,
+     * and function is not main() */
+    
+//    debugf(stderr, "function name: %s ARGS=%p\n", sym->name, FUNC_ARGS(sym->type));
+    if(strcmp(sym->name, "main")) {
+      if(0 
+        || !options.ommitFramePtr 
+//        || sym->regsUsed
+        || IFFUNC_ARGS(sym->type)
+        || FUNC_HASSTACKPARM(sym->etype)
+        ) {
+        /* setup the stack frame */
+        if(STACK_MODEL_LARGE)
+          pic16_pushpCodeOp(pic16_popCopyReg(pic16_framepnt_hi));
+        pic16_pushpCodeOp(pic16_popCopyReg(pic16_framepnt_lo));
+
+        pic16_emitpcode(POC_MOVFF, pic16_popCombine2( pic16_stackpnt_lo, pic16_framepnt_lo, 0));
+        if(STACK_MODEL_LARGE)
+          pic16_emitpcode(POC_MOVFF, pic16_popCombine2( pic16_stackpnt_hi, pic16_framepnt_hi, 0));
+      }
+    }
 
-						_G.nRegsSaved++;
+    if ((IFFUNC_ISREENT(sym->type) || options.stackAuto)
+          && sym->stack) {
 
-						if(!pic16_regWithIdx(i)->wasUsed) {
-							fprintf(stderr, "%s:%d register %s is used in function but was wasUsed = 0d\n",
-								__FILE__, __LINE__, pic16_regWithIdx(i)->name);
+      if (sym->stack > 127)werror(W_STACK_OVERFLOW, sym->name);
 
-							pic16_regWithIdx(i)->wasUsed = 1;
-						}
-					
-					}
-				}
-			}
-		}
-   	}
+      pic16_emitpcode(POC_MOVLW, pic16_popGetLit(sym->stack));
+      pic16_emitpcode(POC_SUBWF, pic16_popCopyReg( pic16_stackpnt_lo ));	//&pic16_pc_fsr1l));
+      emitSKPC;
+      pic16_emitpcode(POC_DECF, pic16_popCopyReg( pic16_stackpnt_hi ));		//&pic16_pc_fsr1h));
+    }
+          
+    if(inWparamList(sym->name) || FUNC_ISWPARAM(sym->type)) {
+      if(IFFUNC_HASVARARGS(sym->type) || IFFUNC_ISREENT(sym->type))
+        _G.useWreg = 0;
+      else
+        _G.useWreg = 1;
+    } else
+      _G.useWreg = 0;
 
+    /* if callee-save to be used for this function
+     * then save the registers being used in this function */
+//    if (IFFUNC_CALLEESAVES(sym->type))
+    {
+      int i;
 
+        /* if any registers used */
+        if (sym->regsUsed) {
+          /* save the registers used */
+          DEBUGpic16_emitcode("; **", "Saving used registers in stack");
+          pic16_emitpinfo(INF_LOCALREGS, pic16_newpCodeOpLocalRegs(LR_ENTRY_BEGIN));
+          for ( i = 0 ; i < sym->regsUsed->size ; i++) {
+            if (bitVectBitValue(sym->regsUsed,i)) {
+              pic16_pushpCodeOp( pic16_popRegFromIdx(i) );
+              _G.nRegsSaved++;
+
+              if(!pic16_regWithIdx(i)->wasUsed) {
+                fprintf(stderr, "%s:%d register %s is used in function but was wasUsed = 0d\n",
+                              __FILE__, __LINE__, pic16_regWithIdx(i)->name);
+                pic16_regWithIdx(i)->wasUsed = 1;
+              }
+            }
+          }
+          pic16_emitpinfo(INF_LOCALREGS, pic16_newpCodeOpLocalRegs(LR_ENTRY_END));
+        }
+    }
 	
-#if 0
-	if (IFFUNC_ISREENT(sym->type) || options.stackAuto) {
-
-		if (options.useXstack) {
-			pic16_emitcode("mov","r0,%s",spname);
-			pic16_emitcode("mov","a,_bp");
-			pic16_emitcode("movx","@r0,a");
-			pic16_emitcode("inc","%s",spname);
-		} else {
-			/* set up the stack */
-			pic16_emitcode ("push","_bp");     /* save the callers stack  */
-		}
-		pic16_emitcode ("mov","_bp,%s",spname);
-	}
-#endif
-	DEBUGpic16_emitcode("; ", "need to adjust stack = %d", sym->stack);
-
-	/* adjust the stack for the function */
-	if (sym->stack) {
-	  int i = sym->stack;
-
-		if (i > 127 ) 
-			werror(W_STACK_OVERFLOW,sym->name);
-
-		if (i > 3 && sym->recvSize < 4) {	       
-			pic16_emitcode ("mov","a,sp");
-			pic16_emitcode ("add","a,#0x%02x",((char)sym->stack & 0xff));
-			pic16_emitcode ("mov","sp,a");
-		} else
-			while(i--)
-				pic16_emitcode("inc","sp");
-	}
-
-	if (sym->xstack) {
-		DEBUGpic16_emitcode("; ", "%s", __FUNCTION__);
-
-		pic16_emitcode ("mov","a,_spx");
-		pic16_emitcode ("add","a,#0x%02x",((char)sym->xstack & 0xff));
-		pic16_emitcode ("mov","_spx,a");
-	}
-    
+    DEBUGpic16_emitcode("; ", "need to adjust stack = %d", sym->stack);
+//    fprintf(stderr, "Function '%s' uses %d bytes of stack\n", sym->name, sym->stack);
 }
 
 /*-----------------------------------------------------------------*/
@@ -3644,13 +3849,13 @@ static void genFunction (iCode *ic)
 /*-----------------------------------------------------------------*/
 static void genEndFunction (iCode *ic)
 {
-    symbol *sym = OP_SYMBOL(IC_LEFT(ic));
+  symbol *sym = OP_SYMBOL(IC_LEFT(ic));
 
-    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+    FENTRY;
 
     if(IFFUNC_ISNAKED(sym->type)) {
-    	DEBUGpic16_emitcode("; ***", "_naked function, no epilogue");
-    	return;
+      DEBUGpic16_emitcode("; ***", "_naked function, no epilogue");
+      return;
     }
 
     _G.stack_lat = 0;
@@ -3662,171 +3867,161 @@ static void genEndFunction (iCode *ic)
       /* TODO: add code here -- VR */
     }
     
+//    sym->regsUsed = _G.fregsUsed;
+    
+    /* now we need to restore the registers */
+    /* if any registers used */
 
-#if 0
-    if (IFFUNC_ISREENT(sym->type) || options.stackAuto)
-    {
-        pic16_emitcode ("mov","%s,_bp",spname);
-    }
-#endif
-
-    /* if use external stack but some variables were
-    added to the local stack then decrement the
-    local stack */
-    if (options.useXstack && sym->stack) {      
-        pic16_emitcode("mov","a,sp");
-        pic16_emitcode("add","a,#0x%02x",((char)-sym->stack) & 0xff);
-        pic16_emitcode("mov","sp,a");
+    /* first restore registers that might be used for stack access */
+    if(_G.sregsAllocSet) {
+    regs *sr;
+    
+      _G.sregsAllocSet = reverseSet( _G.sregsAllocSet );
+      for(sr=setFirstItem(_G.sregsAllocSet) ; sr; sr=setNextItem(_G.sregsAllocSet)) {
+        pic16_poppCodeOp( pic16_popRegFromIdx( sr->rIdx ) );
+      }
     }
 
+    if (sym->regsUsed) {
+      int i;
 
-#if 0
-    if ((IFFUNC_ISREENT(sym->type) || options.stackAuto)) {
-	if (options.useXstack) {
-	    pic16_emitcode("mov","r0,%s",spname);
-	    pic16_emitcode("movx","a,@r0");
-	    pic16_emitcode("mov","_bp,a");
-	    pic16_emitcode("dec","%s",spname);
-	}
-	else
-	{
-	    pic16_emitcode ("pop","_bp");
-	}
+        pic16_emitpinfo(INF_LOCALREGS, pic16_newpCodeOpLocalRegs(LR_EXIT_BEGIN));
+        /* restore registers used */
+        DEBUGpic16_emitcode("; **", "Restoring used registers from stack");
+        for ( i = sym->regsUsed->size; i >= 0; i--) {
+          if (bitVectBitValue(sym->regsUsed,i)) {
+            pic16_poppCodeOp( pic16_popRegFromIdx(i) );
+            _G.nRegsSaved--;
+          }
+        }
+        pic16_emitpinfo(INF_LOCALREGS, pic16_newpCodeOpLocalRegs(LR_EXIT_END));
     }
-#endif
 
-	if (IFFUNC_ISISR(sym->type)) {
-		/* now we need to restore the registers */
-		/* if any registers used */
-		if (sym->regsUsed) {
-		  int i;
-
-			/* restore registers used */
-			DEBUGpic16_emitcode("; **", "Restoring used registers from stack");
-			for ( i = sym->regsUsed->size; i >= 0; i--) {
-				if (bitVectBitValue(sym->regsUsed,i)) {
+      
 
-//					fprintf(stderr, "%s:%d function %s uses register %s (restoring)\n",
-//							__FILE__, __LINE__, OP_SYMBOL(IC_LEFT(ic))->name,
-//							pic16_regWithIdx(i)->name);
+    if ((IFFUNC_ISREENT(sym->type) || options.stackAuto)
+          && sym->stack) {
+      if (sym->stack == 1) {
+        pic16_emitpcode(POC_INFSNZ, pic16_popCopyReg( pic16_stackpnt_lo ));
+        pic16_emitpcode(POC_INCF, pic16_popCopyReg( pic16_stackpnt_hi ));
+      } else {
+        // we have to add more than one...
+        pic16_emitpcode(POC_MOVWF, pic16_popCopyReg( pic16_stack_postinc ));	// this holds a return value!
+        pic16_emitpcode(POC_MOVLW, pic16_popGetLit(sym->stack-1));
+        pic16_emitpcode(POC_ADDWF, pic16_popCopyReg( pic16_stackpnt_lo ));
+        emitSKPNC;
+        pic16_emitpcode(POC_INCF, pic16_popCopyReg( pic16_stackpnt_hi ));
+        pic16_emitpcode(POC_COMF,  pic16_popCopyReg(&pic16_pc_wreg)); // WREG = -(WREG+1)!
+        pic16_emitpcode(POC_MOVFW, pic16_popCopyReg(pic16_stack_plusw)); // this holds a retrun value!
+      }
+    }
 
-					pic16_poppCodeOp( pic16_popRegFromIdx(i) );
+    if(strcmp(sym->name, "main")) {
+      if(0
+        || !options.ommitFramePtr
+//        || sym->regsUsed
+        || IFFUNC_ARGS(sym->type)
+        || FUNC_HASSTACKPARM(sym->etype)
+        ) {
+        /* restore stack frame */
+        if(STACK_MODEL_LARGE)
+          pic16_poppCodeOp( pic16_popCopyReg( pic16_framepnt_hi ));
+        pic16_poppCodeOp( pic16_popCopyReg( pic16_framepnt_lo ));
+      }
+    }
 
-//					pic16_emitpcode(POC_MOVFF, pic16_popCombine2(
-//							&pic16_pc_preinc1,
-//							PCOR(pic16_popCopyReg( PCOR(pic16_popRegFromIdx(i)))), 0));
+    _G.useWreg = 0;
 
-				}
-			}
-		}
-	
-		pic16_poppCodeOp( pic16_popCopyReg( &pic16_pc_fsr0h ));
-		pic16_poppCodeOp( pic16_popCopyReg( &pic16_pc_fsr0l));
-		pic16_poppCodeOp( pic16_popCopyReg( &pic16_pc_prodh ));
-		pic16_poppCodeOp( pic16_popCopyReg( &pic16_pc_prodl ));
-
-		if(!(_G.interruptvector == 1)) {
-			/* do not restore interrupt vector for WREG,STATUS,BSR
-			 * for high priority interrupt, see genFunction */
-			 
-			pic16_poppCodeOp( pic16_popCopyReg( &pic16_pc_bsr ));
-			pic16_poppCodeOp( pic16_popCopyReg( &pic16_pc_status ));
-			pic16_poppCodeOp( pic16_popCopyReg( &pic16_pc_wreg ));
-		}
-	
-		_G.interruptvector = 0;		/* sanity check */
+    if (IFFUNC_ISISR(sym->type)) {
+      pic16_poppCodeOp( pic16_popCopyReg( &pic16_pc_fsr0h ));
+      pic16_poppCodeOp( pic16_popCopyReg( &pic16_pc_fsr0l));
+      pic16_poppCodeOp( pic16_popCopyReg( &pic16_pc_prodh ));
+      pic16_poppCodeOp( pic16_popCopyReg( &pic16_pc_prodl ));
 
-//		pic16_pBlockConvert2ISR(pb);
+      if(!FUNC_ISSHADOWREGS(sym->type)) {
+        /* do not restore interrupt vector for WREG,STATUS,BSR
+         * for high priority interrupt, see genFunction */
+	pic16_poppCodeOp( pic16_popCopyReg( &pic16_pc_bsr ));
+	pic16_poppCodeOp( pic16_popCopyReg( &pic16_pc_status ));
+	pic16_poppCodeOp( pic16_popCopyReg( &pic16_pc_wreg ));
+      }
+//      _G.interruptvector = 0;		/* sanity check */
 
 
-		/* if debug then send end of function */
-/* 	if (options.debug && currFunc)  */
-		if (currFunc) {
-			debugFile->writeEndFunction (currFunc, ic, 1);
-		}
-	
-		if(_G.usefastretfie)
-			pic16_emitpcode(POC_RETFIE, pic16_newpCodeOpLit(1));
-		else
-		pic16_emitpcodeNULLop(POC_RETFIE);
-		_G.usefastretfie = 0;
-	} else {
-		if (IFFUNC_ISCRITICAL(sym->type))
-			pic16_emitcode("setb","ea");
+      /* if debug then send end of function */
+/*	if (options.debug && currFunc)  */
+      if (currFunc) {
+        debugFile->writeEndFunction (currFunc, ic, 1);
+      }
 	
+      if(_G.usefastretfie)
+        pic16_emitpcode(POC_RETFIE, pic16_newpCodeOpLit(1));
+      else
+        pic16_emitpcodeNULLop(POC_RETFIE);
 
-//		pic16_emitpcomment("exit regsUsed: %d\n", sym->regsUsed?sym->regsUsed->size:-1);
+      pic16_addpCode2pBlock(pb,pic16_newpCodeFunction(NULL,NULL));
+      
+      _G.usefastretfie = 0;
+      return;
+    }
 
-		/* if any registers used */
-		if (sym->regsUsed) {
-		  int i;
-			/* save the registers used */
-			DEBUGpic16_emitcode("; **", "Restoring used registers from stack");
-			for ( i = sym->regsUsed->size; i >= 0; i--) {
-				if (bitVectBitValue(sym->regsUsed,i)) {
-	
-//					fprintf(stderr, "%s:%d function %s uses register %s (restoring)\n",
-//							__FILE__, __LINE__, OP_SYMBOL(IC_LEFT(ic))->name,
-//							pic16_regWithIdx(i)->name);
-	
-					pic16_poppCodeOp( pic16_popRegFromIdx(i) );
-	        			
-//					pic16_emitpcode(POC_MOVFF, pic16_popCombine2(
-//						&pic16_pc_preinc1,
-//						PCOR(pic16_popCopyReg( PCOR(pic16_popRegFromIdx(i)))), 0));
+    if (IFFUNC_ISCRITICAL(sym->type)) {
+      pic16_emitcode("setb","ea");
+    }
 
-					_G.nRegsSaved--;
-				}
-			}
-		}
-	
-//		pic16_emitpcomment("%s: _G.nRegsSaved upon exit from function: %d\n", __FUNCTION__, _G.nRegsSaved);
-		/* if debug then send end of function */
-		if (currFunc) {
-			debugFile->writeEndFunction (currFunc, ic, 1);
-		}
+    /* if debug then send end of function */
+    if (currFunc) {
+      debugFile->writeEndFunction (currFunc, ic, 1);
+    }
 
-		/* insert code to restore stack frame, if user enabled it
-		 * and function is not main() */
+    /* insert code to restore stack frame, if user enabled it
+     * and function is not main() */
 	 
 
-		if(strcmp(sym->name, "main")) {
-			if(1/*!options.ommitFramePtr ||*/ /*sym->regsUsed*/) {
-				/* restore stack frame */
-				if(STACK_MODEL_LARGE)
-					pic16_emitpcode(POC_MOVFF,
-						pic16_popCombine2( &pic16_pc_preinc1, &pic16_pc_fsr2h, 0));
-				pic16_emitpcode(POC_MOVFF,
-						pic16_popCombine2( &pic16_pc_preinc1, &pic16_pc_fsr2l, 0));
-			}
-		}
-
-		pic16_emitpcodeNULLop(POC_RETURN);
-
-		/* Mark the end of a function */
-		pic16_addpCode2pBlock(pb,pic16_newpCodeFunction(NULL,NULL));
-	}
+    pic16_emitpcodeNULLop(POC_RETURN);
 
+    /* Mark the end of a function */
+    pic16_addpCode2pBlock(pb,pic16_newpCodeFunction(NULL,NULL));
 }
 
 
-void pic16_storeForReturn(operand *op, int offset, pCodeOp *dest)
+void pic16_storeForReturn(iCode *ic, /*operand *op,*/ int offset, pCodeOp *dest)
 {
+  unsigned long lit=1;
+  operand *op;
 
-	if(is_LitOp(op)) {
-		pic16_emitpcode(POC_MOVLW, pic16_popGet(AOP(op), offset)); // patch 12
+    op = IC_LEFT(ic);
+  
+    // this fails for is_LitOp(op) (if op is an AOP_PCODE)
+    if(AOP_TYPE(op) == AOP_LIT) {
+      if(!IS_FLOAT(operandType( op ))) {
+        lit = (unsigned long)floatFromVal(AOP(op)->aopu.aop_lit);
+      } else {
+        union {
+          unsigned long lit_int;
+          float lit_float;
+        } info;
+	
+        /* take care if literal is a float */
+        info.lit_float = floatFromVal(AOP(op)->aopu.aop_lit);
+        lit = info.lit_int;
+      }
+    }
 
-		if(dest->type != PO_WREG)
-			pic16_emitpcode(POC_MOVWF, dest);
-	} else {
-		if(dest->type == PO_WREG && (offset == 0)) {
-			pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(op), offset));
-			return;
-		}
-		
-		pic16_emitpcode(POC_MOVFF, pic16_popGet2p(
-			pic16_popGet(AOP(op), offset), dest));
-	}
+    if(is_LitOp(op)) {
+      if(/*(OP_LIVETO(op) <= ic->seq) &&*/ (lit == 0)) {
+        pic16_emitpcode(POC_CLRF, dest);
+      } else {
+        pic16_emitpcode(POC_MOVLW, pic16_popGet(AOP(op), offset));
+        if(dest->type != PO_WREG)pic16_emitpcode(POC_MOVWF, dest);
+      }
+    } else {
+      if(dest->type == PO_WREG && (offset == 0)) {
+        pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(op), offset));
+      return;
+    }
+    pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(op), offset), dest));
+  }
 }
 
 /*-----------------------------------------------------------------*/
@@ -3837,7 +4032,7 @@ static void genRet (iCode *ic)
   int size;
   operand *left;
 
-	DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+    FENTRY;
 	/* if we have no return value then
 	 * just generate the "ret" */
 	
@@ -3850,27 +4045,16 @@ static void genRet (iCode *ic)
 	size = AOP_SIZE(IC_LEFT(ic));
 
 	if(size <= 4) {
-		if(size>3) {
-			pic16_storeForReturn(IC_LEFT(ic), 3, pic16_popCopyReg(&pic16_pc_fsr0l));
-//			pic16_emitpcode(POC_MOVFF,
-//				pic16_popGet2p(pic16_popGet(AOP(IC_LEFT(ic)), 3), pic16_popCopyReg(&pic16_pc_fsr0l)));
-		}
-		if(size>2) {
-			pic16_storeForReturn(IC_LEFT(ic), 2, pic16_popCopyReg(&pic16_pc_prodh));
-//			pic16_emitpcode(POC_MOVFF,
-//				pic16_popGet2p(pic16_popGet(AOP(IC_LEFT(ic)), 2), pic16_popCopyReg(&pic16_pc_prodh)));
-		}
-		if(size>1) {
-			pic16_storeForReturn(IC_LEFT(ic), 1, pic16_popCopyReg(&pic16_pc_prodl));
-//			pic16_emitpcode(POC_MOVFF,
-//				pic16_popGet2p(pic16_popGet(AOP(IC_LEFT(ic)), 1), pic16_popCopyReg(&pic16_pc_prodl)));
-		}
-
-//		pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(IC_LEFT(ic)), 0));  // patch 12
+	  if(size>3)
+	    pic16_storeForReturn(ic, /*IC_LEFT(ic),*/ 3, pic16_popCopyReg(&pic16_pc_fsr0l));
+          
+          if(size>2)
+            pic16_storeForReturn(ic, /*IC_LEFT(ic),*/ 2, pic16_popCopyReg(&pic16_pc_prodh));
 
-		pic16_storeForReturn(IC_LEFT(ic), 0, pic16_popCopyReg(&pic16_pc_wreg));  // patch 12
-//		pic16_emitpcode(POC_MOVFF,
-//			pic16_popGet2p(pic16_popGet(AOP(IC_LEFT(ic)), 0), pic16_popCopyReg(&pic16_pc_wreg)));
+          if(size>1)
+            pic16_storeForReturn(ic, /*IC_LEFT(ic),*/ 1, pic16_popCopyReg(&pic16_pc_prodl));
+          
+          pic16_storeForReturn(ic, /*IC_LEFT(ic),*/ 0, pic16_popCopyReg(&pic16_pc_wreg));
 
 	} else {
 		/* >32-bits, setup stack and FSR0 */
@@ -3886,13 +4070,13 @@ static void genRet (iCode *ic)
 			
 		/* setup FSR0 */
 		pic16_emitpcode(POC_MOVFF, pic16_popGet2p(
-			pic16_popCopyReg(&pic16_pc_fsr1l), pic16_popCopyReg(&pic16_pc_fsr0l)));
+			pic16_popCopyReg( pic16_stackpnt_lo ), pic16_popCopyReg(&pic16_pc_fsr0l)));
 
 		if(STACK_MODEL_LARGE) {
 			pic16_emitpcode(POC_MOVFF, pic16_popGet2p(
-				pic16_popCopyReg(&pic16_pc_fsr1h), pic16_popCopyReg(&pic16_pc_fsr0h)));
+				pic16_popCopyReg( pic16_stackpnt_hi ), pic16_popCopyReg(&pic16_pc_fsr0h)));
 		} else {
-			pic16_emitpcode(POC_CLRF, pic16_popCopyReg( &pic16_pc_fsr1h ) );
+			pic16_emitpcode(POC_CLRF, pic16_popCopyReg( pic16_stackpnt_hi ));
 		}
 	}
 				
@@ -3957,15 +4141,14 @@ jumpret:
 /*-----------------------------------------------------------------*/
 static void genLabel (iCode *ic)
 {
+  FENTRY;
 
+  /* special case never generate */
+  if (IC_LABEL(ic) == entryLabel)
+    return ;
 
-    /* special case never generate */
-    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-    if (IC_LABEL(ic) == entryLabel)
-        return ;
-
-    pic16_emitpLabel(IC_LABEL(ic)->key);
-    pic16_emitcode("","_%05d_DS_:",(IC_LABEL(ic)->key+100 + pic16_labelOffset));
+  pic16_emitpLabel(IC_LABEL(ic)->key);
+//  pic16_emitcode("","_%05d_DS_:",(IC_LABEL(ic)->key+100 + pic16_labelOffset));
 }
 
 /*-----------------------------------------------------------------*/
@@ -3974,8 +4157,9 @@ static void genLabel (iCode *ic)
 //tsd
 static void genGoto (iCode *ic)
 {
+  FENTRY;
   pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_LABEL(ic)->key));
-  pic16_emitcode ("goto","_%05d_DS_",(IC_LABEL(ic)->key+100)+pic16_labelOffset);
+//  pic16_emitcode ("goto","_%05d_DS_",(IC_LABEL(ic)->key+100)+pic16_labelOffset);
 }
 
 
@@ -3986,7 +4170,7 @@ static void genMultbits (operand *left,
                          operand *right, 
                          operand *result)
 {
-  DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+  FENTRY;
 
   if(!pic16_sameRegs(AOP(result),AOP(right)))
     pic16_emitpcode(POC_BSF,  pic16_popGet(AOP(result),0));
@@ -4006,7 +4190,7 @@ static void genMultOneByte (operand *left,
                             operand *result)
 {
 
-  DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+  FENTRY;
   DEBUGpic16_pic16_AopType(__LINE__,left,right,result);
   DEBUGpic16_pic16_AopTypeSign(__LINE__,left,right,result);
 
@@ -4043,35 +4227,34 @@ static void genMultOneWord (operand *left,
                             operand *right,
                             operand *result)
 {
+  FENTRY;
+  DEBUGpic16_pic16_AopType(__LINE__,left,right,result);
+  DEBUGpic16_pic16_AopTypeSign(__LINE__,left,right,result);
 
-	DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-	DEBUGpic16_pic16_AopType(__LINE__,left,right,result);
-	DEBUGpic16_pic16_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;
-	}
+  /* (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 is checked already == 2 */
-//	size = AOP_SIZE(result);
+  /* size is checked already == 2 */
+//  size = AOP_SIZE(result);
 
-	if (AOP_TYPE(right) == AOP_LIT) {
-		pic16_emitpcomment("multiply lit val:%s by variable %s and store in %s", 
-					pic16_aopGet(AOP(right),0,FALSE,FALSE), 
-					pic16_aopGet(AOP(left),0,FALSE,FALSE), 
-					pic16_aopGet(AOP(result),0,FALSE,FALSE));
-	} else {
-		pic16_emitpcomment("multiply variable :%s by variable %s and store in %s", 
-					pic16_aopGet(AOP(right),0,FALSE,FALSE), 
-					pic16_aopGet(AOP(left),0,FALSE,FALSE), 
-					pic16_aopGet(AOP(result),0,FALSE,FALSE));
-	}
+  if (AOP_TYPE(right) == AOP_LIT) {
+    pic16_emitpcomment("multiply lit val:%s by variable %s and store in %s", 
+      pic16_aopGet(AOP(right),0,FALSE,FALSE), 
+      pic16_aopGet(AOP(left),0,FALSE,FALSE), 
+      pic16_aopGet(AOP(result),0,FALSE,FALSE));
+  } else {
+    pic16_emitpcomment("multiply variable :%s by variable %s and store in %s", 
+      pic16_aopGet(AOP(right),0,FALSE,FALSE), 
+      pic16_aopGet(AOP(left),0,FALSE,FALSE), 
+      pic16_aopGet(AOP(result),0,FALSE,FALSE));
+  }
 	
-	pic16_genMult16X16_16(left, right,result);
+  pic16_genMult16X16_16(left, right,result);
 }
 
 /*-----------------------------------------------------------------*/
@@ -4081,35 +4264,34 @@ static void genMultOneLong (operand *left,
                             operand *right,
                             operand *result)
 {
+  FENTRY;
+  DEBUGpic16_pic16_AopType(__LINE__,left,right,result);
+  DEBUGpic16_pic16_AopTypeSign(__LINE__,left,right,result);
 
-	DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-	DEBUGpic16_pic16_AopType(__LINE__,left,right,result);
-	DEBUGpic16_pic16_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;
-	}
+  /* (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 is checked already == 4 */
-//	size = AOP_SIZE(result);
+  /* size is checked already == 4 */
+//  size = AOP_SIZE(result);
 
-	if (AOP_TYPE(right) == AOP_LIT) {
-		pic16_emitpcomment("multiply lit val:%s by variable %s and store in %s", 
-					pic16_aopGet(AOP(right),0,FALSE,FALSE), 
-					pic16_aopGet(AOP(left),0,FALSE,FALSE), 
-					pic16_aopGet(AOP(result),0,FALSE,FALSE));
-	} else {
-		pic16_emitpcomment("multiply variable :%s by variable %s and store in %s", 
-					pic16_aopGet(AOP(right),0,FALSE,FALSE), 
-					pic16_aopGet(AOP(left),0,FALSE,FALSE), 
-					pic16_aopGet(AOP(result),0,FALSE,FALSE));
-	}
+  if (AOP_TYPE(right) == AOP_LIT) {
+    pic16_emitpcomment("multiply lit val:%s by variable %s and store in %s", 
+        pic16_aopGet(AOP(right),0,FALSE,FALSE), 
+        pic16_aopGet(AOP(left),0,FALSE,FALSE), 
+        pic16_aopGet(AOP(result),0,FALSE,FALSE));
+  } else {
+    pic16_emitpcomment("multiply variable :%s by variable %s and store in %s", 
+        pic16_aopGet(AOP(right),0,FALSE,FALSE), 
+        pic16_aopGet(AOP(left),0,FALSE,FALSE), 
+        pic16_aopGet(AOP(result),0,FALSE,FALSE));
+  }
 	
-	pic16_genMult32X32_32(left, right,result);
+  pic16_genMult32X32_32(left, right,result);
 }
 
 
@@ -4123,7 +4305,7 @@ static void genMult (iCode *ic)
   operand *right = IC_RIGHT(ic);
   operand *result= IC_RESULT(ic);   
 
-	DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+    FENTRY;
 	/* assign the amsops */
 	pic16_aopOp (left,ic,FALSE);
 	pic16_aopOp (right,ic,FALSE);
@@ -4180,10 +4362,9 @@ static void genDivbits (operand *left,
                         operand *right, 
                         operand *result)
 {
+  char *l;
 
-    char *l;
-
-    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+    FENTRY;
     /* the result must be bit */    
     pic16_emitcode("mov","b,%s",pic16_aopGet(AOP(right),0,FALSE,FALSE));
     l = pic16_aopGet(AOP(left),0,FALSE,FALSE);
@@ -4202,10 +4383,10 @@ static void genDivOneByte (operand *left,
                            operand *right,
                            operand *result)
 {
-    sym_link *opetype = operandType(result);
-    char *l ;
-    symbol *lbl ;
-    int size,offset;
+  sym_link *opetype = operandType(result);
+  char *l ;
+  symbol *lbl ;
+  int size,offset;
 
 	/* result = divident / divisor
 	 * - divident may be a register or a literal,
@@ -4215,7 +4396,8 @@ static void genDivOneByte (operand *left,
 	 * In addition we must handle signed and unsigned, which
 	 * result in 6 final different cases -- VR */
 
-    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+    FENTRY;
+    
     size = AOP_SIZE(result) - 1;
     offset = 1;
     /* signed or unsigned */
@@ -4358,7 +4540,8 @@ static void genDiv (iCode *ic)
 	 * Division functions written here just in case someone
 	 * wants to inline and not use the support libraries -- VR */
 
-    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+    FENTRY;
+    
     /* assign the amsops */
     pic16_aopOp (left,ic,FALSE);
     pic16_aopOp (right,ic,FALSE);
@@ -4394,9 +4577,11 @@ static void genModbits (operand *left,
                         operand *right, 
                         operand *result)
 {
+  char *l;
 
-    char *l;
-
+    FENTRY;  
+    
+    werror(W_POSSBUG2, __FILE__, __LINE__);
     /* the result must be bit */    
     pic16_emitcode("mov","b,%s",pic16_aopGet(AOP(right),0,FALSE,FALSE));
     l = pic16_aopGet(AOP(left),0,FALSE,FALSE);
@@ -4416,11 +4601,13 @@ static void genModOneByte (operand *left,
                            operand *right,
                            operand *result)
 {
-    sym_link *opetype = operandType(result);
-    char *l ;
-    symbol *lbl ;
+  sym_link *opetype = operandType(result);
+  char *l ;
+  symbol *lbl ;
+
+    FENTRY;
+    werror(W_POSSBUG2, __FILE__, __LINE__);
 
-    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
     /* signed or unsigned */
     if (SPEC_USIGN(opetype)) {
         /* unsigned is easy */
@@ -4488,11 +4675,12 @@ static void genModOneByte (operand *left,
 /*-----------------------------------------------------------------*/
 static void genMod (iCode *ic)
 {
-    operand *left = IC_LEFT(ic);
-    operand *right = IC_RIGHT(ic);
-    operand *result= IC_RESULT(ic);  
+  operand *left = IC_LEFT(ic);
+  operand *right = IC_RIGHT(ic);
+  operand *result= IC_RESULT(ic);  
 
-    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+    FENTRY;
+    
     /* assign the amsops */
     pic16_aopOp (left,ic,FALSE);
     pic16_aopOp (right,ic,FALSE);
@@ -4530,8 +4718,8 @@ release :
 */
 static void genIfxJump (iCode *ic, char *jval)
 {
-
-    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+  FENTRY;
+  
     /* if true label then we jump if condition
     supplied is true */
     if ( IC_TRUE(ic) ) {
@@ -4539,7 +4727,7 @@ static void genIfxJump (iCode *ic, char *jval)
 	if(strcmp(jval,"a") == 0)
 	  emitSKPZ;
 	else if (strcmp(jval,"c") == 0)
-	  emitSKPC;
+	  emitSKPNC;
 	else {
 	  DEBUGpic16_emitcode ("; ***","%d - assuming %s is in bit space",__LINE__,jval);	  
 	  pic16_emitpcode(POC_BTFSC,  pic16_newpCodeOpBit(jval,-1,1, PO_GPR_REGISTER));
@@ -4554,15 +4742,42 @@ static void genIfxJump (iCode *ic, char *jval)
 	if(strcmp(jval,"a") == 0)
 	  emitSKPNZ;
 	else if (strcmp(jval,"c") == 0)
-	  emitSKPNC;
+	  emitSKPC;
 	else {
 	  DEBUGpic16_emitcode ("; ***","%d - assuming %s is in bit space",__LINE__,jval);	  
 	  pic16_emitpcode(POC_BTFSS,  pic16_newpCodeOpBit(jval,-1,1, PO_GPR_REGISTER));
 	}
 
-	pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_FALSE(ic)->key));
-	pic16_emitcode(" goto","_%05d_DS_",IC_FALSE(ic)->key+100 + pic16_labelOffset);
+	pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_FALSE(ic)->key));
+	pic16_emitcode(" goto","_%05d_DS_",IC_FALSE(ic)->key+100 + pic16_labelOffset);
+
+    }
+
+
+    /* mark the icode as generated */
+    ic->generated = 1;
+}
+
+static void genIfxpCOpJump (iCode *ic, pCodeOp *jop)
+{
+  FENTRY;
+  
+    /* if true label then we jump if condition
+    supplied is true */
+    if ( IC_TRUE(ic) ) {
+      DEBUGpic16_emitcode ("; ***","%d - assuming is in bit space",__LINE__);	  
+      pic16_emitpcode(POC_BTFSC, jop);
+
+      pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_TRUE(ic)->key));
+      pic16_emitcode(" goto","_%05d_DS_",IC_TRUE(ic)->key+100 + pic16_labelOffset);
 
+    } else {
+      /* false label is present */
+      DEBUGpic16_emitcode ("; ***","%d - assuming is in bit space",__LINE__);
+      pic16_emitpcode(POC_BTFSS, jop);
+	  
+      pic16_emitpcode(POC_GOTO,pic16_popGetLabel(IC_FALSE(ic)->key));
+      pic16_emitcode(" goto","_%05d_DS_",IC_FALSE(ic)->key+100 + pic16_labelOffset);
     }
 
 
@@ -4636,14 +4851,15 @@ static void genSkipc(resolvedIfx *rifx)
     return;
 
   if(rifx->condition)
-    emitSKPC;
-  else
     emitSKPNC;
+  else
+    emitSKPC;
 
   pic16_emitpcode(POC_GOTO, pic16_popGetLabel(rifx->lbl->key));
   rifx->generated = 1;
 }
 
+#if !(USE_SIMPLE_GENCMP)
 /*-----------------------------------------------------------------*/
 /* genSkipz2                                                       */
 /*-----------------------------------------------------------------*/
@@ -4662,6 +4878,7 @@ static void genSkipz2(resolvedIfx *rifx, int invert_condition)
   pic16_emitpcode(POC_GOTO,pic16_popGetLabel(rifx->lbl->key));
   rifx->generated = 1;
 }
+#endif
 
 #if 0
 /*-----------------------------------------------------------------*/
@@ -4690,6 +4907,7 @@ static void genSkipz(iCode *ifx, int condition)
 }
 #endif
 
+#if !(USE_SIMPLE_GENCMP)
 /*-----------------------------------------------------------------*/
 /* genSkipCond                                                     */
 /*-----------------------------------------------------------------*/
@@ -4707,6 +4925,7 @@ static void genSkipCond(resolvedIfx *rifx,operand *op, int offset, int bit)
   pic16_emitpcode(POC_GOTO,pic16_popGetLabel(rifx->lbl->key));
   rifx->generated = 1;
 }
+#endif
 
 #if 0
 /*-----------------------------------------------------------------*/
@@ -4737,9 +4956,244 @@ static int genChkZeroes(operand *op, int lit,  int size)
 }
 #endif
 
+
+/*-----------------------------------------------------------------*/
+/* mov2w_regOrLit :- move to WREG either the offset's byte from    */
+/*                  aop (if it's NOT a literal) or from lit (if    */
+/*                  aop is a literal)                              */
+/*-----------------------------------------------------------------*/
+void mov2w_regOrLit (asmop *aop, unsigned long lit, int offset) {
+  if (aop->type == AOP_LIT) {
+    pic16_emitpcode (POC_MOVLW, pic16_popGetLit(lit >> (offset*8)));
+  } else {
+    pic16_emitpcode (POC_MOVFW, pic16_popGet (aop, offset));
+  }
+}
+
 /*-----------------------------------------------------------------*/
 /* genCmp :- greater or less than comparison                       */
 /*-----------------------------------------------------------------*/
+
+#if USE_SIMPLE_GENCMP		/* { */
+
+/* genCmp performs a left < right comparison, stores
+ * the outcome in result (if != NULL) and generates
+ * control flow code for the ifx (if != NULL).
+ *
+ * This version leaves in sequences like
+ * "B[CS]F STATUS,0; BTFS[CS] STATUS,0"
+ * which should be optmized by the peephole
+ * optimizer - RN 2005-01-01 */
+static void genCmp (operand *left,operand *right,
+                    operand *result, iCode *ifx, int sign)
+{
+  resolvedIfx rIfx;
+  int size;
+  int offs;
+  symbol *templbl;
+  operand *dummy;
+  unsigned long lit;
+  unsigned long mask;
+  int performedLt;
+
+  FENTRY;
+  
+  assert (AOP_SIZE(left) == AOP_SIZE(right));
+  assert (left && right);
+
+  size = AOP_SIZE(right) - 1;
+  mask = (0x100UL << (size*8)) - 1;
+  // in the end CARRY holds "left < right" (performedLt == 1) or "left >= right" (performedLt == 0)
+  performedLt = 1;
+  templbl = NULL;
+  lit = 0;
+  
+  resolveIfx (&rIfx, ifx);
+
+  /* handle for special cases */
+  if(pic16_genCmp_special(left, right, result, ifx, &rIfx, sign))
+      return;
+
+  /**********************************************************************
+   * handle bits - bit compares are promoted to int compares seemingly! *
+   **********************************************************************/
+#if 0
+  // THIS IS COMPLETELY UNTESTED!
+  if (AOP_TYPE(left) == AOP_CRY && AOP_TYPE(right) == AOP_CRY) {
+    pCodeOp *pcleft = pic16_popGet(AOP(left), 0);
+    pCodeOp *pcright = pic16_popGet(AOP(right), 0);
+    assert (pcleft->type == PO_GPR_BIT && pcright->type == PO_GPR_BIT);
+
+    emitSETC;
+    // 1 < {0,1} is false --> clear C by skipping the next instruction
+    //pic16_emitpcode (POC_BTFSS, pic16_popCopyGPR2Bit (AOP(left),0), PCORB(pcleft)->bit);
+    pic16_emitpcode (POC_BTFSS, pic16_popGet (AOP(left), 0));
+    // {0,1} < 0 is false --> clear C by NOT skipping the next instruction
+    pic16_emitpcode (POC_BTFSS, pic16_popCopyGPR2Bit (pic16_popGet(AOP(right),0), PCORB(pcright)->bit));
+    emitCLRC; // only skipped for left=0 && right=1
+
+    goto correct_result_in_carry;
+  } // if
+#endif
+
+  /*************************************************
+   * make sure that left is register (or the like) *
+   *************************************************/
+  if (!isAOP_REGlike(left)) {
+    DEBUGpc ("swapping arguments (AOP_TYPEs %d/%d)", AOP_TYPE(left), AOP_TYPE(right));
+    assert (isAOP_LIT(left));
+    assert (isAOP_REGlike(right));
+    // swap left and right
+    // left < right <==> right > left <==> (right >= left + 1)
+    lit = (unsigned long)floatFromVal(AOP(left)->aopu.aop_lit);
+
+    if ( (!sign && (lit & mask) == mask) || (sign && (lit & mask) == (mask >> 1)) ) {
+      // MAXVALUE < right? always false
+      if (performedLt) emitCLRC; else emitSETC;
+      goto correct_result_in_carry;
+    } // if
+
+    // This fails for lit = 0xFF (unsigned) AND lit = 0x7F (signed),
+    // that's why we handled it above.
+    lit++;
+
+    dummy = left;
+    left = right;
+    right = dummy;
+
+    performedLt ^= 1; // instead of "left < right" we check for "right >= left+1, i.e. "right < left+1"
+  } else if (isAOP_LIT(right)) {
+    lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
+  } // if
+
+  assert (isAOP_REGlike(left)); // left must be register or the like
+  assert (isAOP_REGlike(right) || isAOP_LIT(right)); // right may be register-like or a literal
+
+  /*************************************************
+   * special cases go here                         *
+   *************************************************/
+
+  if (isAOP_LIT(right)) {
+    if (!sign) {
+      // unsigned comparison to a literal
+      DEBUGpc ("unsigned compare: left %s lit(0x%X=%lu), size=%d", performedLt ? "<" : ">=", lit, lit, size+1);
+      if (lit == 0) {
+	// unsigned left < 0? always false
+	if (performedLt) emitCLRC; else emitSETC;
+	goto correct_result_in_carry;
+      }
+    } else {
+      // signed comparison to a literal
+      DEBUGpc ("signed compare: left %s lit(0x%X=%ld), size=%d, mask=%x", performedLt ? "<" : ">=", lit, lit, size+1, mask);
+      if ((lit & mask) == ((0x80 << (size*8)) & mask)) {
+	// signed left < 0x80000000? always false
+	if (performedLt) emitCLRC; else emitSETC;
+	goto correct_result_in_carry;
+      } else if (lit == 0) {
+	// compare left < 0; set CARRY if SIGNBIT(left) is set
+	if (performedLt) emitSETC; else emitCLRC;
+	pic16_emitpcode (POC_BTFSS, pic16_popCopyGPR2Bit(pic16_popGet (AOP(left), size), 7));
+	if (performedLt) emitCLRC; else emitSETC;
+	goto correct_result_in_carry;
+      }
+    } // if (!sign)
+  } // right is literal
+
+  /*************************************************
+   * perform a general case comparison             *
+   * make sure we get CARRY==1 <==> left >= right  *
+   *************************************************/
+  // compare most significant bytes
+  //DEBUGpc ("comparing bytes at offset %d", size);
+  if (!sign) {
+    // unsigned comparison
+    mov2w_regOrLit (AOP(right), lit, size);
+    pic16_emitpcode (POC_SUBFW, pic16_popGet (AOP(left), size));
+  } else {
+    // signed comparison
+    // (add 2^n to both operands then perform an unsigned comparison)
+    if (isAOP_LIT(right)) {
+      // left >= LIT <-> LIT-left <= 0 <-> LIT-left == 0 OR !(LIT-left >= 0)
+      unsigned char litbyte = (lit >> (8*size)) & 0xFF;
+
+      if (litbyte == 0x80) {
+	// left >= 0x80 -- always true, but more bytes to come
+	pic16_mov2w (AOP(left), size);
+	pic16_emitpcode (POC_XORLW, pic16_popGetLit (0x80)); // set ZERO flag
+	emitSETC;
+      } else {
+	// left >= LIT <-> left + (-LIT) >= 0 <-> left + (0x100-LIT) >= 0x100
+	pic16_mov2w (AOP(left), size);
+	pic16_emitpcode (POC_ADDLW, pic16_popGetLit (0x80));
+	pic16_emitpcode (POC_ADDLW, pic16_popGetLit ((0x100 - (litbyte + 0x80)) & 0x00FF));
+      } // if
+    } else {
+      pCodeOp *pctemp = pic16_popCopyReg(&pic16_pc_prodl);
+      //pCodeOp *pctemp = pic16_popGetTempReg(1);
+      pic16_mov2w (AOP(left), size);
+      pic16_emitpcode (POC_ADDLW, pic16_popGetLit (0x80));
+      pic16_emitpcode (POC_MOVWF, pctemp);
+      pic16_mov2w (AOP(right), size);
+      pic16_emitpcode (POC_ADDLW, pic16_popGetLit (0x80));
+      pic16_emitpcode (POC_SUBFW, pctemp);
+      //pic16_popReleaseTempReg(pctemp, 1);
+    }
+  } // if (!sign)
+
+  // compare remaining bytes (treat as unsigned case from above)
+  templbl = newiTempLabel ( NULL );
+  offs = size;
+  while (offs--) {
+    //DEBUGpc ("comparing bytes at offset %d", offs);
+    pic16_emitpcode (POC_BNZ, pic16_popGetLabel (templbl->key));
+    mov2w_regOrLit (AOP(right), lit, offs);
+    pic16_emitpcode (POC_SUBFW, pic16_popGet (AOP(left), offs));
+  } // while (offs)
+  pic16_emitpLabel (templbl->key);
+  goto result_in_carry;
+
+result_in_carry:
+  
+  /****************************************************
+   * now CARRY contains the result of the comparison: *
+   * SUBWF sets CARRY iff                             *
+   * F-W >= 0 <==> F >= W <==> !(F < W)               *
+   * (F=left, W=right)                                *
+   ****************************************************/
+
+  if (performedLt) {
+    if (result && AOP_TYPE(result) != AOP_CRY) {
+      // value will be stored
+      emitTOGC;
+    } else {
+      // value wil only be used in the following genSkipc()
+      rIfx.condition ^= 1;
+    }
+  } // if
+
+correct_result_in_carry:
+
+  // assign result to variable (if neccessary)
+  if (result && AOP_TYPE(result) != AOP_CRY) {
+    //DEBUGpc ("assign result");
+    size = AOP_SIZE(result);
+    while (size--) {
+      pic16_emitpcode (POC_CLRF, pic16_popGet (AOP(result), size));
+    } // while
+    pic16_emitpcode (POC_RLCF, pic16_popGet (AOP(result), 0));
+  } // if (result)
+
+  // perform conditional jump
+  if (ifx) {
+    //DEBUGpc ("generate control flow");
+    genSkipc (&rIfx);
+    ifx->generated = 1;
+  } // if
+}
+
+#elif 1		/* } */
+		/* { */
+      /* original code */
 static void genCmp (operand *left,operand *right,
                     operand *result, iCode *ifx, int sign)
 {
@@ -4756,6 +5210,8 @@ static void genCmp (operand *left,operand *right,
   }
 */
 
+  FENTRY;
+  
   resolveIfx(&rFalseIfx,ifx);
   truelbl  = newiTempLabel(NULL);
   size = max(AOP_SIZE(left),AOP_SIZE(right));
@@ -4786,6 +5242,7 @@ static void genCmp (operand *left,operand *right,
   /* if left & right are bit variables */
   if (AOP_TYPE(left) == AOP_CRY &&
       AOP_TYPE(right) == AOP_CRY ) {
+    assert (0 && "bit variables used in genCmp");
     pic16_emitcode("mov","c,%s",AOP(right)->aopu.aop_dir);
     pic16_emitcode("anl","c,/%s",AOP(left)->aopu.aop_dir);
   } else {
@@ -5152,6 +5609,10 @@ static void genCmp (operand *left,operand *right,
 	    rFalseIfx.condition ^= 1;
 	    genSkipCond(&rFalseIfx,right,size,7);
 	    if(ifx) ifx->generated = 1;
+
+	    if ((AOP_TYPE(result) != AOP_CRY) && (AOP_SIZE(result)))
+	      goto check_carry;
+
 	    return;
 	  }
 
@@ -5178,6 +5639,10 @@ static void genCmp (operand *left,operand *right,
 	    }
 
 	    if(ifx) ifx->generated = 1;
+
+	    if ((AOP_TYPE(result) != AOP_CRY) && (AOP_SIZE(result)))
+	      goto check_carry;
+
 	    return;
 	  }
 
@@ -5188,11 +5653,17 @@ static void genCmp (operand *left,operand *right,
 	    pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(right),size));
 	    pic16_emitpcode(POC_ADDLW, pic16_popGetLit( 0x80));
 	    pic16_emitpcode(POC_ADDLW, pic16_popGetLit(0x100-i));
-	    rFalseIfx.condition ^= 1;
-	    genSkipc(&rFalseIfx);
 
+	    if ((AOP_TYPE(result) != AOP_CRY) && (AOP_SIZE(result))) {
+	      emitTOGC;
+	      if(ifx) ifx->generated = 1;
+	      goto check_carry;
+	    } else {
+	      rFalseIfx.condition ^= 1;
+	      genSkipc(&rFalseIfx);
+	      if(ifx) ifx->generated = 1;
+	    }
 
-	    if(ifx) ifx->generated = 1;
 	    return;
 	  }
 
@@ -5229,7 +5700,6 @@ static void genCmp (operand *left,operand *right,
 
 	  }
 
-
 	  pic16_emitpcode(POC_MOVLW, pic16_popGetLit((lp1 >> (size*8)) & 0xff));
 	  pic16_emitpcode(POC_SUBFW, pic16_popGet(AOP(right),size));
 
@@ -5246,6 +5716,11 @@ static void genCmp (operand *left,operand *right,
 	  pic16_emitpLabel(truelbl->key);
 
 	  if(ifx) ifx->generated = 1;
+
+
+          if ((AOP_TYPE(result) != AOP_CRY) && (AOP_SIZE(result)))
+            goto check_carry;
+
 	  return;
 	  // end of if (sign)
 	} else {
@@ -5289,6 +5764,10 @@ static void genCmp (operand *left,operand *right,
 	    pic16_emitpLabel(truelbl->key);
 
 	    if(ifx) ifx->generated = 1;
+
+            if ((AOP_TYPE(result) != AOP_CRY) && (AOP_SIZE(result)))
+              goto check_carry;
+
 	    return;
 	  }
 
@@ -5316,123 +5795,496 @@ static void genCmp (operand *left,operand *right,
 	  }
 
 
-	  pic16_emitpLabel(lbl->key);
+	  pic16_emitpLabel(lbl->key);
+
+	  rFalseIfx.condition ^= 1;
+
+	  genSkipc(&rFalseIfx);
+	}
+
+	if(sign)
+	  pic16_emitpLabel(truelbl->key);
+	if(ifx) ifx->generated = 1;
+
+            if ((AOP_TYPE(result) != AOP_CRY) && (AOP_SIZE(result)))
+              goto check_carry;
+
+	return;
+      }
+    }
+    /* Compare two variables */
+
+    DEBUGpic16_emitcode(";sign","%d",sign);
+
+    size--;
+    if(sign) {
+      /* Sigh. thus sucks... */
+      if(size) {
+      	pCodeOp *pctemp;
+      	
+      	pctemp = pic16_popGetTempReg(1);
+	pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(left),size));
+	pic16_emitpcode(POC_MOVWF, pctemp);		//pic16_popRegFromIdx(pic16_Gstack_base_addr));
+	pic16_emitpcode(POC_MOVLW, pic16_popGetLit(0x80));
+	pic16_emitpcode(POC_XORWF, pctemp);		//pic16_popRegFromIdx(pic16_Gstack_base_addr));
+	pic16_emitpcode(POC_XORFW, pic16_popGet(AOP(right),size));
+	pic16_emitpcode(POC_SUBFW, pctemp);		//pic16_popRegFromIdx(pic16_Gstack_base_addr));
+	pic16_popReleaseTempReg(pctemp, 1);
+      } else {
+	/* Signed char comparison */
+	/* Special thanks to Nikolai Golovchenko for this snippet */
+	pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(right),0));
+	pic16_emitpcode(POC_SUBFW, pic16_popGet(AOP(left),0));
+	pic16_emitpcode(POC_RRCFW,  pic16_popGet(AOP(left),0)); /* could be any register */
+	pic16_emitpcode(POC_XORFW, pic16_popGet(AOP(left),0));
+	pic16_emitpcode(POC_XORFW, pic16_popGet(AOP(right),0));
+	pic16_emitpcode(POC_ADDLW, pic16_popGetLit(0x80));
+
+	DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+	genSkipc(&rFalseIfx);
+	  
+	if(ifx) ifx->generated = 1;
+
+            if ((AOP_TYPE(result) != AOP_CRY) && (AOP_SIZE(result)))
+              goto check_carry;
+
+	return;
+      }
+
+    } else {
+
+      pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(right),size));
+      pic16_emitpcode(POC_SUBFW, pic16_popGet(AOP(left),size));
+    }
+
+
+    /* The rest of the bytes of a multi-byte compare */
+    while (size) {
+
+      emitSKPZ;
+      pic16_emitpcode(POC_GOTO,  pic16_popGetLabel(lbl->key));
+      size--;
+
+      pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(right),size));
+      pic16_emitpcode(POC_SUBFW, pic16_popGet(AOP(left),size));
+
+
+    }
+
+    pic16_emitpLabel(lbl->key);
+
+    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+    if ((AOP_TYPE(result) == AOP_CRY && AOP_SIZE(result)) || 
+	(AOP_TYPE(result) == AOP_REG)) {
+      pic16_emitpcode(POC_CLRF, pic16_popGet(AOP(result),0));
+      pic16_emitpcode(POC_RLCF, pic16_popGet(AOP(result),0));
+    } else {
+      genSkipc(&rFalseIfx);
+    }	      
+    //genSkipc(&rFalseIfx);
+    if(ifx) ifx->generated = 1;
+
+
+            if ((AOP_TYPE(result) != AOP_CRY) && (AOP_SIZE(result)))
+              goto check_carry;
+
+    return;
+
+  }
+
+check_carry:
+  if ((AOP_TYPE(result) != AOP_CRY) 
+  	&& AOP_SIZE(result)) {
+    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+
+    if(!ifx)pic16_emitpLabel( rFalseIfx.lbl->key );
+
+    pic16_outBitC(result);
+  } else {
+    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+    /* if the result is used in the next
+       ifx conditional branch then generate
+       code a little differently */
+    if (ifx )
+      genIfxJump (ifx,"c");
+    else
+      pic16_outBitC(result);
+    /* leave the result in acc */
+  }
+
+}
+
+#elif 0	/* VR version of genCmp() */	/* } else { */
+
+/* check all condition and return appropriate instruction, POC_CPFSGT or POC_CPFFSLT */
+static int selectCompareOp(resolvedIfx *rIfx, iCode *ifx,
+        operand *result, int offset, int invert_op)
+{
+  /* add code here */
+  
+  /* check condition, > or < ?? */
+  if(rIfx->condition != 0)invert_op ^= 1;
+  
+  if(ifx && IC_FALSE(ifx))invert_op ^= 1;
+
+  if(!ifx)invert_op ^= 1;
+
+  DEBUGpic16_emitcode("; +++", "%s:%d %s] rIfx->condition= %d, ifx&&IC_FALSE(ifx)= %d, invert_op = %d",
+      __FILE__, __LINE__, __FUNCTION__, rIfx->condition, (ifx && IC_FALSE(ifx)), invert_op);
+  
+  /* do selection */
+  if(!invert_op)return POC_CPFSGT;
+  else return POC_CPFSLT;
+}
+
+static int compareAopfirstpass=1;
+
+static void compareAop(resolvedIfx *resIfx, iCode *ifx, symbol *falselbl,
+            operand *oper, int offset, operand *result,
+            int sign, int invert_op, pCodeOp *pcop, pCodeOp *pcop2,
+            symbol *tlbl)
+{
+  int op;
+  symbol *truelbl;
+
+  /* invert if there is a result to be loaded, in order to fit,
+   * SETC/CLRC sequence */
+  if(AOP_SIZE(result))invert_op ^= 1;
+
+//  if(sign && !offset)invert_op ^= 1;
+  
+//  if(sign)invert_op ^= 1;
+  
+  op = selectCompareOp(resIfx, ifx, result, offset, invert_op);
+
+  if(AOP_SIZE(result) && compareAopfirstpass) {
+    if(!ifx) {
+      if(pcop2)
+        pic16_emitpcode(POC_SETF, pcop2);
+      else
+        emitSETC;
+    } else {
+      if(pcop2)
+        pic16_emitpcode(POC_CLRF, pcop2);
+      else
+        emitCLRC;
+    }
+  }
+
+  compareAopfirstpass = 0;
+
+      /* there is a bug when comparing operands with size > 1,
+       * because higher bytes can be equal and test should be performed
+       * to the next lower byte, current algorithm, considers operands
+       * inequal in these cases! -- VR 20041107 */
+
+    
+  if(pcop)
+    pic16_emitpcode(op, pcop);
+  else
+    pic16_emitpcode(op, pic16_popGet(AOP(oper), offset));
+
+
+  if((!sign || !offset) && AOP_SIZE(result)) {
+    if(!ifx) {
+      if(pcop2)
+        pic16_emitpcode(POC_CLRF, pcop2);
+        else
+        emitCLRC;
+    } else {
+      if(pcop2)
+        pic16_emitpcode(POC_SETF, pcop2);
+      else
+        emitSETC;
+    }
+    
+    /* don't emit final branch (offset == 0) */
+    if(offset) {
+
+      if(pcop2)
+        pic16_emitpcode(POC_RRCF, pcop2);
+
+      pic16_emitpcode(POC_BNC, pic16_popGetLabel(falselbl->key));
+    }
+  } else {
+    if((ifx && (IC_TRUE(ifx)!=NULL)) || (sign && !offset)) {
+      DEBUGpic16_emitcode ("; +++","%s: %d: ifx = %p, IC_TRUE(ifx) = %d, sign = %d, offset = %d",
+            __FUNCTION__, __LINE__, ifx, (ifx&&IC_TRUE(ifx)), sign, offset);
+
+      truelbl = newiTempLabel( NULL );
+      pic16_emitpcode(POC_BRA, pic16_popGetLabel(truelbl->key));
+      if((!ifx || !IC_TRUE(ifx)) && (sign && !offset))
+        pic16_emitpcode(POC_GOTO, pic16_popGetLabel(tlbl->key));
+      else
+        pic16_emitpcode(POC_GOTO, pic16_popGetLabel(resIfx->lbl->key));
+      pic16_emitpLabel(truelbl->key);
+    } else {
+      pic16_emitpcode(POC_GOTO, pic16_popGetLabel(resIfx->lbl->key));
+    }
+  }
+}
+
+static void genCmp (operand *left, operand *right,
+                    operand *result, iCode *ifx, int sign)
+{
+  int size, cmpop=1;
+  long lit = 0L;
+  resolvedIfx rFalseIfx;
+  symbol *falselbl, *tlbl;
+
+    FENTRY;
+    
+    DEBUGpic16_pic16_AopType(__LINE__,left,right,result);
+
+    resolveIfx(&rFalseIfx, ifx);
+    size = max(AOP_SIZE(left), AOP_SIZE(right));
+    
+    /* if left & right are bit variables */
+    if(AOP_TYPE(left) == AOP_CRY
+      && AOP_TYPE(right) == AOP_CRY ) {
+
+        pic16_emitcode("mov","c,%s",AOP(right)->aopu.aop_dir);
+        pic16_emitcode("anl","c,/%s",AOP(left)->aopu.aop_dir);
+        
+        werror(W_POSSBUG2, __FILE__, __LINE__);
+        exit(-1);
+    }
+    
+    /* 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);
+
+//      lit = (lit - 1) & mask;
+        right = left;
+        left = tmp;
+        rFalseIfx.condition ^= 1;		/* reverse compare */
+    } else
+    if ((AOP_TYPE(left) == AOP_LIT)) {
+      /* float compares are handled by support functions */
+      lit = /*(unsigned long)*/floatFromVal(AOP(left)->aopu.aop_lit);
+    }
 
-	  rFalseIfx.condition ^= 1;
+    /* actual comparing algorithm */
+//    size = AOP_SIZE( right );
 
-	  genSkipc(&rFalseIfx);
-	}
+    falselbl = newiTempLabel( NULL );
+    if(AOP_TYPE(left) == AOP_LIT) {
+      /* compare to literal */
+      DEBUGpic16_emitcode ("; ***","%s: %d: compare to literal", __FUNCTION__, __LINE__);
+      
+      if(sign) {
+        pCodeOp *pct, *pct2;
+        symbol *tlbl1;
 
-	if(sign)
-	  pic16_emitpLabel(truelbl->key);
-	if(ifx) ifx->generated = 1;
-	return;
-      }
-    }
-    /* Compare two variables */
+        /* signed compare */
+        DEBUGpic16_emitcode ("; ***","%s: %d: signed compare", __FUNCTION__, __LINE__);
 
-    DEBUGpic16_emitcode(";sign","%d",sign);
+        pct = pic16_popCopyReg(&pic16_pc_prodl);
+        pct2 = pic16_popCopyReg(&pic16_pc_prodh);
+        tlbl = newiTempLabel( NULL );
+        
+        /* first compare signs:
+         *  a. if both are positive, compare just like unsigned
+         *  b. if both are negative, invert cmpop, compare just like unsigned
+         *  c. if different signs, determine the result directly */
 
-    size--;
-    if(sign) {
-      /* Sigh. thus sucks... */
-      if(size) {
-      	pCodeOp *pctemp;
-      	
-      	pctemp = pic16_popGetTempReg(1);
-	pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(left),size));
-	pic16_emitpcode(POC_MOVWF, pctemp);		//pic16_pic16_popRegFromIdx(pic16_Gstack_base_addr));
-	pic16_emitpcode(POC_MOVLW, pic16_popGetLit(0x80));
-	pic16_emitpcode(POC_XORWF, pctemp);		//pic16_popRegFromIdx(pic16_Gstack_base_addr));
-	pic16_emitpcode(POC_XORFW, pic16_popGet(AOP(right),size));
-	pic16_emitpcode(POC_SUBFW, pctemp);		//pic16_popRegFromIdx(pic16_Gstack_base_addr));
-	pic16_popReleaseTempReg(pctemp, 1);
+        size--;
+
+#if 1
+	/* { */
+        tlbl1 = newiTempLabel( NULL );
+//        pic16_emitpcode(POC_RLCFW, pic16_popGet( AOP(right), size));	/* move sign to carry */
+
+        if(lit > 0) {
+
+          /* literal is zero or positive:
+           *  a. if carry is zero, too, continue compare,
+           *  b. if carry is set, then continue depending on cmpop ^ condition:
+           *	1. '<' return false (literal < variable),
+           *	2. '>' return true (literal > variable) */
+//          pic16_emitpcode(POC_BNC, pic16_popGetLabel( tlbl1->key ));
+          pic16_emitpcode(POC_BTFSC, pic16_popCopyGPR2Bit(pic16_popGet(AOP(right), size), 7));
+          
+          
+          if(cmpop ^ rFalseIfx.condition)pic16_emitpcode(POC_GOTO, pic16_popGetLabel( tlbl->key ));
+          else pic16_emitpcode(POC_GOTO, pic16_popGetLabel( rFalseIfx.lbl->key ));
+        } else 
+        if(lit < 0) {
+          
+          /* literal is negative:
+           *  a. if carry is set, too, continue compare,
+           *  b. if carry is zero, then continue depending on cmpop ^ condition:
+           *	1. '<' return true (literal < variable),
+           *	2. '>' return false (literal > variable) */
+//          pic16_emitpcode(POC_BC, pic16_popGetLabel( tlbl1->key ));
+          pic16_emitpcode(POC_BTFSS, pic16_popCopyGPR2Bit(pic16_popGet(AOP(right), size), 7));
+          
+          if(!(cmpop ^ rFalseIfx.condition))pic16_emitpcode(POC_GOTO, pic16_popGetLabel( tlbl->key ));
+          else pic16_emitpcode(POC_GOTO, pic16_popGetLabel( rFalseIfx.lbl->key));
+        }
+#if 1
+        else {
+          /* lit == 0 */
+          pic16_emitpcode(POC_BTFSC, pic16_popCopyGPR2Bit(pic16_popGet(AOP(right), size), 7));
+          
+          if(!(cmpop ^ rFalseIfx.condition))pic16_emitpcode(POC_GOTO, pic16_popGetLabel( tlbl->key ));
+          else pic16_emitpcode(POC_GOTO, pic16_popGetLabel( rFalseIfx.lbl->key));
+        }
+#endif
+        
+        
+        pic16_emitpLabel( tlbl1->key );
+#endif	/* } */
+
+        compareAopfirstpass=1;
+//        pic16_emitpcode(POC_MOVLW, pic16_popGetLit(0x80));
+//        pic16_emitpcode(POC_ADDFW, pic16_popGet(AOP(right), size));
+//        pic16_emitpcode(POC_MOVWF, pct);
+
+//        pic16_emitpcode(POC_MOVLW, pic16_popGetLit(BYTEofLONG(lit, size) + 0x80));
+        pic16_emitpcode(POC_MOVLW, pic16_popGetLit(BYTEofLONG(lit, size)));
+//        compareAop(&rFalseIfx, ifx, falselbl, right, size, result, sign, 1, pct, pct2, tlbl);
+        compareAop(&rFalseIfx, ifx, falselbl, right, size, result, sign, 1, NULL, pct2, tlbl);
+
+        /* generic case */        
+          while( size-- ) {
+//            pic16_emitpcode(POC_MOVLW, pic16_popGetLit(0x80));
+//            pic16_emitpcode(POC_MOVLW, pic16_popGetLit(0x0));
+//            pic16_emitpcode(POC_ADDFW, pic16_popGet(AOP(right), size));
+//            pic16_emitpcode(POC_MOVWF, pct);
+
+//            pic16_emitpcode(POC_MOVLW, pic16_popGetLit(BYTEofLONG(lit, size) + 0x80));
+            pic16_emitpcode(POC_MOVLW, pic16_popGetLit(BYTEofLONG(lit, size) + 0x0));
+            compareAop(&rFalseIfx, ifx, falselbl, right, size, result, sign, 1, NULL, pct2, tlbl);
+//            compareAop(&rFalseIfx, ifx, falselbl, right, size, result, sign, 1, pct, pct2, tlbl);
+//            compareAop(&rFalseIfx, ifx, falselbl, right, size, result, sign, 0, pct, pct2, tlbl);
+          }
+        
+        if(ifx)ifx->generated = 1;
+
+        if(AOP_SIZE(result)) {
+          pic16_emitpLabel(tlbl->key);
+          pic16_emitpLabel(falselbl->key);
+          pic16_outBitOp( result, pct2 );
+        } else {
+          pic16_emitpLabel(tlbl->key);
+        }
       } else {
-	/* Signed char comparison */
-	/* Special thanks to Nikolai Golovchenko for this snippet */
-	pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(right),0));
-	pic16_emitpcode(POC_SUBFW, pic16_popGet(AOP(left),0));
-	pic16_emitpcode(POC_RRCFW,  pic16_popGet(AOP(left),0)); /* could be any register */
-	pic16_emitpcode(POC_XORFW, pic16_popGet(AOP(left),0));
-	pic16_emitpcode(POC_XORFW, pic16_popGet(AOP(right),0));
-	pic16_emitpcode(POC_ADDLW, pic16_popGetLit(0x80));
 
-	DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-	genSkipc(&rFalseIfx);
-	  
-	if(ifx) ifx->generated = 1;
-	return;
-      }
+        /* unsigned compare */      
+        DEBUGpic16_emitcode ("; ***","%s: %d: unsigned compare", __FUNCTION__, __LINE__);
+    
+        compareAopfirstpass=1;
+        while(size--) {
+          
+          pic16_emitpcode(POC_MOVLW, pic16_popGetLit(BYTEofLONG(lit, size)));
+          compareAop(&rFalseIfx, ifx, falselbl, right, size, result, sign, 1, NULL, NULL, NULL);
 
-    } else {
+        }
+        if(ifx)ifx->generated = 1;
 
-      pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(right),size));
-      pic16_emitpcode(POC_SUBFW, pic16_popGet(AOP(left),size));
-    }
+        if(AOP_SIZE(result)) {
+          pic16_emitpLabel(falselbl->key);
+          pic16_outBitC( result );
+        }
 
+      }
+    } else {
+      /* compare registers */
+      DEBUGpic16_emitcode ("; ***","%s: %d: compare registers", __FUNCTION__, __LINE__);
 
-    /* The rest of the bytes of a multi-byte compare */
-    while (size) {
 
-      emitSKPZ;
-      pic16_emitpcode(POC_GOTO,  pic16_popGetLabel(lbl->key));
-      size--;
+      if(sign) {
+        pCodeOp *pct, *pct2;
+        
+        /* signed compare */
+        DEBUGpic16_emitcode ("; ***","%s: %d: signed compare", __FUNCTION__, __LINE__);
 
-      pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(right),size));
-      pic16_emitpcode(POC_SUBFW, pic16_popGet(AOP(left),size));
+        pct = pic16_popCopyReg(&pic16_pc_prodl);	/* first temporary register */
+        pct2 = pic16_popCopyReg(&pic16_pc_prodh);	/* second temporary register */
+        tlbl = newiTempLabel( NULL );
+        
+        compareAopfirstpass=1;
 
+        size--;
+        pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(right), size));
+//        pic16_emitpcode(POC_ADDLW, pic16_popGetLit(0x80));
+        pic16_emitpcode(POC_ADDLW, pic16_popGetLit(0x0));
+        pic16_emitpcode(POC_MOVWF, pct);
 
-    }
+        pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(left), size));
+//        pic16_emitpcode(POC_ADDLW, pic16_popGetLit(0x80));
+        pic16_emitpcode(POC_ADDLW, pic16_popGetLit(0x0));
 
-    pic16_emitpLabel(lbl->key);
+        /* WREG already holds left + 0x80 */
+        compareAop(&rFalseIfx, ifx, falselbl, right, size, result, sign, 1, pct, pct2, tlbl);
+        
+        while( size-- ) {
+          pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(right), size));
+//          pic16_emitpcode(POC_ADDLW, pic16_popGetLit(0x80));
+          pic16_emitpcode(POC_ADDLW, pic16_popGetLit(0x0));
+          pic16_emitpcode(POC_MOVWF, pct);
+                
+          pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(left), size));
+//          pic16_emitpcode(POC_ADDLW, pic16_popGetLit(0x80));
+          pic16_emitpcode(POC_ADDLW, pic16_popGetLit(0x0));
 
-    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-    if ((AOP_TYPE(result) == AOP_CRY && AOP_SIZE(result)) || 
-	(AOP_TYPE(result) == AOP_REG)) {
-      pic16_emitpcode(POC_CLRF, pic16_popGet(AOP(result),0));
-      pic16_emitpcode(POC_RLCF, pic16_popGet(AOP(result),0));
-    } else {
-      genSkipc(&rFalseIfx);
-    }	      
-    //genSkipc(&rFalseIfx);
-    if(ifx) ifx->generated = 1;
+          /* WREG already holds left + 0x80 */
+          compareAop(&rFalseIfx, ifx, falselbl, right, size, result, sign, 1, pct, pct2, tlbl);
+//          compareAop(&rFalseIfx, ifx, falselbl, right, size, result, sign, 0, pct, pct2, tlbl);
+        }
+        
+        if(ifx)ifx->generated = 1;
 
-    return;
+        if(AOP_SIZE(result)) {
+          pic16_emitpLabel(tlbl->key);
+          pic16_emitpLabel(falselbl->key);
+          pic16_outBitOp( result, pct2 );
+        } else {
+          pic16_emitpLabel(tlbl->key);
+        }
 
-  }
+      } else {
+        /* unsigned compare */      
+        DEBUGpic16_emitcode ("; ***","%s: %d: unsigned compare", __FUNCTION__, __LINE__);
 
-check_carry:
-  if ((AOP_TYPE(result) != AOP_CRY) 
-  	&& AOP_SIZE(result)) {
-    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+        compareAopfirstpass=1;
+        while(size--) {
+          
+          pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(left), size));
+          compareAop(&rFalseIfx, ifx, falselbl, right, size, result, sign, 1, NULL, NULL, NULL);
 
-    if(!ifx)pic16_emitpLabel( rFalseIfx.lbl->key );
+        }
 
-    pic16_outBitC(result);
-  } else {
-    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-    /* if the result is used in the next
-       ifx conditional branch then generate
-       code a little differently */
-    if (ifx )
-      genIfxJump (ifx,"c");
-    else
-      pic16_outBitC(result);
-    /* leave the result in acc */
-  }
+        if(ifx)ifx->generated = 1;
+        if(AOP_SIZE(result)) {
+
+          pic16_emitpLabel(falselbl->key);
+          pic16_outBitC( result );
+        }
 
+      }
+    }
 }
 
+#endif	/* } */
+
+
+
 /*-----------------------------------------------------------------*/
 /* genCmpGt :- greater than comparison                             */
 /*-----------------------------------------------------------------*/
 static void genCmpGt (iCode *ic, iCode *ifx)
 {
-    operand *left, *right, *result;
-    sym_link *letype , *retype;
-    int sign ;
+  operand *left, *right, *result;
+  sym_link *letype , *retype;
+  int sign ;
 
-    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+    FENTRY;
+    
     left = IC_LEFT(ic);
     right= IC_RIGHT(ic);
     result = IC_RESULT(ic);
@@ -5457,11 +6309,12 @@ static void genCmpGt (iCode *ic, iCode *ifx)
 /*-----------------------------------------------------------------*/
 static void genCmpLt (iCode *ic, iCode *ifx)
 {
-    operand *left, *right, *result;
-    sym_link *letype , *retype;
-    int sign ;
+  operand *left, *right, *result;
+  sym_link *letype , *retype;
+  int sign ;
+
+    FENTRY;
 
-    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
     left = IC_LEFT(ic);
     right= IC_RIGHT(ic);
     result = IC_RESULT(ic);
@@ -5798,10 +6651,10 @@ static void gencjne(operand *left, operand *right, iCode *ifx)
 /*-----------------------------------------------------------------*/
 static bool is_LitOp(operand *op)
 {
-  return (AOP_TYPE(op) == AOP_LIT)
+  return ((AOP_TYPE(op) == AOP_LIT)
       || ( (AOP_TYPE(op) == AOP_PCODE)
           && ( (AOP(op)->aopu.pcop->type == PO_LITERAL)
-              || (AOP(op)->aopu.pcop->type == PO_IMMEDIATE) ));  
+              || (AOP(op)->aopu.pcop->type == PO_IMMEDIATE) )));
 }
 
 /*-----------------------------------------------------------------*/
@@ -5809,10 +6662,10 @@ static bool is_LitOp(operand *op)
 /*-----------------------------------------------------------------*/
 static bool is_LitAOp(asmop *aop)
 {
-  return (aop->type == AOP_LIT)
+  return ((aop->type == AOP_LIT)
       || ( (aop->type == AOP_PCODE)
           && ( (aop->aopu.pcop->type == PO_LITERAL)
-              || (aop->aopu.pcop->type == PO_IMMEDIATE) ));  
+              || (aop->aopu.pcop->type == PO_IMMEDIATE) )));
 }
 
 
@@ -5829,16 +6682,19 @@ static void genCmpEq (iCode *ic, iCode *ifx)
   int preserve_result = 0;
   int generate_result = 0;
   int i=0;
+  unsigned long lit = -1;
 
+  FENTRY;
+  
   pic16_aopOp((left=IC_LEFT(ic)),ic,FALSE);
   pic16_aopOp((right=IC_RIGHT(ic)),ic,FALSE);
   pic16_aopOp((result=IC_RESULT(ic)),ic,TRUE);
  
-  DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
   DEBUGpic16_pic16_AopType(__LINE__,left,right,result);
 
   if( (AOP_TYPE(right) == AOP_CRY) || (AOP_TYPE(left) == AOP_CRY) )
     {
+      werror(W_POSSBUG2, __FILE__, __LINE__);
       DEBUGpic16_emitcode ("; ***","%s  %d -- ERROR",__FUNCTION__,__LINE__);
       fprintf(stderr, "%s  %d error - left/right CRY operands not supported\n",__FUNCTION__,__LINE__);
       goto release;
@@ -5851,6 +6707,10 @@ static void genCmpEq (iCode *ic, iCode *ifx)
       left = tmp;
     }
 
+  if (AOP_TYPE(right) == AOP_LIT) {
+    lit = (unsigned long) floatFromVal (AOP(right)->aopu.aop_lit);
+  }
+
   if ( regsInCommon(left, result) || regsInCommon(right, result) )
     preserve_result = 1;
 
@@ -5872,9 +6732,11 @@ static void genCmpEq (iCode *ic, iCode *ifx)
           else
             pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(left), i));
         }
-      if(is_LitOp(right))
-        pic16_emitpcode(POC_XORLW, pic16_popGet(AOP(right), i)); 
-      else
+      if(is_LitOp(right)) {
+        if (is_LitOp(left) || (0 != ((lit >> (8*i))&0x00FF))) {
+          pic16_emitpcode(POC_XORLW, pic16_popGet(AOP(right), i)); 
+        }
+      } else
         pic16_emitpcode(POC_XORFW, pic16_popGet(AOP(right), i)); 
 
       pic16_emitpcode(POC_BNZ,pic16_popGetLabel(falselbl->key));
@@ -6253,8 +7115,9 @@ release:
 /*-----------------------------------------------------------------*/
 static iCode *ifxForOp ( operand *op, iCode *ic )
 {
+  FENTRY2;
+
     /* if true symbol then needs to be assigned */
-    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
     if (IS_TRUE_SYMOP(op))
         return NULL ;
 
@@ -6270,12 +7133,14 @@ static iCode *ifxForOp ( operand *op, iCode *ic )
           return ic->next;
     }
 
+    /*
     if (ic->next &&
         ic->next->op == IFX &&
         IC_COND(ic->next)->key == op->key) {
       DEBUGpic16_emitcode ("; WARNING ","%d IGNORING liveTo range in %s",__LINE__,__FUNCTION__);
       return ic->next;
     }
+    */
 
     DEBUGpic16_emitcode ("; NULL :(","%d",__LINE__);
     if (ic->next &&
@@ -6328,16 +7193,17 @@ static iCode *ifxForOp ( operand *op, iCode *ic )
 /*-----------------------------------------------------------------*/
 static void genAndOp (iCode *ic)
 {
-    operand *left,*right, *result;
+  operand *left,*right, *result;
 /*     symbol *tlbl; */
 
-    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+    FENTRY;
+
     /* note here that && operations that are in an
     if statement are taken away by backPatchLabels
     only those used in arthmetic operations remain */
     pic16_aopOp((left=IC_LEFT(ic)),ic,FALSE);
     pic16_aopOp((right=IC_RIGHT(ic)),ic,FALSE);
-    pic16_aopOp((result=IC_RESULT(ic)),ic,FALSE);
+    pic16_aopOp((result=IC_RESULT(ic)),ic,TRUE);
 
     DEBUGpic16_pic16_AopType(__LINE__,left,right,result);
 
@@ -6376,16 +7242,17 @@ static void genAndOp (iCode *ic)
 
 static void genOrOp (iCode *ic)
 {
-    operand *left,*right, *result;
-    symbol *tlbl;
+  operand *left,*right, *result;
+  symbol *tlbl;
 
-    /* note here that || operations that are in an
+    FENTRY;  
+
+  /* note here that || operations that are in an
     if statement are taken away by backPatchLabels
     only those used in arthmetic operations remain */
-    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
     pic16_aopOp((left=IC_LEFT(ic)),ic,FALSE);
     pic16_aopOp((right=IC_RIGHT(ic)),ic,FALSE);
-    pic16_aopOp((result=IC_RESULT(ic)),ic,FALSE);
+    pic16_aopOp((result=IC_RESULT(ic)),ic,TRUE);
 
     DEBUGpic16_pic16_AopType(__LINE__,left,right,result);
 
@@ -6443,10 +7310,10 @@ static int isLiteralBit(unsigned long lit)
 /*-----------------------------------------------------------------*/
 static void continueIfTrue (iCode *ic)
 {
-    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-    if(IC_TRUE(ic))
-        pic16_emitcode("ljmp","%05d_DS_",IC_TRUE(ic)->key+100);
-    ic->generated = 1;
+  FENTRY;
+  if(IC_TRUE(ic))
+    pic16_emitcode("ljmp","%05d_DS_",IC_TRUE(ic)->key+100);
+  ic->generated = 1;
 }
 
 /*-----------------------------------------------------------------*/
@@ -6454,10 +7321,10 @@ static void continueIfTrue (iCode *ic)
 /*-----------------------------------------------------------------*/
 static void jumpIfTrue (iCode *ic)
 {
-    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-    if(!IC_TRUE(ic))
-        pic16_emitcode("ljmp","%05d_DS_",IC_FALSE(ic)->key+100);
-    ic->generated = 1;
+  FENTRY;
+  if(!IC_TRUE(ic))
+    pic16_emitcode("ljmp","%05d_DS_",IC_FALSE(ic)->key+100);
+  ic->generated = 1;
 }
 
 /*-----------------------------------------------------------------*/
@@ -6465,20 +7332,19 @@ static void jumpIfTrue (iCode *ic)
 /*-----------------------------------------------------------------*/
 static void jmpTrueOrFalse (iCode *ic, symbol *tlbl)
 {
-    // ugly but optimized by peephole
-    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-    if(IC_TRUE(ic)){
-        symbol *nlbl = newiTempLabel(NULL);
-        pic16_emitcode("sjmp","%05d_DS_",nlbl->key+100);                 
-        pic16_emitcode("","%05d_DS_:",tlbl->key+100);
-        pic16_emitcode("ljmp","%05d_DS_",IC_TRUE(ic)->key+100);
-        pic16_emitcode("","%05d_DS_:",nlbl->key+100);
-    }
-    else{
-        pic16_emitcode("ljmp","%05d_DS_",IC_FALSE(ic)->key+100);
-        pic16_emitcode("","%05d_DS_:",tlbl->key+100);
-    }
-    ic->generated = 1;
+  // ugly but optimized by peephole
+  FENTRY;
+  if(IC_TRUE(ic)){
+    symbol *nlbl = newiTempLabel(NULL);
+      pic16_emitcode("sjmp","%05d_DS_",nlbl->key+100);                 
+      pic16_emitcode("","%05d_DS_:",tlbl->key+100);
+      pic16_emitcode("ljmp","%05d_DS_",IC_TRUE(ic)->key+100);
+      pic16_emitcode("","%05d_DS_:",nlbl->key+100);
+  } else {
+    pic16_emitcode("ljmp","%05d_DS_",IC_FALSE(ic)->key+100);
+    pic16_emitcode("","%05d_DS_:",tlbl->key+100);
+  }
+  ic->generated = 1;
 }
 
 /*-----------------------------------------------------------------*/
@@ -6492,8 +7358,8 @@ static void genAnd (iCode *ic, iCode *ifx)
   int bytelit = 0;
   resolvedIfx rIfx;
 
-
-  DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+    FENTRY;
+    
   pic16_aopOp((left = IC_LEFT(ic)),ic,FALSE);
   pic16_aopOp((right= IC_RIGHT(ic)),ic,FALSE);
   pic16_aopOp((result=IC_RESULT(ic)),ic,TRUE);
@@ -6609,7 +7475,7 @@ static void genAnd (iCode *ic, iCode *ifx)
 	      bp -= 8;
 	      ofs++;
 	    }
-	
+
 	  pic16_emitpcode(((rIfx.condition) ? POC_BTFSC : POC_BTFSS),
 		    pic16_newpCodeOpBit(pic16_aopGet(AOP(left),ofs,FALSE,FALSE),bp,0, PO_GPR_REGISTER));
 
@@ -6681,9 +7547,9 @@ static void genAnd (iCode *ic, iCode *ifx)
       else {
         if(ifx) {
           pic16_emitpcode(POC_BRA, pic16_popGetLabel(rIfx.lbl->key));
-          pic16_emitpLabel(tlbl->key);
           ifx->generated = 1;
         }
+        pic16_emitpLabel(tlbl->key);
         goto release;
       }
     }
@@ -6709,7 +7575,7 @@ static void genAnd (iCode *ic, iCode *ifx)
 
 	default:
 	  {
-	    int p = my_powof2( (~lit) & 0xff );
+	    int p = pic16_my_powof2( (~lit) & 0xff );
 	    if(p>=0) {
 	      /* only one bit is set in the literal, so use a bcf instruction */
 //	      pic16_emitcode("bcf","%s,%d",pic16_aopGet(AOP(left),offset,FALSE,TRUE),p);
@@ -7013,7 +7879,7 @@ static void genOr (iCode *ic, iCode *ifx)
 	    /*  or'ing with 0 has no effect */
 	    continue;
 	  else {
-	    int p = my_powof2(lit & 0xff);
+	    int p = pic16_my_powof2(lit & 0xff);
 	    if(p>=0) {
 	      /* only one bit is set in the literal, so use a bsf instruction */
 	      pic16_emitpcode(POC_BSF,
@@ -7374,8 +8240,69 @@ static void genInline (iCode *ic)
 
 	buffer = bp = bp1 = Safe_calloc(1, strlen(IC_INLINE(ic))+1);
 	strcpy(buffer,IC_INLINE(ic));
+	
+	while((bp1=strstr(bp, "\\n"))) {
+	  *bp1++ = '\n';
+	  *bp1++ = ' ';
+	  bp = bp1;
+        }
+        bp = bp1 = buffer;
 
-//	fprintf(stderr, "%s:%d inline asm : < %s >\n", __FILE__, __LINE__, buffer);
+#if 0
+  /* This is an experimental code for #pragma inline
+     and is temporarily disabled for 2.5.0 release */
+        if(asmInlineMap)
+        {
+          symbol *sym;
+          char *s;
+          char *cbuf;
+          int cblen;
+
+            cbuf = Safe_strdup(buffer);
+            cblen = strlen(buffer)+1;
+            memset(cbuf, 0, cblen);
+
+            bp = buffer;
+            bp1 = cbuf;
+            while(*bp) {
+              if(*bp != '%')*bp1++ = *bp++;
+              else {
+                int i;
+
+                  bp++;
+                  i = *bp - '0';
+                  if(i>elementsInSet(asmInlineMap))break;
+                  
+                  bp++;
+                  s = indexSet(asmInlineMap, i);
+                  DEBUGpc("searching symbol s = `%s'", s);
+                  sym = findSym(SymbolTab, NULL, s);
+
+                  if(sym->reqv) {
+                    strcat(bp1, sym->reqv->operand.symOperand->regs[0]->name);
+                  } else {
+                    strcat(bp1, sym->rname);
+                  }
+                  
+                  while(*bp1)bp1++;
+              }
+              
+              if(strlen(bp1) > cblen - 16) {
+                int i = strlen(cbuf);
+                cblen += 50;
+                cbuf = realloc(cbuf, cblen);
+                memset(cbuf+i, 0, 50);
+                bp1 = cbuf + i;
+              }
+            }
+            
+            free(buffer);
+            buffer = Safe_strdup( cbuf );
+            free(cbuf);
+            
+            bp = bp1 = buffer;
+        }
+#endif  /* 0 */
 
 	/* emit each line as a code */
 	while (*bp) {
@@ -7423,7 +8350,7 @@ static void genRRC (iCode *ic)
   left = IC_LEFT(ic);
   result=IC_RESULT(ic);
   pic16_aopOp (left,ic,FALSE);
-  pic16_aopOp (result,ic,FALSE);
+  pic16_aopOp (result,ic,TRUE);
 
   DEBUGpic16_pic16_AopType(__LINE__,left,NULL,result);
 
@@ -7468,7 +8395,7 @@ static void genRLC (iCode *ic)
   left = IC_LEFT(ic);
   result=IC_RESULT(ic);
   pic16_aopOp (left,ic,FALSE);
-  pic16_aopOp (result,ic,FALSE);
+  pic16_aopOp (result,ic,TRUE);
 
   DEBUGpic16_pic16_AopType(__LINE__,left,NULL,result);
 
@@ -7774,7 +8701,7 @@ static void shiftR1Left2ResultSigned (operand *left, int offl,
     } else {
       pic16_emitpcode(POC_CLRF,  pic16_popGet(AOP(result),offr));
       pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(left),offl,FALSE,FALSE),7,0, PO_GPR_REGISTER));
-      pic16_emitpcode(POC_DECF,  pic16_popGet(AOP(result),offr));
+      pic16_emitpcode(POC_SETF,  pic16_popGet(AOP(result),offr));
       pic16_emitpcode(POC_BTFSS, pic16_newpCodeOpBit(pic16_aopGet(AOP(left),offl,FALSE,FALSE),6,0, PO_GPR_REGISTER));
       pic16_emitpcode(POC_BCF,   pic16_newpCodeOpBit(pic16_aopGet(AOP(result),offr,FALSE,FALSE),0,0, PO_GPR_REGISTER));
     }
@@ -7789,7 +8716,7 @@ static void shiftR1Left2ResultSigned (operand *left, int offl,
     } else {
       pic16_emitpcode(POC_CLRF,  pic16_popGet(AOP(result),offr));
       pic16_emitpcode(POC_BTFSC, pic16_newpCodeOpBit(pic16_aopGet(AOP(left),offl,FALSE,FALSE),7,0, PO_GPR_REGISTER));
-      pic16_emitpcode(POC_DECF,  pic16_popGet(AOP(result),offr));
+      pic16_emitpcode(POC_SETF,  pic16_popGet(AOP(result),offr));
     }
 
   default:
@@ -8490,19 +9417,20 @@ static void genlshFour (operand *result, operand *left, int shCount)
 /*-----------------------------------------------------------------*/
 /* genLeftShiftLiteral - left shifting by known count              */
 /*-----------------------------------------------------------------*/
-static void genLeftShiftLiteral (operand *left,
+void pic16_genLeftShiftLiteral (operand *left,
                                  operand *right,
                                  operand *result,
                                  iCode *ic)
 {    
-    int shCount = (int) floatFromVal (AOP(right)->aopu.aop_lit);
+    int shCount = (int) abs(floatFromVal (AOP(right)->aopu.aop_lit));
     int size;
 
-    DEBUGpic16_emitcode ("; ***","%s  %d shCount:%d",__FUNCTION__,__LINE__,shCount);
+    FENTRY;
+    DEBUGpic16_emitcode ("; ***","shCount:%d", shCount);
     pic16_freeAsmop(right,NULL,ic,TRUE);
 
     pic16_aopOp(left,ic,FALSE);
-    pic16_aopOp(result,ic,FALSE);
+    pic16_aopOp(result,ic,TRUE);
 
     size = getSize(operandType(result));
 
@@ -8569,6 +9497,8 @@ static void genMultiAsm( PIC_OPCODE poc, operand *reg, int size, int endian)
   }
 
 }
+
+#if !(USE_GENERIC_SIGNED_SHIFT)
 /*-----------------------------------------------------------------*/
 /* genLeftShift - generates code for left shifting                 */
 /*-----------------------------------------------------------------*/
@@ -8591,7 +9521,7 @@ static void genLeftShift (iCode *ic)
   /* if the shift count is known then do it 
      as efficiently as possible */
   if (AOP_TYPE(right) == AOP_LIT) {
-    genLeftShiftLiteral (left,right,result,ic);
+    pic16_genLeftShiftLiteral (left,right,result,ic);
     return ;
   }
 
@@ -8626,7 +9556,7 @@ static void genLeftShift (iCode *ic)
 #endif
       {
         /* we don't know if left is a literal or a register, take care -- VR */
-        mov2f(AOP(result), AOP(left), offset);
+        pic16_mov2f(AOP(result), AOP(left), offset);
       }
       offset++;
     }
@@ -8658,7 +9588,7 @@ static void genLeftShift (iCode *ic)
 #if 1
       /* this is already done, why change it? */
       if (!pic16_sameRegs(AOP(left),AOP(result))) {
-                mov2f(AOP(result), AOP(left), 0);
+                pic16_mov2f(AOP(result), AOP(left), 0);
       }
 #endif
 
@@ -8750,7 +9680,7 @@ static void genLeftShift (iCode *ic)
   pic16_freeAsmop(left,NULL,ic,TRUE);
   pic16_freeAsmop(result,NULL,ic,TRUE);
 }
-
+#endif
 
 
 #if 0
@@ -8777,7 +9707,7 @@ static void genLeftShift (iCode *ic)
   /* if the shift count is known then do it 
      as efficiently as possible */
   if (AOP_TYPE(right) == AOP_LIT) {
-    genLeftShiftLiteral (left,right,result,ic);
+    pic16_genLeftShiftLiteral (left,right,result,ic);
     return ;
   }
 
@@ -8809,7 +9739,7 @@ static void genLeftShift (iCode *ic)
       } else {
 
         /* we don't know if left is a literal or a register, take care -- VR */
-        mov2f(AOP(result), AOP(left), offset);
+        pic16_mov2f(AOP(result), AOP(left), offset);
       }
       offset++;
     }
@@ -8838,7 +9768,7 @@ static void genLeftShift (iCode *ic)
 
       tlbl = newiTempLabel(NULL);
       if (!pic16_sameRegs(AOP(left),AOP(result))) {
-                mov2f(AOP(result), AOP(left), 0);
+                pic16_mov2f(AOP(result), AOP(left), 0);
                 
 //		pic16_emitpcode(POC_MOVFW,  pic16_popGet(AOP(left),0));
 //		pic16_emitpcode(POC_MOVWF,  pic16_popGet(AOP(result),0));
@@ -8960,12 +9890,7 @@ static void genrshTwo (operand *result,operand *left,
     else
       movLeft2Result(left, MSB16, result, LSB);
 
-    pic16_emitpcode(POC_CLRF,pic16_popGet(AOP(result),MSB16));
-
-    if(sign) {
-      pic16_emitpcode(POC_BTFSC,pic16_newpCodeOpBit(pic16_aopGet(AOP(left),LSB,FALSE,FALSE),7,0, PO_GPR_REGISTER));
-      pic16_emitpcode(POC_DECF, pic16_popGet(AOP(result),MSB16));
-    }
+    pic16_addSign (result, 1, sign);
   }
 
   /*  1 <= shCount <= 7 */
@@ -9102,13 +10027,13 @@ static void genRightShiftLiteral (operand *left,
                                   iCode *ic,
                                   int sign)
 {    
-  int shCount = (int) floatFromVal (AOP(right)->aopu.aop_lit);
+  int shCount = (int) abs(floatFromVal (AOP(right)->aopu.aop_lit));
   int lsize,res_size;
 
   pic16_freeAsmop(right,NULL,ic,TRUE);
 
   pic16_aopOp(left,ic,FALSE);
-  pic16_aopOp(result,ic,FALSE);
+  pic16_aopOp(result,ic,TRUE);
 
   DEBUGpic16_emitcode ("; ***","%s  %d shCount:%d result:%d left:%d",__FUNCTION__,__LINE__,shCount,AOP_SIZE(result),AOP_SIZE(left));
 
@@ -9123,8 +10048,10 @@ static void genRightShiftLiteral (operand *left,
 
   /* I suppose that the left size >= result size */
   if(shCount == 0){
-    while(res_size--)
-      movLeft2Result(left, lsize, result, res_size);
+    assert (res_size <= lsize);
+    while (res_size--) {
+      pic16_mov2f (AOP(result), AOP(left), res_size);
+    } // for
   }
 
   else if(shCount >= (lsize * 8)){
@@ -9133,7 +10060,7 @@ static void genRightShiftLiteral (operand *left,
       pic16_emitpcode(POC_CLRF, pic16_popGet(AOP(result),LSB));
       if(sign) {
 	pic16_emitpcode(POC_BTFSC,pic16_newpCodeOpBit(pic16_aopGet(AOP(left),lsize-1,FALSE,FALSE),7,0, PO_GPR_REGISTER));
-	pic16_emitpcode(POC_DECF, pic16_popGet(AOP(result),LSB));
+	pic16_emitpcode(POC_SETF, pic16_popGet(AOP(result),LSB));
       }
     } else {
 
@@ -9174,6 +10101,7 @@ static void genRightShiftLiteral (operand *left,
   pic16_freeAsmop(result,NULL,ic,TRUE);
 }
 
+#if !(USE_GENERIC_SIGNED_SHIFT)
 /*-----------------------------------------------------------------*/
 /* genSignedRightShift - right shift of signed number              */
 /*-----------------------------------------------------------------*/
@@ -9314,7 +10242,10 @@ static void genSignedRightShift (iCode *ic)
   pic16_freeAsmop(result,NULL,ic,TRUE);
   pic16_freeAsmop(right,NULL,ic,TRUE);
 }
+#endif
 
+#if !(USE_GENERIC_SIGNED_SHIFT)
+#warning This implementation of genRightShift() is incomplete!
 /*-----------------------------------------------------------------*/
 /* genRightShift - generate code for right shifting                */
 /*-----------------------------------------------------------------*/
@@ -9423,19 +10354,233 @@ static void genRightShift (iCode *ic)
     }
     reAdjustPreg(AOP(result));
 
-    pic16_emitcode("","%05d_DS_:",tlbl1->key+100);
-    pic16_emitcode("djnz","b,%05d_DS_",tlbl->key+100);
+    pic16_emitcode("","%05d_DS_:",tlbl1->key+100);
+    pic16_emitcode("djnz","b,%05d_DS_",tlbl->key+100);
+
+release:
+    pic16_freeAsmop(left,NULL,ic,TRUE);
+    pic16_freeAsmop (right,NULL,ic,TRUE);
+    pic16_freeAsmop(result,NULL,ic,TRUE);
+}
+#endif
+
+#if (USE_GENERIC_SIGNED_SHIFT)
+/*-----------------------------------------------------------------*/
+/* genGenericShift - generates code for left or right shifting     */
+/*-----------------------------------------------------------------*/
+static void genGenericShift (iCode *ic, int isShiftLeft) {
+  operand *left,*right, *result;
+  int offset;
+  int sign, signedCount;
+  symbol *label_complete, *label_loop_pos, *label_loop_neg, *label_negative;
+  PIC_OPCODE pos_shift, neg_shift;
+
+  FENTRY;
+
+  right = IC_RIGHT(ic);
+  left  = IC_LEFT(ic);
+  result = IC_RESULT(ic);
+
+  pic16_aopOp(right,ic,FALSE);
+  pic16_aopOp(left,ic,FALSE);
+  pic16_aopOp(result,ic,TRUE);
+
+  sign = !SPEC_USIGN(operandType (left));
+  signedCount = !SPEC_USIGN(operandType (right));
+
+  /* if the shift count is known then do it 
+     as efficiently as possible */
+  if (AOP_TYPE(right) == AOP_LIT) {
+    long lit = (long)floatFromVal(AOP(right)->aopu.aop_lit);
+    if (signedCount && lit < 0) { lit = -lit; isShiftLeft = !isShiftLeft; }
+    // we should modify right->aopu.aop_lit here!
+    // Instead we use abs(shCount) in genXXXShiftLiteral()...
+    // lit > 8*size is handled in pic16_genXXXShiftLiteral()
+    if (isShiftLeft)
+      pic16_genLeftShiftLiteral (left,right,result,ic);
+    else
+      genRightShiftLiteral (left,right,result,ic, sign);
+
+    goto release;
+  } // if (right is literal)
+
+  /* shift count is unknown then we have to form a loop.
+   * Note: we take only the lower order byte since shifting
+   * more than 32 bits make no sense anyway, ( the
+   * largest size of an object can be only 32 bits )
+   * Note: we perform arithmetic shifts if the left operand is
+   * signed and we do an (effective) right shift, i. e. we
+   * shift in the sign bit from the left. */
+   
+  label_complete = newiTempLabel ( NULL );
+  label_loop_pos = newiTempLabel ( NULL );
+  label_loop_neg = NULL;
+  label_negative = NULL;
+  pos_shift = isShiftLeft ? POC_RLCF : POC_RRCF;
+  neg_shift = isShiftLeft ? POC_RRCF : POC_RLCF;
+
+  if (signedCount) {
+    // additional labels needed
+    label_loop_neg = newiTempLabel ( NULL );
+    label_negative = newiTempLabel ( NULL );
+  } // if
+
+  // copy source to result -- this will effectively truncate the left operand to the size of result!
+  // (e.g. char c = 0x100 << -3 will become c = 0x00 >> 3 == 0x00 instad of 0x20)
+  // This is fine, as it only occurs for left shifting with negative count which is not standardized!
+  for (offset=0; offset < min(AOP_SIZE(left), AOP_SIZE(result)); offset++) {
+    pic16_mov2f (AOP(result),AOP(left), offset);
+  } // for
+
+  // if result is longer than left, fill with zeros (or sign)
+  if (AOP_SIZE(left) < AOP_SIZE(result)) {
+    if (sign && AOP_SIZE(left) > 0) {
+      // shift signed operand -- fill with sign
+      pic16_emitpcode (POC_CLRF, pic16_popCopyReg (&pic16_pc_wreg));
+      pic16_emitpcode (POC_BTFSC, pic16_popCopyGPR2Bit(pic16_popGet(AOP(result), AOP_SIZE(left)-1), 7));
+      pic16_emitpcode (POC_MOVLW, pic16_popGetLit (0xFF));
+      for (offset=AOP_SIZE(left); offset < AOP_SIZE(result); offset++) {
+        pic16_emitpcode (POC_MOVWF, pic16_popGet (AOP(result), offset));
+      } // for
+    } else {
+      // shift unsigned operand -- fill result with zeros
+      for (offset=AOP_SIZE(left); offset < AOP_SIZE(result); offset++) {
+        pic16_emitpcode (POC_CLRF, pic16_popGet (AOP(result), offset));
+      } // for
+    }
+  } // if (size mismatch)
+
+  pic16_mov2w (AOP(right), 0);
+  pic16_emitpcode (POC_BZ, pic16_popGetLabel (label_complete->key));
+  if (signedCount) pic16_emitpcode (POC_BN, pic16_popGetLabel (label_negative->key));
+  
+#if 0
+  // perform a shift by one (shift count is positive)
+  // cycles used for shifting {unsigned,signed} values on n bytes by [unsigned,signed] shift count c>0:
+  // 2n+[2,3]+({1,3}+n+3)c-2+[0,2]=({4,6}+n)c+2n+[0,3]		({5,7}c+[2,5] / {6,8}c+[4, 7] / {8,10}c+[ 8,11])
+  pic16_emitpLabel (label_loop_pos->key);
+  emitCLRC;
+  if (sign && (pos_shift == POC_RRCF)) {
+    pic16_emitpcode (POC_BTFSC, pic16_popCopyGPR2Bit(pic16_popGet(AOP(result), AOP_SIZE(result)-1), 7));
+    emitSETC;
+  } // if
+  genMultiAsm (pos_shift, result, AOP_SIZE(result), pos_shift == POC_RRCF);
+  pic16_emitpcode (POC_DECFSZ, pic16_popCopyReg (&pic16_pc_wreg));
+  pic16_emitpcode (POC_BRA, pic16_popGetLabel (label_loop_pos->key));
+#else
+  // perform a shift by one (shift count is positive)
+  // cycles used for shifting {unsigned,signed} values on n bytes by [unsigned,signed] shift count c>0:
+  // 2n+[2,3]+2+({0,2}+n+3)c-1+[0,2]=({3,5}+n)c+2n+[3,6]	({4,6}c+[5,8] / {5,7}c+[7,10] / {7, 9}c+[11,14])
+  // This variant is slower for 0<c<3, equally fast for c==3, and faster for 3<c.
+  pic16_emitpcode (POC_NEGF, pic16_popCopyReg (&pic16_pc_wreg));
+  emitCLRC;
+  pic16_emitpLabel (label_loop_pos->key);
+  if (sign && (pos_shift == POC_RRCF)) {
+    pic16_emitpcode (POC_BTFSC, pic16_popCopyGPR2Bit(pic16_popGet(AOP(result), AOP_SIZE(result)-1), 7));
+    emitSETC;
+  } // if
+  genMultiAsm (pos_shift, result, AOP_SIZE(result), pos_shift == POC_RRCF);
+  //pic16_emitpcode (POC_INCF, pic16_popCopyReg (&pic16_pc_wreg)); // gpsim does not like this...
+  pic16_emitpcode (POC_ADDLW, pic16_popGetLit (0x01));
+  pic16_emitpcode (POC_BNC, pic16_popGetLabel (label_loop_pos->key));
+#endif
+
+  if (signedCount) {
+    pic16_emitpcode (POC_BRA, pic16_popGetLabel (label_complete->key));
+
+    pic16_emitpLabel (label_negative->key);
+    // perform a shift by -1 (shift count is negative)
+    // 2n+4+1+({0,2}+n+3)*c-1=({3,5}+n)c+2n+4			({4,6}c+6 / {5,7}c+8 / {7,9}c+12)
+    emitCLRC;
+    pic16_emitpLabel (label_loop_neg->key);
+    if (sign && (neg_shift == POC_RRCF)) {
+      pic16_emitpcode (POC_BTFSC, pic16_popCopyGPR2Bit(pic16_popGet(AOP(result), AOP_SIZE(result)-1), 7));
+      emitSETC;
+    } // if
+    genMultiAsm (neg_shift, result, AOP_SIZE(result), neg_shift == POC_RRCF);
+    //pic16_emitpcode (POC_INCF, pic16_popCopyReg (&pic16_pc_wreg)); // gpsim does not like this...
+    pic16_emitpcode (POC_ADDLW, pic16_popGetLit (0x01));
+    pic16_emitpcode (POC_BNC, pic16_popGetLabel (label_loop_neg->key));
+  } // if (signedCount)
+
+  pic16_emitpLabel (label_complete->key);
 
 release:
-    pic16_freeAsmop(left,NULL,ic,TRUE);
-    pic16_freeAsmop (right,NULL,ic,TRUE);
-    pic16_freeAsmop(result,NULL,ic,TRUE);
+  pic16_freeAsmop (right,NULL,ic,TRUE);
+  pic16_freeAsmop(left,NULL,ic,TRUE);
+  pic16_freeAsmop(result,NULL,ic,TRUE);
+}
+
+static void genLeftShift (iCode *ic) {
+  genGenericShift (ic, 1);
+}
+
+static void genRightShift (iCode *ic) {
+  genGenericShift (ic, 0);
 }
+#endif
 
 
-void pic16_loadFSR0(operand *op)
+/* load FSR0 with address of/from op according to is_LitOp() or if lit is 1 */
+void pic16_loadFSR0(operand *op, int lit)
+{
+  if(OP_SYMBOL(op)->remat || is_LitOp( op )) {
+    pic16_emitpcode(POC_LFSR, pic16_popGetLit2(0, pic16_popGet(AOP(op), 0)));
+  } else {
+    assert (!OP_SYMBOL(op)->remat);
+    // set up FSR0 with address of result
+    pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(op),0), pic16_popCopyReg(&pic16_pc_fsr0l)));
+    pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(op),1), pic16_popCopyReg(&pic16_pc_fsr0h)));
+  }
+}
+
+/*----------------------------------------------------------------*/
+/* pic16_derefPtr - move one byte from the location ptr points to */
+/*                  to WREG (doWrite == 0) or one byte from WREG   */
+/*                  to the location ptr points to (doWrite != 0)   */
+/*----------------------------------------------------------------*/
+static void pic16_derefPtr (operand *ptr, int p_type, int doWrite, int *fsr0_setup)
 {
-	pic16_emitpcode(POC_LFSR, pic16_popGetLit2(0, pic16_popGet(AOP(op), 0)));
+  switch (p_type) {
+    case FPOINTER:
+    case POINTER:
+      if (!fsr0_setup || !*fsr0_setup)
+      {
+        pic16_loadFSR0( ptr, 0 );
+        if (fsr0_setup) *fsr0_setup = 1;
+      }
+      if (doWrite)
+        pic16_emitpcode(POC_MOVWF, pic16_popCopyReg(&pic16_pc_indf0));
+      else
+        pic16_emitpcode(POC_MOVFW, pic16_popCopyReg(&pic16_pc_indf0));
+      break;
+
+    case GPOINTER:
+      if (AOP(ptr)->aopu.aop_reg[2]) {
+        if (doWrite) pic16_emitpcode (POC_MOVWF, pic16_popCopyReg(pic16_stack_postdec));
+	// prepare call to __gptrget1, this is actually genGenPointerGet(result, WREG, ?ic?)
+	pic16_emitpcode (POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(ptr),0), pic16_popCopyReg(&pic16_pc_fsr0l)));
+	pic16_emitpcode (POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(ptr),1), pic16_popCopyReg(&pic16_pc_prodl)));
+	pic16_emitpcode (POC_MOVFW, pic16_popGet(AOP(ptr),2));
+	pic16_callGenericPointerRW(doWrite, 1);
+      } else {
+	// data pointer (just 2 byte given)
+	if (!fsr0_setup || !*fsr0_setup)
+	{
+	  pic16_loadFSR0( ptr, 0 );
+	  if (fsr0_setup) *fsr0_setup = 1;
+	}
+	if (doWrite)
+	  pic16_emitpcode(POC_MOVWF, pic16_popCopyReg(&pic16_pc_indf0));
+	else
+	  pic16_emitpcode(POC_MOVFW, pic16_popCopyReg(&pic16_pc_indf0));
+      }
+      break;
+
+    default:
+      assert (0 && "invalid pointer type specified");
+      break;
+  }
 }
 
 /*-----------------------------------------------------------------*/
@@ -9443,34 +10588,58 @@ void pic16_loadFSR0(operand *op)
 /*-----------------------------------------------------------------*/
 static void genUnpackBits (operand *result, operand *left, char *rname, int ptype)
 {    
-    int shCnt ;
-    int rlen = 0 ;
-    sym_link *etype;
-    int offset = 0 ;
+  int shCnt ;
+  sym_link *etype, *letype;
+  int blen=0, bstr=0;
+  int lbstr;
 
-	DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-	etype = getSpec(operandType(result));
+    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+    etype = getSpec(operandType(result));
+    letype = getSpec(operandType(left));
+    
+//    if(IS_BITFIELD(etype)) {
+      blen = SPEC_BLEN(etype);
+      bstr = SPEC_BSTR(etype);
+//    }
+
+    lbstr = SPEC_BSTR( letype );
+
+#if 1
+    if((blen == 1) && (bstr < 8)) {
+      /* it is a single bit, so use the appropriate bit instructions */
+      DEBUGpic16_emitcode (";","%s %d optimize bit read",__FUNCTION__,__LINE__);
+
+      pic16_emitpcode(POC_CLRF, pic16_popCopyReg(&pic16_pc_wreg));
+      
+      // distinguish (p->bitfield) and p.bitfield, remat seems to work...
+      if(!IS_PTR(operandType(left))/* && OP_SYMBOL(left)->remat && (ptype == POINTER)*/) {
+        /* workaround to reduce the extra lfsr instruction */
+        pic16_emitpcode(POC_BTFSC,
+              pic16_popCopyGPR2Bit(pic16_popGet(AOP(left), 0), bstr));
+      } else {
+	pic16_loadFSR0 (left, 0);
+        pic16_emitpcode(POC_BTFSC,
+              pic16_popCopyGPR2Bit(pic16_popCopyReg(&pic16_pc_indf0), bstr));
+      }
+	
+      pic16_emitpcode(POC_INCF, pic16_popCopyReg(&pic16_pc_wreg));
+
+      pic16_emitpcode(POC_MOVWF, pic16_popGet( AOP(result), 0 ));      
+      return;
+    }
+
+#endif
 
         /* the following call to pic16_loadFSR0 is temporary until
          * optimization to handle single bit assignments is added
          * to the function. Until then use the old safe way! -- VR */
-        pic16_loadFSR0( left );
- 
-	/* read the first byte  */
-	switch (ptype) {
-		case POINTER:
-		case IPOINTER:
-		case PPOINTER:
-		case FPOINTER:
-		case GPOINTER:
-			pic16_emitpcode(POC_MOVFW, pic16_popCopyReg(&pic16_pc_indf0));
-			break;
-		case CPOINTER:
-			pic16_emitcode("clr","a");
-			pic16_emitcode("movc","a","@a+dptr");
-			break;
-	}
-	
+
+    if (!IS_PTR(operandType(left)) /*OP_SYMBOL(left)->remat*/) {
+	// access symbol directly
+	pic16_mov2w (AOP(left), 0);
+    } else {
+      pic16_derefPtr (left, ptype, 0, NULL);
+    }
 
 	/* if we have bitdisplacement then it fits   */
 	/* into this byte completely or if length is */
@@ -9501,55 +10670,6 @@ static void genUnpackBits (operand *result, operand *left, char *rname, int ptyp
 	fprintf(stderr, "bitfields of size >=8. Instead of generating wrong code, bailling out...\n");
 	exit(-1);
 
-    /* bit field did not fit in a byte  */
-    rlen = SPEC_BLEN(etype) - 8;
-    pic16_aopPut(AOP(result),"a",offset++);
-
-    while (1)  {
-
-	switch (ptype) {
-	case POINTER:
-	case IPOINTER:
-	    pic16_emitcode("inc","%s",rname);
-	    pic16_emitcode("mov","a,@%s",rname);
-	    break;
-	    
-	case PPOINTER:
-	    pic16_emitcode("inc","%s",rname);
-	    pic16_emitcode("movx","a,@%s",rname);
-	    break;
-
-	case FPOINTER:
-	    pic16_emitcode("inc","dptr");
-	    pic16_emitcode("movx","a,@dptr");
-	    break;
-	    
-	case CPOINTER:
-	    pic16_emitcode("clr","a");
-	    pic16_emitcode("inc","dptr");
-	    pic16_emitcode("movc","a","@a+dptr");
-	    break;
-	    
-	case GPOINTER:
-	    pic16_emitcode("inc","dptr");
-	    pic16_emitcode("lcall","__gptrget");
-	    break;
- 	}
-
-	rlen -= 8;            
-	/* if we are done */
-	if ( rlen <= 0 )
-	    break ;
-	
-	pic16_aopPut(AOP(result),"a",offset++);
-       			      
-    }
-    
-    if (rlen) {
-	pic16_emitcode("anl","a,#0x%02x",((unsigned char)-1)>>(-rlen));
-	pic16_aopPut(AOP(result),"a",offset);	       
-    }
-    
     return ;
 }
 
@@ -9561,7 +10681,9 @@ static void genDataPointerGet(operand *left,
   int size, offset = 0, leoffset=0 ;
 
 	DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-	pic16_aopOp(result, ic, FALSE);
+	pic16_aopOp(result, ic, TRUE);
+
+	FENTRY;
 
 	size = AOP_SIZE(result);
 //	fprintf(stderr, "%s:%d size= %d\n", __FILE__, __LINE__, size);
@@ -9613,9 +10735,9 @@ static void genDataPointerGet(operand *left,
 	while (size--) {
 		DEBUGpic16_emitcode("; ***", "%s loop offset=%d leoffset=%d", __FUNCTION__, offset, leoffset);
 		
-		if(AOP(result)->aopu.pcop->type == PO_IMMEDIATE
-			|| AOP(left)->aopu.pcop->type == PO_IMMEDIATE) {
-			mov2w(AOP(left), offset); // patch 8
+//		pic16_DumpOp("(result)",result);
+		if(is_LitAOp(AOP(result))) {
+			pic16_mov2w(AOP(left), offset); // patch 8
 			pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result), offset));
 		} else {
 			pic16_emitpcode(POC_MOVFF, pic16_popGet2p(
@@ -9640,136 +10762,133 @@ static void genNearPointerGet (operand *left,
 			       operand *result, 
 			       iCode *ic)
 {
-    asmop *aop = NULL;
-    //regs *preg = NULL ;
-    sym_link *rtype, *retype;
-    sym_link *ltype = operandType(left);    
+//  asmop *aop = NULL;
+  //regs *preg = NULL ;
+  sym_link *rtype, *retype;
+  sym_link *ltype, *letype;
 
-	DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-	rtype = operandType(result);
-	retype= getSpec(rtype);
+    FENTRY;
     
-	pic16_aopOp(left,ic,FALSE);
-
-//	pic16_DumpOp("(left)",left);
-//	pic16_DumpOp("(result)",result);
+    rtype = operandType(result);
+    retype= getSpec(rtype);
+    ltype = operandType(left);
+    letype= getSpec(ltype);
+    
+    pic16_aopOp(left,ic,FALSE);
 
-	/* if left is rematerialisable and
-	 * 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_PCODE
-		&& !IS_BITFIELD(retype)
-		&& DCL_TYPE(ltype) == POINTER) {
+//    pic16_DumpOp("(left)",left);
+//    pic16_DumpOp("(result)",result);
 
-		genDataPointerGet (left,result,ic);
-		pic16_freeAsmop(left, NULL, ic, TRUE);
-	  return ;
-	}
+    /* if left is rematerialisable and
+     * result is not bit variable type and
+     * the left is pointer to data space i.e
+     * lower 128 bytes of space */
     
-	DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+    if (AOP_TYPE(left) == AOP_PCODE
+      && !IS_BITFIELD(retype)
+      && DCL_TYPE(ltype) == POINTER) {
 
-	/* if the value is already in a pointer register
-	 * then don't need anything more */
-	if (!AOP_INPREG(AOP(left))) {
-		/* otherwise get a free pointer register */
-		DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-		
-		/* VR -- the whole concept is to load FSR0 with the address of the symbol */
-		if( (AOP_TYPE(left) == AOP_PCODE) 
-			&& ((AOP(left)->aopu.pcop->type == PO_IMMEDIATE)
-				|| (AOP(left)->aopu.pcop->type == PO_DIR))) // patch 10
-		{
-			if(!IS_BITFIELD(retype))
-				pic16_loadFSR0( left );  // patch 10
-		} else {
-			// set up FSR0 with address from left
-			pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(left),0), pic16_popCopyReg(&pic16_pc_fsr0l))); // patch 10
-			pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(left),1), pic16_popCopyReg(&pic16_pc_fsr0h))); // patch 10
-		}
-	}
-//	 else
-//	rname = pic16_aopGet(AOP(left),0,FALSE,FALSE);
+        genDataPointerGet (left,result,ic);
+        pic16_freeAsmop(left, NULL, ic, TRUE);
+        return ;
+    }
     
-	pic16_aopOp (result,ic,FALSE);
+    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+    pic16_aopOp (result,ic,TRUE);
     
-      /* if bitfield then unpack the bits */
-    if (IS_BITFIELD(retype)) 
-	genUnpackBits (result, left, NULL, POINTER);
+    DEBUGpic16_pic16_AopType(__LINE__, left, NULL, result);
+
+#if 1
+    if(IS_BITFIELD( retype )
+      && (SPEC_BLEN(operandType(result))==1)
+    ) {
+      iCode *nextic;
+      pCodeOp *jop;
+      int bitstrt, bytestrt;
+
+        /* if this is bitfield of size 1, see if we are checking the value
+         * of a single bit in an if-statement,
+         * if yes, then don't generate usual code, but execute the
+         * genIfx directly -- VR */
+
+        nextic = ic->next;
+
+        /* CHECK: if next iCode is IFX
+         * and current result operand is nextic's conditional operand
+         * and current result operand live ranges ends at nextic's key number
+         */
+        if((nextic->op == IFX)
+          && (result == IC_COND(nextic))
+          && (OP_LIVETO(result) == nextic->seq)
+          && (OP_SYMBOL(left)->remat)	// below fails for "if (p->bitfield)"
+          ) {
+            /* everything is ok then */
+            /* find a way to optimize the genIfx iCode */
+
+            bytestrt = SPEC_BSTR(operandType(result))/8;
+            bitstrt = SPEC_BSTR(operandType(result))%8;
+            
+            jop = pic16_popCopyGPR2Bit(pic16_popGet(AOP(left), 0), bitstrt);
+
+            genIfxpCOpJump(nextic, jop);
+            
+            pic16_freeAsmop(left, NULL, ic, TRUE);
+            pic16_freeAsmop(result, NULL, ic, TRUE);
+            return;
+        }
+    }
+#endif
+
+    /* if bitfield then unpack the bits */
+    if (IS_BITFIELD(letype)) 
+      genUnpackBits (result, left, NULL, POINTER);
     else {
-	/* we have can just get the values */
+      /* we have can just get the values */
       int size = AOP_SIZE(result);
       int offset = 0;	
 	
       DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
 
+      pic16_loadFSR0( left, 0 );
 
-	/* fsr0 is loaded already -- VR */
-//	pic16_loadFSR0( left );
-
-//      pic16_emitpcode(POC_MOVFW,pic16_popGet(AOP(left),0));
-//      pic16_emitpcode(POC_MOVWF,pic16_popCopyReg(&pic16_pc_fsr0));
       while(size--) {
-
-	if(size) {
-		pic16_emitpcode(POC_MOVFF,
-			pic16_popGet2p(pic16_popCopyReg(&pic16_pc_postinc0),
-				pic16_popGet(AOP(result), offset++)));
-	} else {
-		pic16_emitpcode(POC_MOVFF,
-			pic16_popGet2p(pic16_popCopyReg(&pic16_pc_indf0),
-				pic16_popGet(AOP(result), offset++)));
-	}
+        if(size) {
+          pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popCopyReg(&pic16_pc_postinc0),
+                pic16_popGet(AOP(result), offset++)));
+        } else {
+          pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popCopyReg(&pic16_pc_indf0),
+                pic16_popGet(AOP(result), offset++)));
+        }
       }
-#if 0
-//	pic16_emitpcode(POC_MOVFW,pic16_popCopyReg(&pic16_pc_postinc0));
-//	pic16_emitpcode(POC_MOVWF,pic16_popGet(AOP(result),offset++));
-	if(size)
-	  pic16_emitpcode(POC_INCF,pic16_popCopyReg(&pic16_pc_fsr0));
-#endif
-/*
-	while (size--) {
-	    if (IS_AOP_PREG(result) || AOP_TYPE(result) == AOP_STK ) {
-
-		pic16_emitcode("mov","a,@%s",rname);
-		pic16_aopPut(AOP(result),"a",offset);
-	    } else {
-		sprintf(buffer,"@%s",rname);
-		pic16_aopPut(AOP(result),buffer,offset);
-	    }
-	    offset++ ;
-	    if (size)
-		pic16_emitcode("inc","%s",rname);
-	}
-*/
     }
 
+#if 0
     /* now some housekeeping stuff */
     if (aop) {
-	/* we had to allocate for this iCode */
-    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-	pic16_freeAsmop(NULL,aop,ic,TRUE);
+      /* we had to allocate for this iCode */
+      DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+      pic16_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 */
-    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-	if (AOP_SIZE(result) > 1 &&
-	    !OP_SYMBOL(left)->remat &&
-	    ( OP_SYMBOL(left)->liveTo > ic->seq ||
-	      ic->depth )) {
-//	    int size = AOP_SIZE(result) - 1;
-//	    while (size--)
-//		pic16_emitcode("dec","%s",rname);
+      /* 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 */
+      DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+      if (AOP_SIZE(result) > 1
+        && !OP_SYMBOL(left)->remat
+        && ( OP_SYMBOL(left)->liveTo > ic->seq
+            || ic->depth )) {
+//        int size = AOP_SIZE(result) - 1;
+//        while (size--)
+//          pic16_emitcode("dec","%s",rname);
 	}
     }
+#endif
 
     /* done */
     pic16_freeAsmop(left,NULL,ic,TRUE);
     pic16_freeAsmop(result,NULL,ic,TRUE);
-     
 }
 
 /*-----------------------------------------------------------------*/
@@ -9805,7 +10924,7 @@ static void genPagedPointerGet (operand *left,
 	rname = pic16_aopGet(AOP(left),0,FALSE,FALSE);
     
     pic16_freeAsmop(left,NULL,ic,TRUE);
-    pic16_aopOp (result,ic,FALSE);
+    pic16_aopOp (result,ic,TRUE);
 
     /* if bitfield then unpack the bits */
     if (IS_BITFIELD(retype)) 
@@ -9883,7 +11002,7 @@ static void genFarPointerGet (operand *left,
     }
     /* so dptr know contains the address */
     pic16_freeAsmop(left,NULL,ic,TRUE);
-    pic16_aopOp(result,ic,FALSE);
+    pic16_aopOp(result,ic,TRUE);
 
     /* if bit then unpack */
     if (IS_BITFIELD(retype)) 
@@ -9902,6 +11021,7 @@ static void genFarPointerGet (operand *left,
 
     pic16_freeAsmop(result,NULL,ic,TRUE);
 }
+
 #if 0
 /*-----------------------------------------------------------------*/
 /* genCodePointerGet - get value from code space                  */
@@ -9954,6 +11074,7 @@ static void genCodePointerGet (operand *left,
     pic16_freeAsmop(result,NULL,ic,TRUE);
 }
 #endif
+
 #if 0
 /*-----------------------------------------------------------------*/
 /* genGenPointerGet - gget value from generic pointer space        */
@@ -9995,7 +11116,7 @@ static void genGenPointerGet (operand *left,
 		// set up FSR0 with address from left
 		pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(left),0), pic16_popCopyReg(&pic16_pc_fsr0l)));
 		pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(left),1), pic16_popCopyReg(&pic16_pc_fsr0h)));
-
+                
 		offset = 0 ;
 
 		while(size--) {
@@ -10020,7 +11141,6 @@ static void genGenPointerGet (operand *left,
 }
 #endif
 
-extern set *externs;
 
 /*-----------------------------------------------------------------*/
 /* genGenPointerGet - gget value from generic pointer space        */
@@ -10029,15 +11149,20 @@ static void genGenPointerGet (operand *left,
                               operand *result, iCode *ic)
 {
   int size, offset, lit;
-  sym_link *retype = getSpec(operandType(result));
-  char fgptrget[32];
+  sym_link *letype = getSpec(operandType(left));
 
     DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
     pic16_aopOp(left,ic,FALSE);
-    pic16_aopOp(result,ic,FALSE);
+    pic16_aopOp(result,ic,TRUE);
     size = AOP_SIZE(result);
 
     DEBUGpic16_pic16_AopType(__LINE__,left,NULL,result);
+  
+    /* if bit then unpack */
+    if (IS_BITFIELD(letype)) {
+      genUnpackBits(result,left,"BAD",GPOINTER);
+      goto release;
+    }
 
     if (AOP_TYPE(left) == AOP_IMMD) { // do we ever get here? (untested!)
 
@@ -10066,37 +11191,13 @@ static void genGenPointerGet (operand *left,
       pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(left),1), pic16_popCopyReg(&pic16_pc_prodl)));
       pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(left), 2));
       
-      switch( size ) {
-        case 1: strcpy(fgptrget, "__gptrget1"); break;
-        case 2: strcpy(fgptrget, "__gptrget2"); break;
-        case 3: strcpy(fgptrget, "__gptrget3"); break;
-        case 4: strcpy(fgptrget, "__gptrget4"); break;
-        default:
-          werror(W_POSSBUG2, __FILE__, __LINE__);
-          abort();
-      }
-      
-      pic16_emitpcode(POC_CALL, pic16_popGetWithString( fgptrget ));
+      pic16_callGenericPointerRW(0, size);
       
       assignResultValue(result, 1);
       
-      {
-        symbol *sym;
-
-          sym = newSymbol( fgptrget, 0 );
-          strcpy(sym->rname, fgptrget);
-          checkAddSym(&externs, sym);
-
-//          fprintf(stderr, "%s:%d adding extern symbol %s in externs\n", __FILE__, __LINE__, fgptrget);
-      }
-              
       goto release;
     }
 
-  /* if bit then unpack */
-    if (IS_BITFIELD(retype)) 
-      genUnpackBits(result,left,"BAD",GPOINTER);
-
 release:
   pic16_freeAsmop(left,NULL,ic,TRUE);
   pic16_freeAsmop(result,NULL,ic,TRUE);
@@ -10123,29 +11224,11 @@ static void genConstPointerGet (operand *left,
   DEBUGpic16_pic16_AopType(__LINE__,left,NULL,result);
 
   DEBUGpic16_emitcode ("; "," %d getting const pointer",__LINE__);
-#if 0									// patch 15
-  pic16_emitpcode(POC_CALL,pic16_popGetLabel(albl->key));
-  pic16_emitpcode(POC_GOTO,pic16_popGetLabel(blbl->key));
-  pic16_emitpLabel(albl->key);
-
-  poc = ( (AOP_TYPE(left) == AOP_PCODE) ? POC_MOVLW : POC_MOVFW);
-  
-  /* this performs a goto to the specified address -- Why not to use pointer? -- VR */
-  pic16_emitpcode(poc,pic16_popGet(AOP(left),1));
-  pic16_emitpcode(POC_MOVWF,pic16_popCopyReg(&pic16_pc_pclath));
-  pic16_emitpcode(poc,pic16_popGet(AOP(left),0));
-  pic16_emitpcode(POC_MOVWF,pic16_popCopyReg(&pic16_pc_pcl));
-
-  pic16_emitpLabel(blbl->key);
-
-  pic16_emitpcode(POC_MOVWF,pic16_popGet(AOP(result),0));
-#endif									// patch 15
-
 
   // set up table pointer
   if( (AOP_TYPE(left) == AOP_PCODE) 
       && ((AOP(left)->aopu.pcop->type == PO_IMMEDIATE)
-          || (AOP(left)->aopu.pcop->type == PO_DIR))) 			// patch 15 ......
+          || (AOP(left)->aopu.pcop->type == PO_DIR)))
     {
       pic16_emitpcode(POC_MOVLW,pic16_popGet(AOP(left),0));
       pic16_emitpcode(POC_MOVWF,pic16_popCopyReg(&pic16_pc_tblptrl));
@@ -10153,25 +11236,20 @@ static void genConstPointerGet (operand *left,
       pic16_emitpcode(POC_MOVWF,pic16_popCopyReg(&pic16_pc_tblptrh));
       pic16_emitpcode(POC_MOVLW,pic16_popGet(AOP(left),2));
       pic16_emitpcode(POC_MOVWF,pic16_popCopyReg(&pic16_pc_tblptru));
-    }
-  else
-    {
-      pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(left),0), pic16_popCopyReg(&pic16_pc_tblptrl)));
-      pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(left),1), pic16_popCopyReg(&pic16_pc_tblptrh)));
-      pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(left),2), pic16_popCopyReg(&pic16_pc_tblptru)));
-    }
-
+  } else {
+    pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(left),0), pic16_popCopyReg(&pic16_pc_tblptrl)));
+    pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(left),1), pic16_popCopyReg(&pic16_pc_tblptrh)));
+    pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(left),2), pic16_popCopyReg(&pic16_pc_tblptru)));
+  }
 
-  while(size--)
-    {
-      pic16_emitpcodeNULLop(POC_TBLRD_POSTINC);
-      pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popCopyReg(&pic16_pc_tablat), pic16_popGet(AOP(result),offset)));
-      offset++;
-    }
+  while(size--) {
+    pic16_emitpcodeNULLop(POC_TBLRD_POSTINC);
+    pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popCopyReg(&pic16_pc_tablat), pic16_popGet(AOP(result),offset)));
+    offset++;
+  }
     
   pic16_freeAsmop(left,NULL,ic,TRUE);
   pic16_freeAsmop(result,NULL,ic,TRUE);
-
 }
 
 
@@ -10180,12 +11258,12 @@ static void genConstPointerGet (operand *left,
 /*-----------------------------------------------------------------*/
 static void genPointerGet (iCode *ic)
 {
-    operand *left, *result ;
-    sym_link *type, *etype;
-    int p_type;
-
-    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+  operand *left, *result ;
+  sym_link *type, *etype;
+  int p_type;
 
+    FENTRY;
+    
     left = IC_LEFT(ic);
     result = IC_RESULT(ic) ;
 
@@ -10203,57 +11281,56 @@ static void genPointerGet (iCode *ic)
 
     /* if left is of type of pointer then it is simple */
     if (IS_PTR(type) && !IS_FUNC(type->next)) 
-        p_type = DCL_TYPE(type);
+      p_type = DCL_TYPE(type);
     else {
-	/* we have to go by the storage class */
-	p_type = PTR_TYPE(SPEC_OCLS(etype));
+      /* we have to go by the storage class */
+      p_type = PTR_TYPE(SPEC_OCLS(etype));
 
-	DEBUGpic16_emitcode ("; ***","%d - resolve pointer by storage class",__LINE__);
+      DEBUGpic16_emitcode ("; ***","%d - resolve pointer by storage class",__LINE__);
 
-	if (SPEC_OCLS(etype)->codesp ) {
-	  DEBUGpic16_emitcode ("; ***","%d - cpointer",__LINE__);
-	  //p_type = CPOINTER ;	
-	}
-	else
-	    if (SPEC_OCLS(etype)->fmap && !SPEC_OCLS(etype)->paged)
-	      DEBUGpic16_emitcode ("; ***","%d - fpointer",__LINE__);
-	       /*p_type = FPOINTER ;*/ 
-	    else
-		if (SPEC_OCLS(etype)->fmap && SPEC_OCLS(etype)->paged)
-		  DEBUGpic16_emitcode ("; ***","%d - ppointer",__LINE__);
-/* 		    p_type = PPOINTER; */
-		else
-		    if (SPEC_OCLS(etype) == idata )
-		      DEBUGpic16_emitcode ("; ***","%d - ipointer",__LINE__);
-/* 			p_type = IPOINTER; */
-		    else
-		      DEBUGpic16_emitcode ("; ***","%d - pointer",__LINE__);
-/* 			p_type = POINTER ; */
+      if (SPEC_OCLS(etype)->codesp ) {
+        DEBUGpic16_emitcode ("; ***","%d - cpointer",__LINE__);
+        //p_type = CPOINTER ;	
+      } else
+      if (SPEC_OCLS(etype)->fmap && !SPEC_OCLS(etype)->paged) {
+        DEBUGpic16_emitcode ("; ***","%d - fpointer",__LINE__);
+        /*p_type = FPOINTER ;*/ 
+      } else
+      if (SPEC_OCLS(etype)->fmap && SPEC_OCLS(etype)->paged) {
+        DEBUGpic16_emitcode ("; ***","%d - ppointer",__LINE__);
+        /* p_type = PPOINTER; */
+      } else
+      if (SPEC_OCLS(etype) == idata ) {
+        DEBUGpic16_emitcode ("; ***","%d - ipointer",__LINE__);
+        /* p_type = IPOINTER; */
+      } else {
+        DEBUGpic16_emitcode ("; ***","%d - pointer",__LINE__);
+        /* p_type = POINTER ; */
+      }
     }
 
     /* now that we have the pointer type we assign
     the pointer values */
     switch (p_type) {
-
-    case POINTER:	
-    case IPOINTER:
+      case POINTER:	
+      case IPOINTER:
 	genNearPointerGet (left,result,ic);
 	break;
 
-    case PPOINTER:
+      case PPOINTER:
 	genPagedPointerGet(left,result,ic);
 	break;
 
-    case FPOINTER:
+      case FPOINTER:
 	genFarPointerGet (left,result,ic);
 	break;
 
-    case CPOINTER:
+      case CPOINTER:
 	genConstPointerGet (left,result,ic);
 	//pic16_emitcodePointerGet (left,result,ic);
 	break;
 
-    case GPOINTER:
+      case GPOINTER:
 #if 0
       if (IS_PTR_CONST(type))
 	genConstPointerGet (left,result,ic);
@@ -10267,7 +11344,6 @@ static void genPointerGet (iCode *ic)
 	      "genPointerGet: illegal pointer type");
     
     }
-
 }
 
 /*-----------------------------------------------------------------*/
@@ -10281,12 +11357,14 @@ static void genPackBits (sym_link    *etype , operand *result,
   int offset = 0  ;
   int rLen = 0 ;
   int blen, bstr ;   
-  char *l ;
+  sym_link *retype;
 
 	DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
 	blen = SPEC_BLEN(etype);
 	bstr = SPEC_BSTR(etype);
 
+	retype = getSpec(operandType(right));
+
 	if(AOP_TYPE(right) == AOP_LIT) {
 		if((blen == 1) && (bstr < 8)) {
 		  unsigned long lit;
@@ -10296,7 +11374,7 @@ static void genPackBits (sym_link    *etype , operand *result,
 
 			lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
 //			pic16_emitpcode(POC_MOVFW, pic16_popCopyReg(&pic16_pc_indf0));
-			if((p_type == POINTER) && (result)) {
+			if(OP_SYMBOL(result)->remat && (p_type == POINTER) && (result)) {
 				/* workaround to reduce the extra lfsr instruction */
 				if(lit) {
 					pic16_emitpcode(POC_BSF,
@@ -10306,7 +11384,7 @@ static void genPackBits (sym_link    *etype , operand *result,
 						pic16_popCopyGPR2Bit(pic16_popGet(AOP(result), 0), bstr));
 				}
 			} else {
-
+                                pic16_loadFSR0(result, 0);
 				if(lit) {
 					pic16_emitpcode(POC_BSF,
 						pic16_popCopyGPR2Bit(pic16_popCopyReg(&pic16_pc_indf0), bstr));
@@ -10318,76 +11396,111 @@ static void genPackBits (sym_link    *etype , operand *result,
 	
 		  return;
 		}
-
+                /* move literal to W */
 		pic16_emitpcode(POC_MOVLW, pic16_popGet(AOP(right), 0));
 		offset++;
 	} else
-		pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(right), offset++));
+	if(IS_BITFIELD(retype) 
+	  && (AOP_TYPE(right) == AOP_REG || AOP_TYPE(right) == AOP_DIR)
+	  && (blen == 1)) {
+	  int rblen, rbstr;
 
-	/* if the bit lenth is less than or    */
-	/* it exactly fits a byte then         */
-	if((shCnt=SPEC_BSTR(etype))
-		|| SPEC_BLEN(etype) <= 8 )  {
+	    rblen = SPEC_BLEN( retype );
+	    rbstr = SPEC_BSTR( retype );
+	    
 
-		/* shift left acc */
-		AccLsh(shCnt);
+            if(IS_BITFIELD(etype)) {
+              pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(result), 0));
+              pic16_emitpcode(POC_BCF, pic16_popCopyGPR2Bit(pic16_popCopyReg(&pic16_pc_wreg), bstr));
+            } else {
+              pic16_emitpcode(POC_CLRF, pic16_popCopyReg(&pic16_pc_wreg));
+            }
+            
+	    pic16_emitpcode(POC_BTFSC, pic16_popCopyGPR2Bit(pic16_popGet(AOP(right), 0), rbstr));
+	    
+	    if(IS_BITFIELD(etype)) {
+	      pic16_emitpcode(POC_BSF, pic16_popCopyGPR2Bit(pic16_popCopyReg(&pic16_pc_wreg), bstr));
+            } else {
+              pic16_emitpcode(POC_INCF, pic16_popCopyReg(&pic16_pc_wreg));
+            }
 
-		/* using PRODL as a temporary register here */
-		pic16_emitpcode(POC_MOVWF, pic16_popCopyReg(&pic16_pc_prodl));
+            pic16_emitpcode(POC_MOVWF, pic16_popGet( AOP(result), 0));
+            
+            return;
+        } else {
+          /* move right to W */
+          pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(right), offset++));
+        }
 
-		switch (p_type) {
-			case FPOINTER:
-			case POINTER:
-			case GPOINTER:
-				pic16_emitpcode(POC_MOVFW, pic16_popCopyReg(&pic16_pc_indf0));
-//				pic16_emitcode ("mov","b,a");
-//				pic16_emitcode("mov","a,@%s",rname);
-				break;
-		}
+	/* if the bit length is less than or   */
+	/* it exactly fits a byte then         */
+	if((shCnt=SPEC_BSTR(etype))
+		|| SPEC_BLEN(etype) <= 8 )  {
+		int fsr0_setup = 0;
+
+		if (blen != 8 || bstr != 0) {
+		  // we need to combine the value with the old value
+		  pic16_emitpcode(POC_ANDLW, pic16_popGetLit((1U << blen)-1));
+
+	  DEBUGpic16_emitcode(";", "shCnt = %d SPEC_BSTR(etype) = %d:%d", shCnt,
+	        SPEC_BSTR(etype), SPEC_BLEN(etype));
+	        
+		  /* shift left acc */
+		  AccLsh(shCnt);
+
+		  /* using PRODH as a temporary register here */
+		  pic16_emitpcode(POC_MOVWF, pic16_popCopyReg(&pic16_pc_prodh));
+
+		  if (IS_SYMOP(result) && !IS_PTR(operandType (result))/*OP_SYMBOL(result)->remat*/) {
+		    /* access symbol directly */
+		    pic16_mov2w (AOP(result), 0);
+		  } else {
+		    /* get old value */
+		    pic16_derefPtr (result, p_type, 0, &fsr0_setup);
+		  }
 #if 1
-		pic16_emitpcode(POC_ANDLW, pic16_popGetLit(
+		  pic16_emitpcode(POC_ANDLW, pic16_popGetLit(
 			(unsigned char)((unsigned char)(0xff << (blen+bstr)) |
 					(unsigned char)(0xff >> (8-bstr))) ));
-		pic16_emitpcode(POC_IORFW, pic16_popCopyReg(&pic16_pc_prodl));
-		pic16_emitpcode(POC_MOVWF, pic16_popCopyReg(&pic16_pc_indf0));
+		  pic16_emitpcode(POC_IORFW, pic16_popCopyReg(&pic16_pc_prodh));
+		} // if (blen != 8 || bstr != 0)
+
+		/* write new value back */
+	        if (IS_SYMOP(result) & !IS_PTR(operandType(result))) {
+		  pic16_emitpcode (POC_MOVWF, pic16_popGet(AOP(result),0));
+	        } else {
+		  pic16_derefPtr (result, p_type, 1, &fsr0_setup);
+	       }
 #endif
 
 	  return;
 	}
 
 
+#if 0
 	fprintf(stderr, "SDCC pic16 port error: the port currently does not support\n");
 	fprintf(stderr, "bitfields of size >=8. Instead of generating wrong code, bailling out...\n");
 	exit(-1);
+#endif
 
 
-    /* if we r done */
-    if ( SPEC_BLEN(etype) <= 8 )
-        return ;
-
-    pic16_emitcode("inc","%s",rname);
-    rLen = SPEC_BLEN(etype) ;     
-
-
-
+    pic16_loadFSR0(result, 0);			// load FSR0 with address of result
+    rLen = SPEC_BLEN(etype)-8;
+    
     /* now generate for lengths greater than one byte */
     while (1) {
-
-        l = pic16_aopGet(AOP(right),offset++,FALSE,TRUE);
-
         rLen -= 8 ;
-        if (rLen <= 0 )
-            break ;
+        if (rLen <= 0 ) {
+          mov2fp(pic16_popCopyReg(&pic16_pc_prodh), AOP(right), offset);
+          break ;
+        }
 
         switch (p_type) {
             case POINTER:
-                if (*l == '@') {
-                    MOVA(l);
-                    pic16_emitcode("mov","@%s,a",rname);
-                } else
-                    pic16_emitcode("mov","@%s,%s",rname,l);
+                  pic16_emitpcode(POC_MOVWF, pic16_popCopyReg(&pic16_pc_postinc0));
                 break;
 
+/*
             case FPOINTER:
                 MOVA(l);
                 pic16_emitcode("movx","@dptr,a");
@@ -10397,21 +11510,25 @@ static void genPackBits (sym_link    *etype , operand *result,
                 MOVA(l);
                 DEBUGpic16_emitcode(";lcall","__gptrput");
                 break;  
+*/
+          default:
+            assert(0);
         }   
-        pic16_emitcode ("inc","%s",rname);
-    }
 
-    MOVA(l);
+
+        pic16_mov2w(AOP(right), offset++);
+    }
 
     /* last last was not complete */
     if (rLen)   {
         /* save the byte & read byte */
         switch (p_type) {
             case POINTER:
-                pic16_emitcode ("mov","b,a");
-                pic16_emitcode("mov","a,@%s",rname);
+//                pic16_emitpcode(POC_MOVWF, pic16_popCopyReg(&pic16_pc_prodl));
+                pic16_emitpcode(POC_MOVFW, pic16_popCopyReg(&pic16_pc_indf0));
                 break;
 
+/*
             case FPOINTER:
                 pic16_emitcode ("mov","b,a");
                 pic16_emitcode("movx","a,@dptr");
@@ -10423,29 +11540,40 @@ static void genPackBits (sym_link    *etype , operand *result,
                 pic16_emitcode ("lcall","__gptrget");
                 pic16_emitcode ("pop","b");
                 break;
+*/
+            default:
+              assert(0);
         }
-
-        pic16_emitcode ("anl","a,#0x%02x",((unsigned char)-1 << -rLen) );
-        pic16_emitcode ("orl","a,b");
+        DEBUGpic16_emitcode(";", "rLen = %i", rLen);
+        pic16_emitpcode(POC_ANDLW, pic16_popGetLit((unsigned char)-1 << -rLen));
+        pic16_emitpcode(POC_IORFW, pic16_popCopyReg(&pic16_pc_prodh));
+//        pic16_emitcode ("anl","a,#0x%02x",((unsigned char)-1 << -rLen) );
+//        pic16_emitcode ("orl","a,b");
     }
 
-    if (p_type == GPOINTER)
-        pic16_emitcode("pop","b");
+//    if (p_type == GPOINTER)
+//        pic16_emitcode("pop","b");
 
     switch (p_type) {
 
-    case POINTER:
-	pic16_emitcode("mov","@%s,a",rname);
+      case POINTER:
+        pic16_emitpcode(POC_MOVWF, pic16_popCopyReg(&pic16_pc_indf0));
+//	pic16_emitcode("mov","@%s,a",rname);
 	break;
-	
-    case FPOINTER:
+/*
+      case FPOINTER:
 	pic16_emitcode("movx","@dptr,a");
 	break;
 	
-    case GPOINTER:
+      case GPOINTER:
 	DEBUGpic16_emitcode(";lcall","__gptrput");
 	break;   		
+*/
+      default:
+        assert(0);
     }
+    
+//    pic16_freeAsmop(right, NULL, ic, TRUE);
 }
 /*-----------------------------------------------------------------*/
 /* genDataPointerSet - remat pointer to data space                 */
@@ -10478,19 +11606,32 @@ static void genDataPointerSet(operand *right,
 
 	while (size--) {
 		if (AOP_TYPE(right) == AOP_LIT) {
-		  unsigned int lit = (unsigned int) floatFromVal (AOP(IC_RIGHT(ic))->aopu.aop_lit);
-
-			lit = lit >> (8*offset);
-			if(lit&0xff) {
-				pic16_emitpcode(POC_MOVLW, pic16_popGetLit(lit&0xff));
-				pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),offset)); // pstch 8
-			} else {
-				pic16_emitpcode(POC_CLRF, pic16_popGet(AOP(result),offset)); // patch 8
-			}
-		} else {
-			mov2w(AOP(right), offset);
-			pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),offset)); // patch 8
-		}
+		  unsigned int lit;
+
+		    if(!IS_FLOAT(operandType( right )))
+		      lit = (unsigned long)floatFromVal(AOP(IC_RIGHT(ic))->aopu.aop_lit);
+                    else {
+                      union {
+                        unsigned long lit_int;
+                        float lit_float;
+                      } info;
+	
+                        /* take care if literal is a float */
+                        info.lit_float = floatFromVal(AOP(IC_RIGHT(ic))->aopu.aop_lit);
+                        lit = info.lit_int;
+                    }
+
+                    lit = lit >> (8*offset);
+                    if(lit&0xff) {
+                      pic16_emitpcode(POC_MOVLW, pic16_popGetLit(lit&0xff));
+                      pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),offset)); // pstch 8
+                    } else {
+                      pic16_emitpcode(POC_CLRF, pic16_popGet(AOP(result),offset)); // patch 8
+                    }
+                } else {
+                  pic16_mov2w(AOP(right), offset);
+                  pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result),offset)); // patch 8
+                }
 		offset++;
 		resoffset++;
 	}
@@ -10508,7 +11649,6 @@ static void genNearPointerSet (operand *right,
                                iCode *ic)
 {
   asmop *aop = NULL;
-  char *l;
   sym_link *retype;
   sym_link *ptype = operandType(result);
   sym_link *resetype;
@@ -10538,30 +11678,6 @@ static void genNearPointerSet (operand *right,
 	pic16_aopOp(right,ic,FALSE);
 	DEBUGpic16_pic16_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 */
-		DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-
-		if( (AOP_TYPE(result) == AOP_PCODE) 
-			&& ((AOP(result)->aopu.pcop->type == PO_IMMEDIATE)
-				|| (AOP(result)->aopu.pcop->type == PO_DIR))) // patch 10
-		{
-		  if(!IS_BITFIELD(resetype))
-			pic16_loadFSR0( result );  // patch 10
-		} else {
-			// set up FSR0 with address of result
-			pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(result),0), pic16_popCopyReg(&pic16_pc_fsr0l))); // patch 10
-			pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(result),1), pic16_popCopyReg(&pic16_pc_fsr0h))); // patch 10
-		}
-
-	}
-//	else
-//	rname = pic16_aopGet(AOP(result),0,FALSE,FALSE);
-
-	DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-
 	/* if bitfield then unpack the bits */
 	if (IS_BITFIELD(resetype)) {
 		genPackBits (resetype, result, right, NULL, POINTER);
@@ -10570,68 +11686,62 @@ static void genNearPointerSet (operand *right,
 	  int size = AOP_SIZE(right);
 	  int offset = 0 ;    
 
+	    pic16_loadFSR0(result, 0);
+	    
 		DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
 		while (size--) {
-			l = pic16_aopGet(AOP(right),offset,FALSE,TRUE);
-			if (*l == '@' ) {
-				//MOVA(l);
-				//pic16_emitcode("mov","@%s,a",rname);
-				pic16_emitcode("movf","indf0,w ;1");
-			} else {
-
-				if (AOP_TYPE(right) == AOP_LIT) {							// patch 10
-					pic16_emitpcode(POC_MOVLW, pic16_popGet(AOP(right),offset));			// 
-					if (size) {									// 
-						pic16_emitpcode(POC_MOVWF,pic16_popCopyReg(&pic16_pc_postinc0));	// 
-					} else {									// 
-						pic16_emitpcode(POC_MOVWF,pic16_popCopyReg(&pic16_pc_indf0));		// 
-					}										// 
-				} else { // no literal									// 
-					if(size) {									// 
-						pic16_emitpcode(POC_MOVFF, 						// 
-								pic16_popGet2p(pic16_popGet(AOP(right),offset), 	// 
-									pic16_popCopyReg(&pic16_pc_postinc0)));		// 
-					} else {									// 
-						pic16_emitpcode(POC_MOVFF, 						// 
-								pic16_popGet2p(pic16_popGet(AOP(right),offset), 	// 
-									pic16_popCopyReg(&pic16_pc_indf0)));		//
-					}										//
-				}											// patch 10
-			}
+				if (AOP_TYPE(right) == AOP_LIT) {
+					pic16_emitpcode(POC_MOVLW, pic16_popGet(AOP(right),offset));
+					if (size) {
+						pic16_emitpcode(POC_MOVWF,pic16_popCopyReg(&pic16_pc_postinc0));
+					} else {
+						pic16_emitpcode(POC_MOVWF,pic16_popCopyReg(&pic16_pc_indf0));
+					}
+				} else { // no literal
+					if(size) {
+						pic16_emitpcode(POC_MOVFF,
+								pic16_popGet2p(pic16_popGet(AOP(right),offset),
+									pic16_popCopyReg(&pic16_pc_postinc0)));
+					} else {
+						pic16_emitpcode(POC_MOVFF,
+								pic16_popGet2p(pic16_popGet(AOP(right),offset),
+									pic16_popCopyReg(&pic16_pc_indf0)));
+					}
+				}
 			offset++;
 		}
-	}
+        }
 
 	DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
 	/* now some housekeeping stuff */
 	if (aop) {
-		/* we had to allocate for this iCode */
-		pic16_freeAsmop(NULL,aop,ic,TRUE);
+	  /* we had to allocate for this iCode */
+          pic16_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 */
-		DEBUGpic16_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--)
-				pic16_emitcode("decf","fsr0,f");
-			//pic16_emitcode("dec","%s",rname);
-		}
-	}
+	  /* 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 */
+	  DEBUGpic16_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--)
+	          pic16_emitcode("decf","fsr0,f");
+	          //pic16_emitcode("dec","%s",rname);
+            }
+        }
 
-	DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
-	/* done */
+    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+    /* done */
 //release:
-	pic16_freeAsmop(right,NULL,ic,TRUE);
-	pic16_freeAsmop(result,NULL,ic,TRUE);
+    pic16_freeAsmop(right,NULL,ic,TRUE);
+    pic16_freeAsmop(result,NULL,ic,TRUE);
 }
 
 /*-----------------------------------------------------------------*/
@@ -10896,8 +12006,7 @@ static void genGenPointerSet (operand *right,
                               operand *result, iCode *ic)
 {
   int size;
-  sym_link *retype = getSpec(operandType(right));
-  char fgptrput[32];
+  sym_link *retype = getSpec(operandType(result));
 
     DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
 
@@ -10920,8 +12029,14 @@ static void genGenPointerSet (operand *right,
     DEBUGpic16_emitcode ("; ***","%s  %d size=%d",__FUNCTION__,__LINE__,size);
 
 
-    /* load value to write in TBLPTRH:TBLPTRL:PRODH:PRODL */
-    mov2fp(pic16_popCopyReg(&pic16_pc_gptrreg), AOP(right), 0);
+    /* load value to write in TBLPTRH:TBLPTRL:PRODH:[stack] */
+
+    /* value of right+0 is placed on stack, which will be retrieved
+     * by the support function this restoring the stack. The important
+     * thing is that there is no need to manually restore stack pointer
+     * here */
+    pushaop(AOP(right), 0);
+//    mov2fp(pic16_popCopyReg(&pic16_pc_postdec1), AOP(right), 0);
     if(size>1)mov2fp(pic16_popCopyReg(&pic16_pc_prodh), AOP(right), 1);
     if(size>2)mov2fp(pic16_popCopyReg(&pic16_pc_tblptrl), AOP(right), 2);
     if(size>3)mov2fp(pic16_popCopyReg(&pic16_pc_tblptrh), AOP(right), 3);
@@ -10933,33 +12048,7 @@ static void genGenPointerSet (operand *right,
                                 pic16_popCopyReg(&pic16_pc_prodl)));
     pic16_emitpcode(POC_MOVFW, pic16_popGet(AOP(result), 2));
     
-
-    /* put code here */
-    switch (size) {
-      case 1: strcpy(fgptrput, "__gptrput1"); break;
-      case 2: strcpy(fgptrput, "__gptrput2"); break;
-      case 3: strcpy(fgptrput, "__gptrput3"); break;
-      case 4: strcpy(fgptrput, "__gptrput4"); break;
-      default:
-        werror(W_POSSBUG2, __FILE__, __LINE__);
-        abort();
-    }
-    
-    pic16_emitpcode(POC_CALL, pic16_popGetWithString( fgptrput ));
-    
-    {
-      symbol *sym;
-                  
-        sym = newSymbol( fgptrput, 0 );
-        strcpy(sym->rname, fgptrput);
-        checkAddSym(&externs, sym);
-
-	sym = newSymbol("__GPTRREG", 0);
-        strcpy(sym->rname, "__GPTRREG");
-        checkAddSym(&externs, sym);
-
-//          fprintf(stderr, "%s:%d adding extern symbol %s in externs\n", __FILE__, __LINE__, fgptrget);
-    }
+    pic16_callGenericPointerRW(1, size);
 
 release:
     pic16_freeAsmop(right,NULL,ic,TRUE);
@@ -10971,11 +12060,11 @@ release:
 /*-----------------------------------------------------------------*/
 static void genPointerSet (iCode *ic)
 {    
-    operand *right, *result ;
-    sym_link *type, *etype;
-    int p_type;
+  operand *right, *result ;
+  sym_link *type, *etype;
+  int p_type;
 
-    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+    FENTRY;
 
     right = IC_RIGHT(ic);
     result = IC_RESULT(ic) ;
@@ -10984,6 +12073,7 @@ static void genPointerSet (iCode *ic)
     move it to the correct pointer register */
     type = operandType(result);
     etype = getSpec(type);
+    
     /* if left is of type of pointer then it is simple */
     if (IS_PTR(type) && !IS_FUNC(type->next)) {
         p_type = DCL_TYPE(type);
@@ -11011,27 +12101,26 @@ static void genPointerSet (iCode *ic)
     /* now that we have the pointer type we assign
     the pointer values */
     switch (p_type) {
+      case POINTER:
+      case IPOINTER:
+        genNearPointerSet (right,result,ic);
+        break;
 
-    case POINTER:
-    case IPOINTER:
-	genNearPointerSet (right,result,ic);
-	break;
-
-    case PPOINTER:
-	genPagedPointerSet (right,result,ic);
+      case PPOINTER:
+        genPagedPointerSet (right,result,ic);
 	break;
 
-    case FPOINTER:
-	genFarPointerSet (right,result,ic);
-	break;
-
-    case GPOINTER:
-	genGenPointerSet (right,result,ic);
-	break;
+      case FPOINTER:
+        genFarPointerSet (right,result,ic);
+        break;
+        
+      case GPOINTER:
+        genGenPointerSet (right,result,ic);
+        break;
 
-    default:
-      werror (E_INTERNAL_ERROR, __FILE__, __LINE__, 
-	      "genPointerSet: illegal pointer type");
+      default:
+        werror (E_INTERNAL_ERROR, __FILE__, __LINE__, 
+          "genPointerSet: illegal pointer type");
     }
 }
 
@@ -11043,36 +12132,34 @@ static void genIfx (iCode *ic, iCode *popIc)
   operand *cond = IC_COND(ic);
   int isbit =0;
 
-  DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+    FENTRY;
 
-  pic16_aopOp(cond,ic,FALSE);
+    pic16_aopOp(cond,ic,FALSE);
 
-  /* get the value into acc */
-  if (AOP_TYPE(cond) != AOP_CRY)
-    pic16_toBoolean(cond);
-  else
-    isbit = 1;
-  /* the result is now in the accumulator */
-  pic16_freeAsmop(cond,NULL,ic,TRUE);
-
-  /* if there was something to be popped then do it */
-  if (popIc)
-    genIpop(popIc);
-
-  /* if the condition is  a bit variable */
-  if (isbit && IS_ITEMP(cond) && 
-      SPIL_LOC(cond)) {
-    genIfxJump(ic,SPIL_LOC(cond)->rname);
-    DEBUGpic16_emitcode ("; isbit  SPIL_LOC","%s",SPIL_LOC(cond)->rname);
-  }
-  else {
-    if (isbit && !IS_ITEMP(cond))
-      genIfxJump(ic,OP_SYMBOL(cond)->rname);
+    /* get the value into acc */
+    if (AOP_TYPE(cond) != AOP_CRY)
+      pic16_toBoolean(cond);
     else
-      genIfxJump(ic,"a");
-  }
-  ic->generated = 1;
-
+      isbit = 1;
+    /* the result is now in the accumulator */
+    pic16_freeAsmop(cond,NULL,ic,TRUE);
+
+    /* if there was something to be popped then do it */
+    if (popIc)
+      genIpop(popIc);
+
+    /* if the condition is  a bit variable */
+    if (isbit && IS_ITEMP(cond) && 
+        SPIL_LOC(cond)) {
+      genIfxJump(ic,"c");
+      DEBUGpic16_emitcode ("; isbit  SPIL_LOC","%s",SPIL_LOC(cond)->rname);
+    } else {
+      if (isbit && !IS_ITEMP(cond))
+        genIfxJump(ic,OP_SYMBOL(cond)->rname);
+        else
+        genIfxJump(ic,"a");
+    }
+    ic->generated = 1;
 }
 
 /*-----------------------------------------------------------------*/
@@ -11085,7 +12172,7 @@ static void genAddrOf (iCode *ic)
   symbol *sym;	// = OP_SYMBOL(IC_LEFT(ic));
   pCodeOp *pcop0, *pcop1, *pcop2;
 
-    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+    FENTRY;
 
     pic16_aopOp((result=IC_RESULT(ic)),ic,TRUE);
 
@@ -11095,21 +12182,27 @@ static void genAddrOf (iCode *ic)
       /* get address of symbol on stack */
       DEBUGpic16_emitcode(";    ", "%s symbol %s on stack", __FUNCTION__, sym->name);
 #if 0
-      fprintf(stderr, "%s:%d symbol %s on stack offset %d\n", __FILE__, __LINE__,
-                  OP_SYMBOL(left)->name, OP_SYMBOL(left)->stack);
+      fprintf(stderr, "%s:%d symbol %s on stack offset %i\n", __FILE__, __LINE__,
+                  OP_SYMBOL(IC_LEFT(ic))->name, OP_SYMBOL(IC_LEFT(ic))->stack);
 #endif
 
-      pic16_emitpcode(POC_MOVFF, pic16_popGet2p(
-                      pic16_popCopyReg(&pic16_pc_fsr2l),
-                      pic16_popGet(AOP(result), 0)));
-      pic16_emitpcode(POC_MOVFF, pic16_popGet2p(
-                      pic16_popCopyReg(&pic16_pc_fsr2h),
-                      pic16_popGet(AOP(result), 1)));
-      
-      pic16_emitpcode(POC_MOVLW, pic16_popGetLit( OP_SYMBOL( IC_LEFT(ic))->stack ) /*+ _G.stack_lat*/);
-      pic16_emitpcode(POC_ADDWF, pic16_popGet(AOP(result), 0));
-      emitSKPNC;
-      pic16_emitpcode(POC_INCF, pic16_popGet(AOP(result), 1));
+      // operands on stack are accessible via "FSR2 + index" with index
+      // starting at 2 for arguments and growing from 0 downwards for
+      // local variables (index == 0 is not assigned so we add one here)
+      {
+	int soffs = OP_SYMBOL( IC_LEFT(ic))->stack;
+	if (soffs <= 0) {
+	  assert (soffs < 0);
+	  soffs++;
+	} // if
+	DEBUGpic16_emitcode("*!*", "accessing stack symbol at offset=%d", soffs);
+	pic16_emitpcode(POC_MOVLW , pic16_popGetLit( soffs & 0x00FF ));
+	pic16_emitpcode(POC_ADDFW , pic16_popCopyReg(pic16_framepnt_lo));
+	pic16_emitpcode(POC_MOVWF , pic16_popGet(AOP(result), 0));
+	pic16_emitpcode(POC_MOVLW , pic16_popGetLit( (soffs >> 8) & 0x00FF ));
+	pic16_emitpcode(POC_ADDFWC, pic16_popCopyReg(pic16_framepnt_hi));
+	pic16_emitpcode(POC_MOVWF , pic16_popGet(AOP(result), 1));
+      }
 
       goto release;
     }
@@ -11122,10 +12215,6 @@ static void genAddrOf (iCode *ic)
     pic16_aopOp((left=IC_LEFT(ic)), ic, FALSE);
     size = AOP_SIZE(IC_RESULT(ic));
 
-
-    /* Assume that what we want the address of is in data space
-     * since there is no stack on the PIC, yet! -- VR */
-  
     pcop0 = PCOP(pic16_newpCodeOpImmd(sym->rname, 0, 0, IN_CODESPACE( SPEC_OCLS(sym->etype))));
     pcop1 = PCOP(pic16_newpCodeOpImmd(sym->rname, 1, 0, IN_CODESPACE( SPEC_OCLS(sym->etype))));
     pcop2 = PCOP(pic16_newpCodeOpImmd(sym->rname, 2, 0, IN_CODESPACE( SPEC_OCLS(sym->etype))));
@@ -11195,7 +12284,7 @@ static void genAssign (iCode *ic)
   result = IC_RESULT(ic);
   right  = IC_RIGHT(ic) ;
 
-  DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+  FENTRY;
   
   /* if they are the same */
   if (operandsEqu (IC_RESULT(ic),IC_RIGHT(ic)))
@@ -11266,34 +12355,53 @@ static void genAssign (iCode *ic)
   offset = 0 ;
 
   if(AOP_TYPE(right) == AOP_LIT) {
-	if(!IS_FLOAT(operandType( right )))
+	if(!(IS_FLOAT(operandType( right )) || IS_FIXED(operandType(right))))
 		lit = (unsigned long)floatFromVal(AOP(right)->aopu.aop_lit);
-	else {
+	else{
 	   union {
 	      unsigned long lit_int;
 	      float lit_float;
 	    } info;
 	
+
+	      if(IS_FIXED16X16(operandType(right))) {
+	        lit = (unsigned long)fixed16x16FromDouble( floatFromVal( AOP(right)->aopu.aop_lit));
+              } else {
 		/* take care if literal is a float */
 		info.lit_float = floatFromVal(AOP(right)->aopu.aop_lit);
 		lit = info.lit_int;
+              }
 	}
   }
 
 //  fprintf(stderr, "%s:%d: assigning value 0x%04lx (%d:%d)\n", __FUNCTION__, __LINE__, lit,
 //			sizeof(unsigned long int), sizeof(float));
 
+
+  if (AOP_TYPE(right) == AOP_REG) {
+    DEBUGpic16_emitcode(";   ", "%s:%d assign from register\n", __FUNCTION__, __LINE__);
+    while (size--) {
+      pic16_emitpcode (POC_MOVFF, pic16_popGet2(AOP(right), AOP(result), offset++));
+    } // while
+    goto release;
+  }
+
+  /* when do we have to read the program memory?
+   * - if right itself is a symbol in code space
+   *   (we don't care what it points to if it's a pointer)
+   * - AND right is not a function (we would want its address)
+   */
   if(AOP_TYPE(right) != AOP_LIT
-  	&& IN_CODESPACE(SPEC_OCLS(OP_SYMBOL(right)->etype))) {
+  	&& IN_CODESPACE(SPEC_OCLS(OP_SYM_ETYPE(right)))
+  	&& !IS_FUNC(OP_SYM_TYPE(right))
+	&& !IS_ITEMP(right))
+  {
   	DEBUGpic16_emitcode(";   ", "%s:%d symbol in code space, take special care\n", __FUNCTION__, __LINE__);
   	fprintf(stderr, "%s:%d symbol %s = [ %s ] is in code space\n", __FILE__, __LINE__, OP_SYMBOL(result)->name, OP_SYMBOL(right)->name);
 
 	// set up table pointer
-	if( (AOP_TYPE(right) == AOP_PCODE)
-		&& ((AOP(right)->aopu.pcop->type == PO_IMMEDIATE)
-		|| (AOP(right)->aopu.pcop->type == PO_DIR)))
-	{
-		fprintf(stderr, "%s:%d inside block 1\n", __FILE__, __LINE__);
+	if(is_LitOp(right)) {
+//		fprintf(stderr, "%s:%d inside block 1\n", __FILE__, __LINE__);
 		pic16_emitpcode(POC_MOVLW,pic16_popGet(AOP(right),0));
 		pic16_emitpcode(POC_MOVWF,pic16_popCopyReg(&pic16_pc_tblptrl));
 		pic16_emitpcode(POC_MOVLW,pic16_popGet(AOP(right),1));
@@ -11301,7 +12409,7 @@ static void genAssign (iCode *ic)
 		pic16_emitpcode(POC_MOVLW,pic16_popGet(AOP(right),2));
 		pic16_emitpcode(POC_MOVWF,pic16_popCopyReg(&pic16_pc_tblptru));
 	} else {
-		fprintf(stderr, "%s:%d inside block 2\n", __FILE__, __LINE__);
+//		fprintf(stderr, "%s:%d inside block 2\n", __FILE__, __LINE__);
 		pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(right),0),
 				pic16_popCopyReg(&pic16_pc_tblptrl)));
 		pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popGet(AOP(right),1),
@@ -11310,7 +12418,8 @@ static void genAssign (iCode *ic)
 				pic16_popCopyReg(&pic16_pc_tblptru)));
 	}
 
-	size = min(AOP_SIZE(right), AOP_SIZE(result));
+	/* must fetch 3 bytes for pointers (was OP_SYM_ETYPE before) */
+	size = min(getSize(OP_SYM_TYPE(right)), AOP_SIZE(result));
 	while(size--) {
 		pic16_emitpcodeNULLop(POC_TBLRD_POSTINC);
 		pic16_emitpcode(POC_MOVFF, pic16_popGet2p(pic16_popCopyReg(&pic16_pc_tablat),
@@ -11318,8 +12427,11 @@ static void genAssign (iCode *ic)
 		offset++;
 	}
 
-	if(AOP_SIZE(result) > AOP_SIZE(right)) {
-		size = AOP_SIZE(result) - AOP_SIZE(right);
+	/* FIXME: for pointers we need to extend differently (according
+	 * to pointer type DATA/CODE/EEPROM/... :*/
+	size = getSize(OP_SYM_TYPE(right));
+	if(AOP_SIZE(result) > size) {
+		size = AOP_SIZE(result) - size;
 		while(size--) {
 			pic16_emitpcode(POC_CLRF, pic16_popGet(AOP(result), offset));
 			offset++;
@@ -11365,7 +12477,8 @@ static void genAssign (iCode *ic)
     } else if (AOP_TYPE(right) == AOP_CRY) {
       pic16_emitpcode(POC_CLRF, pic16_popGet(AOP(result),offset));
       if(offset == 0) {
-	pic16_emitpcode(POC_BTFSS, pic16_popGet(AOP(right),0));
+        //debugf("%s: BTFSS offset == 0\n", __FUNCTION__);
+	pic16_emitpcode(POC_BTFSC, pic16_popGet(AOP(right),0));
 	pic16_emitpcode(POC_INCF, pic16_popGet(AOP(result),0));
       }
     } else if ( (AOP_TYPE(right) == AOP_PCODE) && (AOP(right)->aopu.pcop->type == PO_IMMEDIATE) ) {
@@ -11391,10 +12504,13 @@ static void genAssign (iCode *ic)
 /*-----------------------------------------------------------------*/
 static void genJumpTab (iCode *ic)
 {
-    symbol *jtab;
-    char *l;
+  symbol *jtab;
+  char *l;
+  pCodeOp *jt_offs;
+  pCodeOp *jt_offs_hi;
+  pCodeOp *jt_label;
 
-    DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+    FENTRY;
 
     pic16_aopOp(IC_JTCOND(ic),ic,FALSE);
     /* get the condition into accumulator */
@@ -11409,6 +12525,7 @@ static void genJumpTab (iCode *ic)
     pic16_emitcode("jmp","@a+dptr");
     pic16_emitcode("","%05d_DS_:",jtab->key+100);
 
+#if 0
     pic16_emitpcode(POC_MOVLW, pic16_popGetLabel(jtab->key));
     pic16_emitpcode(POC_ADDFW, pic16_popGet(AOP(IC_JTCOND(ic)),0));
     emitSKPNC;
@@ -11416,15 +12533,59 @@ static void genJumpTab (iCode *ic)
     pic16_emitpcode(POC_MOVWF, pic16_popCopyReg(&pic16_pc_pcl));
     pic16_emitpLabel(jtab->key);
 
+#else
+
+    jt_offs = pic16_popGetTempReg(0);
+    jt_offs_hi = pic16_popGetTempReg(1);
+    jt_label = pic16_popGetLabel (jtab->key);
+    //fprintf (stderr, "Creating jump table...\n");
+
+    // calculate offset into jump table (idx * sizeof (GOTO))
+    pic16_emitpcode(POC_CLRF  , jt_offs_hi);
+    pic16_emitpcode(POC_RLCFW , pic16_popGet(AOP(IC_JTCOND(ic)),0));
+    pic16_emitpcode(POC_RLCF  , jt_offs_hi);
+    pic16_emitpcode(POC_RLCFW , pic16_popCopyReg(&pic16_pc_wreg));
+    pic16_emitpcode(POC_RLCF  , jt_offs_hi);
+    pic16_emitpcode(POC_ANDLW , pic16_popGetLit (0xFC));
+    pic16_emitpcode(POC_MOVWF , jt_offs);
+
+    // prepare PCLATx (set to first entry in jump table)
+    pic16_emitpcode(POC_MOVLW , pic16_popGetImmd(jt_label->name, 2, 0));
+    pic16_emitpcode(POC_MOVWF , pic16_popCopyReg(&pic16_pc_pclatu));
+    pic16_emitpcode(POC_MOVLW , pic16_popGetImmd(jt_label->name, 1, 0));
+    pic16_emitpcode(POC_MOVWF , pic16_popCopyReg(&pic16_pc_pclath));
+    pic16_emitpcode(POC_MOVLW , pic16_popGetImmd(jt_label->name, 0, 0));
+
+    // set PCLATx to selected entry (new PCL is stored in jt_offs)
+    pic16_emitpcode(POC_ADDWF , jt_offs);
+    pic16_emitpcode(POC_MOVFW , jt_offs_hi);
+    pic16_emitpcode(POC_ADDWFC, pic16_popCopyReg(&pic16_pc_pclath));
+    emitSKPNC;
+    pic16_emitpcode(POC_INCF  , pic16_popCopyReg(&pic16_pc_pclatu));
+
+    // release temporaries and prepare jump into table (new PCL --> WREG)
+    pic16_emitpcode(POC_MOVFW , jt_offs);
+    pic16_popReleaseTempReg (jt_offs_hi, 1);
+    pic16_popReleaseTempReg (jt_offs, 0);
+
+    // jump into the table
+    pic16_emitpcode(POC_MOVWF , pic16_popCopyReg(&pic16_pc_pcl));
+
+    pic16_emitpLabelFORCE(jtab->key);
+#endif
+
     pic16_freeAsmop(IC_JTCOND(ic),NULL,ic,TRUE);
+//          pic16_emitpinfo(INF_LOCALREGS, pic16_newpCodeOpLocalRegs(LR_ENTRY_BEGIN));
 
+    pic16_emitpinfo (INF_OPTIMIZATION, pic16_newpCodeOpOpt (OPT_JUMPTABLE_BEGIN, ""));
     /* now generate the jump labels */
     for (jtab = setFirstItem(IC_JTLABELS(ic)) ; jtab;
          jtab = setNextItem(IC_JTLABELS(ic))) {
-        pic16_emitcode("ljmp","%05d_DS_",jtab->key+100);
+//        pic16_emitcode("ljmp","%05d_DS_",jtab->key+100);
 	pic16_emitpcode(POC_GOTO,pic16_popGetLabel(jtab->key));
 	
     }
+    pic16_emitpinfo (INF_OPTIMIZATION, pic16_newpCodeOpOpt (OPT_JUMPTABLE_END, ""));
 
 }
 
@@ -11567,19 +12728,23 @@ static void genCast (iCode *ic)
   operand *result = IC_RESULT(ic);
   sym_link *ctype = operandType(IC_LEFT(ic));
   sym_link *rtype = operandType(IC_RIGHT(ic));
+  sym_link *restype = operandType(IC_RESULT(ic));
   operand *right = IC_RIGHT(ic);
   int size, offset ;
 
-	DEBUGpic16_emitcode("; ***","%s  %d",__FUNCTION__,__LINE__);
+
+    FENTRY;
+
 	/* if they are equivalent then do nothing */
-	if (operandsEqu(IC_RESULT(ic),IC_RIGHT(ic)))
-		return ;
+//	if (operandsEqu(IC_RESULT(ic),IC_RIGHT(ic)))
+//		return ;
 
-	pic16_aopOp(right,ic,FALSE) ;
 	pic16_aopOp(result,ic,FALSE);
+	pic16_aopOp(right,ic,FALSE) ;
 
 	DEBUGpic16_pic16_AopType(__LINE__,NULL,right,result);
 
+
 	/* if the result is a bit */
 	if (AOP_TYPE(result) == AOP_CRY) {
 	
@@ -11643,6 +12808,11 @@ static void genCast (iCode *ic)
 		goto release;
 	}
 
+	if(IS_BITFIELD(getSpec(restype))
+	  && IS_BITFIELD(getSpec(rtype))) {
+	  DEBUGpic16_emitcode("***", "%d casting a bit to another bit", __LINE__);
+        }
+
 	/* if they are the same size : or less */
 	if (AOP_SIZE(result) <= AOP_SIZE(right)) {
 
@@ -11757,7 +12927,7 @@ static void genCast (iCode *ic)
 	    while (size--) {
 	      if(offset < AOP_SIZE(right)) {
                 DEBUGpic16_emitcode("; ***","%s  %d - pointer cast3 ptype = 0x%x",__FUNCTION__,__LINE__, p_type);
-                mov2f(AOP(result), AOP(right), offset);
+                pic16_mov2f(AOP(result), AOP(right), offset);
 /*
 		if ((AOP_TYPE(right) == AOP_PCODE) && 
 		    AOP(right)->aopu.pcop->type == PO_IMMEDIATE) {
@@ -11797,7 +12967,13 @@ static void genCast (iCode *ic)
 		break;
 
             case GPOINTER:
-              pic16_emitpcode(POC_MOVFF, pic16_popGet2(AOP(right), AOP(result), GPTRSIZE-1));
+		if (GPTRSIZE > AOP_SIZE(right)) {
+		  // assume data pointer... THIS MIGHT BE WRONG!
+	          pic16_emitpcode(POC_MOVLW, pic16_popGetLit(0x80));
+	          pic16_emitpcode(POC_MOVWF, pic16_popGet(AOP(result), GPTRSIZE - 1));
+		} else {
+		  pic16_emitpcode(POC_MOVFF, pic16_popGet2(AOP(right), AOP(result), GPTRSIZE-1));
+		}
               break;
               
 	    default:
@@ -11810,6 +12986,8 @@ static void genCast (iCode *ic)
 	    goto release ;
 	}
 	
+	
+	assert( 0 );
 	/* just copy the pointers */
 	size = AOP_SIZE(result);
 	offset = 0 ;
@@ -11837,8 +13015,10 @@ static void genCast (iCode *ic)
     /* we move to result for the size of source */
     size = AOP_SIZE(right);
     offset = 0 ;
+
     while (size--) {
-      mov2f(AOP(result), AOP(right), offset);
+      if(!_G.resDirect)
+        pic16_mov2f(AOP(result), AOP(right), offset);
       offset++;
     }
 
@@ -11855,7 +13035,7 @@ static void genCast (iCode *ic)
 	/* Save one instruction of casting char to int */
 	pic16_emitpcode(POC_CLRF,   pic16_popGet(AOP(result),offset));
 	pic16_emitpcode(POC_BTFSC,  pic16_newpCodeOpBit(pic16_aopGet(AOP(right),offset-1,FALSE,FALSE),7,0, PO_GPR_REGISTER));
-	pic16_emitpcode(POC_DECF,   pic16_popGet(AOP(result),offset));
+	pic16_emitpcode(POC_SETF,   pic16_popGet(AOP(result),offset));
       } else {
         pic16_emitpcode(POC_CLRF,pic16_popCopyReg(&pic16_pc_wreg));
 
@@ -11939,7 +13119,8 @@ static int genDjnz (iCode *ic, iCode *ifx)
 /*-----------------------------------------------------------------*/
 static void genReceive (iCode *ic)
 {    
-  DEBUGpic16_emitcode ("; ***","%s  %d",__FUNCTION__,__LINE__);
+
+  FENTRY;
 
 #if 0
   fprintf(stderr, "%s:%d %s for symbol %s\tonStack: %d\n", __FILE__, __LINE__, __FUNCTION__,
@@ -11972,10 +13153,14 @@ static void genReceive (iCode *ic)
       }
   } else {
     DEBUGpic16_emitcode ("; ***","2 %s  %d argreg = %d",__FUNCTION__,__LINE__, SPEC_ARGREG(OP_SYM_ETYPE(IC_RESULT(ic)) ));
-
     _G.accInUse++;
     pic16_aopOp(IC_RESULT(ic),ic,FALSE);  
     _G.accInUse--;
+
+    /* set pseudo stack pointer to where it should be - dw*/
+    GpsuedoStkPtr = ic->parmBytes;
+
+    /* setting GpsuedoStkPtr has side effects here: */
     assignResultValue(IC_RESULT(ic), 0);
   }
 
@@ -11988,10 +13173,26 @@ static void genReceive (iCode *ic)
 static void
 genDummyRead (iCode * ic)
 {
-  pic16_emitcode ("; genDummyRead","");
-  pic16_emitcode ("; not implemented","");
+  operand *op;
+  int i;
 
-  ic = ic;
+  op = IC_RIGHT(ic);
+  if (op && IS_SYMOP(op)) {
+    if (IN_CODESPACE(SPEC_OCLS(OP_SYM_ETYPE(op)))) {
+      fprintf (stderr, "%s: volatile symbols in codespace?!? -- might go wrong...\n", __FUNCTION__);
+      return;
+    }
+    pic16_aopOp (op, ic, FALSE);
+    for (i=0; i < AOP_SIZE(op); i++) {
+      // may need to protect this from the peepholer -- this is not nice but works...
+      pic16_addpCode2pBlock(pb,pic16_newpCodeAsmDir(";", "VOLATILE READ - BEGIN"));
+      pic16_mov2w (AOP(op),i);
+      pic16_addpCode2pBlock(pb,pic16_newpCodeAsmDir(";", "VOLATILE READ - END"));
+    } // for i
+    pic16_freeAsmop (op, NULL, ic, TRUE);
+  } else if (op) {
+    fprintf (stderr, "%s: not implemented for non-symbols (volatile operand might not be read)\n", __FUNCTION__);
+  } // if
 }
 
 /*-----------------------------------------------------------------*/
@@ -12008,8 +13209,8 @@ genDummyRead (iCode * ic)
 
 void genpic16Code (iCode *lic)
 {
-    iCode *ic;
-    int cln = 0;
+  iCode *ic;
+  int cln = 0;
 
     lineHead = lineCurr = NULL;
 
@@ -12020,242 +13221,239 @@ void genpic16Code (iCode *lic)
     /* if debug information required */
     if (options.debug && currFunc) {
       if (currFunc) {
-	cdbSymbol(currFunc,cdbFile,FALSE,TRUE);
+        cdbSymbol(currFunc,cdbFile,FALSE,TRUE);
       }
     }
 #endif
 
     for (ic = lic ; ic ; ic = ic->next ) {
 
-      DEBUGpic16_emitcode(";ic ", "\t%c 0x%x",ic->op, ic->op);
-	if ( cln != ic->lineno ) {
-	    if ( options.debug ) {
-	      debugFile->writeCLine (ic);
-	    }
-	    
-	    if(!options.noCcodeInAsm) {
-	    	pic16_addpCode2pBlock(pb,
-			pic16_newpCodeCSource(ic->lineno, ic->filename, 
-				printCLine(ic->filename, ic->lineno)));
-	    }
+      DEBUGpic16_emitcode(";ic ", "\t%c 0x%x\t(%s)",ic->op, ic->op, pic16_decodeOp(ic->op));
+      if ( cln != ic->lineno ) {
+        if ( options.debug ) {
+          debugFile->writeCLine (ic);
+        }
+        
+        if(!options.noCcodeInAsm) {
+          pic16_addpCode2pBlock(pb, pic16_newpCodeCSource(ic->lineno, ic->filename, 
+              printCLine(ic->filename, ic->lineno)));
+        }
 
-	    cln = ic->lineno ;
-	}
+        cln = ic->lineno ;
+      }
 	
-	if(options.iCodeInAsm) {
-		char *l;
-		/* insert here code to print iCode as comment */
-		l = Safe_strdup(printILine(ic));
-		pic16_emitpcomment("ic:%d: %s", ic->seq, l);
-	}
+      if(options.iCodeInAsm) {
+        char *l;
+
+          /* insert here code to print iCode as comment */
+          l = Safe_strdup(printILine(ic));
+          pic16_emitpcomment("ic:%d: %s", ic->seq, l);
+      }
 	
-	/* if the result is marked as
-	   spilt and rematerializable or code for
-	   this has already been generated then
-	   do nothing */
-	if (resultRemat(ic) || ic->generated ) 
-	    continue ;
+      /* if the result is marked as
+       * spilt and rematerializable or code for
+       * this has already been generated then
+       * do nothing */
+      if (resultRemat(ic) || ic->generated ) 
+        continue ;
 	
-	/* depending on the operation */
-	switch (ic->op) {
-	case '!' :
-	    pic16_genNot(ic);
-	    break;
-	    
-	case '~' :
-	    pic16_genCpl(ic);
-	    break;
-	    
-	case UNARYMINUS:
-	    genUminus (ic);
-	    break;
-	    
-	case IPUSH:
-	    genIpush (ic);
-	    break;
+      /* depending on the operation */
+      switch (ic->op) {
+        case '!' :
+          pic16_genNot(ic);
+          break;
 	    
-	case IPOP:
-	    /* IPOP happens only when trying to restore a 
-	       spilt live range, if there is an ifx statement
-	       following this pop then the if statement might
-	       be using some of the registers being popped which
-	       would destroy the contents of the register so
-	       we need to check for this condition and handle it */
-	    if (ic->next            && 
-		ic->next->op == IFX &&
-		regsInCommon(IC_LEFT(ic),IC_COND(ic->next))) 
-		genIfx (ic->next,ic);
-	    else
-		genIpop (ic);
-	    break; 
+        case '~' :
+          pic16_genCpl(ic);
+          break;
 	    
-	case CALL:
-	    genCall (ic);
-	    break;
+        case UNARYMINUS:
+          genUminus (ic);
+          break;
 	    
-	case PCALL:
-	    genPcall (ic);
-	    break;
+        case IPUSH:
+          genIpush (ic);
+          break;
 	    
-	case FUNCTION:
-	    genFunction (ic);
-	    break;
+        case IPOP:
+          /* IPOP happens only when trying to restore a 
+	   * spilt live range, if there is an ifx statement
+	   * following this pop then the if statement might
+	   * be using some of the registers being popped which
+	   * would destroy the contents of the register so
+	   * we need to check for this condition and handle it */
+	   if (ic->next
+	     && ic->next->op == IFX
+	     && regsInCommon(IC_LEFT(ic),IC_COND(ic->next))) 
+	       genIfx (ic->next,ic);
+          else
+            genIpop (ic);
+          break; 
 	    
-	case ENDFUNCTION:
-	    genEndFunction (ic);
-	    break;
+        case CALL:
+          genCall (ic);
+          break;
 	    
-	case RETURN:
-	    genRet (ic);
-	    break;
+        case PCALL:
+          genPcall (ic);
+          break;
 	    
-	case LABEL:
-	    genLabel (ic);
-	    break;
+        case FUNCTION:
+          genFunction (ic);
+          break;
 	    
-	case GOTO:
-	    genGoto (ic);
-	    break;
+        case ENDFUNCTION:
+          genEndFunction (ic);
+          break;
 	    
-	case '+' :
-	    pic16_genPlus (ic) ;
-	    break;
+        case RETURN:
+          genRet (ic);
+          break;
 	    
-	case '-' :
-	    if ( ! genDjnz (ic,ifxForOp(IC_RESULT(ic),ic)))
-		pic16_genMinus (ic);
-	    break;
+        case LABEL:
+          genLabel (ic);
+          break;
 	    
-	case '*' :
-	    genMult (ic);
-	    break;
+        case GOTO:
+          genGoto (ic);
+          break;
 	    
-	case '/' :
-	    genDiv (ic) ;
-	    break;
+        case '+' :
+          pic16_genPlus (ic) ;
+          break;
 	    
-	case '%' :
-	    genMod (ic);
-	    break;
+        case '-' :
+          if ( ! genDjnz (ic,ifxForOp(IC_RESULT(ic),ic)))
+            pic16_genMinus (ic);
+          break;
+
+        case '*' :
+          genMult (ic);
+          break;
 	    
-	case '>' :
-	    genCmpGt (ic,ifxForOp(IC_RESULT(ic),ic));		      
-	    break;
+        case '/' :
+          genDiv (ic) ;
+          break;
 	    
-	case '<' :
-	    genCmpLt (ic,ifxForOp(IC_RESULT(ic),ic));
-	    break;
+        case '%' :
+          genMod (ic);
+          break;
 	    
-	case LE_OP:
-	case GE_OP:
-	case NE_OP:
+        case '>' :
+          genCmpGt (ic,ifxForOp(IC_RESULT(ic),ic));		      
+          break;
 	    
-	    /* note these two are xlated by algebraic equivalence
-	       during parsing SDCC.y */
-	    werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
-		   "got '>=' or '<=' shouldn't have come here");
-	    break;	
+        case '<' :
+          genCmpLt (ic,ifxForOp(IC_RESULT(ic),ic));
+          break;
 	    
-	case EQ_OP:
-	    genCmpEq (ic,ifxForOp(IC_RESULT(ic),ic));
-	    break;	    
+        case LE_OP:
+        case GE_OP:
+        case NE_OP:
+          /* note these two are xlated by algebraic equivalence
+           * during parsing SDCC.y */
+          werror(E_INTERNAL_ERROR,__FILE__,__LINE__,
+            "got '>=' or '<=' shouldn't have come here");
+          break;
+
+        case EQ_OP:
+          genCmpEq (ic,ifxForOp(IC_RESULT(ic),ic));
+          break;	    
 	    
-	case AND_OP:
-	    genAndOp (ic);
-	    break;
+        case AND_OP:
+          genAndOp (ic);
+          break;
 	    
-	case OR_OP:
-	    genOrOp (ic);
-	    break;
+        case OR_OP:
+          genOrOp (ic);
+          break;
 	    
-	case '^' :
-	    genXor (ic,ifxForOp(IC_RESULT(ic),ic));
-	    break;
+        case '^' :
+          genXor (ic,ifxForOp(IC_RESULT(ic),ic));
+          break;
 	    
-	case '|' :
-		genOr (ic,ifxForOp(IC_RESULT(ic),ic));
-	    break;
+        case '|' :
+          genOr (ic,ifxForOp(IC_RESULT(ic),ic));
+          break;
 	    
-	case BITWISEAND:
-            genAnd (ic,ifxForOp(IC_RESULT(ic),ic));
-	    break;
+        case BITWISEAND:
+          genAnd (ic,ifxForOp(IC_RESULT(ic),ic));
+          break;
 	    
-	case INLINEASM:
-	    genInline (ic);
-	    break;
+        case INLINEASM:
+          genInline (ic);
+          break;
 	    
-	case RRC:
-	    genRRC (ic);
-	    break;
+        case RRC:
+          genRRC (ic);
+          break;
 	    
-	case RLC:
-	    genRLC (ic);
-	    break;
+        case RLC:
+          genRLC (ic);
+          break;
 	    
-	case GETHBIT:
-	    genGetHbit (ic);
-	    break;
+        case GETHBIT:
+          genGetHbit (ic);
+          break;
 	    
-	case LEFT_OP:
-	    genLeftShift (ic);
-	    break;
+        case LEFT_OP:
+          genLeftShift (ic);
+          break;
 	    
-	case RIGHT_OP:
-	    genRightShift (ic);
-	    break;
+        case RIGHT_OP:
+          genRightShift (ic);
+          break;
 	    
-	case GET_VALUE_AT_ADDRESS:
-	    genPointerGet(ic);
-	    break;
+        case GET_VALUE_AT_ADDRESS:
+          genPointerGet(ic);
+          break;
 	    
-	case '=' :
-	    if (POINTER_SET(ic))
-		genPointerSet(ic);
-	    else
-		genAssign(ic);
-	    break;
+        case '=' :
+          if (POINTER_SET(ic))
+            genPointerSet(ic);
+          else
+            genAssign(ic);
+          break;
 	    
-	case IFX:
-	    genIfx (ic,NULL);
-	    break;
+        case IFX:
+          genIfx (ic,NULL);
+          break;
 	    
-	case ADDRESS_OF:
-	    genAddrOf (ic);
-	    break;
+        case ADDRESS_OF:
+          genAddrOf (ic);
+          break;
 	    
-	case JUMPTABLE:
-	    genJumpTab (ic);
-	    break;
+        case JUMPTABLE:
+          genJumpTab (ic);
+          break;
 	    
-	case CAST:
-	    genCast (ic);
-	    break;
+        case CAST:
+          genCast (ic);
+          break;
 	    
-	case RECEIVE:
-	    genReceive(ic);
-	    break;
+        case RECEIVE:
+          genReceive(ic);
+          break;
 	    
-	case SEND:
-	    addSet(&_G.sendSet,ic);
-            /* create a reversed list of SEND iCodes */
-//            addSetHead(&_G.sendSet, ic);
-	    break;
+        case SEND:
+          addSet(&_G.sendSet,ic);
+          break;
 
-	case DUMMY_READ_VOLATILE:
-	  genDummyRead (ic);
-	  break;
+        case DUMMY_READ_VOLATILE:
+          genDummyRead (ic);
+          break;
 
-	default :
-	    ic = ic;
-        }
+        default :
+          ic = ic;
+      }
     }
 
 
     /* now we are ready to call the
        peep hole optimizer */
-    if (!options.nopeep) {
+    if (!options.nopeep)
       peepHole (&lineHead);
-    }
+
     /* now do the actual printing */
     printLine (lineHead, codeOutFile);