* debugger/mcs51/break.c,

* debugger/mcs51/cmd.c (throughout): removed unused variables and labels,
  use %p to print pointers, made address variables unsigned
* debugger/mcs51/cmd.c (infoSymbols): added missing parameter to printf
* debugger/mcs51/symtab.c (parseSymbol): must return something
* src/mcs51/gen.c (aopForSym): small optimization,
   moved declarations mcs51_ptrRegReq and mcs51_nRegs to ralloc.h,
  (freeAsmop): added missing break,
  (aopPut): removed parameter bvolatile, determine it inside the function,
  (saveRegisters, unsaveRegisters): small optimization,
  (genIpush): removed pointless check,
  (throughout): replaced Safe_calloc, strcpy with Safe_strdup,
  replaced sprintf with SNPRINTF,
  replaced strcpy with strncpyz,
  updated aopPut calls,
  replaced D(emitcode("; genXXX", "")) with D(emitcode(";", "genXXX"))
* src/mcs51/ralloc.h:  added declarations mcs51_ptrRegReq and mcs51_nRegs

git-svn-id: https://sdcc.svn.sourceforge.net/svnroot/sdcc/trunk/sdcc@4190 4a8a32a2-be11-0410-ad9d-d568d2c75423

diff --git a/ChangeLog b/ChangeLog
index d9554663021e899278dc2bb8ad772f14095f838e..5ca95622b92d628ee4121d38001936f85ab6077a 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,23 @@
+2006-05-26 Maarten Brock <sourceforge.brock AT dse.nl>
+
+       * debugger/mcs51/break.c,
+       * debugger/mcs51/cmd.c (throughout): removed unused variables and labels,
+         use %p to print pointers, made address variables unsigned
+       * debugger/mcs51/cmd.c (infoSymbols): added missing parameter to printf
+       * debugger/mcs51/symtab.c (parseSymbol): must return something
+       * src/mcs51/gen.c (aopForSym): small optimization,
+          moved declarations mcs51_ptrRegReq and mcs51_nRegs to ralloc.h,
+         (freeAsmop): added missing break,
+         (aopPut): removed parameter bvolatile, determine it inside the function,
+         (saveRegisters, unsaveRegisters): small optimization,
+         (genIpush): removed pointless check,
+         (throughout): replaced Safe_calloc, strcpy with Safe_strdup,
+         replaced sprintf with SNPRINTF,
+         replaced strcpy with strncpyz,
+         updated aopPut calls,
+         replaced D(emitcode("; genXXX", "")) with D(emitcode(";", "genXXX"))
+       * src/mcs51/ralloc.h:  added declarations mcs51_ptrRegReq and mcs51_nRegs
+

 2006-05-24 Borut Razem <borut.razem AT siol.net>
 
        * support/regression/tests/bug-221100.c: fixed xdata problem caused by
 2006-05-24 Borut Razem <borut.razem AT siol.net>
 
        * support/regression/tests/bug-221100.c: fixed xdata problem caused by

diff --git a/debugger/mcs51/break.c b/debugger/mcs51/break.c
index e18cbcff081e88db61639d430925d228384f1b0d..f3597ddbf42a88da35f0952a0cd48c29a6abec21 100644 (file)
--- a/debugger/mcs51/break.c
+++ b/debugger/mcs51/break.c
@@ -74,7 +74,6 @@ int setBreakPoint (unsigned addr, char addrType, char bpType,
         char *fileName, int lineno)
 {
     breakp *bp, *bpl;
         char *fileName, int lineno)
 {
     breakp *bp, *bpl;

-    char simbuf[50];

 
     Dprintf(D_break, ("setBreakPoint: addr:%x atype:%s bpType:%s [%s:%d]\n",
         addr,
 
     Dprintf(D_break, ("setBreakPoint: addr:%x atype:%s bpType:%s [%s:%d]\n",
         addr,


@@ -158,7 +157,6 @@ void deleteNEXTbp ()
 {
     breakp *bp;
     int k;
 {
     breakp *bp;
     int k;

-    char simcmd[50];

 
     Dprintf(D_break, ("break: Deleting all NEXT BPs\n"));
 
 
     Dprintf(D_break, ("break: Deleting all NEXT BPs\n"));
 


@@ -193,7 +191,6 @@ void deleteUSERbp (int bpnum)
 {
     breakp *bp;
     int k;
 {
     breakp *bp;
     int k;

-    char simcmd[50];

 
     Dprintf(D_break, ("break: deleteUSERbp %d\n", bpnum));
 
 
     Dprintf(D_break, ("break: deleteUSERbp %d\n", bpnum));
 


@@ -364,7 +361,6 @@ static int simStopBPCB( unsigned int addr)
 void clearUSERbp ( unsigned int addr )
 {
     breakp *bp;
 void clearUSERbp ( unsigned int addr )
 {
     breakp *bp;

-    char simcmd[50];

 
     /* for break points delete if they are STEP */
     for ( bp = hTabFirstItemWK(bptable,addr); bp ;
 
     /* for break points delete if they are STEP */
     for ( bp = hTabFirstItemWK(bptable,addr); bp ;


@@ -498,7 +494,7 @@ BP_CALLBACK(userBpCB)
 
     if ( bp->commands )
     {
 
     if ( bp->commands )
     {

-        Dprintf(D_break, ("break: userBpCB: commands:%d\n", bp->commands));
+        Dprintf(D_break, ("break: userBpCB: commands:%p\n", bp->commands));

         setCmdLine(bp->commands);
     }
     
         setCmdLine(bp->commands);
     }
     

diff --git a/debugger/mcs51/cmd.c b/debugger/mcs51/cmd.c
index 64e163c12ac32ba82cb52707481890ad0d0dfce6..6bfe2b11e9bbe40ead804d5566e773338cff6d40 100644 (file)
--- a/debugger/mcs51/cmd.c
+++ b/debugger/mcs51/cmd.c
@@ -7,19 +7,19 @@
    under the terms of the GNU General Public License as published by the
    Free Software Foundation; either version 2, or (at your option) any
    later version.
    under the terms of the GNU General Public License as published by the
    Free Software Foundation; either version 2, or (at your option) any
    later version.

-   
+

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

-   
+

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   
+

    In other words, you are welcome to use, share and improve this program.
    You are forbidden to forbid anyone else to use, share and improve
    In other words, you are welcome to use, share and improve this program.
    You are forbidden to forbid anyone else to use, share and improve

-   what you give them.   Help stamp out software-hoarding!  
+   what you give them.   Help stamp out software-hoarding!

 -------------------------------------------------------------------------*/
 
 #include "sdcdb.h"
 -------------------------------------------------------------------------*/
 
 #include "sdcdb.h"


@@ -330,8 +330,8 @@ static char *warranty=
 
 static void printTypeInfo(link *);
 static void printValAggregates (symbol *,link *,char,unsigned int,int);
 
 static void printTypeInfo(link *);
 static void printValAggregates (symbol *,link *,char,unsigned int,int);

-static  int printOrSetSymValue (symbol *sym, context *cctxt, 
-                                int flg, int dnum, int fmt, 
+static  int printOrSetSymValue (symbol *sym, context *cctxt,
+                                int flg, int dnum, int fmt,

                                 char *rs, char *val, char cmp);
 
 int srcMode = SRC_CMODE ;
                                 char *rs, char *val, char cmp);
 
 int srcMode = SRC_CMODE ;


@@ -353,7 +353,7 @@ DEFSETFUNC(funcWithName)
        *funcp = func;
        return 1;
     }
        *funcp = func;
        return 1;
     }

-    
+

     return 0;
 }
 
     return 0;
 }
 


@@ -371,7 +371,7 @@ DEFSETFUNC(symWithAddr)
         return 0;
 
     if ( sym->addr == laddr &&
         return 0;
 
     if ( sym->addr == laddr &&

-         sym->addrspace == laddrspace ) 
+         sym->addrspace == laddrspace )

     {
         *rsym = sym;
         return 1;
     {
         *rsym = sym;
         return 1;


@@ -388,7 +388,7 @@ static void setBPatModLine (module *mod, int line, char bpType )
     int next_line;
 
     /* look for the first executable line after the line
     int next_line;
 
     /* look for the first executable line after the line

-       specified & get the break point there */   
+       specified & get the break point there */

 
     if ( line < 0 )
         return;
 
     if ( line < 0 )
         return;


@@ -398,7 +398,7 @@ static void setBPatModLine (module *mod, int line, char bpType )
                 line,mod->c_name);
         return ;
     }
                 line,mod->c_name);
         return ;
     }

-    
+

     if (srcMode == SRC_AMODE && line > mod->nasmLines) {
         fprintf(stderr,"No line %d in file \"%s\".\n",
                 line,mod->asm_name);
     if (srcMode == SRC_AMODE && line > mod->nasmLines) {
         fprintf(stderr,"No line %d in file \"%s\".\n",
                 line,mod->asm_name);


@@ -406,11 +406,11 @@ static void setBPatModLine (module *mod, int line, char bpType )
     }
 
     next_line = line;
     }
 
     next_line = line;

-    for ( ; next_line < (srcMode == SRC_CMODE ? mod->ncLines : mod->nasmLines ) ; 
+    for ( ; next_line < (srcMode == SRC_CMODE ? mod->ncLines : mod->nasmLines ) ;

          next_line++ ) {
        if (srcMode == SRC_CMODE) {
            if (mod->cLines[next_line]->addr != INT_MAX) {
          next_line++ ) {
        if (srcMode == SRC_CMODE) {
            if (mod->cLines[next_line]->addr != INT_MAX) {

-               setBreakPoint (mod->cLines[next_line]->addr, CODE, bpType, 
+               setBreakPoint (mod->cLines[next_line]->addr, CODE, bpType,

                               userBpCB, mod->c_name, next_line);
                return;
 //             break;
                               userBpCB, mod->c_name, next_line);
                return;
 //             break;


@@ -418,11 +418,11 @@ static void setBPatModLine (module *mod, int line, char bpType )
        }
        else {
           if (mod->asmLines[next_line]->addr != INT_MAX) {
        }
        else {
           if (mod->asmLines[next_line]->addr != INT_MAX) {

-              setBreakPoint (mod->asmLines[next_line]->addr, CODE, bpType, 
+              setBreakPoint (mod->asmLines[next_line]->addr, CODE, bpType,

                              userBpCB, mod->asm_name, next_line);
                return;
 //            break;
                              userBpCB, mod->asm_name, next_line);
                return;
 //            break;

-          } 
+          }

        }
     }
 
        }
     }
 


@@ -444,23 +444,23 @@ static void clearBPatModLine (module *mod, int line)
                line,mod->c_name);
        return ;
     }
                line,mod->c_name);
        return ;
     }

-    
+

     if (srcMode == SRC_AMODE && line > mod->ncLines) {
        fprintf(stderr,"No line %d in file \"%s\".\n",
                line,mod->c_name);
        return ;
     if (srcMode == SRC_AMODE && line > mod->ncLines) {
        fprintf(stderr,"No line %d in file \"%s\".\n",
                line,mod->c_name);
        return ;

-    }    
-    
-    for ( ; line < (srcMode == SRC_CMODE ? mod->ncLines : mod->nasmLines ) ; 
+    }
+
+    for ( ; line < (srcMode == SRC_CMODE ? mod->ncLines : mod->nasmLines ) ;

          line++ ) {
          line++ ) {

-       if (srcMode == SRC_CMODE) 
+       if (srcMode == SRC_CMODE)

            if (mod->cLines[line]->addr) {
            if (mod->cLines[line]->addr) {

-               clearUSERbp (mod->cLines[line]->addr);                    
+               clearUSERbp (mod->cLines[line]->addr);

                break;
            }
        else
            if (mod->asmLines[line]->addr) {
                break;
            }
        else
            if (mod->asmLines[line]->addr) {

-               clearUSERbp (mod->asmLines[line]->addr);                          
+               clearUSERbp (mod->asmLines[line]->addr);

                break;
            }
     }
                break;
            }
     }


@@ -483,7 +483,7 @@ DEFSETFUNC(moduleLineWithAddr)
     if (*rmod)
         return 0;
 
     if (*rmod)
         return 0;
 

-    for (i=0; i < mod->nasmLines; i++ ) 
+    for (i=0; i < mod->nasmLines; i++ )

     {
         if ( mod->asmLines[i]->addr == addr)
         {
     {
         if ( mod->asmLines[i]->addr == addr)
         {


@@ -491,7 +491,7 @@ DEFSETFUNC(moduleLineWithAddr)
             if (line )
             {
                 *line = 0;
             if (line )
             {
                 *line = 0;

-                for ( i=0; i < mod->ncLines; i++ ) 
+                for ( i=0; i < mod->ncLines; i++ )

                 {
                     if ( mod->cLines[i]->addr > addr)
                         break;
                 {
                     if ( mod->cLines[i]->addr > addr)
                         break;


@@ -508,7 +508,7 @@ DEFSETFUNC(moduleLineWithAddr)
 /*-----------------------------------------------------------------*/
 /* funcWithNameModule - returns functions with a name module combo */
 /*-----------------------------------------------------------------*/
 /*-----------------------------------------------------------------*/
 /* funcWithNameModule - returns functions with a name module combo */
 /*-----------------------------------------------------------------*/

-DEFSETFUNC(funcWithNameModule) 
+DEFSETFUNC(funcWithNameModule)

 {
     function *func = item;
     V_ARG(char *,fname);
 {
     function *func = item;
     V_ARG(char *,fname);


@@ -542,12 +542,12 @@ DEFSETFUNC(funcInAddr)
     /* in the address range */
     if (func->sym->addr <= addr &&
        func->sym->eaddr >= addr) {
     /* in the address range */
     if (func->sym->addr <= addr &&
        func->sym->eaddr >= addr) {

-       
+

        *funcp = func;
        return 1;
     }
 
        *funcp = func;
        return 1;
     }
 

-    return 0;      
+    return 0;

 }
 
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/


@@ -556,11 +556,11 @@ DEFSETFUNC(funcInAddr)
 DEFSETFUNC(setStepBp)
 {
     function *func = item;
 DEFSETFUNC(setStepBp)
 {
     function *func = item;

-    
+

     if (func->sym && func->sym->addr ) {
     if (func->sym && func->sym->addr ) {

-       
+

        /* set the entry break point */
        /* set the entry break point */

-       setBreakPoint (func->sym->addr , CODE , STEP , 
+       setBreakPoint (func->sym->addr , CODE , STEP ,

                       stepBpCB ,func->mod->c_name , func->entryline);
 
        return 1;
                       stepBpCB ,func->mod->c_name , func->entryline);
 
        return 1;


@@ -577,8 +577,8 @@ DEFSETFUNC(setStepEPBp)
     exePoint *ep = item;
     V_ARG(int,bptype);
     V_ARG(char *,mname);
     exePoint *ep = item;
     V_ARG(int,bptype);
     V_ARG(char *,mname);

-   
-    setBreakPoint (ep->addr, CODE, bptype, 
+
+    setBreakPoint (ep->addr, CODE, bptype,

                   stepBpCB, mname, ep->line);
     return 1;
 }
                   stepBpCB, mname, ep->line);
     return 1;
 }


@@ -591,8 +591,8 @@ DEFSETFUNC(setNextEPBp)
     exePoint *ep = item;
     V_ARG(int,bptype);
     V_ARG(char *,mname);
     exePoint *ep = item;
     V_ARG(int,bptype);
     V_ARG(char *,mname);

-   
-    setBreakPoint (ep->addr, CODE, bptype, 
+
+    setBreakPoint (ep->addr, CODE, bptype,

                   nextBpCB, mname, ep->line);
     return 1;
 }
                   nextBpCB, mname, ep->line);
     return 1;
 }


@@ -619,7 +619,7 @@ DEFSETFUNC(lineAtAddr)
     }
 
     return 0;
     }
 
     return 0;

-    
+

 }
 
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/


@@ -644,7 +644,7 @@ DEFSETFUNC(lineNearAddr)
     }
 
     return 0;
     }
 
     return 0;

-    
+

 }
 
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/


@@ -673,25 +673,25 @@ context *discoverContext (unsigned addr, function *func)
         currCtxt->func = func;
         currCtxt->addr = func->laddr = addr;
         currCtxt->modName = func->modName;
         currCtxt->func = func;
         currCtxt->addr = func->laddr = addr;
         currCtxt->modName = func->modName;

-    
+

         /* find the c line number */
         if(applyToSet(func->cfpoints,lineAtAddr,addr,
         /* find the c line number */
         if(applyToSet(func->cfpoints,lineAtAddr,addr,

-                  &line,&currCtxt->block,&currCtxt->level)) 
+                  &line,&currCtxt->block,&currCtxt->level))

             currCtxt->cline = func->lline = line;
         else if(applyToSet(func->cfpoints,lineNearAddr,addr,
             currCtxt->cline = func->lline = line;
         else if(applyToSet(func->cfpoints,lineNearAddr,addr,

-                  &line,&currCtxt->block,&currCtxt->level)) 
+                  &line,&currCtxt->block,&currCtxt->level))

             currCtxt->cline = func->lline = line;
         else
             currCtxt->cline = -1;
             currCtxt->cline = func->lline = line;
         else
             currCtxt->cline = -1;

-    }    
+    }

     /* find the asm line number */
     line = 0;
     if (applyToSet(func->afpoints,lineAtAddr,addr,
                   &line,NULL,NULL))
     /* find the asm line number */
     line = 0;
     if (applyToSet(func->afpoints,lineAtAddr,addr,
                   &line,NULL,NULL))

-        currCtxt->asmline = line;       
+        currCtxt->asmline = line;

     else
         currCtxt->asmline = -1;
     else
         currCtxt->asmline = -1;

-        
+

     return currCtxt ;
 }
 
     return currCtxt ;
 }
 


@@ -700,12 +700,12 @@ context *discoverContext (unsigned addr, function *func)
 /* simGo - send 'go' cmd to simulator and wait till a break occurs */
 /*-----------------------------------------------------------------*/
 void simGo (unsigned int gaddr)
 /* simGo - send 'go' cmd to simulator and wait till a break occurs */
 /*-----------------------------------------------------------------*/
 void simGo (unsigned int gaddr)

-{   
+{

     unsigned int addr ;
     context *ctxt;
     int rv;
     stopCommandList();
     unsigned int addr ;
     context *ctxt;
     int rv;
     stopCommandList();

- top:    
+ top:

     if ( userinterrupt )
     {
         userinterrupt = 0;
     if ( userinterrupt )
     {
         userinterrupt = 0;


@@ -720,27 +720,26 @@ void simGo (unsigned int gaddr)
     addr = simGoTillBp (gaddr);
 
     /* got the pc for the break point now first
     addr = simGoTillBp (gaddr);
 
     /* got the pc for the break point now first

-       discover the program context i.e. module, function 
+       discover the program context i.e. module, function

        linenumber of the source etc, etc etc */
        linenumber of the source etc, etc etc */

-    currentFrame = 0; 
+    currentFrame = 0;

     ctxt = discoverContext (addr, NULL);
     ctxt = discoverContext (addr, NULL);

-    
+

     /* dispatch all the break point call back functions */
     /* dispatch all the break point call back functions */

-    rv = dispatchCB (addr,ctxt);    
- ret:    
+    rv = dispatchCB (addr,ctxt);

 
     /* the dispatch call back function will return
        non-zero if an user break point has been hit
 
     /* the dispatch call back function will return
        non-zero if an user break point has been hit

-       if not then we continue with the execution 
+       if not then we continue with the execution

        of the program */
        of the program */

-    if (!rv) 
+    if (!rv)

     {
                if ( gaddr == 0 )
             gaddr = -1;
                if ( gaddr == -1 || doingSteps == 1 )
             goto top ;
     }
     {
                if ( gaddr == 0 )
             gaddr = -1;
                if ( gaddr == -1 || doingSteps == 1 )
             goto top ;
     }

-    
+

 }
 
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/


@@ -756,7 +755,7 @@ static char *preparePrint(char *s, context *cctxt, int *fmt, symbol **sym)
     *sym = NULL;
 
     while (isspace(*s)) s++;
     *sym = NULL;
 
     while (isspace(*s)) s++;

-    if (!*s) 
+    if (!*s)

         return (char *)0;
 
     while (isspace(*bp)) bp--;
         return (char *)0;
 
     while (isspace(*bp)) bp--;


@@ -799,11 +798,11 @@ static char *preparePrint(char *s, context *cctxt, int *fmt, symbol **sym)
     return bp;
 }
 
     return bp;
 }
 

-static int printAsmLine( function *func, module *m, long saddr, long eaddr)
+static int printAsmLine( function *func, module *m, unsigned saddr, unsigned eaddr)

 {
     int i,j,delta;
 {
     int i,j,delta;

-    int symaddr;
-    int lastaddr = saddr+1;
+    unsigned symaddr;
+    unsigned lastaddr = saddr+1;

     char *symname;
 
     if ( func )
     char *symname;
 
     if ( func )


@@ -816,7 +815,7 @@ static int printAsmLine( function *func, module *m, long saddr, long eaddr)
         symaddr = saddr;
         symname = "" ;
     }
         symaddr = saddr;
         symname = "" ;
     }

-    for (j=0,i=0; i < m->nasmLines; i++ ) 
+    for (j=0,i=0; i < m->nasmLines; i++ )

     {
         if ( saddr >= 0 && m->asmLines[i]->addr < saddr)
         {
     {
         if ( saddr >= 0 && m->asmLines[i]->addr < saddr)
         {


@@ -826,12 +825,12 @@ static int printAsmLine( function *func, module *m, long saddr, long eaddr)
         {
                 continue;
         }
         {
                 continue;
         }

-        if ( func && 
+        if ( func &&

             (m->asmLines[i]->addr < func->sym->addr ||
              m->asmLines[i]->addr > func->sym->eaddr ))
         {
             continue;
             (m->asmLines[i]->addr < func->sym->addr ||
              m->asmLines[i]->addr > func->sym->eaddr ))
         {
             continue;

-        } 
+        }

         delta = m->asmLines[i]->addr - symaddr;
         if ( delta >= 0 )
         {
         delta = m->asmLines[i]->addr - symaddr;
         if ( delta >= 0 )
         {


@@ -839,7 +838,7 @@ static int printAsmLine( function *func, module *m, long saddr, long eaddr)
             lastaddr = m->asmLines[i]->addr;
             printf("0x%08x <%s",lastaddr,symname);
             if (delta > 0) printf("+%d",delta);
             lastaddr = m->asmLines[i]->addr;
             printf("0x%08x <%s",lastaddr,symname);
             if (delta > 0) printf("+%d",delta);

-            printf(">:\t%s",m->asmLines[i]->src);            
+            printf(">:\t%s",m->asmLines[i]->src);

         }
     }
     return lastaddr;
         }
     }
     return lastaddr;


@@ -877,7 +876,7 @@ static int cmdDisasm (char *s, context *cctxt, int args)
     }
 
     if ( eaddr == -1 )
     }
 
     if ( eaddr == -1 )

-    {       
+    {

         /* no start or only start so dump function */
         if ( saddr == -1 )
         {
         /* no start or only start so dump function */
         if ( saddr == -1 )
         {


@@ -892,7 +891,7 @@ static int cmdDisasm (char *s, context *cctxt, int args)
             printf("Dump of assembler code for function %s:\n",func->sym->name);
             printAsmLine(func,func->mod,-1,-1);
             printf("End of assembler dump.\n");
             printf("Dump of assembler code for function %s:\n",func->sym->name);
             printAsmLine(func,func->mod,-1,-1);
             printf("End of assembler dump.\n");

-            return 0; 
+            return 0;

         }
         else
         {
         }
         else
         {


@@ -902,7 +901,7 @@ static int cmdDisasm (char *s, context *cctxt, int args)
                 printf("Dump of assembler code:\n");
                 printAsmLine(NULL,modul,saddr,eaddr);
                 printf("End of assembler dump.\n");
                 printf("Dump of assembler code:\n");
                 printAsmLine(NULL,modul,saddr,eaddr);
                 printf("End of assembler dump.\n");

-                return 0; 
+                return 0;

             }
         }
     }
             }
         }
     }


@@ -932,9 +931,9 @@ static int cmdDisasm (char *s, context *cctxt, int args)
         {
             if ( args > 1 )
                 printf("End of assembler dump.\n");
         {
             if ( args > 1 )
                 printf("End of assembler dump.\n");

-            return 0; 
+            return 0;

         }
         }

-        
+

     }
     fprintf(stderr,"No function contains specified address.\n");
     if( saddr >= 0 )
     }
     fprintf(stderr,"No function contains specified address.\n");
     if( saddr >= 0 )


@@ -945,7 +944,7 @@ static int cmdDisasm (char *s, context *cctxt, int args)
         waitForSim(1000, NULL);
         fputs(simResponse(),stdout);
     }
         waitForSim(1000, NULL);
         fputs(simResponse(),stdout);
     }

-    return 0; 
+    return 0;

 }
 /*-----------------------------------------------------------------*/
 /* cmdDisasm1 - disassemble one asm instruction                    */
 }
 /*-----------------------------------------------------------------*/
 /* cmdDisasm1 - disassemble one asm instruction                    */


@@ -967,7 +966,7 @@ static int commonSetUserBp(char *s, context *cctxt, char bpType)
 {
     char *bp ;
     function *func = NULL;
 {
     char *bp ;
     function *func = NULL;

-       
+

     /* user break point location specification can be of the following
        forms
        a) <nothing>        - break point at current location
     /* user break point location specification can be of the following
        forms
        a) <nothing>        - break point at current location


@@ -975,7 +974,7 @@ static int commonSetUserBp(char *s, context *cctxt, char bpType)
        c) filename:lineno  - line number of the given file
        e) filename:function- function X in file Y (useful for static functions)
        f) function         - function entry point
        c) filename:lineno  - line number of the given file
        e) filename:function- function X in file Y (useful for static functions)
        f) function         - function entry point

-       g) *addr            - break point at address 
+       g) *addr            - break point at address

     */
 
     if (!cctxt) {
     */
 
     if (!cctxt) {


@@ -984,7 +983,7 @@ static int commonSetUserBp(char *s, context *cctxt, char bpType)
     }
     /* white space skip */
     while (*s && isspace(*s)) s++;
     }
     /* white space skip */
     while (*s && isspace(*s)) s++;

-    
+

     /* null terminate it after stripping trailing blanks*/
     bp = s + strlen(s);
     while (bp != s && isspace(*bp)) bp--;
     /* null terminate it after stripping trailing blanks*/
     bp = s + strlen(s);
     while (bp != s && isspace(*bp)) bp--;


@@ -1005,11 +1004,11 @@ static int commonSetUserBp(char *s, context *cctxt, char bpType)
            else
                setBreakPoint ( cctxt->addr , CODE , bpType , userBpCB ,
                                cctxt->func->mod->asm_name, cctxt->asmline);
            else
                setBreakPoint ( cctxt->addr , CODE , bpType , userBpCB ,
                                cctxt->func->mod->asm_name, cctxt->asmline);

-               
+

        }
        else
            fprintf(stderr,"No default breakpoint address now.\n");
        }
        else
            fprintf(stderr,"No default breakpoint address now.\n");

-                       
+

        goto ret ;
     }
     /* case g) *addr */
        goto ret ;
     }
     /* case g) *addr */


@@ -1022,7 +1021,7 @@ static int commonSetUserBp(char *s, context *cctxt, char bpType)
             module *modul;
             if (!applyToSet(modules,moduleLineWithAddr,braddr,&modul,&line))
             {
             module *modul;
             if (!applyToSet(modules,moduleLineWithAddr,braddr,&modul,&line))
             {

-                fprintf(stderr,"Address 0x%08x not exists in code.\n",braddr); 
+                fprintf(stderr,"Address 0x%08x not exists in code.\n",braddr);

             }
             else
             {
             }
             else
             {


@@ -1056,16 +1055,16 @@ static int commonSetUserBp(char *s, context *cctxt, char bpType)
     }
        /* if current context not present then we must get the module
           which has main & set the break point @ line number provided
     }
        /* if current context not present then we must get the module
           which has main & set the break point @ line number provided

-          of that module : if current context known then set the bp 
-          at the line number given for the current module 
+          of that module : if current context known then set the bp
+          at the line number given for the current module

        */
        if (cctxt->func) {
            if (!cctxt->func->mod) {
                if (!applyToSet(functions,funcWithName,"main"))
                    fprintf(stderr,"Function \"main\" not defined.\n");
        */
        if (cctxt->func) {
            if (!cctxt->func->mod) {
                if (!applyToSet(functions,funcWithName,"main"))
                    fprintf(stderr,"Function \"main\" not defined.\n");

-               else 
+               else

                    setBPatModLine(func->mod,line, bpType);
                    setBPatModLine(func->mod,line, bpType);

-           } else 
+           } else

                setBPatModLine(cctxt->func->mod,line, bpType);
        } else {
                if (list_mod) {
                setBPatModLine(cctxt->func->mod,line, bpType);
        } else {
                if (list_mod) {


@@ -1074,15 +1073,15 @@ static int commonSetUserBp(char *s, context *cctxt, char bpType)
                  fprintf(stdout,"Sdcdb fails to have module symbol context at %d\n", __LINE__);
                }
        }
                  fprintf(stdout,"Sdcdb fails to have module symbol context at %d\n", __LINE__);
                }
        }

-       
+

        goto ret;
     }
 
     if ((bp = strchr(s,':'))) {
        goto ret;
     }
 
     if ((bp = strchr(s,':'))) {

-       
+

        module *mod = NULL;
        *bp = '\0';
        module *mod = NULL;
        *bp = '\0';

-       
+

        if (srcMode == SRC_CMODE) {
            if (!applyToSet(modules,moduleWithCName,s,&mod)) {
                fprintf (stderr,"No source file named %s.\n",s);
        if (srcMode == SRC_CMODE) {
            if (!applyToSet(modules,moduleWithCName,s,&mod)) {
                fprintf (stderr,"No source file named %s.\n",s);


@@ -1094,38 +1093,38 @@ static int commonSetUserBp(char *s, context *cctxt, char bpType)
                goto ret;
            }
        }
                goto ret;
            }
        }

-               
+

        /* case c) filename:lineno */
        /* case c) filename:lineno */

-       if (isdigit(*(bp +1))) {                         
+       if (isdigit(*(bp +1))) {

         Dprintf(D_break, ("commonSetUserBp: c) line:%d \n",atoi(bp+1)));
         Dprintf(D_break, ("commonSetUserBp: c) line:%d \n",atoi(bp+1)));

-           setBPatModLine (mod,atoi(bp+1)-1,bpType);       
+           setBPatModLine (mod,atoi(bp+1)-1,bpType);

            goto ret;
            goto ret;

-           
+

        }
        /* case d) filename:function */
        }
        /* case d) filename:function */

-       if (!applyToSet(functions,funcWithNameModule,bp+1,s,&func)) 
-           fprintf(stderr,"Function \"%s\" not defined.\n",bp+1); 
-       else        
+       if (!applyToSet(functions,funcWithNameModule,bp+1,s,&func))
+           fprintf(stderr,"Function \"%s\" not defined.\n",bp+1);
+       else

         Dprintf(D_break, ("commonSetUserBp: d) \n"));
            setBPatModLine (mod,
         Dprintf(D_break, ("commonSetUserBp: d) \n"));
            setBPatModLine (mod,

-                           (srcMode == SRC_CMODE ? 
+                           (srcMode == SRC_CMODE ?

                             func->entryline :
                             func->aentryline),bpType);
                             func->entryline :
                             func->aentryline),bpType);

-       
+

        goto ret;
     }
        goto ret;
     }

-            
+

     /* case e) function */
     Dprintf(D_break, ("commonSetUserBp: e) \n"));
     if (!applyToSet(functions,funcWithName,s,&func))
     /* case e) function */
     Dprintf(D_break, ("commonSetUserBp: e) \n"));
     if (!applyToSet(functions,funcWithName,s,&func))

-       fprintf(stderr,"Function \"%s\" not defined.\n",s); 
+       fprintf(stderr,"Function \"%s\" not defined.\n",s);

     else
        setBPatModLine(func->mod,
                       (srcMode == SRC_CMODE ?
                        func->entryline :
                        func->aentryline),bpType);
 
     else
        setBPatModLine(func->mod,
                       (srcMode == SRC_CMODE ?
                        func->entryline :
                        func->aentryline),bpType);
 

- ret:    
+ ret:

     return 0;
 }
 
     return 0;
 }
 


@@ -1152,20 +1151,20 @@ int cmdJump (char *s, context *cctxt)
 {
     char *bp ;
     function *func = NULL;
 {
     char *bp ;
     function *func = NULL;

-    if (STACK_EMPTY(callStack)) 
+    if (STACK_EMPTY(callStack))

     {
         fprintf(stdout,"The program is not running.\n");
         return 0;
     {
         fprintf(stdout,"The program is not running.\n");
         return 0;

-    } 
+    }

 
     /* white space skip */
     while (*s && isspace(*s)) s++;
 
     /* white space skip */
     while (*s && isspace(*s)) s++;

-    
+

     /* null terminate it after stripping trailing blanks*/
     bp = s + strlen(s);
     while (bp != s && isspace(*bp)) bp--;
     *bp = '\0';
     /* null terminate it after stripping trailing blanks*/
     bp = s + strlen(s);
     while (bp != s && isspace(*bp)) bp--;
     *bp = '\0';

-    if (! *s ) 
+    if (! *s )

     {
         fprintf(stdout,"No argument: need line or *addr.\n");
         return 0;
     {
         fprintf(stdout,"No argument: need line or *addr.\n");
         return 0;


@@ -1184,11 +1183,11 @@ int cmdJump (char *s, context *cctxt)
         simSetPC(addr);
         return 0;
     }
         simSetPC(addr);
         return 0;
     }

-    if (isdigit(*s)) 
+    if (isdigit(*s))

     {
         /* get the lineno */
         int line = atoi(s) -1;
     {
         /* get the lineno */
         int line = atoi(s) -1;

-        if (!cctxt || !cctxt->func || !cctxt->func->mod) 
+        if (!cctxt || !cctxt->func || !cctxt->func->mod)

         {
                    fprintf(stderr,"Function not defined.\n");
             return 0;
         {
                    fprintf(stderr,"Function not defined.\n");
             return 0;


@@ -1208,20 +1207,20 @@ int cmdJump (char *s, context *cctxt)
         simSetPC(cctxt->func->mod->cLines[line]->addr);
         return 0;
     }
         simSetPC(cctxt->func->mod->cLines[line]->addr);
         return 0;
     }

-    if ((bp = strchr(s,':'))) 
+    if ((bp = strchr(s,':')))

     {
         int line;
         module *mod = NULL;
         *bp++ = '\0';
     {
         int line;
         module *mod = NULL;
         *bp++ = '\0';

-        if (!applyToSet(modules,moduleWithCName,s,&mod)) 
+        if (!applyToSet(modules,moduleWithCName,s,&mod))

         {
             fprintf (stderr,"No source file named %s.\n",s);
             return 0;
         {
             fprintf (stderr,"No source file named %s.\n",s);
             return 0;

-        } 
-        if (!isdigit(*bp)) 
-        {                       
+        }
+        if (!isdigit(*bp))
+        {

             fprintf (stderr,"No line number.\n");
             fprintf (stderr,"No line number.\n");

-            return 0;      
+            return 0;

         }
         line = atoi(bp) -1;
         if (line >= mod->ncLines )
         }
         line = atoi(bp) -1;
         if (line >= mod->ncLines )


@@ -1235,7 +1234,7 @@ int cmdJump (char *s, context *cctxt)
         {
             fprintf(stdout,"Warning line %d outside actual function.\n",
                     line+1);
         {
             fprintf(stdout,"Warning line %d outside actual function.\n",
                     line+1);

-        }             
+        }

         simSetPC(mod->cLines[line]->addr);
     }
     return 0;
         simSetPC(mod->cLines[line]->addr);
     }
     return 0;


@@ -1246,14 +1245,14 @@ int cmdJump (char *s, context *cctxt)
 /*-----------------------------------------------------------------*/
 int cmdListAsm (char *s, context *cctxt)
 {
 /*-----------------------------------------------------------------*/
 int cmdListAsm (char *s, context *cctxt)
 {

-    if (  cctxt && cctxt->func) 
+    if (  cctxt && cctxt->func)

     {
         /* actual line */
         if ( cctxt->addr != INT_MAX )
         {
             if (printAsmLine(cctxt->func,cctxt->func->mod,
                          (long)cctxt->addr,(long)cctxt->addr))
     {
         /* actual line */
         if ( cctxt->addr != INT_MAX )
         {
             if (printAsmLine(cctxt->func,cctxt->func->mod,
                          (long)cctxt->addr,(long)cctxt->addr))

-            return 0; 
+            return 0;

         }
     }
     return 0;
         }
     }
     return 0;


@@ -1270,12 +1269,12 @@ int cmdSetOption (char *s, context *cctxt)
            srcMode = SRC_AMODE;
        else
            srcMode = SRC_CMODE;
            srcMode = SRC_AMODE;
        else
            srcMode = SRC_CMODE;

-       fprintf(stderr,"source mode set to '%s'\n", 
+       fprintf(stderr,"source mode set to '%s'\n",

                (srcMode == SRC_CMODE ? "C" : "asm"));
        return 0;
     }
 
                (srcMode == SRC_CMODE ? "C" : "asm"));
        return 0;
     }
 

-    if (strncmp(s,"listsize ",9) == 0) 
+    if (strncmp(s,"listsize ",9) == 0)

     {
         listlines = strtol(s+9,0,0);
         if ( listlines < LISTLINES )
     {
         listlines = strtol(s+9,0,0);
         if ( listlines < LISTLINES )


@@ -1284,13 +1283,13 @@ int cmdSetOption (char *s, context *cctxt)
     }
 
 #ifdef SDCDB_DEBUG
     }
 
 #ifdef SDCDB_DEBUG

-    if (strncmp(s,"debug ",6) == 0) 
+    if (strncmp(s,"debug ",6) == 0)

     {
         sdcdbDebug = strtol(s+6,0,0);
         return 0;
     }
 #endif
     {
         sdcdbDebug = strtol(s+6,0,0);
         return 0;
     }
 #endif

-    if (strncmp(s,"variable ",9) == 0) 
+    if (strncmp(s,"variable ",9) == 0)

     {
         symbol *sym ;
         int fmt;
     {
         symbol *sym ;
         int fmt;


@@ -1309,10 +1308,10 @@ int cmdSetOption (char *s, context *cctxt)
         }
         else
             fprintf(stdout,"No new value for \"%s\".\n",s);
         }
         else
             fprintf(stdout,"No new value for \"%s\".\n",s);

-        return 0;       
+        return 0;

     }
 
     }
 

- 
+

     fprintf(stderr,"'set %s' command not yet implemented\n",s);
     return 0;
 }
     fprintf(stderr,"'set %s' command not yet implemented\n",s);
     return 0;
 }


@@ -1337,17 +1336,17 @@ int cmdContinue (char *s, context *cctxt)
 /* cmdIgnore - set ignorecount for breakpoint                      */
 /*-----------------------------------------------------------------*/
 int cmdIgnore (char *s, context *cctxt)
 /* cmdIgnore - set ignorecount for breakpoint                      */
 /*-----------------------------------------------------------------*/
 int cmdIgnore (char *s, context *cctxt)

-{   
+{

     int bpnum, cnt ;
     while (isspace(*s)) s++;
     int bpnum, cnt ;
     while (isspace(*s)) s++;

-    if (!*s ) 
+    if (!*s )

     {
         fprintf(stdout,"Argument required (breakpoint number).\n");
         return 0;
     }
     bpnum = strtol(s,&s,10);
     while (isspace(*s)) s++;
     {
         fprintf(stdout,"Argument required (breakpoint number).\n");
         return 0;
     }
     bpnum = strtol(s,&s,10);
     while (isspace(*s)) s++;

-    if (!*s ) 
+    if (!*s )

     {
         fprintf(stdout,"Second argument (specified ignore-count) is missing.");
         return 0;
     {
         fprintf(stdout,"Second argument (specified ignore-count) is missing.");
         return 0;


@@ -1361,10 +1360,10 @@ int cmdIgnore (char *s, context *cctxt)
 /* cmdCondition - set condition for breakpoint                     */
 /*-----------------------------------------------------------------*/
 int cmdCondition (char *s, context *cctxt)
 /* cmdCondition - set condition for breakpoint                     */
 /*-----------------------------------------------------------------*/
 int cmdCondition (char *s, context *cctxt)

-{   
+{

     int bpnum ;
     while (isspace(*s)) s++;
     int bpnum ;
     while (isspace(*s)) s++;

-    if (!*s ) 
+    if (!*s )

     {
         fprintf(stdout,"Argument required (breakpoint number).\n");
         return 0;
     {
         fprintf(stdout,"Argument required (breakpoint number).\n");
         return 0;


@@ -1383,12 +1382,12 @@ int cmdCondition (char *s, context *cctxt)
 /* cmdCommands - set commands for breakpoint                       */
 /*-----------------------------------------------------------------*/
 int cmdCommands (char *s, context *cctxt)
 /* cmdCommands - set commands for breakpoint                       */
 /*-----------------------------------------------------------------*/
 int cmdCommands (char *s, context *cctxt)

-{   
+{

     int bpnum ;
     char *cmds,*line;
     while (isspace(*s)) s++;
     int bpnum ;
     char *cmds,*line;
     while (isspace(*s)) s++;

-    
-    if (!*s ) 
+
+    if (!*s )

         bpnum = getLastBreakptNumber();
     else
         bpnum = strtol(s,0,10);
         bpnum = getLastBreakptNumber();
     else
         bpnum = strtol(s,0,10);


@@ -1420,7 +1419,7 @@ int cmdDelUserBp (char *s, context *cctxt)
 {
     int bpnum ;
     while (isspace(*s)) s++;
 {
     int bpnum ;
     while (isspace(*s)) s++;

-    
+

     if (!*s ) {
        if (userBpPresent) {
            char buffer[10];
     if (!*s ) {
        if (userBpPresent) {
            char buffer[10];


@@ -1428,11 +1427,11 @@ int cmdDelUserBp (char *s, context *cctxt)
            fflush(stdout);
            fgets(buffer,sizeof(buffer),stdin);
            if (toupper(buffer[0]) == 'Y')
            fflush(stdout);
            fgets(buffer,sizeof(buffer),stdin);
            if (toupper(buffer[0]) == 'Y')

-               deleteUSERbp(-1);          
+               deleteUSERbp(-1);

        }
        return 0;
     }
        }
        return 0;
     }

-    
+

     /* determine the break point number */
     if (sscanf(s,"%d",&bpnum) == 1)
        deleteUSERbp(bpnum);
     /* determine the break point number */
     if (sscanf(s,"%d",&bpnum) == 1)
        deleteUSERbp(bpnum);


@@ -1448,10 +1447,10 @@ int cmdStepi (char *s, context *cctxt)
 
     if (0 /*STACK_EMPTY(callStack)*/)
         fprintf(stdout,"The program is not being run.\n");
 
     if (0 /*STACK_EMPTY(callStack)*/)
         fprintf(stdout,"The program is not being run.\n");

-    else 
+    else

     {
         doingSteps = 2;
     {
         doingSteps = 2;

-           simGo(2);   
+           simGo(2);

         doingSteps = 0;
         showfull = 1;
     }
         doingSteps = 0;
         showfull = 1;
     }


@@ -1475,7 +1474,7 @@ int cmdStep (char *s, context *cctxt)
             if ((func = STACK_PEEK(callStack))) {
                 if (srcMode == SRC_CMODE)
                     applyToSet (func->cfpoints,setStepEPBp,STEP,
             if ((func = STACK_PEEK(callStack))) {
                 if (srcMode == SRC_CMODE)
                     applyToSet (func->cfpoints,setStepEPBp,STEP,

-                                func->mod->c_name);    
+                                func->mod->c_name);

                 else
                     applyToSet (func->afpoints,setStepEPBp,STEP,
                                 func->mod->asm_name);
                 else
                     applyToSet (func->afpoints,setStepEPBp,STEP,
                                 func->mod->asm_name);


@@ -1484,50 +1483,50 @@ int cmdStep (char *s, context *cctxt)
             /* set breakpoints at all function entry points
                and all exepoints of this functions & for
                all functions one up in the call stack */
             /* set breakpoints at all function entry points
                and all exepoints of this functions & for
                all functions one up in the call stack */

-           
+

             /* all function entry points */
             /* all function entry points */

-            applyToSet(functions,setStepBp); 
-           
+            applyToSet(functions,setStepBp);
+

             if (srcMode == SRC_CMODE) {
                 /* for all execution points in this function */
                 applyToSet(cctxt->func->cfpoints,setStepEPBp,STEP,
                            cctxt->func->mod->c_name);
             if (srcMode == SRC_CMODE) {
                 /* for all execution points in this function */
                 applyToSet(cctxt->func->cfpoints,setStepEPBp,STEP,
                            cctxt->func->mod->c_name);

-               
+

                 /* set a break point @ the current function's
                    exit */
                 /* set a break point @ the current function's
                    exit */

-                setBreakPoint (cctxt->func->sym->eaddr, CODE, STEP , 
-                               stepBpCB, cctxt->func->mod->c_name, 
+                setBreakPoint (cctxt->func->sym->eaddr, CODE, STEP ,
+                               stepBpCB, cctxt->func->mod->c_name,

                                cctxt->func->exitline);
                                cctxt->func->exitline);

-               
+

                 /* now break point @ callers execution points */
                 if ((func = STACK_PPEEK(callStack))) {
                     applyToSet (func->cfpoints,setStepEPBp,STEP,
                 /* now break point @ callers execution points */
                 if ((func = STACK_PPEEK(callStack))) {
                     applyToSet (func->cfpoints,setStepEPBp,STEP,

-                                func->mod->c_name);    
+                                func->mod->c_name);

                     /* set bp @ callers exit point */
                     /* set bp @ callers exit point */

-                    setBreakPoint (func->sym->eaddr, CODE, STEP , 
-                                   stepBpCB, func->mod->c_name, 
+                    setBreakPoint (func->sym->eaddr, CODE, STEP ,
+                                   stepBpCB, func->mod->c_name,

                                    func->exitline);
                 }
             } else {
                 /* for all execution points in this function */
                 applyToSet(cctxt->func->afpoints,setStepEPBp,STEP,
                            cctxt->func->mod->asm_name);
                                    func->exitline);
                 }
             } else {
                 /* for all execution points in this function */
                 applyToSet(cctxt->func->afpoints,setStepEPBp,STEP,
                            cctxt->func->mod->asm_name);

-               
+

                 /* set a break point @ the current function's
                    exit */
                 /* set a break point @ the current function's
                    exit */

-                setBreakPoint (cctxt->func->sym->eaddr, CODE, STEP , 
-                               stepBpCB, cctxt->func->mod->asm_name, 
+                setBreakPoint (cctxt->func->sym->eaddr, CODE, STEP ,
+                               stepBpCB, cctxt->func->mod->asm_name,

                                cctxt->func->aexitline);
                                cctxt->func->aexitline);

-               
+

                 /* now break point @ callers execution points */
                 if ((func = STACK_PPEEK(callStack))) {
                 /* now break point @ callers execution points */
                 if ((func = STACK_PPEEK(callStack))) {

-                   
+

                     applyToSet (func->afpoints,setStepEPBp,STEP,
                     applyToSet (func->afpoints,setStepEPBp,STEP,

-                                func->mod->asm_name);  
-                   
+                                func->mod->asm_name);
+

                     /* set bp @ callers exit point */
                     /* set bp @ callers exit point */

-                    setBreakPoint (func->sym->eaddr, CODE, STEP , 
-                                   stepBpCB, func->mod->asm_name, 
+                    setBreakPoint (func->sym->eaddr, CODE, STEP ,
+                                   stepBpCB, func->mod->asm_name,

                                    func->aexitline);
                 }
             }
                                    func->aexitline);
                 }
             }


@@ -1548,13 +1547,13 @@ int cmdNexti (char *s, context *cctxt)
 {
     if (STACK_EMPTY(callStack))
         fprintf(stdout,"The program is not being run.\n");
 {
     if (STACK_EMPTY(callStack))
         fprintf(stdout,"The program is not being run.\n");

-    else 
+    else

     {
         doingSteps = 2;
     {
         doingSteps = 2;

-           simGo(1);   
+           simGo(1);

         doingSteps = 0;
         showfull = 1;
         doingSteps = 0;
         showfull = 1;

-    }  
+    }

     return 0;
 }
 
     return 0;
 }
 


@@ -1577,7 +1576,7 @@ int cmdNext (char *s, context *cctxt)
             if ((func = STACK_PEEK(callStack))) {
                 if (srcMode == SRC_CMODE)
                     applyToSet (func->cfpoints,setStepEPBp,NEXT,
             if ((func = STACK_PEEK(callStack))) {
                 if (srcMode == SRC_CMODE)
                     applyToSet (func->cfpoints,setStepEPBp,NEXT,

-                                func->mod->c_name);    
+                                func->mod->c_name);

                 else
                     applyToSet (func->afpoints,setStepEPBp,NEXT,
                                 func->mod->asm_name);
                 else
                     applyToSet (func->afpoints,setStepEPBp,NEXT,
                                 func->mod->asm_name);


@@ -1589,17 +1588,17 @@ int cmdNext (char *s, context *cctxt)
                            cctxt->func->mod->c_name);
                 /* set a break point @ the current function's
                    exit */
                            cctxt->func->mod->c_name);
                 /* set a break point @ the current function's
                    exit */

-                setBreakPoint (cctxt->func->sym->eaddr, CODE, NEXT , 
-                               nextBpCB, cctxt->func->mod->c_name, 
+                setBreakPoint (cctxt->func->sym->eaddr, CODE, NEXT ,
+                               nextBpCB, cctxt->func->mod->c_name,

                                cctxt->func->exitline);
                                cctxt->func->exitline);

-               
-                /* now break point @ callers execution points */       
+
+                /* now break point @ callers execution points */

                 if ((func = STACK_PPEEK(callStack))) {
                     applyToSet (func->cfpoints,setNextEPBp,NEXT ,
                 if ((func = STACK_PPEEK(callStack))) {
                     applyToSet (func->cfpoints,setNextEPBp,NEXT ,

-                                func->mod->c_name);    
+                                func->mod->c_name);

                     /* set bp @ callers exit point */
                     /* set bp @ callers exit point */

-                    setBreakPoint (func->sym->eaddr, CODE, NEXT , 
-                                   stepBpCB, func->mod->c_name, 
+                    setBreakPoint (func->sym->eaddr, CODE, NEXT ,
+                                   stepBpCB, func->mod->c_name,

                                    func->exitline);
                 }
             } else {
                                    func->exitline);
                 }
             } else {


@@ -1608,26 +1607,26 @@ int cmdNext (char *s, context *cctxt)
                            cctxt->func->mod->asm_name);
                 /* set a break point @ the current function's
                    exit */
                            cctxt->func->mod->asm_name);
                 /* set a break point @ the current function's
                    exit */

-                setBreakPoint (cctxt->func->sym->eaddr, CODE, NEXT , 
-                               nextBpCB, cctxt->func->mod->asm_name, 
+                setBreakPoint (cctxt->func->sym->eaddr, CODE, NEXT ,
+                               nextBpCB, cctxt->func->mod->asm_name,

                                cctxt->func->aexitline);
                                cctxt->func->aexitline);

-               
-                /* now break point @ callers execution points */       
+
+                /* now break point @ callers execution points */

                 if ((func = STACK_PPEEK(callStack))) {
                     applyToSet (func->cfpoints,setNextEPBp,NEXT ,
                 if ((func = STACK_PPEEK(callStack))) {
                     applyToSet (func->cfpoints,setNextEPBp,NEXT ,

-                                func->mod->asm_name);  
+                                func->mod->asm_name);

                     /* set bp @ callers exit point */
                     /* set bp @ callers exit point */

-                    setBreakPoint (func->sym->eaddr, CODE, NEXT , 
-                                   stepBpCB, func->mod->asm_name, 
+                    setBreakPoint (func->sym->eaddr, CODE, NEXT ,
+                                   stepBpCB, func->mod->asm_name,

                                    func->aexitline);
                 }
             }
         }
         doingSteps = 1;
                                    func->aexitline);
                 }
             }
         }
         doingSteps = 1;

-        simGo(1);      
+        simGo(1);

         doingSteps = 0;
         showfull = 1;
         doingSteps = 0;
         showfull = 1;

-    }    
+    }

     return 0;
 }
 
     return 0;
 }
 


@@ -1647,7 +1646,7 @@ int cmdRun (char *s, context *cctxt)
     resetHitCount();
        simGo(0);
     } else {
     resetHitCount();
        simGo(0);
     } else {

-       
+

        fprintf(stdout,
                "The program being debugged has been started already.\n");
        fprintf(stdout,"Start it from the beginning? (y or n) ");
        fprintf(stdout,
                "The program being debugged has been started already.\n");
        fprintf(stdout,"Start it from the beginning? (y or n) ");


@@ -1693,11 +1692,11 @@ int cmdListSymbols (char *s, context *cctxt)
           sy->name, sy->size, sy->level, sy->block);
         printf("    isonstack:%d, isfunc:%d, offset:%d addr:%d\n",
           sy->isonstack, sy->isfunc, sy->offset, sy->addr);
           sy->name, sy->size, sy->level, sy->block);
         printf("    isonstack:%d, isfunc:%d, offset:%d addr:%d\n",
           sy->isonstack, sy->isfunc, sy->offset, sy->addr);

-        printf("    eaddr:%d, addr_type:%c, type:%x etype:%x\n",
+        printf("    eaddr:%d, addr_type:%c, type:%p etype:%p\n",

           sy->eaddr, sy->addr_type, sy->type, sy->etype);
         printf("    scopetype:%c, sname:%s, rname:%s addrspace:%c\n",
           sy->scopetype, sy->sname, sy->rname, sy->addrspace);
           sy->eaddr, sy->addr_type, sy->type, sy->etype);
         printf("    scopetype:%c, sname:%s, rname:%s addrspace:%c\n",
           sy->scopetype, sy->sname, sy->rname, sy->addrspace);

-        printf("    next:%x\n", sy->next);
+        printf("    next:%p\n", sy->next);

       }
       ++i;
       sy = setNextItem(symbols);
       }
       ++i;
       sy = setNextItem(symbols);


@@ -1728,11 +1727,11 @@ int cmdListFunctions (char *s, context *cctxt)
       if (f == NULL)
         break;
       if (our_verbose) {
       if (f == NULL)
         break;
       if (our_verbose) {

-        printf("  %d) sym:%x, fname:%s, modName:%s, mod:%x\n", i,
+        printf("  %d) sym:%p, fname:%s, modName:%s, mod:%p\n", i,

           f->sym, f->sym->name, f->modName, f->mod);
         printf("    entryline:%d, aentryline:%d, exitline:%d, aexitline:%d\n",
                 f->entryline, f->aentryline, f->exitline, f->aexitline);
           f->sym, f->sym->name, f->modName, f->mod);
         printf("    entryline:%d, aentryline:%d, exitline:%d, aexitline:%d\n",
                 f->entryline, f->aentryline, f->exitline, f->aexitline);

-        printf("    cfpoints:%x, afpoints:%x, laddr:%x, lline:%d\n",
+        printf("    cfpoints:%p, afpoints:%p, laddr:%x, lline:%d\n",

                 f->cfpoints, f->afpoints, f->laddr, f->lline);
       }
       else {
                 f->cfpoints, f->afpoints, f->laddr, f->lline);
       }
       else {


@@ -1773,7 +1772,7 @@ int cmdListModules (char *s, context *cctxt)
         m->cfullname, m->afullname, m->name);
       printf("    c_name:%s, asm_name:%s, ncLines:%d, nasmLines:%d\n",
               m->c_name, m->asm_name, m->ncLines, m->nasmLines);
         m->cfullname, m->afullname, m->name);
       printf("    c_name:%s, asm_name:%s, ncLines:%d, nasmLines:%d\n",
               m->c_name, m->asm_name, m->ncLines, m->nasmLines);

-      printf("    cLines:%x, asmLines:%x\n",
+      printf("    cLines:%p, asmLines:%p\n",

               m->cLines, m->asmLines);
       }
       if (our_verbose >= 2) {
               m->cLines, m->asmLines);
       }
       if (our_verbose >= 2) {


@@ -1815,15 +1814,15 @@ static void infoSymbols(context *ctxt)
 {
   int our_verbose = 0;
 
 {
   int our_verbose = 0;
 

-  printf("[context:%x] func:%x modName:%s addr:%x\n",
+  printf("[context:%p] func:%p modName:%s addr:%x\n",

     ctxt, ctxt->func, ctxt->modName, ctxt->addr);
 
   printf("  cline:%d asmline:%d block:%d level:%d\n",
     ctxt, ctxt->func, ctxt->modName, ctxt->addr);
 
   printf("  cline:%d asmline:%d block:%d level:%d\n",

-    ctxt->cline, ctxt->asmline, ctxt->level);
+    ctxt->cline, ctxt->asmline, ctxt->block, ctxt->level);

 
 

-  printf("[globals] currCtxt:%x, modules:%x, functions:%x symbols:%x\n",
+  printf("[globals] currCtxt:%p, modules:%p, functions:%p symbols:%p\n",

     currCtxt, modules, functions, symbols);
     currCtxt, modules, functions, symbols);

-  printf("  nStructs:%d, structs:%x, ssdirl:%s\n",
+  printf("  nStructs:%d, structs:%p, ssdirl:%s\n",

     nStructs, structs, ssdirl);
 
   /**************** modules *******************/
     nStructs, structs, ssdirl);
 
   /**************** modules *******************/


@@ -1841,7 +1840,7 @@ static void infoSymbols(context *ctxt)
         m->cfullname, m->afullname, m->name);
       printf("    c_name:%s, asm_name:%s, ncLines:%d, nasmLines:%d\n",
               m->c_name, m->asm_name, m->ncLines, m->nasmLines);
         m->cfullname, m->afullname, m->name);
       printf("    c_name:%s, asm_name:%s, ncLines:%d, nasmLines:%d\n",
               m->c_name, m->asm_name, m->ncLines, m->nasmLines);

-      printf("    cLines:%x, asmLines:%x\n",
+      printf("    cLines:%p, asmLines:%p\n",

               m->cLines, m->asmLines);
       i = 0;
       if (m->cLines) {
               m->cLines, m->asmLines);
       i = 0;
       if (m->cLines) {


@@ -1886,11 +1885,11 @@ static void infoSymbols(context *ctxt)
       if (f == NULL)
         break;
       if (our_verbose) {
       if (f == NULL)
         break;
       if (our_verbose) {

-        printf("  %d) sym:%x, modName:%s, mod:%x\n", i,
+        printf("  %d) sym:%p, modName:%s, mod:%p\n", i,

           f->sym, f->modName, f->mod);
         printf("    entryline:%d, aentryline:%d, exitline:%d, aexitline:%d\n",
                 f->entryline, f->aentryline, f->exitline, f->aexitline);
           f->sym, f->modName, f->mod);
         printf("    entryline:%d, aentryline:%d, exitline:%d, aexitline:%d\n",
                 f->entryline, f->aentryline, f->exitline, f->aexitline);

-        printf("    cfpoints:%x, afpoints:%x, laddr:%x, lline:%d\n",
+        printf("    cfpoints:%p, afpoints:%p, laddr:%x, lline:%d\n",

                 f->cfpoints, f->afpoints, f->laddr, f->lline);
       }
       ++i;
                 f->cfpoints, f->afpoints, f->laddr, f->lline);
       }
       ++i;


@@ -1915,11 +1914,11 @@ static void infoSymbols(context *ctxt)
           s->name, s->size, s->level, s->block);
         printf("    isonstack:%d, isfunc:%d, offset:%d addr:%d\n",
           s->isonstack, s->isfunc, s->offset, s->addr);
           s->name, s->size, s->level, s->block);
         printf("    isonstack:%d, isfunc:%d, offset:%d addr:%d\n",
           s->isonstack, s->isfunc, s->offset, s->addr);

-        printf("    eaddr:%d, addr_type:%c, type:%x etype:%x\n",
+        printf("    eaddr:%d, addr_type:%c, type:%p etype:%p\n",

           s->eaddr, s->addr_type, s->type, s->etype);
         printf("    scopetype:%c, sname:%s, rname:%s addrspace:%c\n",
           s->scopetype, s->sname, s->rname, s->addrspace);
           s->eaddr, s->addr_type, s->type, s->etype);
         printf("    scopetype:%c, sname:%s, rname:%s addrspace:%c\n",
           s->scopetype, s->sname, s->rname, s->addrspace);

-        printf("    next:%x\n", s->next);
+        printf("    next:%p\n", s->next);

       }
       ++i;
       s = setNextItem(symbols);
       }
       ++i;
       s = setNextItem(symbols);


@@ -1935,15 +1934,15 @@ static void infoSymbols(context *ctxt)
 /*-----------------------------------------------------------------*/
 static void infoRegisters( int all, context *ctxt)
 {
 /*-----------------------------------------------------------------*/
 static void infoRegisters( int all, context *ctxt)
 {

-    static unsigned int regaddrs[] = {0x81,0x82,0x83,0xb8,0xd0,0xe0,0xf0,0};
+    static int regaddrs[] = {0x81,0x82,0x83,0xb8,0xd0,0xe0,0xf0,0};

     unsigned long val;
     int i,j,*r;
 
     unsigned long val;
     int i,j,*r;
 

-    i   = simGetValue (0xd0,'I',1);
+    i = simGetValue (0xd0,'I',1);

     fprintf(stdout,"IP  : 0x%04X  RegisterBank %d:\nR0-7:",ctxt->addr,(i>>3)&3);
     for ( j = 0; j < 8 ; j++ )
     {
     fprintf(stdout,"IP  : 0x%04X  RegisterBank %d:\nR0-7:",ctxt->addr,(i>>3)&3);
     for ( j = 0; j < 8 ; j++ )
     {

-        val = simGetValue (j ,'R',1);
+        val = simGetValue (j,'R',1);

         fprintf(stdout," 0x%02X",val);
     }
     fprintf(stdout,"\n");
         fprintf(stdout," 0x%02X",val);
     }
     fprintf(stdout,"\n");


@@ -2048,7 +2047,7 @@ int cmdInfo (char *s, context *cctxt)
        cmdListSrc (s+4,cctxt);
        return 0;
     }
        cmdListSrc (s+4,cctxt);
        return 0;
     }

-    if (strncmp(s,"source",6) == 0) 
+    if (strncmp(s,"source",6) == 0)

     {
         module *m;
         if ( s[6] == 's' )
     {
         module *m;
         if ( s[6] == 's' )


@@ -2057,14 +2056,14 @@ int cmdInfo (char *s, context *cctxt)
             fprintf(stdout,"Source files for which symbols have been read in:\n\n");
             for (m = setFirstItem(modules); m ; m = setNextItem(modules))
             {
             fprintf(stdout,"Source files for which symbols have been read in:\n\n");
             for (m = setFirstItem(modules); m ; m = setNextItem(modules))
             {

-                fprintf(stdout,"%s%s, %s",k ? ", ":"",m->cfullname, m->afullname); 
+                fprintf(stdout,"%s%s, %s",k ? ", ":"",m->cfullname, m->afullname);

                 k = 1;
             }
                 k = 1;
             }

-            fprintf(stdout,"\n"); 
+            fprintf(stdout,"\n");

         }
         else
         {
         }
         else
         {

-            if (!cctxt || !cctxt->func || !cctxt->func->mod) 
+            if (!cctxt || !cctxt->func || !cctxt->func->mod)

             {
                 fprintf(stdout,"No source file loaded\n");
                 return 0;
             {
                 fprintf(stdout,"No source file loaded\n");
                 return 0;


@@ -2077,7 +2076,7 @@ int cmdInfo (char *s, context *cctxt)
         }
         return 0;
     }
         }
         return 0;
     }

-    if (strncmp(s,"functions",7) == 0) 
+    if (strncmp(s,"functions",7) == 0)

     {
         function *f;
         module *m = NULL;
     {
         function *f;
         module *m = NULL;


@@ -2107,7 +2106,7 @@ int cmdInfo (char *s, context *cctxt)
     }
 
     /* info stack display call stack */
     }
 
     /* info stack display call stack */

-    if (strcmp(s,"all-registers") == 0) 
+    if (strcmp(s,"all-registers") == 0)

     {
         infoRegisters(1,cctxt);
         return 0;
     {
         infoRegisters(1,cctxt);
         return 0;


@@ -2137,7 +2136,7 @@ int cmdInfo (char *s, context *cctxt)
 /* cmdQuit  - quit debugging                                       */
 /*-----------------------------------------------------------------*/
 int cmdQuit (char *s, context *cctxt)
 /* cmdQuit  - quit debugging                                       */
 /*-----------------------------------------------------------------*/
 int cmdQuit (char *s, context *cctxt)

-{   
+{

     if (simactive)
        closeSimulator();
     return 1;
     if (simactive)
        closeSimulator();
     return 1;


@@ -2147,7 +2146,7 @@ int cmdQuit (char *s, context *cctxt)
 /* cmdListSrc  - list src                                          */
 /*-----------------------------------------------------------------*/
 int cmdListSrc (char *s, context *cctxt)
 /* cmdListSrc  - list src                                          */
 /*-----------------------------------------------------------------*/
 int cmdListSrc (char *s, context *cctxt)

-{   
+{

     static int currline = 0;
     int i =0 ;
     int pline = 0;
     static int currline = 0;
     int i =0 ;
     int pline = 0;


@@ -2156,7 +2155,7 @@ int cmdListSrc (char *s, context *cctxt)
 
 
     while (*s && isspace(*s)) s++;
 
 
     while (*s && isspace(*s)) s++;

-    
+

     /* if the user has spcified line numer then the line number
        can be of the following formats
        LINE          - just line number
     /* if the user has spcified line numer then the line number
        can be of the following formats
        LINE          - just line number


@@ -2177,10 +2176,10 @@ int cmdListSrc (char *s, context *cctxt)
            else
              list_mod = cctxt->func->mod;
         pline = strtol(s,&s,10) - 1;
            else
              list_mod = cctxt->func->mod;
         pline = strtol(s,&s,10) - 1;

-        if (s && (s = strchr(s,','))) 
+        if (s && (s = strchr(s,',')))

         {
             /* LINE,LASTLINE */
         {
             /* LINE,LASTLINE */

-            llines = strtol(s+1,0,10); 
+            llines = strtol(s+1,0,10);

             if ( llines > 0 )
                 llines -= pline+1;
             else
             if ( llines > 0 )
                 llines -= pline+1;
             else


@@ -2189,7 +2188,7 @@ int cmdListSrc (char *s, context *cctxt)
        }
        else {
            char *bp;
        }
        else {
            char *bp;

-           
+

            /* if ':' present then FILE:LINE || FILE:FUNCTION */
            if ((bp = strchr(s,':'))) {
                *bp = '\0';
            /* if ':' present then FILE:LINE || FILE:FUNCTION */
            if ((bp = strchr(s,':'))) {
                *bp = '\0';


@@ -2209,10 +2208,10 @@ int cmdListSrc (char *s, context *cctxt)
                        }
                    }
                    pline = strtol(bp,&bp,10) - 1;
                        }
                    }
                    pline = strtol(bp,&bp,10) - 1;

-            if (bp && (bp = strchr(bp,','))) 
+            if (bp && (bp = strchr(bp,',')))

             {
                 /* FILE:LINE,LASTLINE */
             {
                 /* FILE:LINE,LASTLINE */

-                llines = strtol(bp+1,0,10); 
+                llines = strtol(bp+1,0,10);

                 if ( llines > 0 )
                     llines -= pline+1;
                 else
                 if ( llines > 0 )
                     llines -= pline+1;
                 else


@@ -2236,28 +2235,28 @@ int cmdListSrc (char *s, context *cctxt)
            }
            else {
                /* FUNCTION */
            }
            else {
                /* FUNCTION */

-            if (*s == '\'') 
+            if (*s == '\'')

             {
                 /* 'FUNCTION' */
                 s++ ;
             {
                 /* 'FUNCTION' */
                 s++ ;

-                if ((bp = strrchr(s,'\''))) 
+                if ((bp = strrchr(s,'\'')))

                 {
                     *bp = '\0';
                 }
                 {
                     *bp = '\0';
                 }

-                
+

             }
                if (!applyToSet(functions,funcWithName,s,&func)) {
             }
                if (!applyToSet(functions,funcWithName,s,&func)) {

-                   fprintf(stderr,"Function \"%s\" not defined.\n",s); 
+                   fprintf(stderr,"Function \"%s\" not defined.\n",s);

                    return 0;
                }
                else {
                    list_mod = func->mod;
                    if (srcMode == SRC_CMODE) {
                        pline = func->entryline;
                    return 0;
                }
                else {
                    list_mod = func->mod;
                    if (srcMode == SRC_CMODE) {
                        pline = func->entryline;

-                       llines = func->exitline - func->entryline + 1; 
+                       llines = func->exitline - func->entryline + 1;

                    } else {
                        pline = func->aentryline;
                    } else {
                        pline = func->aentryline;

-                       llines = func->aexitline - func->aentryline + 1; 
+                       llines = func->aexitline - func->aentryline + 1;

                    }
                }
            }
                    }
                }
            }


@@ -2289,13 +2288,13 @@ int cmdListSrc (char *s, context *cctxt)
         return 0;
     if ( infomode )
     {
         return 0;
     if ( infomode )
     {

-        int firstaddr , lastaddr ;
+        unsigned firstaddr , lastaddr ;

            if ( pline  >= list_mod->ncLines )
             pline = cctxt->cline;
         firstaddr = lastaddr = list_mod->cLines[pline]->addr;
         if (!func && cctxt && cctxt->func )
             func = cctxt->func;
            if ( pline  >= list_mod->ncLines )
             pline = cctxt->cline;
         firstaddr = lastaddr = list_mod->cLines[pline]->addr;
         if (!func && cctxt && cctxt->func )
             func = cctxt->func;

-           fprintf(stdout,"Line %d of \"%s\" starts at address 0x%08x <%s+%d>", 
+           fprintf(stdout,"Line %d of \"%s\" starts at address 0x%08x <%s+%d>",

                 pline+1,
                 list_mod->c_name, lastaddr,
                 func ? func->sym->name : "?",
                 pline+1,
                 list_mod->c_name, lastaddr,
                 func ? func->sym->name : "?",


@@ -2309,7 +2308,7 @@ int cmdListSrc (char *s, context *cctxt)
                 break;
             }
         }
                 break;
             }
         }

-        fprintf(stdout," and ends at 0x%08x <%s+%d>.\n", 
+        fprintf(stdout," and ends at 0x%08x <%s+%d>.\n",

                 lastaddr,
                 func ? func->sym->name : "?",
                 func ? lastaddr -func->sym->addr : 0);
                 lastaddr,
                 func ? func->sym->name : "?",
                 func ? lastaddr -func->sym->addr : 0);


@@ -2342,9 +2341,9 @@ int cmdListSrc (char *s, context *cctxt)
 static unsigned long getValBasic(symbol *sym, link *type, char *val)
 {
     char *s;
 static unsigned long getValBasic(symbol *sym, link *type, char *val)
 {
     char *s;

-    union 
-    {          
-        float f;     
+    union
+    {
+        float f;

         unsigned long val;
         long         sval;
         struct {
         unsigned long val;
         long         sval;
         struct {


@@ -2354,14 +2353,14 @@ static unsigned long getValBasic(symbol *sym, link *type, char *val)
         unsigned char b[4];
     }v;
 
         unsigned char b[4];
     }v;
 

-    if (IS_FLOAT(type))        
-        v.f = strtod(val,NULL);    
+    if (IS_FLOAT(type))
+        v.f = strtod(val,NULL);

     else
        if (IS_PTR(type))
            v.val = strtol(val,NULL,0);
        else
     {
     else
        if (IS_PTR(type))
            v.val = strtol(val,NULL,0);
        else
     {

-           if (IS_INTEGRAL(type)) 
+           if (IS_INTEGRAL(type))

         {
             link *etype;
             if ( type->next )
         {
             link *etype;
             if ( type->next )


@@ -2374,7 +2373,7 @@ static unsigned long getValBasic(symbol *sym, link *type, char *val)
                 {
                     if ( s[1] == '\\' )
                         v.b[0] = strtol(s+2,NULL,8);
                 {
                     if ( s[1] == '\\' )
                         v.b[0] = strtol(s+2,NULL,8);

-                    else 
+                    else

                         v.b[0] = s[1];
                 }
                 else
                         v.b[0] = s[1];
                 }
                 else


@@ -2383,14 +2382,14 @@ static unsigned long getValBasic(symbol *sym, link *type, char *val)
                 }
             }
             else
                 }
             }
             else

-                if (IS_INT(etype)) 
+                if (IS_INT(etype))

                     if (IS_LONG(etype))
                         v.val = strtol(val,NULL,0);
                     else
                         v.i.lo = strtol(val,NULL,0);
                 else
                     v.val = strtol(val,NULL,0);
                     if (IS_LONG(etype))
                         v.val = strtol(val,NULL,0);
                     else
                         v.i.lo = strtol(val,NULL,0);
                 else
                     v.val = strtol(val,NULL,0);

-           } 
+           }

         else
             v.val = strtol(val,NULL,0);
     }
         else
             v.val = strtol(val,NULL,0);
     }


@@ -2400,14 +2399,14 @@ static unsigned long getValBasic(symbol *sym, link *type, char *val)
 /*-----------------------------------------------------------------*/
 /* printFmtInteger - print value in bin,oct,dez or hex             */
 /*-----------------------------------------------------------------*/
 /*-----------------------------------------------------------------*/
 /* printFmtInteger - print value in bin,oct,dez or hex             */
 /*-----------------------------------------------------------------*/

-static void printFmtInteger(char *deffmt,int fmt, long val, 
+static void printFmtInteger(char *deffmt,int fmt, long val,

                             int sign, int size)
 {
                             int sign, int size)
 {

-    static char digits[] = 
+    static char digits[] =

     {
         '0' , '1' , '2' , '3' , '4' , '5' ,
         '6' , '7' , '8' , '9' , 'a' , 'b' ,
     {
         '0' , '1' , '2' , '3' , '4' , '5' ,
         '6' , '7' , '8' , '9' , 'a' , 'b' ,

-        'c' , 'd' , 'e' , 'f' , 'g' , 'h' 
+        'c' , 'd' , 'e' , 'f' , 'g' , 'h'

     };
     static int radixOfFormat[] = { 0 , 2, 8 ,10, 16  };
     static int olenOfSize[]    = { 0 , 3, 6 , 8, 11  };
     };
     static int radixOfFormat[] = { 0 , 2, 8 ,10, 16  };
     static int olenOfSize[]    = { 0 , 3, 6 , 8, 11  };


@@ -2432,7 +2431,7 @@ static void printFmtInteger(char *deffmt,int fmt, long val,
            val = -val;
 
        buf[39] = '\0';
            val = -val;
 
        buf[39] = '\0';

-    while (val <= -radix) 
+    while (val <= -radix)

     {
            buf[charPos--] = digits[-(val % radix)];
            val = val / radix;
     {
            buf[charPos--] = digits[-(val % radix)];
            val = val / radix;


@@ -2455,7 +2454,7 @@ static void printFmtInteger(char *deffmt,int fmt, long val,
     while (charPos > 39 - radix )
     {
         buf[--charPos] = '0';
     while (charPos > 39 - radix )
     {
         buf[--charPos] = '0';

-    } 
+    }

     switch ( fmt )
     {
         case FMT_OCT:
     switch ( fmt )
     {
         case FMT_OCT:


@@ -2479,29 +2478,26 @@ static void printFmtInteger(char *deffmt,int fmt, long val,
 static void printValBasic(symbol *sym, link *type,
                           char mem, unsigned addr,int size, int fmt)
 {
 static void printValBasic(symbol *sym, link *type,
                           char mem, unsigned addr,int size, int fmt)
 {

-    union {    
-       float f;     
-       unsigned long val;
-       long         sval;
-       struct {
-           unsigned short    lo;
-           unsigned short    hi;
-       } i;
-       unsigned char b[4];
-    }v;

     union {
     union {

-       unsigned char b[4];
-    }v1;
-    
+        float f;
+        unsigned long val;
+        long         sval;
+        struct {
+            unsigned short    lo;
+            unsigned short    hi;
+        } i;
+        unsigned char b[4];
+    }v;
+

     v.val = simGetValue(addr,mem,size);
     /* if this a floating point number then */
     v.val = simGetValue(addr,mem,size);
     /* if this a floating point number then */

-    if (IS_FLOAT(type))        
-       fprintf(stdout,"%f",v.f);    
+    if (IS_FLOAT(type))
+       fprintf(stdout,"%f",v.f);

     else
        if (IS_PTR(type))
            fprintf(stdout,"0x%*x",size<<1,v.val);
        else
     else
        if (IS_PTR(type))
            fprintf(stdout,"0x%*x",size<<1,v.val);
        else

-        if (IS_INTEGRAL(type)) 
+        if (IS_INTEGRAL(type))

         {
             link *etype;
             if ( type->next )
         {
             link *etype;
             if ( type->next )


@@ -2509,7 +2505,7 @@ static void printValBasic(symbol *sym, link *type,
             else
                 etype = type;
             if (IS_CHAR(etype))
             else
                 etype = type;
             if (IS_CHAR(etype))

-            { 
+            {

                 if ( isprint(v.val))
                     printFmtInteger((SPEC_USIGN(etype)?"0x%02x":"'%c'"),
                                     fmt,(long)v.val,0,size);
                 if ( isprint(v.val))
                     printFmtInteger((SPEC_USIGN(etype)?"0x%02x":"'%c'"),
                                     fmt,(long)v.val,0,size);


@@ -2519,7 +2515,7 @@ static void printValBasic(symbol *sym, link *type,
             }
             else
             {
             }
             else
             {

-                if (IS_INT(etype)) 
+                if (IS_INT(etype))

                     if (IS_LONG(etype))
                         if (SPEC_USIGN(etype))
                             printFmtInteger("%u",fmt,(long)v.val,0,size);
                     if (IS_LONG(etype))
                         if (SPEC_USIGN(etype))
                             printFmtInteger("%u",fmt,(long)v.val,0,size);


@@ -2539,7 +2535,7 @@ static void printValBasic(symbol *sym, link *type,
                 }
             }
            } else
                 }
             }
            } else

-            fprintf(stdout,"0x%0*x",size<<1,v.val);  
+            fprintf(stdout,"0x%0*x",size<<1,v.val);

 }
 
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/


@@ -2558,11 +2554,11 @@ static void printArrayValue (symbol *sym,  link *type,
 {
        link *elem_type = type->next;
        int i;
 {
        link *elem_type = type->next;
        int i;

-       
+

        fprintf(stdout,"{");
        fprintf(stdout,"{");

-       for (i = 0 ; i < DCL_ELEM(type) ; i++) {                
+       for (i = 0 ; i < DCL_ELEM(type) ; i++) {

                if (IS_AGGREGATE(elem_type)) {
                if (IS_AGGREGATE(elem_type)) {

-                       printValAggregates(sym,elem_type,space,addr,fmt);                      
+                       printValAggregates(sym,elem_type,space,addr,fmt);

                } else {
                        printValBasic(sym,elem_type,space,addr,getSize(elem_type),fmt);
                }
                } else {
                        printValBasic(sym,elem_type,space,addr,getSize(elem_type),fmt);
                }


@@ -2571,14 +2567,14 @@ static void printArrayValue (symbol *sym,  link *type,
                        fprintf(stdout,",");
        }
 
                        fprintf(stdout,",");
        }
 

-       fprintf(stdout,"}");            
+       fprintf(stdout,"}");

 }
 
 /*-----------------------------------------------------------------*/
 /* printStructValue - prints structures elements                   */
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/
 /* printStructValue - prints structures elements                   */
 /*-----------------------------------------------------------------*/

-static void printStructValue (symbol *sym, link *type, 
-                              char space, unsigned int addr, int fmt) 
+static void printStructValue (symbol *sym, link *type,
+                              char space, unsigned int addr, int fmt)

 {
        symbol *fields = SPEC_STRUCT(type)->fields;
     int first = 1;
 {
        symbol *fields = SPEC_STRUCT(type)->fields;
     int first = 1;


@@ -2609,53 +2605,53 @@ static void printValAggregates (symbol *sym, link *type,
                return ;
        }
 
                return ;
        }
 

-       if (IS_STRUCT(type)) { 
-               printStructValue(sym, type, space, addr, fmt); 
-               return; 
-       } 
+       if (IS_STRUCT(type)) {
+               printStructValue(sym, type, space, addr, fmt);
+               return;
+       }

 }
 
 /*-----------------------------------------------------------------*/
 /* printOrSetSymValue - print or set value of a symbol             */
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/
 /* printOrSetSymValue - print or set value of a symbol             */
 /*-----------------------------------------------------------------*/

-static int printOrSetSymValue (symbol *sym, context *cctxt, 
-                                int flg, int dnum, int fmt, char *rs, 
+static int printOrSetSymValue (symbol *sym, context *cctxt,
+                                int flg, int dnum, int fmt, char *rs,

                                 char *val, char cmp )
 {
     static char fmtChar[] = " todx ";
     static int stack = 1;
        symbol *fields;
     link *type;
                                 char *val, char cmp )
 {
     static char fmtChar[] = " todx ";
     static int stack = 1;
        symbol *fields;
     link *type;

-    unsigned int  addr; 
+    unsigned int  addr;

     int size, n;
     char *s, *s2;
     char save_ch, save_ch2;
 
     /* if it is on stack then compute address & fall thru */
     int size, n;
     char *s, *s2;
     char save_ch, save_ch2;
 
     /* if it is on stack then compute address & fall thru */

-    if (sym->isonstack) 
+    if (sym->isonstack)

     {
         symbol *bp = symLookup("bp",cctxt);
     {
         symbol *bp = symLookup("bp",cctxt);

-        if (!bp) 
+        if (!bp)

         {
             fprintf(stdout,"cannot determine stack frame\n");
             return 1;
         }
 
         sym->addr = simGetValue(bp->addr,bp->addrspace,bp->size)
         {
             fprintf(stdout,"cannot determine stack frame\n");
             return 1;
         }
 
         sym->addr = simGetValue(bp->addr,bp->addrspace,bp->size)

-            + sym->offset ;      
+            + sym->offset ;

     }
     }

-    
+

     /* get the value from the simulator and
        print it */
     switch (flg)
     {
     /* get the value from the simulator and
        print it */
     switch (flg)
     {

-        case 0: 
+        case 0:

         default:
             break;
         default:
             break;

-        case 1: 
+        case 1:

             fprintf(stdout,"$%d = ",stack++);
             break;
             fprintf(stdout,"$%d = ",stack++);
             break;

-        case 2: 
+        case 2:

             fprintf(stdout,"%d: ", dnum);
             if ( fmt != FMT_NON )
                 fprintf(stdout,"/%c ",fmtChar[fmt]);
             fprintf(stdout,"%d: ", dnum);
             if ( fmt != FMT_NON )
                 fprintf(stdout,"/%c ",fmtChar[fmt]);


@@ -2687,13 +2683,13 @@ static int printOrSetSymValue (symbol *sym, context *cctxt,
                 if ( ! fields )
                 {
                     fprintf(stdout,"Unknown variable \"%s\" for index.\n", s);
                 if ( ! fields )
                 {
                     fprintf(stdout,"Unknown variable \"%s\" for index.\n", s);

-                    return 1;                    
+                    return 1;

                 }
                 /* arrays & structures first */
                 if (! IS_INTEGRAL(fields->type))
                 {
                     fprintf(stdout,"Wrong type of variable \"%s\" for index \n", s);
                 }
                 /* arrays & structures first */
                 if (! IS_INTEGRAL(fields->type))
                 {
                     fprintf(stdout,"Wrong type of variable \"%s\" for index \n", s);

-                    return 1;                    
+                    return 1;

                 }
                 n = simGetValue(fields->addr,fields->addrspace,getSize(fields->type));
             }
                 }
                 n = simGetValue(fields->addr,fields->addrspace,getSize(fields->type));
             }


@@ -2704,7 +2700,7 @@ static int printOrSetSymValue (symbol *sym, context *cctxt,
             if ( n < 0 || n >= DCL_ELEM(type))
             {
                 fprintf(stdout,"Wrong index %d.\n", n);
             if ( n < 0 || n >= DCL_ELEM(type))
             {
                 fprintf(stdout,"Wrong index %d.\n", n);

-                return 1;                    
+                return 1;

             }
             type = type->next;
             size = getSize(type);
             }
             type = type->next;
             size = getSize(type);


@@ -2719,7 +2715,7 @@ static int printOrSetSymValue (symbol *sym, context *cctxt,
             save_ch = *rs;
             if ( *rs )
                 *rs = '\0';
             save_ch = *rs;
             if ( *rs )
                 *rs = '\0';

-            for (fields = SPEC_STRUCT(type)->fields; fields; fields = fields->next) 
+            for (fields = SPEC_STRUCT(type)->fields; fields; fields = fields->next)

             {
                 if (!(strcmp(s,fields->name)))
                     break;
             {
                 if (!(strcmp(s,fields->name)))
                     break;


@@ -2728,7 +2724,7 @@ static int printOrSetSymValue (symbol *sym, context *cctxt,
             if ( ! fields )
             {
                 fprintf(stdout,"Unknown field \"%s\" of structure\n", s);
             if ( ! fields )
             {
                 fprintf(stdout,"Unknown field \"%s\" of structure\n", s);

-                return 1;                    
+                return 1;

             }
             type = fields->type;
             size = getSize(type);
             }
             type = fields->type;
             size = getSize(type);


@@ -2759,7 +2755,7 @@ static int printOrSetSymValue (symbol *sym, context *cctxt,
             return 1;
     }
        else
             return 1;
     }
        else

-    { 
+    {

            if ( val )
         {
             unsigned long newval;
            if ( val )
         {
             unsigned long newval;


@@ -2785,10 +2781,10 @@ static int printOrSetSymValue (symbol *sym, context *cctxt,
                 {
                     /* Symbol with address of IP */
                     if ( cctxt ) cctxt->addr = newval;
                 {
                     /* Symbol with address of IP */
                     if ( cctxt ) cctxt->addr = newval;

-                    simSetPC(cctxt->addr); 
+                    simSetPC(cctxt->addr);

                 }
                 else
                 }
                 else

-                    simSetValue(addr,sym->addrspace,size,newval);      
+                    simSetValue(addr,sym->addrspace,size,newval);

                 return 1;
             }
         }
                 return 1;
             }
         }


@@ -2806,7 +2802,7 @@ static void printStructInfo (structdef *sdef)
 {
     symbol *field = sdef->fields ;
     int i = 0 ;
 {
     symbol *field = sdef->fields ;
     int i = 0 ;

-    
+

     while (field) {
        i += field->offset;
        field = field->next;
     while (field) {
        i += field->offset;
        field = field->next;


@@ -2842,7 +2838,7 @@ static void printTypeInfo(link *p)
            printTypeInfo (p->next);
            fprintf(stdout,"[%d]",DCL_ELEM(p));
            break;
            printTypeInfo (p->next);
            fprintf(stdout,"[%d]",DCL_ELEM(p));
            break;

-       
+

        case IPOINTER:
        case PPOINTER:
        case POINTER:
        case IPOINTER:
        case PPOINTER:
        case POINTER:


@@ -2859,17 +2855,17 @@ static void printTypeInfo(link *p)
            printTypeInfo( p->next);
            fprintf(stdout,"(_code *)");
            break;
            printTypeInfo( p->next);
            fprintf(stdout,"(_code *)");
            break;

-           
+

        case GPOINTER:
            printTypeInfo( p->next);
            fprintf(stdout,"(_generic *)");
        case GPOINTER:
            printTypeInfo( p->next);
            fprintf(stdout,"(_generic *)");

-           break;                   
+           break;

        }
     } else {
        switch (SPEC_NOUN(p)) { /* depending on the specifier type */
        case V_INT:
        }
     } else {
        switch (SPEC_NOUN(p)) { /* depending on the specifier type */
        case V_INT:

-           (IS_LONG(p) ? fputs("long ",stdout) : 
-            ( IS_SHORT(p) ? fputs("short ",stdout) : 
+           (IS_LONG(p) ? fputs("long ",stdout) :
+            ( IS_SHORT(p) ? fputs("short ",stdout) :

               fputs("int ",stdout))) ;
            break;
        case V_FLOAT:
               fputs("int ",stdout))) ;
            break;
        case V_FLOAT:


@@ -2893,7 +2889,7 @@ static void printTypeInfo(link *p)
            break;
 
        case V_BIT:
            break;
 
        case V_BIT:

-           fprintf(stdout,": %d" ,SPEC_BLEN(p));       
+           fprintf(stdout,": %d" ,SPEC_BLEN(p));

            break;
        }
     }
            break;
        }
     }


@@ -2903,7 +2899,7 @@ static void printTypeInfo(link *p)
 /* conditionIsTrue - compare variable with constant value        */
 /*-----------------------------------------------------------------*/
 int conditionIsTrue( char *s, context *cctxt)
 /* conditionIsTrue - compare variable with constant value        */
 /*-----------------------------------------------------------------*/
 int conditionIsTrue( char *s, context *cctxt)

-{   
+{

     symbol *sym = NULL;
     int fmt;
     char *rs, *dup, cmp_char;
     symbol *sym = NULL;
     int fmt;
     char *rs, *dup, cmp_char;


@@ -2914,12 +2910,12 @@ int conditionIsTrue( char *s, context *cctxt)
         fmt = 1;
     else
     {
         fmt = 1;
     else
     {

-        cmp_char = *s;    
+        cmp_char = *s;

         *s++ = '\0';
         if ( *s == '=' )
         {
         *s++ = '\0';
         if ( *s == '=' )
         {

-            /* if <= or >= an other char is used 
-             * == or !=  not checked in switch 
+            /* if <= or >= an other char is used
+             * == or !=  not checked in switch

              */
             switch( cmp_char )
             {
              */
             switch( cmp_char )
             {


@@ -2939,17 +2935,17 @@ int conditionIsTrue( char *s, context *cctxt)
 /* cmdPrint - print value of variable                              */
 /*-----------------------------------------------------------------*/
 int cmdPrint (char *s, context *cctxt)
 /* cmdPrint - print value of variable                              */
 /*-----------------------------------------------------------------*/
 int cmdPrint (char *s, context *cctxt)

-{   
+{

     symbol *sym ;
     int fmt;
     char *rs;
     if ( !( rs = preparePrint(s, cctxt, &fmt, &sym )))
         return 0;
 
     symbol *sym ;
     int fmt;
     char *rs;
     if ( !( rs = preparePrint(s, cctxt, &fmt, &sym )))
         return 0;
 

-    if ( sym ) 
+    if ( sym )

     {
         printOrSetSymValue(sym,cctxt,1,0,fmt,rs,NULL,'\0');
     {
         printOrSetSymValue(sym,cctxt,1,0,fmt,rs,NULL,'\0');

-    } 
+    }

     return 0;
 }
 
     return 0;
 }
 


@@ -2957,17 +2953,17 @@ int cmdPrint (char *s, context *cctxt)
 /* cmdOutput - print value of variable without number and newline  */
 /*-----------------------------------------------------------------*/
 int cmdOutput (char *s, context *cctxt)
 /* cmdOutput - print value of variable without number and newline  */
 /*-----------------------------------------------------------------*/
 int cmdOutput (char *s, context *cctxt)

-{   
+{

     symbol *sym ;
     int fmt;
     char *rs;
     if ( !( rs = preparePrint(s, cctxt, &fmt, &sym )))
         return 0;
 
     symbol *sym ;
     int fmt;
     char *rs;
     if ( !( rs = preparePrint(s, cctxt, &fmt, &sym )))
         return 0;
 

-    if ( sym ) 
+    if ( sym )

     {
         printOrSetSymValue(sym,cctxt,0,0,fmt,rs,NULL,'\0');
     {
         printOrSetSymValue(sym,cctxt,0,0,fmt,rs,NULL,'\0');

-    } 
+    }

     return 0;
 }
 
     return 0;
 }
 


@@ -2998,7 +2994,7 @@ void displayAll(context *cctxt)
         return;
     for (dsym = setFirstItem(dispsymbols);
          dsym ;
         return;
     for (dsym = setFirstItem(dispsymbols);
          dsym ;

-         dsym = setNextItem(dispsymbols)) 
+         dsym = setNextItem(dispsymbols))

     {
         if ( (sym = symLookup(dsym->name,cctxt)))
             printOrSetSymValue(sym,cctxt,2,dsym->dnum,dsym->fmt,
     {
         if ( (sym = symLookup(dsym->name,cctxt)))
             printOrSetSymValue(sym,cctxt,2,dsym->dnum,dsym->fmt,


@@ -3010,7 +3006,7 @@ void displayAll(context *cctxt)
 /* cmdDisplay  - display value of variable                         */
 /*-----------------------------------------------------------------*/
 int cmdDisplay (char *s, context *cctxt)
 /* cmdDisplay  - display value of variable                         */
 /*-----------------------------------------------------------------*/
 int cmdDisplay (char *s, context *cctxt)

-{   
+{

     static int dnum = 1;
     symbol *sym ;
     int fmt;
     static int dnum = 1;
     symbol *sym ;
     int fmt;


@@ -3021,7 +3017,7 @@ int cmdDisplay (char *s, context *cctxt)
         return 0;
     }
 
         return 0;
     }
 

-    if ( sym ) 
+    if ( sym )

     {
         dsymbol *dsym = (dsymbol *)Safe_calloc(1,sizeof(dsymbol));
         dsym->dnum = dnum++ ;
     {
         dsymbol *dsym = (dsymbol *)Safe_calloc(1,sizeof(dsymbol));
         dsym->dnum = dnum++ ;


@@ -3037,7 +3033,7 @@ int cmdDisplay (char *s, context *cctxt)
 /* cmdUnDisplay  - undisplay value of variable                              */
 /*-----------------------------------------------------------------*/
 int cmdUnDisplay (char *s, context *cctxt)
 /* cmdUnDisplay  - undisplay value of variable                              */
 /*-----------------------------------------------------------------*/
 int cmdUnDisplay (char *s, context *cctxt)

-{   
+{

     dsymbol *dsym;
     int dnum;
 
     dsymbol *dsym;
     int dnum;
 


@@ -3049,7 +3045,7 @@ int cmdUnDisplay (char *s, context *cctxt)
              dsym = setNextItem(dispsymbols))
         {
             Safe_free(dsym->rs);
              dsym = setNextItem(dispsymbols))
         {
             Safe_free(dsym->rs);

-            Safe_free(dsym); 
+            Safe_free(dsym);

         }
         deleteSet(&dispsymbols);
         return 0;
         }
         deleteSet(&dispsymbols);
         return 0;


@@ -3057,15 +3053,15 @@ int cmdUnDisplay (char *s, context *cctxt)
     while ( s && *s )
     {
         dnum = strtol(s,&s,10);
     while ( s && *s )
     {
         dnum = strtol(s,&s,10);

-        if (applyToSetFTrue(dispsymbols,dsymWithNumber,dnum,&dsym)) 
+        if (applyToSetFTrue(dispsymbols,dsymWithNumber,dnum,&dsym))

         {
             deleteSetItem(&dispsymbols,dsym);
             Safe_free(dsym->rs);
         {
             deleteSetItem(&dispsymbols,dsym);
             Safe_free(dsym->rs);

-            Safe_free(dsym); 
-        } 
+            Safe_free(dsym);
+        }

         else
         {
         else
         {

-            fprintf(stdout,"Arguments must be display numbers.\n");    
+            fprintf(stdout,"Arguments must be display numbers.\n");

         }
     }
     return 0;
         }
     }
     return 0;


@@ -3075,7 +3071,7 @@ int cmdUnDisplay (char *s, context *cctxt)
 /* cmdPrintType - print type of a variable                         */
 /*-----------------------------------------------------------------*/
 int cmdPrintType (char *s, context *cctxt)
 /* cmdPrintType - print type of a variable                         */
 /*-----------------------------------------------------------------*/
 int cmdPrintType (char *s, context *cctxt)

-{   
+{

         symbol *sym ;
     char *bp = s+strlen(s) -1;
 
         symbol *sym ;
     char *bp = s+strlen(s) -1;
 


@@ -3093,17 +3089,17 @@ int cmdPrintType (char *s, context *cctxt)
                "No symbol \"%s\" in current context.\n",
                s);
     }
                "No symbol \"%s\" in current context.\n",
                s);
     }

-    return 0;   
+    return 0;

 }
 
 /*-----------------------------------------------------------------*/
 /* cmdClrUserBp - clear user break point                           */
 /*-----------------------------------------------------------------*/
 int cmdClrUserBp (char *s, context *cctxt)
 }
 
 /*-----------------------------------------------------------------*/
 /* cmdClrUserBp - clear user break point                           */
 /*-----------------------------------------------------------------*/
 int cmdClrUserBp (char *s, context *cctxt)

-{   
-    char *bp ;    
+{
+    char *bp ;

     function *func = NULL;
     function *func = NULL;

-       
+

     /* clear break point location specification can be of the following
        forms
        a) <nothing>        - break point at current location
     /* clear break point location specification can be of the following
        forms
        a) <nothing>        - break point at current location


@@ -3120,7 +3116,7 @@ int cmdClrUserBp (char *s, context *cctxt)
 
     /* white space skip */
     while (*s && isspace(*s)) s++;
 
     /* white space skip */
     while (*s && isspace(*s)) s++;

-    
+

     /* null terminate it after stripping trailing blanks*/
     bp = s + strlen(s);
     while (bp != s && isspace(*bp)) bp--;
     /* null terminate it after stripping trailing blanks*/
     bp = s + strlen(s);
     while (bp != s && isspace(*bp)) bp--;


@@ -3132,12 +3128,12 @@ int cmdClrUserBp (char *s, context *cctxt)
     if (! *s ) {
 
        /* if current context is known */
     if (! *s ) {
 
        /* if current context is known */

-       if (cctxt->func) 
+       if (cctxt->func)

            /* clear the break point @ current location */
            clearUSERbp (cctxt->addr);
        else
            fprintf(stderr,"No default breakpoint address now.\n");
            /* clear the break point @ current location */
            clearUSERbp (cctxt->addr);
        else
            fprintf(stderr,"No default breakpoint address now.\n");

-                       
+

        goto ret ;
     }
 
        goto ret ;
     }
 


@@ -3149,63 +3145,63 @@ int cmdClrUserBp (char *s, context *cctxt)
 
        /* if current context not present then we must get the module
           which has main & set the break point @ line number provided
 
        /* if current context not present then we must get the module
           which has main & set the break point @ line number provided

-          of that module : if current context known then set the bp 
-          at the line number given for the current module 
+          of that module : if current context known then set the bp
+          at the line number given for the current module

        */
        if (cctxt->func) {
            if (!cctxt->func->mod) {
                if (!applyToSet(functions,funcWithName,"main"))
                    fprintf(stderr,"Function \"main\" not defined.\n");
        */
        if (cctxt->func) {
            if (!cctxt->func->mod) {
                if (!applyToSet(functions,funcWithName,"main"))
                    fprintf(stderr,"Function \"main\" not defined.\n");

-               else 
+               else

                    clearBPatModLine(func->mod,line);
                    clearBPatModLine(func->mod,line);

-           } else 
-               clearBPatModLine(cctxt->func->mod,line);                        
+           } else
+               clearBPatModLine(cctxt->func->mod,line);

        }
        }

-       
+

        goto ret;
     }
 
     if ((bp = strchr(s,':'))) {
        goto ret;
     }
 
     if ((bp = strchr(s,':'))) {

-       
+

        module *mod = NULL;
        *bp = '\0';
        module *mod = NULL;
        *bp = '\0';

-       
+

        if (!applyToSet(modules,moduleWithCName,s,&mod)) {
            fprintf (stderr,"No source file named %s.\n",s);
            goto ret;
        }
 
        /* case c) filename:lineno */
        if (!applyToSet(modules,moduleWithCName,s,&mod)) {
            fprintf (stderr,"No source file named %s.\n",s);
            goto ret;
        }
 
        /* case c) filename:lineno */

-       if (isdigit(*(bp +1))) {                    
-        
-           clearBPatModLine (mod,atoi(bp+1));      
+       if (isdigit(*(bp +1))) {
+
+           clearBPatModLine (mod,atoi(bp+1));

            goto ret;
            goto ret;

-           
+

        }
        /* case d) filename:function */
        }
        /* case d) filename:function */

-       if (!applyToSet(functions,funcWithNameModule,bp+1,s,&func)) 
-           fprintf(stderr,"Function \"%s\" not defined.\n",bp+1); 
+       if (!applyToSet(functions,funcWithNameModule,bp+1,s,&func))
+           fprintf(stderr,"Function \"%s\" not defined.\n",bp+1);

        else
            clearBPatModLine (mod,func->entryline);
        else
            clearBPatModLine (mod,func->entryline);

-       
+

        goto ret;
     }
        goto ret;
     }

-            
+

     /* case e) function */
     if (!applyToSet(functions,funcWithName,s,&func))
     /* case e) function */
     if (!applyToSet(functions,funcWithName,s,&func))

-       fprintf(stderr,"Function \"%s\" not defined.\n",s); 
+       fprintf(stderr,"Function \"%s\" not defined.\n",s);

     else
        clearBPatModLine(func->mod,func->entryline);
 
     else
        clearBPatModLine(func->mod,func->entryline);
 

- ret:    
-    return 0;        
+ ret:
+    return 0;

 }
 
 /*-----------------------------------------------------------------*/
 /* cmdSimulator - send command to simulator                        */
 /*-----------------------------------------------------------------*/
 int cmdSimulator (char *s, context *cctxt)
 }
 
 /*-----------------------------------------------------------------*/
 /* cmdSimulator - send command to simulator                        */
 /*-----------------------------------------------------------------*/
 int cmdSimulator (char *s, context *cctxt)

-{   
+{

   char tmpstr[82];
 
     if (strlen(s) > 80) {
   char tmpstr[82];
 
     if (strlen(s) > 80) {


@@ -3223,7 +3219,7 @@ int cmdSimulator (char *s, context *cctxt)
 void setMainContext()
 {
     function *func = NULL;
 void setMainContext()
 {
     function *func = NULL;

-    currentFrame = 0; 
+    currentFrame = 0;

     if (!applyToSet(functions,funcWithName,"_main",&func) &&
         !applyToSet(functions,funcWithName,"main",&func))
             return;
     if (!applyToSet(functions,funcWithName,"_main",&func) &&
         !applyToSet(functions,funcWithName,"main",&func))
             return;


@@ -3243,7 +3239,7 @@ function *needExtraMainFunction()
     }
     return NULL;
 }
     }
     return NULL;
 }

-    
+

 static void printFrame()
 {
     int i;
 static void printFrame()
 {
     int i;


@@ -3309,9 +3305,9 @@ int cmdDown(char *s, context *cctxt)
 /* cmdFrame - Frame command                                        */
 /*-----------------------------------------------------------------*/
 int cmdFrame (char *s, context *cctxt)
 /* cmdFrame - Frame command                                        */
 /*-----------------------------------------------------------------*/
 int cmdFrame (char *s, context *cctxt)

-{   
+{

     function *func = NULL;
     function *func = NULL;

-    int i, framenr = 0;
+    int framenr = 0;

 
     while (isspace(*s)) s++;
     if ( *s )
 
     while (isspace(*s)) s++;
     if ( *s )


@@ -3331,19 +3327,19 @@ int cmdFinish (char *s, context *ctxt)
     }
 
     if (srcMode == SRC_CMODE) {
     }
 
     if (srcMode == SRC_CMODE) {

-       setBreakPoint (ctxt->func->sym->eaddr, CODE, STEP, 
-                      stepBpCB, ctxt->func->mod->c_name, 
+       setBreakPoint (ctxt->func->sym->eaddr, CODE, STEP,
+                      stepBpCB, ctxt->func->mod->c_name,

                       ctxt->func->exitline);
     } else {
                       ctxt->func->exitline);
     } else {

-       setBreakPoint (ctxt->func->sym->eaddr, CODE, STEP, 
-                      stepBpCB, ctxt->func->mod->asm_name, 
+       setBreakPoint (ctxt->func->sym->eaddr, CODE, STEP,
+                      stepBpCB, ctxt->func->mod->asm_name,

                       ctxt->func->aexitline);
     }
 
     simGo(-1);
     showfull = 1;
     return 0;
                       ctxt->func->aexitline);
     }
 
     simGo(-1);
     showfull = 1;
     return 0;

-    
+

 }
 
 
 }
 
 


@@ -3359,7 +3355,7 @@ int cmdShow (char *s, context *cctxt)
        fputs(copying,stdout);
        return 0;
     }
        fputs(copying,stdout);
        return 0;
     }

-    
+

     if (strcmp(s,"warranty") == 0) {
        fputs(warranty,stdout);
        return 0;
     if (strcmp(s,"warranty") == 0) {
        fputs(warranty,stdout);
        return 0;

diff --git a/debugger/mcs51/symtab.c b/debugger/mcs51/symtab.c
index 423bf2b6ab99c185bf1cd9676540a280eaa6cd8d..7c14aa89fcde8af797696d8b9bc567266c948223 100644 (file)
--- a/debugger/mcs51/symtab.c
+++ b/debugger/mcs51/symtab.c
@@ -261,7 +261,7 @@ symbol *parseSymbol (char *s, char **rs, int doadd)
         if ( applyToSetFTrue(symbols,symWithRName,s,&nsym))
         {
             if ( nsym->rname != nsym->name )
         if ( applyToSetFTrue(symbols,symWithRName,s,&nsym))
         {
             if ( nsym->rname != nsym->name )

-                return;
+                return NULL;

             doadd = 0;
         }
     }
             doadd = 0;
         }
     }

diff --git a/src/mcs51/gen.c b/src/mcs51/gen.c
index baaf26643a2f95900d80fe6bddb94813586b2bef..6ababda9db752bc272f82730220deb370ac6ff52 100644 (file)
--- a/src/mcs51/gen.c
+++ b/src/mcs51/gen.c
@@ -72,13 +72,13 @@ static unsigned short rbank = -1;
                        AOP_TYPE(x) == AOP_R0))
 
 #define AOP_NEEDSACC(x) (AOP(x) && (AOP_TYPE(x) == AOP_CRY ||  \
                        AOP_TYPE(x) == AOP_R0))
 
 #define AOP_NEEDSACC(x) (AOP(x) && (AOP_TYPE(x) == AOP_CRY ||  \

-                        AOP_TYPE(x) == AOP_DPTR || AOP(x)->paged))
+                        AOP_TYPE(x) == AOP_DPTR || \
+                        AOP(x)->paged))

 
 #define AOP_INPREG(x) (x && (x->type == AOP_REG &&                        \
                       (x->aopu.aop_reg[0] == mcs51_regWithIdx(R0_IDX) || \
                       x->aopu.aop_reg[0] == mcs51_regWithIdx(R1_IDX) )))
 
 
 #define AOP_INPREG(x) (x && (x->type == AOP_REG &&                        \
                       (x->aopu.aop_reg[0] == mcs51_regWithIdx(R0_IDX) || \
                       x->aopu.aop_reg[0] == mcs51_regWithIdx(R1_IDX) )))
 

-

 #define SYM_BP(sym)   (SPEC_OCLS (sym->etype)->paged ? "_bpx" : "_bp")
 
 #define R0INB   _G.bu.bs.r0InB
 #define SYM_BP(sym)   (SPEC_OCLS (sym->etype)->paged ? "_bpx" : "_bp")
 
 #define R0INB   _G.bu.bs.r0InB


@@ -115,8 +115,6 @@ static char *rb1regs[] = {
     "b0",  "b1",  "b2",  "b3",  "b4",  "b5",  "b6",  "b7"
 };
 
     "b0",  "b1",  "b2",  "b3",  "b4",  "b5",  "b6",  "b7"
 };
 

-extern int mcs51_ptrRegReq;
-extern int mcs51_nRegs;

 extern FILE *codeOutFile;
 static void saveRBank (int, iCode *, bool);
 
 extern FILE *codeOutFile;
 static void saveRBank (int, iCode *, bool);
 


@@ -158,21 +156,33 @@ emitcode (char *inst, const char *fmt,...)
   if (inst && *inst)
     {
       if (fmt && *fmt)
   if (inst && *inst)
     {
       if (fmt && *fmt)

+        {

           SNPRINTF (lb, sizeof(lb), "%s\t", inst);
           SNPRINTF (lb, sizeof(lb), "%s\t", inst);

+        }

       else
       else

+        {

           SNPRINTF (lb, sizeof(lb), "%s", inst);
           SNPRINTF (lb, sizeof(lb), "%s", inst);

+        }
+

       tvsprintf (lb + strlen(lb), sizeof(lb) - strlen(lb), fmt, ap);
     }
   else
       tvsprintf (lb + strlen(lb), sizeof(lb) - strlen(lb), fmt, ap);
     }
   else

+    {

       tvsprintf (lb, sizeof(lb), fmt, ap);
       tvsprintf (lb, sizeof(lb), fmt, ap);

+    }

 
   while (isspace ((unsigned char)*lbp))
 
   while (isspace ((unsigned char)*lbp))

+    {

       lbp++;
       lbp++;

+    }

 
   if (lbp && *lbp)
 
   if (lbp && *lbp)

+    {

       lineCurr = (lineCurr ?
                   connectLine (lineCurr, newLineNode (lb)) :
                   (lineHead = newLineNode (lb)));
       lineCurr = (lineCurr ?
                   connectLine (lineCurr, newLineNode (lb)) :
                   (lineHead = newLineNode (lb)));

+    }
+

   lineCurr->isInline = _G.inLine;
   lineCurr->isDebug = _G.debugLine;
   lineCurr->ic = _G.current_iCode;
   lineCurr->isInline = _G.inLine;
   lineCurr->isDebug = _G.debugLine;
   lineCurr->ic = _G.current_iCode;


@@ -202,7 +212,7 @@ mova (const char *x)
   if (!strncmp(x, "a", 2) || !strncmp(x, "acc", 4))
     return;
 
   if (!strncmp(x, "a", 2) || !strncmp(x, "acc", 4))
     return;
 

-  emitcode("mov","a,%s", x);
+  emitcode("mov", "a,%s", x);

 }
 
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/


@@ -561,6 +571,7 @@ aopForSym (iCode * ic, symbol * sym, bool result)
 {
   asmop *aop;
   memmap *space;
 {
   asmop *aop;
   memmap *space;

+  bool accuse = leftRightUseAcc (ic) || _G.accInUse;

 
   wassertl (ic != NULL, "Got a null iCode");
   wassertl (sym != NULL, "Got a null symbol");
 
   wassertl (ic != NULL, "Got a null iCode");
   wassertl (sym != NULL, "Got a null symbol");


@@ -570,7 +581,7 @@ aopForSym (iCode * ic, symbol * sym, bool result)
   /* if already has one */
   if (sym->aop)
     {
   /* if already has one */
   if (sym->aop)
     {

-         sym->aop->allocated++;
+      sym->aop->allocated++;

       return sym->aop;
     }
 
       return sym->aop;
     }
 


@@ -587,14 +598,14 @@ aopForSym (iCode * ic, symbol * sym, bool result)
          the pointer register */
       if (aop->type != AOP_STK)
         {
          the pointer register */
       if (aop->type != AOP_STK)
         {

-

           if (sym->onStack)
             {
               char offset = ((sym->stack < 0) ?
                          ((char) (sym->stack - _G.nRegsSaved)) :
                          ((char) sym->stack)) & 0xff;
 
           if (sym->onStack)
             {
               char offset = ((sym->stack < 0) ?
                          ((char) (sym->stack - _G.nRegsSaved)) :
                          ((char) sym->stack)) & 0xff;
 

-              if ((offset >= -3) && (offset <= 3))
+              if ((abs(offset) <= 3) ||
+                  (accuse && (abs(offset) <= 7)))

                 {
                   emitcode ("mov", "%s,%s",
                             aop->aopu.aop_ptr->name, SYM_BP (sym));
                 {
                   emitcode ("mov", "%s,%s",
                             aop->aopu.aop_ptr->name, SYM_BP (sym));


@@ -611,20 +622,21 @@ aopForSym (iCode * ic, symbol * sym, bool result)
                 }
               else
                 {
                 }
               else
                 {

-                  if (_G.accInUse || leftRightUseAcc (ic))
+                  if (accuse)

                     emitcode ("push", "acc");
                   emitcode ("mov", "a,%s", SYM_BP (sym));
                   emitcode ("add", "a,#0x%02x", offset);
                     emitcode ("push", "acc");
                   emitcode ("mov", "a,%s", SYM_BP (sym));
                   emitcode ("add", "a,#0x%02x", offset);

-                  emitcode ("mov", "%s,a",
-                            aop->aopu.aop_ptr->name);
-                  if (_G.accInUse || leftRightUseAcc (ic))
+                  emitcode ("mov", "%s,a", aop->aopu.aop_ptr->name);
+                  if (accuse)

                     emitcode ("pop", "acc");
                 }
             }
           else
                     emitcode ("pop", "acc");
                 }
             }
           else

-            emitcode ("mov", "%s,#%s",
-                      aop->aopu.aop_ptr->name,
-                      sym->rname);
+            {
+              emitcode ("mov", "%s,#%s",
+                        aop->aopu.aop_ptr->name,
+                        sym->rname);
+            }

           aop->paged = space->paged;
         }
       else
           aop->paged = space->paged;
         }
       else


@@ -656,8 +668,7 @@ aopForSym (iCode * ic, symbol * sym, bool result)
   if (IS_FUNC (sym->type))
     {
       sym->aop = aop = newAsmop (AOP_IMMD);
   if (IS_FUNC (sym->type))
     {
       sym->aop = aop = newAsmop (AOP_IMMD);

-      aop->aopu.aop_immd.aop_immd1 = Safe_calloc (1, strlen (sym->rname) + 1);
-      strcpy (aop->aopu.aop_immd.aop_immd1, sym->rname);
+      aop->aopu.aop_immd.aop_immd1 = Safe_strdup(sym->rname);

       aop->size = getSize (sym->type);
       return aop;
     }
       aop->size = getSize (sym->type);
       return aop;
     }


@@ -704,21 +715,25 @@ aopForRemat (symbol * sym)
     }
 
   if (val)
     }
 
   if (val)

-    sprintf (buffer, "(%s %c 0x%04x)",
-             OP_SYMBOL (IC_LEFT (ic))->rname,
-             val >= 0 ? '+' : '-',
-             abs (val) & 0xffff);
+    {
+      SNPRINTF (buffer, sizeof(buffer),
+                "(%s %c 0x%04x)",
+                OP_SYMBOL (IC_LEFT (ic))->rname,
+                val >= 0 ? '+' : '-',
+                abs (val) & 0xffff);
+    }

   else
   else

-    strcpy (buffer, OP_SYMBOL (IC_LEFT (ic))->rname);
+    {
+      strncpyz (buffer, OP_SYMBOL (IC_LEFT (ic))->rname, sizeof(buffer));
+    }

 
 

-  aop->aopu.aop_immd.aop_immd1 = Safe_calloc (1, strlen (buffer) + 1);
-  strcpy (aop->aopu.aop_immd.aop_immd1, buffer);
+  aop->aopu.aop_immd.aop_immd1 = Safe_strdup(buffer);

   /* set immd2 field if required */
   /* set immd2 field if required */

-  if (aop->aopu.aop_immd.from_cast_remat) {
-          sprintf(buffer,"#0x%02x",ptr_type);
-          aop->aopu.aop_immd.aop_immd2 = Safe_calloc (1, strlen (buffer) + 1);
-          strcpy (aop->aopu.aop_immd.aop_immd2, buffer);
-  }
+  if (aop->aopu.aop_immd.from_cast_remat)
+    {
+      sprintf(buffer,"#0x%02x",ptr_type);
+      aop->aopu.aop_immd.aop_immd2 = Safe_strdup(buffer);
+    }

 
   return aop;
 }
 
   return aop;
 }


@@ -879,7 +894,7 @@ aopOp (operand * op, iCode * ic, bool result)
   /* if already has a asmop then continue */
   if (op->aop)
     {
   /* if already has a asmop then continue */
   if (op->aop)
     {

-         op->aop->allocated++;
+      op->aop->allocated++;

       return;
     }
 
       return;
     }
 


@@ -887,7 +902,7 @@ aopOp (operand * op, iCode * ic, bool result)
   if (IS_SYMOP (op) && OP_SYMBOL (op)->aop)
     {
       op->aop = OP_SYMBOL (op)->aop;
   if (IS_SYMOP (op) && OP_SYMBOL (op)->aop)
     {
       op->aop = OP_SYMBOL (op)->aop;

-         op->aop->allocated++;
+      op->aop->allocated++;

       return;
     }
 
       return;
     }
 


@@ -1097,6 +1112,7 @@ freeAsmop (operand * op, asmop * aaop, iCode * ic, bool pop)
             _G.r0Pushed--;
           }
       }
             _G.r0Pushed--;
           }
       }

+      break;

     }
 
 dealloc:
     }
 
 dealloc:


@@ -1239,14 +1255,12 @@ aopGetUsesAcc (operand * oper, int offset)
     }
 }
 
     }
 }
 

-/*-----------------------------------------------------------------*/
-/* aopGet - for fetching value of the aop                          */
-/*-----------------------------------------------------------------*/
+/*-------------------------------------------------------------------*/
+/* aopGet - for fetching value of the aop                            */
+/*-------------------------------------------------------------------*/

 static char *
 aopGet (operand * oper, int offset, bool bit16, bool dname)
 {
 static char *
 aopGet (operand * oper, int offset, bool bit16, bool dname)
 {

-  char *s = buffer;
-  char *rs;

   asmop * aop = AOP (oper);
 
   /* offset is greater than
   asmop * aop = AOP (oper);
 
   /* offset is greater than


@@ -1282,10 +1296,9 @@ aopGet (operand * oper, int offset, bool bit16, bool dname)
           emitcode ("movx", "a,@%s", aop->aopu.aop_ptr->name);
           return (dname ? "acc" : "a");
         }
           emitcode ("movx", "a,@%s", aop->aopu.aop_ptr->name);
           return (dname ? "acc" : "a");
         }

-      sprintf (s, "@%s", aop->aopu.aop_ptr->name);
-      rs = Safe_calloc (1, strlen (s) + 1);
-      strcpy (rs, s);
-      return rs;
+      SNPRINTF (buffer, sizeof(buffer), "@%s", aop->aopu.aop_ptr->name);
+      return Safe_strdup(buffer);
+

 
     case AOP_DPTR:
       if (aop->code && aop->coff==0 && offset>=1) {
 
     case AOP_DPTR:
       if (aop->code && aop->coff==0 && offset>=1) {


@@ -1318,36 +1331,52 @@ aopGet (operand * oper, int offset, bool bit16, bool dname)
         }
       return (dname ? "acc" : "a");
 
         }
       return (dname ? "acc" : "a");
 

-

     case AOP_IMMD:
     case AOP_IMMD:

-      if (aop->aopu.aop_immd.from_cast_remat && (offset == (aop->size-1))) {
-              sprintf(s,"%s",aop->aopu.aop_immd.aop_immd2);
-      } else if (bit16)
-        sprintf (s, "#%s", aop->aopu.aop_immd.aop_immd1);
+      if (aop->aopu.aop_immd.from_cast_remat && (offset == (aop->size-1)))
+        {
+          SNPRINTF(buffer, sizeof(buffer),
+                   "%s",aop->aopu.aop_immd.aop_immd2);
+        }
+      else if (bit16)
+        {
+          SNPRINTF(buffer, sizeof(buffer),
+                   "#%s", aop->aopu.aop_immd.aop_immd1);
+        }

       else if (offset)
       else if (offset)

-        sprintf (s, "#(%s >> %d)",
-                 aop->aopu.aop_immd.aop_immd1,
-                 offset * 8);
+        {
+          SNPRINTF (buffer, sizeof(buffer),
+                    "#(%s >> %d)",
+                    aop->aopu.aop_immd.aop_immd1,
+                    offset * 8);
+        }

       else
       else

-        sprintf (s, "#%s",
-                 aop->aopu.aop_immd.aop_immd1);
-      rs = Safe_calloc (1, strlen (s) + 1);
-      strcpy (rs, s);
-      return rs;
+        {
+          SNPRINTF (buffer, sizeof(buffer),
+                    "#%s", aop->aopu.aop_immd.aop_immd1);
+        }
+      return Safe_strdup(buffer);

 
     case AOP_DIR:
       if (SPEC_SCLS (getSpec (operandType (oper))) == S_SFR && offset)
 
     case AOP_DIR:
       if (SPEC_SCLS (getSpec (operandType (oper))) == S_SFR && offset)

-        sprintf (s, "(%s >> %d)",
-                 aop->aopu.aop_dir, offset * 8);
+        {
+          SNPRINTF (buffer, sizeof(buffer),
+                    "(%s >> %d)",
+                    aop->aopu.aop_dir, offset * 8);
+        }

       else if (offset)
       else if (offset)

-        sprintf (s, "(%s + %d)",
-                 aop->aopu.aop_dir,
-                 offset);
+        {
+          SNPRINTF (buffer, sizeof(buffer),
+                    "(%s + %d)",
+                   aop->aopu.aop_dir,
+                   offset);
+        }

       else
       else

-        sprintf (s, "%s", aop->aopu.aop_dir);
-      rs = Safe_calloc (1, strlen (s) + 1);
-      strcpy (rs, s);
-      return rs;
+        {
+          SNPRINTF (buffer, sizeof(buffer),
+                   "%s", aop->aopu.aop_dir);
+        }
+
+      return Safe_strdup(buffer);

 
     case AOP_REG:
       if (dname)
 
     case AOP_REG:
       if (dname)


@@ -1431,9 +1460,9 @@ aopPutUsesAcc (operand * oper, const char *s, int offset)
 /* aopPut - puts a string for a aop and indicates if acc is in use */
 /*-----------------------------------------------------------------*/
 static bool
 /* aopPut - puts a string for a aop and indicates if acc is in use */
 /*-----------------------------------------------------------------*/
 static bool

-aopPut (operand * result, const char *s, int offset, bool bvolatile)
+aopPut (operand * result, const char *s, int offset)

 {
 {

-  char *d = buffer;
+  bool bvolatile = isOperandVolatile (result, FALSE);

   bool accuse = FALSE;
   asmop * aop = AOP (result);
 
   bool accuse = FALSE;
   asmop * aop = AOP (result);
 


@@ -1455,17 +1484,31 @@ aopPut (operand * result, const char *s, int offset, bool bvolatile)
 
     case AOP_DIR:
       if (SPEC_SCLS (getSpec (operandType (result))) == S_SFR && offset)
 
     case AOP_DIR:
       if (SPEC_SCLS (getSpec (operandType (result))) == S_SFR && offset)

-        sprintf (d, "(%s >> %d)", aop->aopu.aop_dir, offset * 8);
+        {
+          SNPRINTF (buffer, sizeof(buffer),
+                    "(%s >> %d)",
+                    aop->aopu.aop_dir, offset * 8);
+        }

       else if (offset)
       else if (offset)

-        sprintf (d, "(%s + %d)", aop->aopu.aop_dir, offset);
+        {
+            SNPRINTF (buffer, sizeof(buffer),
+                      "(%s + %d)",
+                      aop->aopu.aop_dir, offset);
+        }

       else
       else

-        sprintf (d, "%s", aop->aopu.aop_dir);
+        {
+            SNPRINTF (buffer, sizeof(buffer),
+                     "%s", aop->aopu.aop_dir);
+        }

 
 

-      if (strcmp (d, s) || bvolatile)
-          emitcode ("mov", "%s,%s", d, s);
-      if (!strcmp (d, "acc"))
+      if (strcmp (buffer, s) || bvolatile)
+        {
+            emitcode ("mov", "%s,%s", buffer, s);
+        }
+      if (!strcmp (buffer, "acc"))
+        {

           accuse = TRUE;
           accuse = TRUE;

-
+        }

       break;
 
     case AOP_REG:
       break;
 
     case AOP_REG:


@@ -1481,11 +1524,15 @@ aopPut (operand * result, const char *s, int offset, bool bvolatile)
               strcmp (s, "r5") == 0 ||
               strcmp (s, "r6") == 0 ||
               strcmp (s, "r7") == 0)
               strcmp (s, "r5") == 0 ||
               strcmp (s, "r6") == 0 ||
               strcmp (s, "r7") == 0)

-            emitcode ("mov", "%s,%s",
-                      aop->aopu.aop_reg[offset]->dname, s);
+            {
+              emitcode ("mov", "%s,%s",
+                        aop->aopu.aop_reg[offset]->dname, s);
+            }

           else
           else

-            emitcode ("mov", "%s,%s",
-                      aop->aopu.aop_reg[offset]->name, s);
+            {
+              emitcode ("mov", "%s,%s",
+                        aop->aopu.aop_reg[offset]->name, s);
+            }

         }
       break;
 
         }
       break;
 


@@ -1551,13 +1598,14 @@ aopPut (operand * result, const char *s, int offset, bool bvolatile)
                strcmp (s, "r7") == 0)
         {
           char buffer[10];
                strcmp (s, "r7") == 0)
         {
           char buffer[10];

-          sprintf (buffer, "a%s", s);
+          SNPRINTF (buffer, sizeof(buffer), "a%s", s);

           emitcode ("mov", "@%s,%s",
                     aop->aopu.aop_ptr->name, buffer);
         }
       else
           emitcode ("mov", "@%s,%s",
                     aop->aopu.aop_ptr->name, buffer);
         }
       else

-        emitcode ("mov", "@%s,%s", aop->aopu.aop_ptr->name, s);
-
+        {
+          emitcode ("mov", "@%s,%s", aop->aopu.aop_ptr->name, s);
+        }

       break;
 
     case AOP_STK:
       break;
 
     case AOP_STK:


@@ -1602,20 +1650,17 @@ aopPut (operand * result, const char *s, int offset, bool bvolatile)
 
     case AOP_STR:
       aop->coff = offset;
 
     case AOP_STR:
       aop->coff = offset;

-      if (strcmp (aop->aopu.aop_str[offset], s) ||
-          bvolatile)
+      if (strcmp (aop->aopu.aop_str[offset], s) || bvolatile)

         emitcode ("mov", "%s,%s", aop->aopu.aop_str[offset], s);
       break;
 
     case AOP_ACC:
       accuse = TRUE;
       aop->coff = offset;
         emitcode ("mov", "%s,%s", aop->aopu.aop_str[offset], s);
       break;
 
     case AOP_ACC:
       accuse = TRUE;
       aop->coff = offset;

-      if (!offset && (strcmp (s, "acc") == 0) &&
-          !bvolatile)
+      if (!offset && (strcmp (s, "acc") == 0) && !bvolatile)

         break;
 
         break;
 

-      if (strcmp (aop->aopu.aop_str[offset], s) &&
-          !bvolatile)
+      if (strcmp (aop->aopu.aop_str[offset], s) && !bvolatile)

         emitcode ("mov", "%s,%s", aop->aopu.aop_str[offset], s);
       break;
 
         emitcode ("mov", "%s,%s", aop->aopu.aop_str[offset], s);
       break;
 


@@ -1663,7 +1708,7 @@ pointToEnd (asmop * aop)
 static void
 reAdjustPreg (asmop * aop)
 {
 static void
 reAdjustPreg (asmop * aop)
 {

-  if ((aop->coff==0) || aop->size <= 1)
+  if ((aop->coff==0) || (aop->size <= 1))

     return;
 
   switch (aop->type)
     return;
 
   switch (aop->type)


@@ -1731,13 +1776,13 @@ outAcc (operand * result)
   size = getDataSize (result);
   if (size)
     {
   size = getDataSize (result);
   if (size)
     {

-      aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", 0);

       size--;
       offset = 1;
       /* unsigned or positive */
       while (size--)
         {
       size--;
       offset = 1;
       /* unsigned or positive */
       while (size--)
         {

-          aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
+          aopPut (result, zero, offset++);

         }
     }
 }
         }
     }
 }


@@ -1750,7 +1795,9 @@ outBitC (operand * result)
 {
   /* if the result is bit */
   if (AOP_TYPE (result) == AOP_CRY)
 {
   /* if the result is bit */
   if (AOP_TYPE (result) == AOP_CRY)

-    aopPut (result, "c", 0, isOperandVolatile (result, FALSE));
+    {
+      aopPut (result, "c", 0);
+    }

   else
     {
       emitcode ("clr", "a");
   else
     {
       emitcode ("clr", "a");


@@ -1809,7 +1856,7 @@ genNot (iCode * ic)
 {
   symbol *tlbl;
 
 {
   symbol *tlbl;
 

-  D(emitcode (";     genNot",""));
+  D (emitcode (";", "genNot"));

 
   /* assign asmOps to operand & result */
   aopOp (IC_LEFT (ic), ic, FALSE);
 
   /* assign asmOps to operand & result */
   aopOp (IC_LEFT (ic), ic, FALSE);


@@ -1904,7 +1951,7 @@ genCpl (iCode * ic)
       char *l = aopGet (IC_LEFT (ic), offset, FALSE, FALSE);
       MOVA (l);
       emitcode ("cpl", "a");
       char *l = aopGet (IC_LEFT (ic), offset, FALSE, FALSE);
       MOVA (l);
       emitcode ("cpl", "a");

-      aopPut (IC_RESULT (ic), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+      aopPut (IC_RESULT (ic), "a", offset++);

     }
 
 
     }
 
 


@@ -1923,7 +1970,7 @@ genUminusFloat (operand * op, operand * result)
   int size, offset = 0;
   char *l;
 
   int size, offset = 0;
   char *l;
 

-  D(emitcode (";     genUminusFloat",""));
+  D (emitcode (";", "genUminusFloat"));

 
   /* for this we just copy and then flip the bit */
 
 
   /* for this we just copy and then flip the bit */
 


@@ -1933,17 +1980,15 @@ genUminusFloat (operand * op, operand * result)
     {
       aopPut (result,
               aopGet (op, offset, FALSE, FALSE),
     {
       aopPut (result,
               aopGet (op, offset, FALSE, FALSE),

-              offset,
-              isOperandVolatile (result, FALSE));
+              offset);

       offset++;
     }
 
   l = aopGet (op, offset, FALSE, FALSE);
       offset++;
     }
 
   l = aopGet (op, offset, FALSE, FALSE);

-

   MOVA (l);
 
   emitcode ("cpl", "acc.7");
   MOVA (l);
 
   emitcode ("cpl", "acc.7");

-  aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+  aopPut (result, "a", offset);

 }
 
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/


@@ -1953,10 +1998,9 @@ static void
 genUminus (iCode * ic)
 {
   int offset, size;
 genUminus (iCode * ic)
 {
   int offset, size;

-  sym_link *optype, *rtype;
+  sym_link *optype;

 
 

-
-  D(emitcode (";     genUminus",""));
+  D (emitcode (";", "genUminus"));

 
   /* assign asmops */
   aopOp (IC_LEFT (ic), ic, FALSE);
 
   /* assign asmops */
   aopOp (IC_LEFT (ic), ic, FALSE);


@@ -1975,7 +2019,6 @@ genUminus (iCode * ic)
     }
 
   optype = operandType (IC_LEFT (ic));
     }
 
   optype = operandType (IC_LEFT (ic));

-  rtype = operandType (IC_RESULT (ic));

 
   /* if float then do float stuff */
   if (IS_FLOAT (optype))
 
   /* if float then do float stuff */
   if (IS_FLOAT (optype))


@@ -1987,7 +2030,6 @@ genUminus (iCode * ic)
   /* otherwise subtract from zero */
   size = AOP_SIZE (IC_LEFT (ic));
   offset = 0;
   /* otherwise subtract from zero */
   size = AOP_SIZE (IC_LEFT (ic));
   offset = 0;

-  //CLRC ;

   while (size--)
     {
       char *l = aopGet (IC_LEFT (ic), offset, FALSE, FALSE);
   while (size--)
     {
       char *l = aopGet (IC_LEFT (ic), offset, FALSE, FALSE);


@@ -2005,7 +2047,7 @@ genUminus (iCode * ic)
           emitcode ("clr", "a");
           emitcode ("subb", "a,%s", l);
         }
           emitcode ("clr", "a");
           emitcode ("subb", "a,%s", l);
         }

-      aopPut (IC_RESULT (ic), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+      aopPut (IC_RESULT (ic), "a", offset++);

     }
 
   /* if any remaining bytes in the result */
     }
 
   /* if any remaining bytes in the result */


@@ -2015,7 +2057,7 @@ genUminus (iCode * ic)
       emitcode ("rlc", "a");
       emitcode ("subb", "a,acc");
       while (size--)
       emitcode ("rlc", "a");
       emitcode ("subb", "a,acc");
       while (size--)

-        aopPut (IC_RESULT (ic), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+        aopPut (IC_RESULT (ic), "a", offset++);

     }
 
 release:
     }
 
 release:


@@ -2062,8 +2104,18 @@ saveRegisters (iCode * lic)
   ic->regsSaved = 1;
   if (options.useXstack)
     {
   ic->regsSaved = 1;
   if (options.useXstack)
     {

+      bitVect *rsavebits = bitVectIntersect (bitVectCopy (mcs51_allBitregs ()), rsave);
+      int nBits = bitVectnBitsOn (rsavebits);

       int count = bitVectnBitsOn (rsave);
 
       int count = bitVectnBitsOn (rsave);
 

+      if (nBits != 0)
+        {
+          count = count - nBits + 1;
+          /* remove all but the first bits as they are pushed all at once */
+          rsave = bitVectCplAnd (rsave, rsavebits);
+          rsave = bitVectSetBit (rsave, bitVectFirstBit (rsavebits));
+        }
+

       if (count == 1)
         {
           regs * reg = mcs51_regWithIdx (bitVectFirstBit (rsave));
       if (count == 1)
         {
           regs * reg = mcs51_regWithIdx (bitVectFirstBit (rsave));


@@ -2083,17 +2135,6 @@ saveRegisters (iCode * lic)
         }
       else if (count != 0)
         {
         }
       else if (count != 0)
         {

-          bitVect *rsavebits = bitVectIntersect (bitVectCopy (mcs51_allBitregs ()), rsave);
-          int nBits = bitVectnBitsOn (rsavebits);
-
-          if (nBits != 0)
-            {
-              count = count - nBits + 1;
-              /* remove all but the first bits as they are pushed all at once */
-              rsave = bitVectCplAnd (rsave, rsavebits);
-              rsave = bitVectSetBit (rsave, bitVectFirstBit (rsavebits));
-            }
-

           if (bitVectBitValue (rsave, R0_IDX))
             {
               emitcode ("push", "%s", mcs51_regWithIdx (R0_IDX)->dname);
           if (bitVectBitValue (rsave, R0_IDX))
             {
               emitcode ("push", "%s", mcs51_regWithIdx (R0_IDX)->dname);


@@ -2162,8 +2203,18 @@ unsaveRegisters (iCode * ic)
 
   if (options.useXstack)
     {
 
   if (options.useXstack)
     {

+      bitVect *rsavebits = bitVectIntersect (bitVectCopy (mcs51_allBitregs ()), rsave);
+      int nBits = bitVectnBitsOn (rsavebits);

       int count = bitVectnBitsOn (rsave);
 
       int count = bitVectnBitsOn (rsave);
 

+      if (nBits != 0)
+        {
+          count = count - nBits + 1;
+          /* remove all but the first bits as they are popped all at once */
+          rsave = bitVectCplAnd (rsave, rsavebits);
+          rsave = bitVectSetBit (rsave, bitVectFirstBit (rsavebits));
+        }
+

       if (count == 1)
         {
           regs * reg = mcs51_regWithIdx (bitVectFirstBit (rsave));
       if (count == 1)
         {
           regs * reg = mcs51_regWithIdx (bitVectFirstBit (rsave));


@@ -2182,17 +2233,6 @@ unsaveRegisters (iCode * ic)
         }
       else if (count != 0)
         {
         }
       else if (count != 0)
         {

-          bitVect *rsavebits = bitVectIntersect (bitVectCopy (mcs51_allBitregs ()), rsave);
-          int nBits = bitVectnBitsOn (rsavebits);
-
-          if (nBits != 0)
-            {
-              count = count - nBits + 1;
-              /* remove all but the first bits as they are popped all at once */
-              rsave = bitVectCplAnd (rsave, rsavebits);
-              rsave = bitVectSetBit (rsave, bitVectFirstBit (rsavebits));
-            }
-

           emitcode ("mov", "r0,%s", spname);
           for (i = mcs51_nRegs; i >= 0; i--)
             {
           emitcode ("mov", "r0,%s", spname);
           for (i = mcs51_nRegs; i >= 0; i--)
             {


@@ -2286,7 +2326,7 @@ assignResultValue (operand * oper, operand * func)
     {
       if ((offset == 3) && pushedA)
         emitcode ("pop", "acc");
     {
       if ((offset == 3) && pushedA)
         emitcode ("pop", "acc");

-      accuse |= aopPut (oper, fReturn[offset], offset, isOperandVolatile (oper, FALSE));
+      accuse |= aopPut (oper, fReturn[offset], offset);

       offset++;
     }
   return accuse;
       offset++;
     }
   return accuse;


@@ -2303,7 +2343,7 @@ genXpush (iCode * ic)
   regs *r;
   int size, offset = 0;
 
   regs *r;
   int size, offset = 0;
 

-  D(emitcode (";     genXpush",""));
+  D (emitcode (";", "genXpush"));

 
   aopOp (IC_LEFT (ic), ic, FALSE);
   r = getFreePtr (ic, &aop, FALSE);
 
   aopOp (IC_LEFT (ic), ic, FALSE);
   r = getFreePtr (ic, &aop, FALSE);


@@ -2347,7 +2387,7 @@ genIpush (iCode * ic)
   char *l;
   char *prev = "";
 
   char *l;
   char *prev = "";
 

-  D(emitcode (";     genIpush",""));
+  D (emitcode (";", "genIpush"));

 
   /* if this is not a parm push : ie. it is spill push
      and spill push is always done on the local stack */
 
   /* if this is not a parm push : ie. it is spill push
      and spill push is always done on the local stack */


@@ -2397,8 +2437,7 @@ genIpush (iCode * ic)
     {
       l = aopGet (IC_LEFT (ic), offset++, FALSE, TRUE);
       if (AOP_TYPE (IC_LEFT (ic)) != AOP_REG &&
     {
       l = aopGet (IC_LEFT (ic), offset++, FALSE, TRUE);
       if (AOP_TYPE (IC_LEFT (ic)) != AOP_REG &&

-          AOP_TYPE (IC_LEFT (ic)) != AOP_DIR &&
-          strcmp (l, "a"))
+          AOP_TYPE (IC_LEFT (ic)) != AOP_DIR)

         {
           if (strcmp (l, prev) || *l == '@')
             MOVA (l);
         {
           if (strcmp (l, prev) || *l == '@')
             MOVA (l);


@@ -2422,7 +2461,7 @@ genIpop (iCode * ic)
 {
   int size, offset;
 
 {
   int size, offset;
 

-  D(emitcode (";     genIpop",""));
+  D (emitcode (";", "genIpop"));

 
   /* if the temp was not pushed then */
   if (OP_SYMBOL (IC_LEFT (ic))->isspilt)
 
   /* if the temp was not pushed then */
   if (OP_SYMBOL (IC_LEFT (ic))->isspilt)


@@ -2432,8 +2471,10 @@ genIpop (iCode * ic)
   size = AOP_SIZE (IC_LEFT (ic));
   offset = (size - 1);
   while (size--)
   size = AOP_SIZE (IC_LEFT (ic));
   offset = (size - 1);
   while (size--)

-    emitcode ("pop", "%s", aopGet (IC_LEFT (ic), offset--,
-                                   FALSE, TRUE));
+    {
+      emitcode ("pop", "%s", aopGet (IC_LEFT (ic), offset--,
+                                     FALSE, TRUE));
+    }

 
   freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
 }
 
   freeAsmop (IC_LEFT (ic), NULL, ic, TRUE);
 }


@@ -2505,7 +2546,6 @@ saveRBank (int bank, iCode * ic, bool pushPsw)
         {
           emitcode ("mov", "a,psw");
           emitcode ("movx", "@%s,a", r->name);
         {
           emitcode ("mov", "a,psw");
           emitcode ("movx", "@%s,a", r->name);

-

         }
       else
         {
         }
       else
         {


@@ -2729,7 +2769,7 @@ genCall (iCode * ic)
   bool resultInF0 = FALSE;
   bool assignResultGenerated = FALSE;
 
   bool resultInF0 = FALSE;
   bool assignResultGenerated = FALSE;
 

-  D(emitcode(";     genCall",""));
+  D (emitcode (";", "genCall"));

 
   dtype = operandType (IC_LEFT (ic));
   etype = getSpec(dtype);
 
   dtype = operandType (IC_LEFT (ic));
   etype = getSpec(dtype);


@@ -2741,7 +2781,6 @@ genCall (iCode * ic)
         } else {
             genSend(_G.sendSet);
         }
         } else {
             genSend(_G.sendSet);
         }

-

       _G.sendSet = NULL;
     }
 
       _G.sendSet = NULL;
     }
 


@@ -2882,7 +2921,7 @@ genCall (iCode * ic)
 }
 
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/

-/* -10l - generates a call by pointer statement                */
+/* genPcall - generates a call by pointer statement                */

 /*-----------------------------------------------------------------*/
 static void
 genPcall (iCode * ic)
 /*-----------------------------------------------------------------*/
 static void
 genPcall (iCode * ic)


@@ -2894,7 +2933,7 @@ genPcall (iCode * ic)
   bool swapBanks = FALSE;
   bool resultInF0 = FALSE;
 
   bool swapBanks = FALSE;
   bool resultInF0 = FALSE;
 

-  D(emitcode(";     genPCall",""));
+  D (emitcode (";", "genPcall"));

 
   dtype = operandType (IC_LEFT (ic))->next;
   etype = getSpec(dtype);
 
   dtype = operandType (IC_LEFT (ic))->next;
   etype = getSpec(dtype);


@@ -3198,7 +3237,6 @@ genFunction (iCode * ic)
      save acc, b, dpl, dph  */
   if (IFFUNC_ISISR (sym->type))
     {
      save acc, b, dpl, dph  */
   if (IFFUNC_ISISR (sym->type))
     {

-

       if (!inExcludeList ("acc"))
         emitcode ("push", "acc");
       if (!inExcludeList ("b"))
       if (!inExcludeList ("acc"))
         emitcode ("push", "acc");
       if (!inExcludeList ("b"))


@@ -3212,14 +3250,13 @@ genFunction (iCode * ic)
          registers :-) */
       if (!FUNC_REGBANK (sym->type))
         {
          registers :-) */
       if (!FUNC_REGBANK (sym->type))
         {

+          int i;

 
           /* if this function does not call any other
              function then we can be economical and
              save only those registers that are used */
           if (!IFFUNC_HASFCALL(sym->type))
             {
 
           /* if this function does not call any other
              function then we can be economical and
              save only those registers that are used */
           if (!IFFUNC_HASFCALL(sym->type))
             {

-              int i;
-

               /* if any registers used */
               if (sym->regsUsed)
                 {
               /* if any registers used */
               if (sym->regsUsed)
                 {


@@ -3234,13 +3271,11 @@ genFunction (iCode * ic)
             }
           else
             {
             }
           else
             {

-

               /* this function has a function call. We cannot
               /* this function has a function call. We cannot

-                 determines register usage so we will have to push the
+                 determine register usage so we will have to push the

                  entire bank */
                 saveRBank (0, ic, FALSE);
                 if (options.parms_in_bank1) {
                  entire bank */
                 saveRBank (0, ic, FALSE);
                 if (options.parms_in_bank1) {

-                    int i;

                     for (i=0; i < 8 ; i++ ) {
                         emitcode ("push","%s",rb1regs[i]);
                     }
                     for (i=0; i < 8 ; i++ ) {
                         emitcode ("push","%s",rb1regs[i]);
                     }


@@ -3643,13 +3678,12 @@ genEndFunction (iCode * ic)
          registers :-) */
       if (!FUNC_REGBANK (sym->type))
         {
          registers :-) */
       if (!FUNC_REGBANK (sym->type))
         {

+          int i;

           /* if this function does not call any other
              function then we can be economical and
              save only those registers that are used */
           if (!IFFUNC_HASFCALL(sym->type))
             {
           /* if this function does not call any other
              function then we can be economical and
              save only those registers that are used */
           if (!IFFUNC_HASFCALL(sym->type))
             {

-              int i;
-

               /* if any registers used */
               if (sym->regsUsed)
                 {
               /* if any registers used */
               if (sym->regsUsed)
                 {


@@ -3665,7 +3699,6 @@ genEndFunction (iCode * ic)
           else
             {
               if (options.parms_in_bank1) {
           else
             {
               if (options.parms_in_bank1) {

-                  int i;

                   for (i = 7 ; i >= 0 ; i-- ) {
                       emitcode ("pop","%s",rb1regs[i]);
                   }
                   for (i = 7 ; i >= 0 ; i-- ) {
                       emitcode ("pop","%s",rb1regs[i]);
                   }


@@ -3864,7 +3897,7 @@ genRet (iCode * ic)
 {
   int size, offset = 0, pushed = 0;
 
 {
   int size, offset = 0, pushed = 0;
 

-  D(emitcode (";     genRet",""));
+  D (emitcode (";", "genRet"));

 
   /* if we have no return value then
      just generate the "ret" */
 
   /* if we have no return value then
      just generate the "ret" */


@@ -3876,7 +3909,6 @@ genRet (iCode * ic)
   aopOp (IC_LEFT (ic), ic, FALSE);
   size = AOP_SIZE (IC_LEFT (ic));
 
   aopOp (IC_LEFT (ic), ic, FALSE);
   size = AOP_SIZE (IC_LEFT (ic));
 

-

   if (IS_BIT(_G.currentFunc->etype))
     {
       movc (aopGet (IC_LEFT (ic), 0, FALSE, FALSE));
   if (IS_BIT(_G.currentFunc->etype))
     {
       movc (aopGet (IC_LEFT (ic), 0, FALSE, FALSE));


@@ -4091,8 +4123,8 @@ genPlusIncr (iCode * ic)
       if ((AOP_TYPE (IC_LEFT (ic)) != AOP_DIR) && (icount > 5))
         return FALSE;
 
       if ((AOP_TYPE (IC_LEFT (ic)) != AOP_DIR) && (icount > 5))
         return FALSE;
 

-      aopPut (IC_RESULT (ic), aopGet (IC_LEFT (ic), 0, FALSE, FALSE), 0, FALSE);
-      aopPut (IC_RESULT (ic), aopGet (IC_LEFT (ic), 1, FALSE, FALSE), 1, FALSE);
+      aopPut (IC_RESULT (ic), aopGet (IC_LEFT (ic), 0, FALSE, FALSE), 0);
+      aopPut (IC_RESULT (ic), aopGet (IC_LEFT (ic), 1, FALSE, FALSE), 1);

       while (icount--)
         emitcode ("inc", "dptr");
 
       while (icount--)
         emitcode ("inc", "dptr");
 


@@ -4119,7 +4151,7 @@ genPlusIncr (iCode * ic)
         {
           MOVA (aopGet (IC_LEFT (ic), 0, FALSE, FALSE));
           emitcode ("add", "a,#0x%02x", ((char) icount) & 0xff);
         {
           MOVA (aopGet (IC_LEFT (ic), 0, FALSE, FALSE));
           emitcode ("add", "a,#0x%02x", ((char) icount) & 0xff);

-          aopPut (IC_RESULT (ic), "a", 0, isOperandVolatile (IC_RESULT (ic), FALSE));
+          aopPut (IC_RESULT (ic), "a", 0);

         }
       else
         {
         }
       else
         {


@@ -4144,7 +4176,7 @@ outBitAcc (operand * result)
   /* if the result is a bit */
   if (AOP_TYPE (result) == AOP_CRY)
     {
   /* if the result is a bit */
   if (AOP_TYPE (result) == AOP_CRY)
     {

-      aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", 0);

     }
   else
     {
     }
   else
     {


@@ -4197,16 +4229,14 @@ adjustArithmeticResult (iCode * ic)
       !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic))))
     aopPut (IC_RESULT (ic),
             aopGet (IC_LEFT (ic)), 2, FALSE, FALSE),
       !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic))))
     aopPut (IC_RESULT (ic),
             aopGet (IC_LEFT (ic)), 2, FALSE, FALSE),

-            2,
-            isOperandVolatile (IC_RESULT (ic), FALSE));
+            2);

 
   if (AOP_SIZE (IC_RESULT (ic)) == 3 &&
       AOP_SIZE (IC_RIGHT (ic)) == 3 &&
       !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_RIGHT (ic))))
     aopPut (IC_RESULT (ic),
             aopGet (IC_RIGHT (ic)), 2, FALSE, FALSE),
 
   if (AOP_SIZE (IC_RESULT (ic)) == 3 &&
       AOP_SIZE (IC_RIGHT (ic)) == 3 &&
       !sameRegs (AOP (IC_RESULT (ic)), AOP (IC_RIGHT (ic))))
     aopPut (IC_RESULT (ic),
             aopGet (IC_RIGHT (ic)), 2, FALSE, FALSE),

-            2,
-            isOperandVolatile (IC_RESULT (ic), FALSE));
+            2);

 
   if (AOP_SIZE (IC_RESULT (ic)) == 3 &&
       AOP_SIZE (IC_LEFT (ic)) < 3 &&
 
   if (AOP_SIZE (IC_RESULT (ic)) == 3 &&
       AOP_SIZE (IC_LEFT (ic)) < 3 &&


@@ -4216,7 +4246,7 @@ adjustArithmeticResult (iCode * ic)
     {
       char buffer[5];
       sprintf (buffer, "#%d", pointerTypeToGPByte (pointerCode (getSpec (operandType (IC_LEFT (ic)))), NULL, NULL));
     {
       char buffer[5];
       sprintf (buffer, "#%d", pointerTypeToGPByte (pointerCode (getSpec (operandType (IC_LEFT (ic)))), NULL, NULL));

-      aopPut (IC_RESULT (ic), buffer, 2, isOperandVolatile (IC_RESULT (ic), FALSE));
+      aopPut (IC_RESULT (ic), buffer, 2);

     }
 }
 #else
     }
 }
 #else


@@ -4233,8 +4263,7 @@ adjustArithmeticResult (iCode * ic)
     {
       aopPut (IC_RESULT (ic),
               aopGet (IC_LEFT (ic), GPTRSIZE - 1, FALSE, FALSE),
     {
       aopPut (IC_RESULT (ic),
               aopGet (IC_LEFT (ic), GPTRSIZE - 1, FALSE, FALSE),

-              GPTRSIZE - 1,
-              isOperandVolatile (IC_RESULT (ic), FALSE));
+              GPTRSIZE - 1);

     }
 
   if (opIsGptr (IC_RESULT (ic)) &&
     }
 
   if (opIsGptr (IC_RESULT (ic)) &&


@@ -4243,8 +4272,7 @@ adjustArithmeticResult (iCode * ic)
     {
       aopPut (IC_RESULT (ic),
               aopGet (IC_RIGHT (ic), GPTRSIZE - 1, FALSE, FALSE),
     {
       aopPut (IC_RESULT (ic),
               aopGet (IC_RIGHT (ic), GPTRSIZE - 1, FALSE, FALSE),

-              GPTRSIZE - 1,
-              isOperandVolatile (IC_RESULT (ic), FALSE));
+              GPTRSIZE - 1);

     }
 
   if (opIsGptr (IC_RESULT (ic)) &&
     }
 
   if (opIsGptr (IC_RESULT (ic)) &&


@@ -4255,7 +4283,7 @@ adjustArithmeticResult (iCode * ic)
     {
       char buffer[5];
       sprintf (buffer, "#%d", pointerTypeToGPByte (pointerCode (getSpec (operandType (IC_LEFT (ic)))), NULL, NULL));
     {
       char buffer[5];
       sprintf (buffer, "#%d", pointerTypeToGPByte (pointerCode (getSpec (operandType (IC_LEFT (ic)))), NULL, NULL));

-      aopPut (IC_RESULT (ic), buffer, GPTRSIZE - 1, isOperandVolatile (IC_RESULT (ic), FALSE));
+      aopPut (IC_RESULT (ic), buffer, GPTRSIZE - 1);

     }
 }
 #endif
     }
 }
 #endif


@@ -4291,7 +4319,7 @@ genPlus (iCode * ic)
       operand *t = IC_RIGHT (ic);
       IC_RIGHT (ic) = IC_LEFT (ic);
       IC_LEFT (ic) = t;
       operand *t = IC_RIGHT (ic);
       IC_RIGHT (ic) = IC_LEFT (ic);
       IC_LEFT (ic) = t;

-         swappedLR = TRUE;
+      swappedLR = TRUE;

     }
 
   /* if both left & right are in bit
     }
 
   /* if both left & right are in bit


@@ -4322,7 +4350,7 @@ genPlus (iCode * ic)
             {
               MOVA (aopGet (IC_RIGHT (ic), offset, FALSE, FALSE));
               emitcode ("addc", "a,#00");
             {
               MOVA (aopGet (IC_RIGHT (ic), offset, FALSE, FALSE));
               emitcode ("addc", "a,#00");

-              aopPut (IC_RESULT (ic), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+              aopPut (IC_RESULT (ic), "a", offset++);

             }
         }
       goto release;
             }
         }
       goto release;


@@ -4351,21 +4379,19 @@ genPlus (iCode * ic)
       D(emitcode (";     genPlus aligned array",""));
       aopPut (IC_RESULT (ic),
               aopGet (rightOp, 0, FALSE, FALSE),
       D(emitcode (";     genPlus aligned array",""));
       aopPut (IC_RESULT (ic),
               aopGet (rightOp, 0, FALSE, FALSE),

-              0,
-              isOperandVolatile (IC_RESULT (ic), FALSE));
+              0);

 
       if( 1 == getDataSize (IC_RIGHT (ic)) )
         {
           aopPut (IC_RESULT (ic),
                   aopGet (leftOp, 1, FALSE, FALSE),
 
       if( 1 == getDataSize (IC_RIGHT (ic)) )
         {
           aopPut (IC_RESULT (ic),
                   aopGet (leftOp, 1, FALSE, FALSE),

-                  1,
-                  isOperandVolatile (IC_RESULT (ic), FALSE));
+                  1);

         }
       else
         {
           MOVA (aopGet (IC_LEFT (ic), 1, FALSE, FALSE));
           emitcode ("add", "a,%s", aopGet (rightOp, 1, FALSE, FALSE));
         }
       else
         {
           MOVA (aopGet (IC_LEFT (ic), 1, FALSE, FALSE));
           emitcode ("add", "a,%s", aopGet (rightOp, 1, FALSE, FALSE));

-          aopPut (IC_RESULT (ic), "a", 1, isOperandVolatile (IC_RESULT (ic), FALSE));
+          aopPut (IC_RESULT (ic), "a", 1);

         }
       goto release;
     }
         }
       goto release;
     }


@@ -4406,7 +4432,7 @@ genPlus (iCode * ic)
               MOVA (aopGet (rightOp, offset, FALSE, TRUE));
               emitcode (add, "a,%s", aopGet (leftOp, offset, FALSE, TRUE));
             }
               MOVA (aopGet (rightOp, offset, FALSE, TRUE));
               emitcode (add, "a,%s", aopGet (leftOp, offset, FALSE, TRUE));
             }

-          aopPut (IC_RESULT (ic), "a", offset, isOperandVolatile (IC_RESULT (ic), FALSE));
+          aopPut (IC_RESULT (ic), "a", offset);

           add = "addc";  /* further adds must propagate carry */
         }
       else
           add = "addc";  /* further adds must propagate carry */
         }
       else


@@ -4417,8 +4443,7 @@ genPlus (iCode * ic)
               /* just move */
               aopPut (IC_RESULT (ic),
                       aopGet (leftOp, offset, FALSE, FALSE),
               /* just move */
               aopPut (IC_RESULT (ic),
                       aopGet (leftOp, offset, FALSE, FALSE),

-                      offset,
-                      isOperandVolatile (IC_RESULT (ic), FALSE));
+                      offset);

             }
         }
       offset++;
             }
         }
       offset++;


@@ -4567,7 +4592,7 @@ genMinusDec (iCode * ic)
         emitcode ("dec", "%s", l);
 
       if (AOP_NEEDSACC (IC_RESULT (ic)))
         emitcode ("dec", "%s", l);
 
       if (AOP_NEEDSACC (IC_RESULT (ic)))

-        aopPut (IC_RESULT (ic), "a", 0, isOperandVolatile (IC_RESULT (ic), FALSE));
+        aopPut (IC_RESULT (ic), "a", 0);

 
       return TRUE;
     }
 
       return TRUE;
     }


@@ -4589,11 +4614,11 @@ addSign (operand * result, int offset, int sign)
           emitcode ("rlc", "a");
           emitcode ("subb", "a,acc");
           while (size--)
           emitcode ("rlc", "a");
           emitcode ("subb", "a,acc");
           while (size--)

-            aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
+            aopPut (result, "a", offset++);

         }
       else
         while (size--)
         }
       else
         while (size--)

-          aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
+          aopPut (result, zero, offset++);

     }
 }
 
     }
 }
 


@@ -4622,7 +4647,7 @@ genMinusBits (iCode * ic)
       emitcode ("jnb", "%s,%05d$", AOP (IC_LEFT (ic))->aopu.aop_dir, (lbl->key + 100));
       emitcode ("inc", "a");
       emitcode ("", "%05d$:", (lbl->key + 100));
       emitcode ("jnb", "%s,%05d$", AOP (IC_LEFT (ic))->aopu.aop_dir, (lbl->key + 100));
       emitcode ("inc", "a");
       emitcode ("", "%05d$:", (lbl->key + 100));

-      aopPut (IC_RESULT (ic), "a", 0, isOperandVolatile (IC_RESULT (ic), FALSE));
+      aopPut (IC_RESULT (ic), "a", 0);

       addSign (IC_RESULT (ic), MSB16, SPEC_USIGN (getSpec (operandType (IC_RESULT (ic)))));
     }
 }
       addSign (IC_RESULT (ic), MSB16, SPEC_USIGN (getSpec (operandType (IC_RESULT (ic)))));
     }
 }


@@ -4687,7 +4712,7 @@ genMinus (iCode * ic)
                   emitcode ("addc", "a,#0x%02x",
                             (unsigned int) ((lit >> (offset * 8)) & 0x0FFL));
                 }
                   emitcode ("addc", "a,#0x%02x",
                             (unsigned int) ((lit >> (offset * 8)) & 0x0FFL));
                 }

-              aopPut (IC_RESULT (ic), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+              aopPut (IC_RESULT (ic), "a", offset++);

             }
           else
             {
             }
           else
             {


@@ -4695,7 +4720,7 @@ genMinus (iCode * ic)
               if (!sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic))))
                 {
                   aopPut (IC_RESULT (ic), aopGet (IC_LEFT (ic), offset, FALSE, FALSE),
               if (!sameRegs (AOP (IC_RESULT (ic)), AOP (IC_LEFT (ic))))
                 {
                   aopPut (IC_RESULT (ic), aopGet (IC_LEFT (ic), offset, FALSE, FALSE),

-                          offset, isOperandVolatile (IC_RESULT (ic), FALSE));
+                          offset);

                 }
               offset++;
             }
                 }
               offset++;
             }


@@ -4743,11 +4768,10 @@ genMinus (iCode * ic)
                       aopGet(rightOp, offset, FALSE, TRUE));
           }
 
                       aopGet(rightOp, offset, FALSE, TRUE));
           }
 

-          aopPut (IC_RESULT (ic), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+          aopPut (IC_RESULT (ic), "a", offset++);

         }
     }
 
         }
     }
 

-

   adjustArithmeticResult (ic);
 
 release:
   adjustArithmeticResult (ic);
 
 release:


@@ -4840,9 +4864,9 @@ genMultOneByte (operand * left,
         }
 
       emitcode ("mul", "ab");
         }
 
       emitcode ("mul", "ab");

-      aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", 0);

       if (size == 2)
       if (size == 2)

-        aopPut (result, "b", 1, isOperandVolatile (result, FALSE));
+        aopPut (result, "b", 1);

 
       popB (pushedB);
       return;
 
       popB (pushedB);
       return;


@@ -4909,7 +4933,6 @@ genMultOneByte (operand * left,
   else /* ! literal */
     {
       if (rUnsigned)  /* emitcode (";", "signed"); */
   else /* ! literal */
     {
       if (rUnsigned)  /* emitcode (";", "signed"); */

-

         emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
       else
         {
         emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
       else
         {


@@ -4968,9 +4991,9 @@ genMultOneByte (operand * left,
         }
       emitcode ("", "%05d$:", (lbl->key + 100));
     }
         }
       emitcode ("", "%05d$:", (lbl->key + 100));
     }

-  aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+  aopPut (result, "a", 0);

   if (size == 2)
   if (size == 2)

-    aopPut (result, "b", 1, isOperandVolatile (result, FALSE));
+    aopPut (result, "b", 1);

 
   popB (pushedB);
 }
 
   popB (pushedB);
 }


@@ -5050,7 +5073,7 @@ genDivbits (operand * left,
 
   popB (pushedB);
 
 
   popB (pushedB);
 

-  aopPut (result, "c", 0, isOperandVolatile (result, FALSE));
+  aopPut (result, "c", 0);

 }
 
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/


@@ -5110,9 +5133,9 @@ genDivOneByte (operand * left,
       emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
       MOVA (aopGet (left, 0, FALSE, FALSE));
       emitcode ("div", "ab");
       emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
       MOVA (aopGet (left, 0, FALSE, FALSE));
       emitcode ("div", "ab");

-      aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", 0);

       while (size--)
       while (size--)

-        aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
+        aopPut (result, zero, offset++);

 
       popB (pushedB);
       return;
 
       popB (pushedB);
       return;


@@ -5228,7 +5251,7 @@ genDivOneByte (operand * left,
       emitcode ("inc", "a");
       emitcode ("", "%05d$:", (lbl->key + 100));
 
       emitcode ("inc", "a");
       emitcode ("", "%05d$:", (lbl->key + 100));
 

-      accuse = aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+      accuse = aopPut (result, "a", 0);

       if (size > 0)
         {
           /* msb is 0x00 or 0xff depending on the sign */
       if (size > 0)
         {
           /* msb is 0x00 or 0xff depending on the sign */


@@ -5242,7 +5265,7 @@ genDivOneByte (operand * left,
               emitcode ("mov", "c,F0");
               emitcode ("subb", "a,acc");
               while (size--)
               emitcode ("mov", "c,F0");
               emitcode ("subb", "a,acc");
               while (size--)

-                aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
+                aopPut (result, "a", offset++);

             }
           else /* compiletimeSign */
             {
             }
           else /* compiletimeSign */
             {


@@ -5252,15 +5275,15 @@ genDivOneByte (operand * left,
                   pushedA = TRUE;
                 }
               while (size--)
                   pushedA = TRUE;
                 }
               while (size--)

-                aopPut (result, "#0xff", offset++, isOperandVolatile (result, FALSE));
+                aopPut (result, "#0xff", offset++);

             }
         }
     }
   else
     {
             }
         }
     }
   else
     {

-      aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", 0);

       while (size--)
       while (size--)

-        aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
+        aopPut (result, zero, offset++);

     }
 
   if (pushedA)
     }
 
   if (pushedA)


@@ -5337,7 +5360,7 @@ genModbits (operand * left,
 
   popB (pushedB);
 
 
   popB (pushedB);
 

-  aopPut (result, "c", 0, isOperandVolatile (result, FALSE));
+  aopPut (result, "c", 0);

 }
 
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/


@@ -5394,16 +5417,16 @@ genModOneByte (operand * left,
                 int size2 = size;
                 int offs2 = offset;
 
                 int size2 = size;
                 int offs2 = offset;
 

-                aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+                aopPut (result, "a", 0);

                 while (size2--)
                 while (size2--)

-                  aopPut (result, "#0xff", offs2++, isOperandVolatile (result, FALSE));
+                  aopPut (result, "#0xff", offs2++);

                 lbl2 = newiTempLabel (NULL);
                 emitcode ("sjmp", "%05d$", (lbl2->key + 100));
               }
             emitcode ("", "%05d$:", (lbl->key + 100));
                 lbl2 = newiTempLabel (NULL);
                 emitcode ("sjmp", "%05d$", (lbl2->key + 100));
               }
             emitcode ("", "%05d$:", (lbl->key + 100));

-            aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+            aopPut (result, "a", 0);

             while (size--)
             while (size--)

-              aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
+              aopPut (result, zero, offset++);

             if (lbl2)
               {
                 emitcode ("", "%05d$:", (lbl2->key + 100));
             if (lbl2)
               {
                 emitcode ("", "%05d$:", (lbl2->key + 100));


@@ -5424,9 +5447,9 @@ genModOneByte (operand * left,
       emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
       MOVA (aopGet (left, 0, FALSE, FALSE));
       emitcode ("div", "ab");
       emitcode ("mov", "b,%s", aopGet (right, 0, FALSE, FALSE));
       MOVA (aopGet (left, 0, FALSE, FALSE));
       emitcode ("div", "ab");

-      aopPut (result, "b", 0, isOperandVolatile (result, FALSE));
+      aopPut (result, "b", 0);

       while (size--)
       while (size--)

-        aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
+        aopPut (result, zero, offset++);

 
       popB (pushedB);
       return;
 
       popB (pushedB);
       return;


@@ -5512,7 +5535,7 @@ genModOneByte (operand * left,
       emitcode ("inc", "a");
       emitcode ("", "%05d$:", (lbl->key + 100));
 
       emitcode ("inc", "a");
       emitcode ("", "%05d$:", (lbl->key + 100));
 

-      aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", 0);

       if (size > 0)
         {
           /* msb is 0x00 or 0xff depending on the sign */
       if (size > 0)
         {
           /* msb is 0x00 or 0xff depending on the sign */


@@ -5521,18 +5544,18 @@ genModOneByte (operand * left,
               emitcode ("mov", "c,F0");
               emitcode ("subb", "a,acc");
               while (size--)
               emitcode ("mov", "c,F0");
               emitcode ("subb", "a,acc");
               while (size--)

-                aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
+                aopPut (result, "a", offset++);

             }
           else /* compiletimeSign */
             while (size--)
             }
           else /* compiletimeSign */
             while (size--)

-              aopPut (result, "#0xff", offset++, isOperandVolatile (result, FALSE));
+              aopPut (result, "#0xff", offset++);

         }
     }
   else
     {
         }
     }
   else
     {

-      aopPut (result, "b", 0, isOperandVolatile (result, FALSE));
+      aopPut (result, "b", 0);

       while (size--)
       while (size--)

-        aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
+        aopPut (result, zero, offset++);

     }
 
   popB (pushedB);
     }
 
   popB (pushedB);


@@ -5937,7 +5960,7 @@ genCmpEq (iCode * ic, iCode * ifx)
       operand *t = IC_RIGHT (ic);
       IC_RIGHT (ic) = IC_LEFT (ic);
       IC_LEFT (ic) = t;
       operand *t = IC_RIGHT (ic);
       IC_RIGHT (ic) = IC_LEFT (ic);
       IC_LEFT (ic) = t;

-         swappedLR = TRUE;
+      swappedLR = TRUE;

     }
 
   if (ifx && !AOP_SIZE (result))
     }
 
   if (ifx && !AOP_SIZE (result))


@@ -6073,7 +6096,7 @@ genCmpEq (iCode * ic, iCode * ifx)
       gencjne (left, right, newiTempLabel (NULL));
       if (AOP_TYPE (result) == AOP_CRY && AOP_SIZE (result))
         {
       gencjne (left, right, newiTempLabel (NULL));
       if (AOP_TYPE (result) == AOP_CRY && AOP_SIZE (result))
         {

-          aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+          aopPut (result, "a", 0);

           goto release;
         }
       if (ifx)
           goto release;
         }
       if (ifx)


@@ -6534,13 +6557,13 @@ genAnd (iCode * ic, iCode * ifx)
                 }
               else if (bytelit == 0)
                 {
                 }
               else if (bytelit == 0)
                 {

-                  aopPut (result, zero, offset, isOperandVolatile (result, FALSE));
+                  aopPut (result, zero, offset);

                 }
               else if (IS_AOP_PREG (result))
                 {
                   MOVA (aopGet (left, offset, FALSE, TRUE));
                   emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));
                 }
               else if (IS_AOP_PREG (result))
                 {
                   MOVA (aopGet (left, offset, FALSE, TRUE));
                   emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));

-                  aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+                  aopPut (result, "a", offset);

                 }
               else
                 emitcode ("anl", "%s,%s",
                 }
               else
                 emitcode ("anl", "%s,%s",


@@ -6560,13 +6583,13 @@ genAnd (iCode * ic, iCode * ifx)
                   emitcode ("mov", "b,%s", aopGet (left, offset, FALSE, FALSE));
                   MOVA (aopGet (right, offset, FALSE, FALSE));
                   emitcode ("anl", "a,b");
                   emitcode ("mov", "b,%s", aopGet (left, offset, FALSE, FALSE));
                   MOVA (aopGet (right, offset, FALSE, FALSE));
                   emitcode ("anl", "a,b");

-                  aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+                  aopPut (result, "a", offset);

                 }
               else if (aopGetUsesAcc (left, offset))
                 {
                   MOVA (aopGet (left, offset, FALSE, FALSE));
                   emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));
                 }
               else if (aopGetUsesAcc (left, offset))
                 {
                   MOVA (aopGet (left, offset, FALSE, FALSE));
                   emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));

-                  aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+                  aopPut (result, "a", offset);

                 }
               else
                 {
                 }
               else
                 {


@@ -6574,7 +6597,7 @@ genAnd (iCode * ic, iCode * ifx)
                   if (IS_AOP_PREG (result))
                     {
                       emitcode ("anl", "a,%s", aopGet (left, offset, FALSE, TRUE));
                   if (IS_AOP_PREG (result))
                     {
                       emitcode ("anl", "a,%s", aopGet (left, offset, FALSE, TRUE));

-                      aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+                      aopPut (result, "a", offset);

                     }
                   else
                     emitcode ("anl", "%s,a",
                     }
                   else
                     emitcode ("anl", "%s,a",


@@ -6653,8 +6676,7 @@ genAnd (iCode * ic, iCode * ifx)
                     {
                       aopPut (result,
                               aopGet (left, offset, FALSE, FALSE),
                     {
                       aopPut (result,
                               aopGet (left, offset, FALSE, FALSE),

-                              offset,
-                              isOperandVolatile (result, FALSE));
+                              offset);

                       continue;
                     }
                   else if (bytelit == 0)
                       continue;
                     }
                   else if (bytelit == 0)


@@ -6662,7 +6684,7 @@ genAnd (iCode * ic, iCode * ifx)
                       /* dummy read of volatile operand */
                       if (isOperandVolatile (left, FALSE))
                         MOVA (aopGet (left, offset, FALSE, FALSE));
                       /* dummy read of volatile operand */
                       if (isOperandVolatile (left, FALSE))
                         MOVA (aopGet (left, offset, FALSE, FALSE));

-                      aopPut (result, zero, offset, isOperandVolatile (result, FALSE));
+                      aopPut (result, zero, offset);

                       continue;
                     }
                   else if (AOP_TYPE (left) == AOP_ACC)
                       continue;
                     }
                   else if (AOP_TYPE (left) == AOP_ACC)


@@ -6670,13 +6692,13 @@ genAnd (iCode * ic, iCode * ifx)
                       if (!offset)
                         {
                           emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));
                       if (!offset)
                         {
                           emitcode ("anl", "a,%s", aopGet (right, offset, FALSE, FALSE));

-                          aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+                          aopPut (result, "a", offset);

                           continue;
                         }
                       else
                         {
                           emitcode ("anl", "b,%s", aopGet (right, offset, FALSE, FALSE));
                           continue;
                         }
                       else
                         {
                           emitcode ("anl", "b,%s", aopGet (right, offset, FALSE, FALSE));

-                          aopPut (result, "b", offset, isOperandVolatile (result, FALSE));
+                          aopPut (result, "b", offset);

                           continue;
                         }
                     }
                           continue;
                         }
                     }


@@ -6705,7 +6727,7 @@ genAnd (iCode * ic, iCode * ifx)
                   MOVA (aopGet (right, offset, FALSE, FALSE));
                   emitcode ("anl", "a,%s", aopGet (left, offset, FALSE, FALSE));
                 }
                   MOVA (aopGet (right, offset, FALSE, FALSE));
                   emitcode ("anl", "a,%s", aopGet (left, offset, FALSE, FALSE));
                 }

-              aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+              aopPut (result, "a", offset);

             }
         }
     }
             }
         }
     }


@@ -6896,13 +6918,13 @@ genOr (iCode * ic, iCode * ifx)
                 }
               else if (bytelit == 0x0FF)
                 {
                 }
               else if (bytelit == 0x0FF)
                 {

-                  aopPut (result, "#0xFF", offset, isOperandVolatile (result, FALSE));
+                  aopPut (result, "#0xFF", offset);

                 }
               else if (IS_AOP_PREG (left))
                 {
                   MOVA (aopGet (left, offset, FALSE, TRUE));
                   emitcode ("orl", "a,%s", aopGet (right, offset, FALSE, FALSE));
                 }
               else if (IS_AOP_PREG (left))
                 {
                   MOVA (aopGet (left, offset, FALSE, TRUE));
                   emitcode ("orl", "a,%s", aopGet (right, offset, FALSE, FALSE));

-                  aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+                  aopPut (result, "a", offset);

                 }
               else
                 {
                 }
               else
                 {


@@ -6924,13 +6946,13 @@ genOr (iCode * ic, iCode * ifx)
                   emitcode ("mov", "b,%s", aopGet (left, offset, FALSE, FALSE));
                   MOVA (aopGet (right, offset, FALSE, FALSE));
                   emitcode ("orl", "a,b");
                   emitcode ("mov", "b,%s", aopGet (left, offset, FALSE, FALSE));
                   MOVA (aopGet (right, offset, FALSE, FALSE));
                   emitcode ("orl", "a,b");

-                  aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+                  aopPut (result, "a", offset);

                 }
               else if (aopGetUsesAcc (left, offset))
                 {
                   MOVA (aopGet (left, offset, FALSE, FALSE));
                   emitcode ("orl", "a,%s", aopGet (right, offset, FALSE, FALSE));
                 }
               else if (aopGetUsesAcc (left, offset))
                 {
                   MOVA (aopGet (left, offset, FALSE, FALSE));
                   emitcode ("orl", "a,%s", aopGet (right, offset, FALSE, FALSE));

-                  aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+                  aopPut (result, "a", offset);

                 }
               else
                 {
                 }
               else
                 {


@@ -6938,7 +6960,7 @@ genOr (iCode * ic, iCode * ifx)
                   if (IS_AOP_PREG (left))
                     {
                       emitcode ("orl", "a,%s", aopGet (left, offset, FALSE, TRUE));
                   if (IS_AOP_PREG (left))
                     {
                       emitcode ("orl", "a,%s", aopGet (left, offset, FALSE, TRUE));

-                      aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+                      aopPut (result, "a", offset);

                     }
                   else
                     {
                     }
                   else
                     {


@@ -7000,8 +7022,7 @@ genOr (iCode * ic, iCode * ifx)
                     {
                       aopPut (result,
                               aopGet (left, offset, FALSE, FALSE),
                     {
                       aopPut (result,
                               aopGet (left, offset, FALSE, FALSE),

-                              offset,
-                              isOperandVolatile (result, FALSE));
+                              offset);

                       continue;
                     }
                   else if (bytelit == 0x0FF)
                       continue;
                     }
                   else if (bytelit == 0x0FF)


@@ -7009,7 +7030,7 @@ genOr (iCode * ic, iCode * ifx)
                       /* dummy read of volatile operand */
                       if (isOperandVolatile (left, FALSE))
                         MOVA (aopGet (left, offset, FALSE, FALSE));
                       /* dummy read of volatile operand */
                       if (isOperandVolatile (left, FALSE))
                         MOVA (aopGet (left, offset, FALSE, FALSE));

-                      aopPut (result, "#0xFF", offset, isOperandVolatile (result, FALSE));
+                      aopPut (result, "#0xFF", offset);

                       continue;
                     }
                 }
                       continue;
                     }
                 }


@@ -7037,7 +7058,7 @@ genOr (iCode * ic, iCode * ifx)
                   MOVA (aopGet (right, offset, FALSE, FALSE));
                   emitcode ("orl", "a,%s", aopGet (left, offset, FALSE, FALSE));
                 }
                   MOVA (aopGet (right, offset, FALSE, FALSE));
                   emitcode ("orl", "a,%s", aopGet (left, offset, FALSE, FALSE));
                 }

-              aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+              aopPut (result, "a", offset);

             }
         }
     }
             }
         }
     }


@@ -7213,7 +7234,7 @@ genXor (iCode * ic, iCode * ifx)
                 {
                   MOVA (aopGet (left, offset, FALSE, TRUE));
                   emitcode ("xrl", "a,%s", aopGet (right, offset, FALSE, FALSE));
                 {
                   MOVA (aopGet (left, offset, FALSE, TRUE));
                   emitcode ("xrl", "a,%s", aopGet (right, offset, FALSE, FALSE));

-                  aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+                  aopPut (result, "a", offset);

                 }
               else
                 {
                 }
               else
                 {


@@ -7235,13 +7256,13 @@ genXor (iCode * ic, iCode * ifx)
                   emitcode ("mov", "b,%s", aopGet (left, offset, FALSE, FALSE));
                   MOVA (aopGet (right, offset, FALSE, FALSE));
                   emitcode ("xrl", "a,b");
                   emitcode ("mov", "b,%s", aopGet (left, offset, FALSE, FALSE));
                   MOVA (aopGet (right, offset, FALSE, FALSE));
                   emitcode ("xrl", "a,b");

-                  aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+                  aopPut (result, "a", offset);

                 }
               else if (aopGetUsesAcc (left, offset))
                 {
                   MOVA (aopGet (left, offset, FALSE, FALSE));
                   emitcode ("xrl", "a,%s", aopGet (right, offset, FALSE, FALSE));
                 }
               else if (aopGetUsesAcc (left, offset))
                 {
                   MOVA (aopGet (left, offset, FALSE, FALSE));
                   emitcode ("xrl", "a,%s", aopGet (right, offset, FALSE, FALSE));

-                  aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+                  aopPut (result, "a", offset);

                 }
               else
                 {
                 }
               else
                 {


@@ -7249,7 +7270,7 @@ genXor (iCode * ic, iCode * ifx)
                   if (IS_AOP_PREG (left))
                     {
                       emitcode ("xrl", "a,%s", aopGet (left, offset, FALSE, TRUE));
                   if (IS_AOP_PREG (left))
                     {
                       emitcode ("xrl", "a,%s", aopGet (left, offset, FALSE, TRUE));

-                      aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+                      aopPut (result, "a", offset);

                     }
                   else
                     emitcode ("xrl", "%s,a",
                     }
                   else
                     emitcode ("xrl", "%s,a",


@@ -7315,8 +7336,7 @@ genXor (iCode * ic, iCode * ifx)
                     {
                       aopPut (result,
                               aopGet (left, offset, FALSE, FALSE),
                     {
                       aopPut (result,
                               aopGet (left, offset, FALSE, FALSE),

-                              offset,
-                              isOperandVolatile (result, FALSE));
+                              offset);

                       continue;
                     }
                 }
                       continue;
                     }
                 }


@@ -7344,7 +7364,7 @@ genXor (iCode * ic, iCode * ifx)
                   MOVA (aopGet (right, offset, FALSE, FALSE));
                   emitcode ("xrl", "a,%s", aopGet (left, offset, FALSE, TRUE));
                 }
                   MOVA (aopGet (right, offset, FALSE, FALSE));
                   emitcode ("xrl", "a,%s", aopGet (left, offset, FALSE, TRUE));
                 }

-              aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+              aopPut (result, "a", offset);

             }
         }
     }
             }
         }
     }


@@ -7363,12 +7383,11 @@ genInline (iCode * ic)
 {
   char *buffer, *bp, *bp1;
 
 {
   char *buffer, *bp, *bp1;
 

-  D(emitcode (";     genInline",""));
+  D (emitcode (";", "genInline"));

 
   _G.inLine += (!options.asmpeep);
 
 
   _G.inLine += (!options.asmpeep);
 

-  buffer = bp = bp1 = Safe_calloc(1, strlen(IC_INLINE(ic))+1);
-  strcpy (buffer, IC_INLINE (ic));
+  buffer = bp = bp1 = Safe_strdup(IC_INLINE(ic));

 
   /* emit each line as a code */
   while (*bp)
 
   /* emit each line as a code */
   while (*bp)


@@ -7434,7 +7453,7 @@ genRRC (iCode * ic)
       MOVA (l);
       emitcode ("rrc", "a");
       if (AOP_SIZE (result) > 1)
       MOVA (l);
       emitcode ("rrc", "a");
       if (AOP_SIZE (result) > 1)

-        aopPut (result, "a", offset--, isOperandVolatile (result, FALSE));
+        aopPut (result, "a", offset--);

     }
   /* now we need to put the carry into the
      highest order byte of the result */
     }
   /* now we need to put the carry into the
      highest order byte of the result */


@@ -7445,7 +7464,7 @@ genRRC (iCode * ic)
     }
   emitcode ("mov", "acc.7,c");
  release:
     }
   emitcode ("mov", "acc.7,c");
  release:

-  aopPut (result, "a", AOP_SIZE (result) - 1, isOperandVolatile (result, FALSE));
+  aopPut (result, "a", AOP_SIZE (result) - 1);

   freeAsmop (result, NULL, ic, TRUE);
   freeAsmop (left, NULL, ic, TRUE);
 }
   freeAsmop (result, NULL, ic, TRUE);
   freeAsmop (left, NULL, ic, TRUE);
 }


@@ -7481,14 +7500,14 @@ genRLC (iCode * ic)
       }
       emitcode("rlc","a"); /* bit0 will be written later */
       if (AOP_SIZE (result) > 1)
       }
       emitcode("rlc","a"); /* bit0 will be written later */
       if (AOP_SIZE (result) > 1)

-        aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
+        aopPut (result, "a", offset++);

       while (size--)
         {
           l = aopGet (left, offset, FALSE, FALSE);
           MOVA (l);
           emitcode ("rlc", "a");
           if (AOP_SIZE (result) > 1)
       while (size--)
         {
           l = aopGet (left, offset, FALSE, FALSE);
           MOVA (l);
           emitcode ("rlc", "a");
           if (AOP_SIZE (result) > 1)

-            aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
+            aopPut (result, "a", offset++);

         }
     }
   /* now we need to put the carry into the
         }
     }
   /* now we need to put the carry into the


@@ -7500,7 +7519,7 @@ genRLC (iCode * ic)
     }
   emitcode ("mov", "acc.0,c");
  release:
     }
   emitcode ("mov", "acc.0,c");
  release:

-  aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+  aopPut (result, "a", 0);

   freeAsmop (result, NULL, ic, TRUE);
   freeAsmop (left, NULL, ic, TRUE);
 }
   freeAsmop (result, NULL, ic, TRUE);
   freeAsmop (left, NULL, ic, TRUE);
 }


@@ -7631,8 +7650,7 @@ genGetByte (iCode * ic)
   offset = (int)floatFromVal (AOP (right)->aopu.aop_lit) / 8;
   aopPut (result,
           aopGet (left, offset, FALSE, FALSE),
   offset = (int)floatFromVal (AOP (right)->aopu.aop_lit) / 8;
   aopPut (result,
           aopGet (left, offset, FALSE, FALSE),

-          0,
-          isOperandVolatile (result, FALSE));
+          0);

 
   freeAsmop (result, NULL, ic, TRUE);
   freeAsmop (right, NULL, ic, TRUE);
 
   freeAsmop (result, NULL, ic, TRUE);
   freeAsmop (right, NULL, ic, TRUE);


@@ -7660,12 +7678,10 @@ genGetWord (iCode * ic)
   offset = (int)floatFromVal (AOP (right)->aopu.aop_lit) / 8;
   aopPut (result,
           aopGet (left, offset, FALSE, FALSE),
   offset = (int)floatFromVal (AOP (right)->aopu.aop_lit) / 8;
   aopPut (result,
           aopGet (left, offset, FALSE, FALSE),

-          0,
-          isOperandVolatile (result, FALSE));
+          0);

   aopPut (result,
           aopGet (left, offset+1, FALSE, FALSE),
   aopPut (result,
           aopGet (left, offset+1, FALSE, FALSE),

-          1,
-          isOperandVolatile (result, FALSE));
+          1);

 
   freeAsmop (result, NULL, ic, TRUE);
   freeAsmop (right, NULL, ic, TRUE);
 
   freeAsmop (result, NULL, ic, TRUE);
   freeAsmop (right, NULL, ic, TRUE);


@@ -7692,15 +7708,14 @@ genSwap (iCode * ic)
     case 1: /* swap nibbles in byte */
       MOVA (aopGet (left, 0, FALSE, FALSE));
       emitcode ("swap", "a");
     case 1: /* swap nibbles in byte */
       MOVA (aopGet (left, 0, FALSE, FALSE));
       emitcode ("swap", "a");

-      aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", 0);

       break;
     case 2: /* swap bytes in word */
       if (AOP_TYPE(left) == AOP_REG && sameRegs(AOP(left), AOP(result)))
         {
           MOVA (aopGet (left, 0, FALSE, FALSE));
       break;
     case 2: /* swap bytes in word */
       if (AOP_TYPE(left) == AOP_REG && sameRegs(AOP(left), AOP(result)))
         {
           MOVA (aopGet (left, 0, FALSE, FALSE));

-          aopPut (result, aopGet (left, 1, FALSE, FALSE),
-                  0, isOperandVolatile (result, FALSE));
-          aopPut (result, "a", 1, isOperandVolatile (result, FALSE));
+          aopPut (result, aopGet (left, 1, FALSE, FALSE), 0);
+          aopPut (result, "a", 1);

         }
       else if (operandsEqu (left, result))
         {
         }
       else if (operandsEqu (left, result))
         {


@@ -7715,19 +7730,16 @@ genSwap (iCode * ic)
               reg = "b";
               leftInB = TRUE;
             }
               reg = "b";
               leftInB = TRUE;
             }

-          aopPut (result, aopGet (left, 1, FALSE, FALSE),
-                  0, isOperandVolatile (result, FALSE));
-          aopPut (result, reg, 1, isOperandVolatile (result, FALSE));
+          aopPut (result, aopGet (left, 1, FALSE, FALSE), 0);
+          aopPut (result, reg, 1);

 
           if (leftInB)
             popB (pushedB);
         }
       else
         {
 
           if (leftInB)
             popB (pushedB);
         }
       else
         {

-          aopPut (result, aopGet (left, 1, FALSE, FALSE),
-                  0, isOperandVolatile (result, FALSE));
-          aopPut (result, aopGet (left, 0, FALSE, FALSE),
-                  1, isOperandVolatile (result, FALSE));
+          aopPut (result, aopGet (left, 1, FALSE, FALSE), 0);
+          aopPut (result, aopGet (left, 0, FALSE, FALSE), 1);

         }
       break;
     default:
         }
       break;
     default:


@@ -7738,7 +7750,6 @@ genSwap (iCode * ic)
   freeAsmop (left, NULL, ic, TRUE);
 }
 
   freeAsmop (left, NULL, ic, TRUE);
 }
 

-

 /*-----------------------------------------------------------------*/
 /* AccRol - rotate left accumulator by known count                 */
 /*-----------------------------------------------------------------*/
 /*-----------------------------------------------------------------*/
 /* AccRol - rotate left accumulator by known count                 */
 /*-----------------------------------------------------------------*/


@@ -7877,7 +7888,7 @@ shiftR1Left2Result (operand * left, int offl,
     AccSRsh (shCount);
   else
     AccRsh (shCount);
     AccSRsh (shCount);
   else
     AccRsh (shCount);

-  aopPut (result, "a", offr, isOperandVolatile (result, FALSE));
+  aopPut (result, "a", offr);

 }
 
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/


@@ -7892,7 +7903,7 @@ shiftL1Left2Result (operand * left, int offl,
   MOVA (l);
   /* shift left accumulator */
   AccLsh (shCount);
   MOVA (l);
   /* shift left accumulator */
   AccLsh (shCount);

-  aopPut (result, "a", offr, isOperandVolatile (result, FALSE));
+  aopPut (result, "a", offr);

 }
 
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/


@@ -7910,19 +7921,19 @@ movLeft2Result (operand * left, int offl,
       if (*l == '@' && (IS_AOP_PREG (result)))
         {
           emitcode ("mov", "a,%s", l);
       if (*l == '@' && (IS_AOP_PREG (result)))
         {
           emitcode ("mov", "a,%s", l);

-          aopPut (result, "a", offr, isOperandVolatile (result, FALSE));
+          aopPut (result, "a", offr);

         }
       else
         {
           if (!sign)
         }
       else
         {
           if (!sign)

-            aopPut (result, l, offr, isOperandVolatile (result, FALSE));
+            aopPut (result, l, offr);

           else
             {
               /* MSB sign in acc.7 ! */
               if (getDataSize (left) == offl + 1)
                 {
                   MOVA (l);
           else
             {
               /* MSB sign in acc.7 ! */
               if (getDataSize (left) == offl + 1)
                 {
                   MOVA (l);

-                  aopPut (result, "a", offr, isOperandVolatile (result, FALSE));
+                  aopPut (result, "a", offr);

                 }
             }
         }
                 }
             }
         }


@@ -8269,13 +8280,13 @@ shiftL2Left2Result (operand * left, int offl,
   if (usedB)
     {
       emitcode ("xch", "a,b");
   if (usedB)
     {
       emitcode ("xch", "a,b");

-      aopPut (result, "a", offr, isOperandVolatile (result, FALSE));
-      aopPut (result, "b", offr + MSB16, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", offr);
+      aopPut (result, "b", offr + MSB16);

       popB (pushedB);
     }
   else
     {
       popB (pushedB);
     }
   else
     {

-      aopPut (result, "a", offr + MSB16, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", offr + MSB16);

     }
 }
 
     }
 }
 


@@ -8323,12 +8334,12 @@ shiftR2Left2Result (operand * left, int offl,
   if (usedB)
     {
       emitcode ("xch", "a,b");
   if (usedB)
     {
       emitcode ("xch", "a,b");

-      aopPut (result, "a", offr, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", offr);

       emitcode ("xch", "a,b");
       popB (pushedB);
     }
   if (getDataSize (result) > 1)
       emitcode ("xch", "a,b");
       popB (pushedB);
     }
   if (getDataSize (result) > 1)

-    aopPut (result, "a", offr + MSB16, isOperandVolatile (result, FALSE));
+    aopPut (result, "a", offr + MSB16);

 }
 
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/


@@ -8353,7 +8364,7 @@ shiftLLeftOrResult (operand * left, int offl,
       emitcode ("orl", "a,%s", aopGet (result, offr, FALSE, FALSE));
     }
   /* back to result */
       emitcode ("orl", "a,%s", aopGet (result, offr, FALSE, FALSE));
     }
   /* back to result */

-  aopPut (result, "a", offr, isOperandVolatile (result, FALSE));
+  aopPut (result, "a", offr);

 }
 
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/


@@ -8369,7 +8380,7 @@ shiftRLeftOrResult (operand * left, int offl,
   /* or with result */
   emitcode ("orl", "a,%s", aopGet (result, offr, FALSE, FALSE));
   /* back to result */
   /* or with result */
   emitcode ("orl", "a,%s", aopGet (result, offr, FALSE, FALSE));
   /* back to result */

-  aopPut (result, "a", offr, isOperandVolatile (result, FALSE));
+  aopPut (result, "a", offr);

 }
 
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/


@@ -8407,7 +8418,7 @@ genlshTwo (operand * result, operand * left, int shCount)
           else
             movLeft2Result (left, LSB, result, MSB16, 0);
         }
           else
             movLeft2Result (left, LSB, result, MSB16, 0);
         }

-      aopPut (result, zero, LSB, isOperandVolatile (result, FALSE));
+      aopPut (result, zero, LSB);

     }
 
   /*  1 <= shCount <= 7 */
     }
 
   /*  1 <= shCount <= 7 */


@@ -8440,7 +8451,7 @@ shiftLLong (operand * left, operand * result, int offr)
         emitcode ("xch", "a,%s",
                   aopGet (left, LSB + offr, FALSE, FALSE));
       else
         emitcode ("xch", "a,%s",
                   aopGet (left, LSB + offr, FALSE, FALSE));
       else

-        aopPut (result, "a", LSB + offr, isOperandVolatile (result, FALSE));
+        aopPut (result, "a", LSB + offr);

     }
 
   if (size >= MSB16 + offr)
     }
 
   if (size >= MSB16 + offr)


@@ -8456,7 +8467,7 @@ shiftLLong (operand * left, operand * result, int offr)
         emitcode ("xch", "a,%s",
                   aopGet (left, MSB16 + offr, FALSE, FALSE));
       else
         emitcode ("xch", "a,%s",
                   aopGet (left, MSB16 + offr, FALSE, FALSE));
       else

-        aopPut (result, "a", MSB16 + offr, isOperandVolatile (result, FALSE));
+        aopPut (result, "a", MSB16 + offr);

     }
 
   if (size >= MSB24 + offr)
     }
 
   if (size >= MSB24 + offr)


@@ -8472,7 +8483,7 @@ shiftLLong (operand * left, operand * result, int offr)
         emitcode ("xch", "a,%s",
                   aopGet (left, MSB24 + offr, FALSE, FALSE));
       else
         emitcode ("xch", "a,%s",
                   aopGet (left, MSB24 + offr, FALSE, FALSE));
       else

-        aopPut (result, "a", MSB24 + offr, isOperandVolatile (result, FALSE));
+        aopPut (result, "a", MSB24 + offr);

     }
 
   if (size > MSB32 + offr)
     }
 
   if (size > MSB32 + offr)


@@ -8483,10 +8494,10 @@ shiftLLong (operand * left, operand * result, int offr)
           MOVA (l);
         }
       emitcode ("rlc", "a");
           MOVA (l);
         }
       emitcode ("rlc", "a");

-      aopPut (result, "a", MSB32 + offr, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", MSB32 + offr);

     }
   if (offr != LSB)
     }
   if (offr != LSB)

-    aopPut (result, zero, LSB, isOperandVolatile (result, FALSE));
+    aopPut (result, zero, LSB);

 }
 
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/


@@ -8511,9 +8522,9 @@ genlshFour (operand * result, operand * left, int shCount)
         shiftL1Left2Result (left, LSB, result, MSB32, shCount);
       else
         movLeft2Result (left, LSB, result, MSB32, 0);
         shiftL1Left2Result (left, LSB, result, MSB32, shCount);
       else
         movLeft2Result (left, LSB, result, MSB32, 0);

-      aopPut (result, zero, LSB, isOperandVolatile (result, FALSE));
-      aopPut (result, zero, MSB16, isOperandVolatile (result, FALSE));
-      aopPut (result, zero, MSB24, isOperandVolatile (result, FALSE));
+      aopPut (result, zero, LSB);
+      aopPut (result, zero, MSB16);
+      aopPut (result, zero, MSB24);

       return;
     }
 
       return;
     }
 


@@ -8530,8 +8541,8 @@ genlshFour (operand * result, operand * left, int shCount)
           movLeft2Result (left, MSB16, result, MSB32, 0);
           movLeft2Result (left, LSB, result, MSB24, 0);
         }
           movLeft2Result (left, MSB16, result, MSB32, 0);
           movLeft2Result (left, LSB, result, MSB24, 0);
         }

-      aopPut (result, zero, MSB16, isOperandVolatile (result, FALSE));
-      aopPut (result, zero, LSB, isOperandVolatile (result, FALSE));
+      aopPut (result, zero, MSB16);
+      aopPut (result, zero, LSB);

       return;
     }
 
       return;
     }
 


@@ -8554,7 +8565,7 @@ genlshFour (operand * result, operand * left, int shCount)
               movLeft2Result (left, MSB24, result, MSB32, 0);
               movLeft2Result (left, MSB16, result, MSB24, 0);
               movLeft2Result (left, LSB, result, MSB16, 0);
               movLeft2Result (left, MSB24, result, MSB32, 0);
               movLeft2Result (left, MSB16, result, MSB24, 0);
               movLeft2Result (left, LSB, result, MSB16, 0);

-              aopPut (result, zero, LSB, isOperandVolatile (result, FALSE));
+              aopPut (result, zero, LSB);

             }
           else if (shCount == 1)
             shiftLLong (left, result, MSB16);
             }
           else if (shCount == 1)
             shiftLLong (left, result, MSB16);


@@ -8563,7 +8574,7 @@ genlshFour (operand * result, operand * left, int shCount)
               shiftL2Left2Result (left, MSB16, result, MSB24, shCount);
               shiftL1Left2Result (left, LSB, result, MSB16, shCount);
               shiftRLeftOrResult (left, LSB, result, MSB24, 8 - shCount);
               shiftL2Left2Result (left, MSB16, result, MSB24, shCount);
               shiftL1Left2Result (left, LSB, result, MSB16, shCount);
               shiftRLeftOrResult (left, LSB, result, MSB24, 8 - shCount);

-              aopPut (result, zero, LSB, isOperandVolatile (result, FALSE));
+              aopPut (result, zero, LSB);

             }
         }
     }
             }
         }
     }


@@ -8621,7 +8632,7 @@ genLeftShiftLiteral (operand * left,
 
   else if (shCount >= (size * 8))
     while (size--)
 
   else if (shCount >= (size * 8))
     while (size--)

-      aopPut (result, zero, size, isOperandVolatile (result, FALSE));
+      aopPut (result, zero, size);

   else
     {
       switch (size)
   else
     {
       switch (size)


@@ -8702,10 +8713,10 @@ genLeftShift (iCode * ic)
             {
 
               emitcode ("mov", "a,%s", l);
             {
 
               emitcode ("mov", "a,%s", l);

-              aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+              aopPut (result, "a", offset);

             }
           else
             }
           else

-            aopPut (result, l, offset, isOperandVolatile (result, FALSE));
+            aopPut (result, l, offset);

           offset++;
         }
     }
           offset++;
         }
     }


@@ -8728,7 +8739,7 @@ genLeftShift (iCode * ic)
       emitcode ("", "%05d$:", tlbl1->key + 100);
       emitcode ("djnz", "b,%05d$", tlbl->key + 100);
       popB (pushedB);
       emitcode ("", "%05d$:", tlbl1->key + 100);
       emitcode ("djnz", "b,%05d$", tlbl->key + 100);
       popB (pushedB);

-      aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", 0);

       goto release;
     }
 
       goto release;
     }
 


@@ -8739,13 +8750,13 @@ genLeftShift (iCode * ic)
   l = aopGet (result, offset, FALSE, FALSE);
   MOVA (l);
   emitcode ("add", "a,acc");
   l = aopGet (result, offset, FALSE, FALSE);
   MOVA (l);
   emitcode ("add", "a,acc");

-  aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
+  aopPut (result, "a", offset++);

   while (--size)
     {
       l = aopGet (result, offset, FALSE, FALSE);
       MOVA (l);
       emitcode ("rlc", "a");
   while (--size)
     {
       l = aopGet (result, offset, FALSE, FALSE);
       MOVA (l);
       emitcode ("rlc", "a");

-      aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", offset++);

     }
   reAdjustPreg (AOP (result));
 
     }
   reAdjustPreg (AOP (result));
 


@@ -8817,23 +8828,23 @@ shiftRLong (operand * left, int offl,
     {
       // shift is > 8
       if (sign)
     {
       // shift is > 8
       if (sign)

-           {
+        {

           emitcode ("rlc", "a");
           emitcode ("subb", "a,acc");
           if (useSameRegs && sameReg (AOP (left), MSB32, AOP (result), MSB32))
           emitcode ("rlc", "a");
           emitcode ("subb", "a,acc");
           if (useSameRegs && sameReg (AOP (left), MSB32, AOP (result), MSB32))

-                   {
+            {

               emitcode ("xch", "a,%s", aopGet (left, MSB32, FALSE, FALSE));
               emitcode ("xch", "a,%s", aopGet (left, MSB32, FALSE, FALSE));

-                   }
+            }

           else
           else

-                   {
-              aopPut (result, "a", MSB32, isOperandVolatile (result, FALSE));
+            {
+              aopPut (result, "a", MSB32);

               MOVA (aopGet (left, MSB32, FALSE, FALSE));
               MOVA (aopGet (left, MSB32, FALSE, FALSE));

-                   }
-           }
-         else
-           {
-          aopPut (result, zero, MSB32, isOperandVolatile (result, FALSE));
-           }
+            }
+        }
+      else
+        {
+          aopPut (result, zero, MSB32);
+        }

     }
 
   if (!sign)
     }
 
   if (!sign)


@@ -8854,7 +8865,7 @@ shiftRLong (operand * left, int offl,
     }
   else
     {
     }
   else
     {

-      aopPut (result, "a", MSB32-offl, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", MSB32-offl);

       MOVA (aopGet (left, MSB24, FALSE, FALSE));
     }
 
       MOVA (aopGet (left, MSB24, FALSE, FALSE));
     }
 


@@ -8866,13 +8877,13 @@ shiftRLong (operand * left, int offl,
     }
   else
     {
     }
   else
     {

-      aopPut (result, "a", MSB24-offl, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", MSB24-offl);

       MOVA (aopGet (left, MSB16, FALSE, FALSE));
     }
   emitcode ("rrc", "a");
   if (offl != LSB)
     {
       MOVA (aopGet (left, MSB16, FALSE, FALSE));
     }
   emitcode ("rrc", "a");
   if (offl != LSB)
     {

-      aopPut (result, "a", MSB16 - offl, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", MSB16 - offl);

     }
   else
     {
     }
   else
     {


@@ -8883,11 +8894,11 @@ shiftRLong (operand * left, int offl,
         }
       else
         {
         }
       else
         {

-          aopPut (result, "a", MSB16 - offl, isOperandVolatile (result, FALSE));
+          aopPut (result, "a", MSB16 - offl);

           MOVA (aopGet (left, LSB, FALSE, FALSE));
           MOVA (aopGet (left, LSB, FALSE, FALSE));

-           }
+        }

       emitcode ("rrc", "a");
       emitcode ("rrc", "a");

-      aopPut (result, "a", LSB, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", LSB);

     }
 }
 
     }
 }
 


@@ -9084,10 +9095,10 @@ genSignedRightShift (iCode * ic)
             {
 
               emitcode ("mov", "a,%s", l);
             {
 
               emitcode ("mov", "a,%s", l);

-              aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+              aopPut (result, "a", offset);

             }
           else
             }
           else

-            aopPut (result, l, offset, isOperandVolatile (result, FALSE));
+            aopPut (result, l, offset);

           offset++;
         }
     }
           offset++;
         }
     }


@@ -9113,7 +9124,7 @@ genSignedRightShift (iCode * ic)
       emitcode ("", "%05d$:", tlbl1->key + 100);
       emitcode ("djnz", "b,%05d$", tlbl->key + 100);
       popB (pushedB);
       emitcode ("", "%05d$:", tlbl1->key + 100);
       emitcode ("djnz", "b,%05d$", tlbl->key + 100);
       popB (pushedB);

-      aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", 0);

       goto release;
     }
 
       goto release;
     }
 


@@ -9126,7 +9137,7 @@ genSignedRightShift (iCode * ic)
       l = aopGet (result, offset, FALSE, FALSE);
       MOVA (l);
       emitcode ("rrc", "a");
       l = aopGet (result, offset, FALSE, FALSE);
       MOVA (l);
       emitcode ("rrc", "a");

-      aopPut (result, "a", offset--, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", offset--);

     }
   reAdjustPreg (AOP (result));
   emitcode ("", "%05d$:", tlbl1->key + 100);
     }
   reAdjustPreg (AOP (result));
   emitcode ("", "%05d$:", tlbl1->key + 100);


@@ -9212,10 +9223,10 @@ genRightShift (iCode * ic)
             {
 
               emitcode ("mov", "a,%s", l);
             {
 
               emitcode ("mov", "a,%s", l);

-              aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+              aopPut (result, "a", offset);

             }
           else
             }
           else

-            aopPut (result, l, offset, isOperandVolatile (result, FALSE));
+            aopPut (result, l, offset);

           offset++;
         }
     }
           offset++;
         }
     }


@@ -9237,7 +9248,7 @@ genRightShift (iCode * ic)
       emitcode ("", "%05d$:", tlbl1->key + 100);
       emitcode ("djnz", "b,%05d$", tlbl->key + 100);
       popB (pushedB);
       emitcode ("", "%05d$:", tlbl1->key + 100);
       emitcode ("djnz", "b,%05d$", tlbl->key + 100);
       popB (pushedB);

-      aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", 0);

       goto release;
     }
 
       goto release;
     }
 


@@ -9250,7 +9261,7 @@ genRightShift (iCode * ic)
       l = aopGet (result, offset, FALSE, FALSE);
       MOVA (l);
       emitcode ("rrc", "a");
       l = aopGet (result, offset, FALSE, FALSE);
       MOVA (l);
       emitcode ("rrc", "a");

-      aopPut (result, "a", offset--, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", offset--);

     }
   reAdjustPreg (AOP (result));
 
     }
   reAdjustPreg (AOP (result));
 


@@ -9405,7 +9416,7 @@ genUnpackBits (operand * result, char *rname, int ptype, iCode *ifx)
           emitcode ("orl", "a,#0x%02x", (unsigned char) (0xff << blen));
           emitcode ("", "%05d$:", tlbl->key + 100);
         }
           emitcode ("orl", "a,#0x%02x", (unsigned char) (0xff << blen));
           emitcode ("", "%05d$:", tlbl->key + 100);
         }

-      aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", offset++);

       goto finish;
     }
 
       goto finish;
     }
 


@@ -9414,7 +9425,7 @@ genUnpackBits (operand * result, char *rname, int ptype, iCode *ifx)
   for (rlen=blen;rlen>=8;rlen-=8)
     {
       emitPtrByteGet (rname, ptype, FALSE);
   for (rlen=blen;rlen>=8;rlen-=8)
     {
       emitPtrByteGet (rname, ptype, FALSE);

-      aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", offset++);

       if (rlen>8)
         emitcode ("inc", "%s", rname);
     }
       if (rlen>8)
         emitcode ("inc", "%s", rname);
     }


@@ -9433,7 +9444,7 @@ genUnpackBits (operand * result, char *rname, int ptype, iCode *ifx)
           emitcode ("orl", "a,#0x%02x", (unsigned char) (0xff << rlen));
           emitcode ("", "%05d$:", tlbl->key + 100);
         }
           emitcode ("orl", "a,#0x%02x", (unsigned char) (0xff << rlen));
           emitcode ("", "%05d$:", tlbl->key + 100);
         }

-      aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", offset++);

     }
 
 finish:
     }
 
 finish:


@@ -9453,7 +9464,7 @@ finish:
         }
       rsize -= offset;
       while (rsize--)
         }
       rsize -= offset;
       while (rsize--)

-        aopPut (result, source, offset++, isOperandVolatile (result, FALSE));
+        aopPut (result, source, offset++);

     }
 }
 
     }
 }
 


@@ -9483,7 +9494,7 @@ genDataPointerGet (operand * left,
         sprintf (buffer, "(%s + %d)", l + 1, offset);
       else
         sprintf (buffer, "%s", l + 1);
         sprintf (buffer, "(%s + %d)", l + 1, offset);
       else
         sprintf (buffer, "%s", l + 1);

-      aopPut (result, buffer, offset++, isOperandVolatile (result, FALSE));
+      aopPut (result, buffer, offset++);

     }
 
   freeAsmop (result, NULL, ic, TRUE);
     }
 
   freeAsmop (result, NULL, ic, TRUE);


@@ -9579,12 +9590,12 @@ genNearPointerGet (operand * left,
 
               emitcode ("mov", "a,@%s", rname);
               if (!ifx)
 
               emitcode ("mov", "a,@%s", rname);
               if (!ifx)

-              aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+                aopPut (result, "a", offset);

             }
           else
             {
               sprintf (buffer, "@%s", rname);
             }
           else
             {
               sprintf (buffer, "@%s", rname);

-              aopPut (result, buffer, offset, isOperandVolatile (result, FALSE));
+              aopPut (result, buffer, offset);

             }
           offset++;
           if (size || pi)
             }
           offset++;
           if (size || pi)


@@ -9596,7 +9607,7 @@ genNearPointerGet (operand * left,
   if (aop)       /* we had to allocate for this iCode */
     {
       if (pi) { /* post increment present */
   if (aop)       /* we had to allocate for this iCode */
     {
       if (pi) { /* post increment present */

-        aopPut (left, rname, 0, isOperandVolatile (left, FALSE));
+        aopPut (left, rname, 0);

       }
       freeAsmop (NULL, aop, ic, RESULTONSTACK (ic) ? FALSE : TRUE);
     }
       }
       freeAsmop (NULL, aop, ic, RESULTONSTACK (ic) ? FALSE : TRUE);
     }


@@ -9683,7 +9694,7 @@ genPagedPointerGet (operand * left,
 
           emitcode ("movx", "a,@%s", rname);
           if (!ifx)
 
           emitcode ("movx", "a,@%s", rname);
           if (!ifx)

-          aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+            aopPut (result, "a", offset);

 
           offset++;
 
 
           offset++;
 


@@ -9695,7 +9706,8 @@ genPagedPointerGet (operand * left,
   /* now some housekeeping stuff */
   if (aop) /* we had to allocate for this iCode */
     {
   /* now some housekeeping stuff */
   if (aop) /* we had to allocate for this iCode */
     {

-      if (pi) aopPut (left, rname, 0, isOperandVolatile (left, FALSE));
+      if (pi)
+        aopPut (left, rname, 0);

       freeAsmop (NULL, aop, ic, TRUE);
     }
   else
       freeAsmop (NULL, aop, ic, TRUE);
     }
   else


@@ -9818,7 +9830,7 @@ genFarPointerGet (operand * left,
         {
           emitcode ("movx", "a,@dptr");
           if (!ifx)
         {
           emitcode ("movx", "a,@dptr");
           if (!ifx)

-            aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
+            aopPut (result, "a", offset++);

           if (size || pi)
             emitcode ("inc", "dptr");
         }
           if (size || pi)
             emitcode ("inc", "dptr");
         }


@@ -9826,10 +9838,10 @@ genFarPointerGet (operand * left,
 
   if (pi && AOP_TYPE (left) != AOP_IMMD && AOP_TYPE (left) != AOP_STR)
     {
 
   if (pi && AOP_TYPE (left) != AOP_IMMD && AOP_TYPE (left) != AOP_STR)
     {

-    aopPut (left, "dpl", 0, isOperandVolatile (left, FALSE));
-    aopPut (left, "dph", 1, isOperandVolatile (left, FALSE));
-    pi->generated = 1;
-  }
+      aopPut (left, "dpl", 0);
+      aopPut (left, "dph", 1);
+      pi->generated = 1;
+    }

 
   if (ifx && !ifx->generated)
     {
 
   if (ifx && !ifx->generated)
     {


@@ -9841,7 +9853,7 @@ genFarPointerGet (operand * left,
 }
 
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/

-/* genCodePointerGet - gget value from code space                  */
+/* genCodePointerGet - get value from code space                   */

 /*-----------------------------------------------------------------*/
 static void
 genCodePointerGet (operand * left,
 /*-----------------------------------------------------------------*/
 static void
 genCodePointerGet (operand * left,


@@ -9871,7 +9883,7 @@ genCodePointerGet (operand * left,
           emitcode ("clr", "a");
           emitcode ("movc", "a,@a+dptr");
           if (!ifx)
           emitcode ("clr", "a");
           emitcode ("movc", "a,@a+dptr");
           if (!ifx)

-            aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
+            aopPut (result, "a", offset++);

           if (size || pi)
             emitcode ("inc", "dptr");
         }
           if (size || pi)
             emitcode ("inc", "dptr");
         }


@@ -9879,10 +9891,10 @@ genCodePointerGet (operand * left,
 
   if (pi && AOP_TYPE (left) != AOP_IMMD && AOP_TYPE (left) != AOP_STR)
     {
 
   if (pi && AOP_TYPE (left) != AOP_IMMD && AOP_TYPE (left) != AOP_STR)
     {

-    aopPut (left, "dpl", 0, isOperandVolatile (left, FALSE));
-    aopPut (left, "dph", 1, isOperandVolatile (left, FALSE));
-    pi->generated = 1;
-  }
+      aopPut (left, "dpl", 0);
+      aopPut (left, "dph", 1);
+      pi->generated = 1;
+    }

 
   if (ifx && !ifx->generated)
     {
 
   if (ifx && !ifx->generated)
     {


@@ -9894,7 +9906,7 @@ genCodePointerGet (operand * left,
 }
 
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/

-/* genGenPointerGet - gget value from generic pointer space        */
+/* genGenPointerGet - get value from generic pointer space         */

 /*-----------------------------------------------------------------*/
 static void
 genGenPointerGet (operand * left,
 /*-----------------------------------------------------------------*/
 static void
 genGenPointerGet (operand * left,


@@ -9923,7 +9935,7 @@ genGenPointerGet (operand * left,
         {
           emitcode ("lcall", "__gptrget");
           if (!ifx)
         {
           emitcode ("lcall", "__gptrget");
           if (!ifx)

-          aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
+            aopPut (result, "a", offset++);

           if (size || pi)
             emitcode ("inc", "dptr");
         }
           if (size || pi)
             emitcode ("inc", "dptr");
         }


@@ -9931,10 +9943,10 @@ genGenPointerGet (operand * left,
 
   if (pi && AOP_TYPE (left) != AOP_IMMD && AOP_TYPE (left) != AOP_STR)
     {
 
   if (pi && AOP_TYPE (left) != AOP_IMMD && AOP_TYPE (left) != AOP_STR)
     {

-    aopPut (left, "dpl", 0, isOperandVolatile (left, FALSE));
-    aopPut (left, "dph", 1, isOperandVolatile (left, FALSE));
-    pi->generated = 1;
-  }
+      aopPut (left, "dpl", 0);
+      aopPut (left, "dph", 1);
+      pi->generated = 1;
+    }

 
   if (ifx && !ifx->generated)
     {
 
   if (ifx && !ifx->generated)
     {


@@ -10282,7 +10294,7 @@ genNearPointerSet (operand * right,
   if (aop) /* we had to allocate for this iCode */
     {
       if (pi)
   if (aop) /* we had to allocate for this iCode */
     {
       if (pi)

-        aopPut (result, rname, 0, isOperandVolatile (result, FALSE));
+        aopPut (result, rname, 0);

       freeAsmop (NULL, aop, ic, TRUE);
     }
   else
       freeAsmop (NULL, aop, ic, TRUE);
     }
   else


@@ -10375,7 +10387,7 @@ genPagedPointerSet (operand * right,
   if (aop) /* we had to allocate for this iCode */
     {
       if (pi)
   if (aop) /* we had to allocate for this iCode */
     {
       if (pi)

-        aopPut (result, rname, 0, isOperandVolatile (result, FALSE));
+        aopPut (result, rname, 0);

       freeAsmop (NULL, aop, ic, TRUE);
     }
   else
       freeAsmop (NULL, aop, ic, TRUE);
     }
   else


@@ -10439,8 +10451,8 @@ genFarPointerSet (operand * right,
         }
     }
   if (pi && AOP_TYPE (result) != AOP_STR && AOP_TYPE (result) != AOP_IMMD) {
         }
     }
   if (pi && AOP_TYPE (result) != AOP_STR && AOP_TYPE (result) != AOP_IMMD) {

-    aopPut (result, "dpl", 0, isOperandVolatile (result, FALSE));
-    aopPut (result, "dph", 1, isOperandVolatile (result, FALSE));
+    aopPut (result, "dpl", 0);
+    aopPut (result, "dph", 1);

     pi->generated=1;
   }
   freeAsmop (result, NULL, ic, TRUE);
     pi->generated=1;
   }
   freeAsmop (result, NULL, ic, TRUE);


@@ -10485,8 +10497,8 @@ genGenPointerSet (operand * right,
     }
 
   if (pi && AOP_TYPE (result) != AOP_STR && AOP_TYPE (result) != AOP_IMMD) {
     }
 
   if (pi && AOP_TYPE (result) != AOP_STR && AOP_TYPE (result) != AOP_IMMD) {

-    aopPut (result, "dpl", 0, isOperandVolatile (result, FALSE));
-    aopPut (result, "dph", 1, isOperandVolatile (result, FALSE));
+    aopPut (result, "dpl", 0);
+    aopPut (result, "dph", 1);

     pi->generated=1;
   }
   freeAsmop (result, NULL, ic, TRUE);
     pi->generated=1;
   }
   freeAsmop (result, NULL, ic, TRUE);


@@ -10628,12 +10640,12 @@ genAddrOf (iCode * ic)
           emitcode ("add", "a,#0x%02x", ((sym->stack < 0) ?
                                          ((char) (sym->stack - _G.nRegsSaved)) :
                                          ((char) sym->stack)) & 0xff);
           emitcode ("add", "a,#0x%02x", ((sym->stack < 0) ?
                                          ((char) (sym->stack - _G.nRegsSaved)) :
                                          ((char) sym->stack)) & 0xff);

-          aopPut (IC_RESULT (ic), "a", 0, isOperandVolatile (IC_RESULT (ic), FALSE));
+          aopPut (IC_RESULT (ic), "a", 0);

         }
       else
         {
           /* we can just move _bp */
         }
       else
         {
           /* we can just move _bp */

-          aopPut (IC_RESULT (ic), SYM_BP (sym), 0, isOperandVolatile (IC_RESULT (ic), FALSE));
+          aopPut (IC_RESULT (ic), SYM_BP (sym), 0);

         }
       /* fill the result with zero */
       size = AOP_SIZE (IC_RESULT (ic)) - 1;
         }
       /* fill the result with zero */
       size = AOP_SIZE (IC_RESULT (ic)) - 1;


@@ -10641,7 +10653,7 @@ genAddrOf (iCode * ic)
       offset = 1;
       while (size--)
         {
       offset = 1;
       while (size--)
         {

-          aopPut (IC_RESULT (ic), zero, offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+          aopPut (IC_RESULT (ic), zero, offset++);

         }
 
       goto release;
         }
 
       goto release;


@@ -10660,7 +10672,7 @@ genAddrOf (iCode * ic)
                  offset * 8);
       else
         sprintf (s, "#%s", sym->rname);
                  offset * 8);
       else
         sprintf (s, "#%s", sym->rname);

-      aopPut (IC_RESULT (ic), s, offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+      aopPut (IC_RESULT (ic), s, offset++);

     }
 
 release:
     }
 
 release:


@@ -10695,7 +10707,7 @@ genFarFarAssign (operand * result, operand * right, iCode * ic)
   while (size--)
     {
       emitcode ("pop", "acc");
   while (size--)
     {
       emitcode ("pop", "acc");

-      aopPut (result, "a", --offset, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", --offset);

     }
   freeAsmop (result, NULL, ic, FALSE);
 }
     }
   freeAsmop (result, NULL, ic, FALSE);
 }


@@ -10750,9 +10762,9 @@ genAssign (iCode * ic)
       if (AOP_TYPE (right) == AOP_LIT)
         {
           if (((int) operandLitValue (right)))
       if (AOP_TYPE (right) == AOP_LIT)
         {
           if (((int) operandLitValue (right)))

-            aopPut (result, one, 0, isOperandVolatile (result, FALSE));
+            aopPut (result, one, 0);

           else
           else

-            aopPut (result, zero, 0, isOperandVolatile (result, FALSE));
+            aopPut (result, zero, 0);

           goto release;
         }
 
           goto release;
         }
 


@@ -10760,13 +10772,13 @@ genAssign (iCode * ic)
       if (AOP_TYPE (right) == AOP_CRY)
         {
           emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
       if (AOP_TYPE (right) == AOP_CRY)
         {
           emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);

-          aopPut (result, "c", 0, isOperandVolatile (result, FALSE));
+          aopPut (result, "c", 0);

           goto release;
         }
 
       /* we need to or */
       toBoolean (right);
           goto release;
         }
 
       /* we need to or */
       toBoolean (right);

-      aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", 0);

       goto release;
     }
 
       goto release;
     }
 


@@ -10786,8 +10798,7 @@ genAssign (iCode * ic)
         {
           aopPut (result,
                   aopGet (right, offset, FALSE, FALSE),
         {
           aopPut (result,
                   aopGet (right, offset, FALSE, FALSE),

-                  offset,
-                  isOperandVolatile (result, FALSE));
+                  offset);

           lit >>= 8;
           offset++;
           size--;
           lit >>= 8;
           offset++;
           size--;


@@ -10795,7 +10806,7 @@ genAssign (iCode * ic)
       emitcode ("clr", "a");
       while (size--)
         {
       emitcode ("clr", "a");
       while (size--)
         {

-          aopPut (result, "a", offset, isOperandVolatile (result, FALSE));
+          aopPut (result, "a", offset);

           offset++;
         }
     }
           offset++;
         }
     }


@@ -10805,8 +10816,7 @@ genAssign (iCode * ic)
         {
           aopPut (result,
                   aopGet (right, offset, FALSE, FALSE),
         {
           aopPut (result,
                   aopGet (right, offset, FALSE, FALSE),

-                  offset,
-                  isOperandVolatile (result, FALSE));
+                  offset);

           offset++;
         }
     }
           offset++;
         }
     }


@@ -10958,9 +10968,9 @@ genCast (iCode * ic)
       if (AOP_TYPE (right) == AOP_LIT)
         {
           if (((int) operandLitValue (right)))
       if (AOP_TYPE (right) == AOP_LIT)
         {
           if (((int) operandLitValue (right)))

-            aopPut (result, one, 0, isOperandVolatile (result, FALSE));
+            aopPut (result, one, 0);

           else
           else

-            aopPut (result, zero, 0, isOperandVolatile (result, FALSE));
+            aopPut (result, zero, 0);

 
           goto release;
         }
 
           goto release;
         }


@@ -10969,17 +10979,16 @@ genCast (iCode * ic)
       if (AOP_TYPE (right) == AOP_CRY)
         {
           emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);
       if (AOP_TYPE (right) == AOP_CRY)
         {
           emitcode ("mov", "c,%s", AOP (right)->aopu.aop_dir);

-          aopPut (result, "c", 0, isOperandVolatile (result, FALSE));
+          aopPut (result, "c", 0);

           goto release;
         }
 
       /* we need to or */
       toBoolean (right);
           goto release;
         }
 
       /* we need to or */
       toBoolean (right);

-      aopPut (result, "a", 0, isOperandVolatile (result, FALSE));
+      aopPut (result, "a", 0);

       goto release;
     }
 
       goto release;
     }
 

-

   /* if they are the same size : or less */
   if (AOP_SIZE (result) <= AOP_SIZE (right))
     {
   /* if they are the same size : or less */
   if (AOP_SIZE (result) <= AOP_SIZE (right))
     {


@@ -10995,14 +11004,12 @@ genCast (iCode * ic)
         {
           aopPut (result,
                   aopGet (right, offset, FALSE, FALSE),
         {
           aopPut (result,
                   aopGet (right, offset, FALSE, FALSE),

-                  offset,
-                  isOperandVolatile (result, FALSE));
+                  offset);

           offset++;
         }
       goto release;
     }
 
           offset++;
         }
       goto release;
     }
 

-

   /* if the result is of type pointer */
   if (IS_PTR (ctype))
     {
   /* if the result is of type pointer */
   if (IS_PTR (ctype))
     {


@@ -11034,8 +11041,7 @@ genCast (iCode * ic)
             {
               aopPut (result,
                       aopGet (right, offset, FALSE, FALSE),
             {
               aopPut (result,
                       aopGet (right, offset, FALSE, FALSE),

-                      offset,
-                      isOperandVolatile (result, FALSE));
+                      offset);

               offset++;
             }
           /* the last byte depending on type */
               offset++;
             }
           /* the last byte depending on type */


@@ -11050,7 +11056,7 @@ genCast (iCode * ic)
                 }
 
                 sprintf(gpValStr, "#0x%x", gpVal);
                 }
 
                 sprintf(gpValStr, "#0x%x", gpVal);

-                aopPut (result, gpValStr, GPTRSIZE - 1, isOperandVolatile (result, FALSE));
+                aopPut (result, gpValStr, GPTRSIZE - 1);

             }
           goto release;
         }
             }
           goto release;
         }


@@ -11062,8 +11068,7 @@ genCast (iCode * ic)
         {
           aopPut (result,
                   aopGet (right, offset, FALSE, FALSE),
         {
           aopPut (result,
                   aopGet (right, offset, FALSE, FALSE),

-                  offset,
-                  isOperandVolatile (result, FALSE));
+                  offset);

           offset++;
         }
       goto release;
           offset++;
         }
       goto release;


@@ -11078,8 +11083,7 @@ genCast (iCode * ic)
     {
       aopPut (result,
               aopGet (right, offset, FALSE, FALSE),
     {
       aopPut (result,
               aopGet (right, offset, FALSE, FALSE),

-              offset,
-              isOperandVolatile (result, FALSE));
+              offset);

       offset++;
     }
 
       offset++;
     }
 


@@ -11089,7 +11093,7 @@ genCast (iCode * ic)
   if (!IS_SPEC (rtype) || SPEC_USIGN (rtype) || AOP_TYPE(right)==AOP_CRY)
     {
       while (size--)
   if (!IS_SPEC (rtype) || SPEC_USIGN (rtype) || AOP_TYPE(right)==AOP_CRY)
     {
       while (size--)

-        aopPut (result, zero, offset++, isOperandVolatile (result, FALSE));
+        aopPut (result, zero, offset++);

     }
   else
     {
     }
   else
     {


@@ -11100,7 +11104,7 @@ genCast (iCode * ic)
       emitcode ("rlc", "a");
       emitcode ("subb", "a,acc");
       while (size--)
       emitcode ("rlc", "a");
       emitcode ("subb", "a,acc");
       while (size--)

-        aopPut (result, "a", offset++, isOperandVolatile (result, FALSE));
+        aopPut (result, "a", offset++);

     }
 
   /* we are done hurray !!!! */
     }
 
   /* we are done hurray !!!! */


@@ -11167,7 +11171,7 @@ genDjnz (iCode * ic, iCode * ifx)
            return 0;
       }
       emitcode ("dec", "%s", rByte);
            return 0;
       }
       emitcode ("dec", "%s", rByte);

-      aopPut (IC_RESULT (ic), rByte, 0, isOperandVolatile (IC_RESULT (ic), FALSE));
+      aopPut (IC_RESULT (ic), rByte, 0);

       emitcode ("jnz", "%05d$", lbl->key + 100);
   }
   else if (IS_AOP_PREG (IC_RESULT (ic)))
       emitcode ("jnz", "%05d$", lbl->key + 100);
   }
   else if (IS_AOP_PREG (IC_RESULT (ic)))


@@ -11228,11 +11232,9 @@ genReceive (iCode * ic)
                   _G.accInUse++;
                   aopOp (IC_RESULT (ic), ic, FALSE);
                   _G.accInUse--;
                   _G.accInUse++;
                   aopOp (IC_RESULT (ic), ic, FALSE);
                   _G.accInUse--;

-                  aopPut (IC_RESULT (ic), "a", offset,
-                          isOperandVolatile (IC_RESULT (ic), FALSE));
+                  aopPut (IC_RESULT (ic), "a", offset);

                   for (offset = 1; offset<size; offset++)
                   for (offset = 1; offset<size; offset++)

-                    aopPut (IC_RESULT (ic), tempRegs[--roffset]->name, offset,
-                            isOperandVolatile (IC_RESULT (ic), FALSE));
+                    aopPut (IC_RESULT (ic), tempRegs[--roffset]->name, offset);

                   goto release;
                 }
             }
                   goto release;
                 }
             }


@@ -11244,8 +11246,7 @@ genReceive (iCode * ic)
                     emitcode("mov","%s,%s", tempRegs[offset]->name, fReturn[offset]);
                   aopOp (IC_RESULT (ic), ic, FALSE);
                   for (offset = 0; offset<size; offset++)
                     emitcode("mov","%s,%s", tempRegs[offset]->name, fReturn[offset]);
                   aopOp (IC_RESULT (ic), ic, FALSE);
                   for (offset = 0; offset<size; offset++)

-                    aopPut (IC_RESULT (ic), tempRegs[offset]->name, offset,
-                            isOperandVolatile (IC_RESULT (ic), FALSE));
+                    aopPut (IC_RESULT (ic), tempRegs[offset]->name, offset);

                   goto release;
                 }
             }
                   goto release;
                 }
             }


@@ -11263,7 +11264,7 @@ genReceive (iCode * ic)
           while (size--)
             {
               emitcode ("pop", "acc");
           while (size--)
             {
               emitcode ("pop", "acc");

-              aopPut (IC_RESULT (ic), "a", offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+              aopPut (IC_RESULT (ic), "a", offset++);

             }
         }
       else
             }
         }
       else


@@ -11290,7 +11291,7 @@ genReceive (iCode * ic)
       rb1off = ic->argreg;
       while (size--)
         {
       rb1off = ic->argreg;
       while (size--)
         {

-          aopPut (IC_RESULT (ic), rb1regs[rb1off++ -5], offset++, isOperandVolatile (IC_RESULT (ic), FALSE));
+          aopPut (IC_RESULT (ic), rb1regs[rb1off++ -5], offset++);

         }
     }
 
         }
     }
 


@@ -11371,9 +11372,9 @@ genCritical (iCode *ic)
   if (IC_RESULT (ic))
     {
       aopOp (IC_RESULT (ic), ic, TRUE);
   if (IC_RESULT (ic))
     {
       aopOp (IC_RESULT (ic), ic, TRUE);

-      aopPut (IC_RESULT (ic), one, 0, 0);
+      aopPut (IC_RESULT (ic), one, 0);

       emitcode ("jbc", "ea,%05d$", (tlbl->key + 100)); /* atomic test & clear */
       emitcode ("jbc", "ea,%05d$", (tlbl->key + 100)); /* atomic test & clear */

-      aopPut (IC_RESULT (ic), zero, 0, 0);
+      aopPut (IC_RESULT (ic), zero, 0);

       emitcode ("", "%05d$:", (tlbl->key + 100));
       freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
     }
       emitcode ("", "%05d$:", (tlbl->key + 100));
       freeAsmop (IC_RESULT (ic), NULL, ic, TRUE);
     }

diff --git a/src/mcs51/ralloc.h b/src/mcs51/ralloc.h
index 276010754f0353d1984ec49242bbd2ee814da159..cfb9584dcc08a6faac152ee701a3c93bc2ff6793 100644 (file)
--- a/src/mcs51/ralloc.h
+++ b/src/mcs51/ralloc.h
@@ -65,4 +65,7 @@ regs *mcs51_regWithIdx (int);
 bitVect *mcs51_rUmaskForOp (operand * op);
 bitVect *mcs51_allBitregs (void);
 
 bitVect *mcs51_rUmaskForOp (operand * op);
 bitVect *mcs51_allBitregs (void);
 

+extern int mcs51_ptrRegReq;
+extern int mcs51_nRegs;
+

 #endif
 #endif