* as/link/hc08/lkelf.c, as/link/lkaomf51.c, as/link/lklibr.c,

[fw/sdcc] / debugger / mcs51 / cmd.c

diff --git a/debugger/mcs51/cmd.c b/debugger/mcs51/cmd.c
index b0a8a937707d429caf8938d9da2d918bc2639c4b..4bfc16fdf33c011416ca86b07b5e816a5b95e9b1 100644 (file)
--- a/debugger/mcs51/cmd.c
+++ b/debugger/mcs51/cmd.c
@@ -1,25 +1,24 @@
 /*-------------------------------------------------------------------------
     cmd.c - source  file for debugger command execution
 /*-------------------------------------------------------------------------
     cmd.c - source  file for debugger command execution

-
-             Written By -  Sandeep Dutta . sandeep.dutta@usa.net (1999)
+        Written By -  Sandeep Dutta . sandeep.dutta@usa.net (1999)

 
    This program is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by the
    Free Software Foundation; either version 2, or (at your option) any
    later version.
 
    This program is free software; you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by the
    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,12 +329,12 @@ 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 ;

-static set  *dispsymbols = NULL   ; /* set of displayable symbols */
+set *dispsymbols = NULL   ; /* set of displayable symbols */

 static int currentFrame = 0;        /* actual displayed frame     */
 /*-----------------------------------------------------------------*/
 /* funcWithName - returns function with name                       */
 static int currentFrame = 0;        /* actual displayed frame     */
 /*-----------------------------------------------------------------*/
 /* funcWithName - returns function with name                       */


@@ -347,13 +346,13 @@ DEFSETFUNC(funcWithName)
     V_ARG(function **,funcp);
 
     if (*funcp)
     V_ARG(function **,funcp);
 
     if (*funcp)

-       return 0;
+        return 0;

 
     if (strcmp(func->sym->name,name) == 0) {
 
     if (strcmp(func->sym->name,name) == 0) {

-       *funcp = func;
-       return 1;
+        *funcp = func;
+        return 1;

     }
     }

-    
+

     return 0;
 }
 
     return 0;
 }
 


@@ -371,7 +370,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;


@@ -385,45 +384,49 @@ DEFSETFUNC(symWithAddr)
 /*-----------------------------------------------------------------*/
 static void setBPatModLine (module *mod, int line, char bpType )
 {
 /*-----------------------------------------------------------------*/
 static void setBPatModLine (module *mod, int line, char bpType )
 {

-  int next_line;
+    int next_line;

 
     /* look for the first executable line after the 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 (srcMode == SRC_CMODE && line > mod->ncLines) {
     if (srcMode == SRC_CMODE && line > mod->ncLines) {

-       fprintf(stderr,"No line %d in file \"%s\".\n",
-               line,mod->c_name);
-       return ;
+        fprintf(stderr,"No line %d in file \"%s\".\n",
+                line,mod->c_name);
+        return ;

     }
     }

-    
+

     if (srcMode == SRC_AMODE && line > mod->nasmLines) {
     if (srcMode == SRC_AMODE && line > mod->nasmLines) {

-       fprintf(stderr,"No line %d in file \"%s\".\n",
-               line,mod->asm_name);
-       return ;
+        fprintf(stderr,"No line %d in file \"%s\".\n",
+                line,mod->asm_name);
+        return ;

     }
 
     next_line = line;
     }
 
     next_line = line;

-    for ( ; next_line < (srcMode == SRC_CMODE ? mod->ncLines : mod->nasmLines ) ; 
-         next_line++ ) {
-       if (srcMode == SRC_CMODE) {
-           if (mod->cLines[next_line]->addr) {
-               setBreakPoint (mod->cLines[next_line]->addr, CODE, bpType, 
-                              userBpCB, mod->c_name, next_line);
-               return;
-//             break;
-           }
-       }
-       else {
-          if (mod->asmLines[next_line]->addr) {
-              setBreakPoint (mod->asmLines[next_line]->addr, CODE, bpType, 
-                             userBpCB, mod->asm_name, next_line);
-               return;
-//            break;
-          } 
-       }
-    }
-
-       fprintf(stderr,"No line %d or after in file \"%s\"..\n",
-                       line,mod->c_name);
+    for ( ; next_line < (srcMode == SRC_CMODE ? mod->ncLines : mod->nasmLines ) ;
+          next_line++ ) {
+        if (srcMode == SRC_CMODE) {
+            if (mod->cLines[next_line]->addr != INT_MAX) {
+                setBreakPoint (mod->cLines[next_line]->addr, CODE, bpType,
+                               userBpCB, mod->c_name, next_line);
+                return;
+//              break;
+            }
+        }
+        else {
+           if (mod->asmLines[next_line]->addr != INT_MAX) {
+               setBreakPoint (mod->asmLines[next_line]->addr, CODE, bpType,
+                              userBpCB, mod->asm_name, next_line);
+                return;
+//             break;
+           }
+        }
+    }
+
+        fprintf(stderr,"No line %d or after in file \"%s\"..\n",
+                        line,mod->c_name);

 
     return;
 }
 
     return;
 }


@@ -436,29 +439,29 @@ static void clearBPatModLine (module *mod, int line)
     /* look for the first executable line after the line
        specified & get the break point there */
     if (srcMode == SRC_CMODE && line > mod->ncLines) {
     /* look for the first executable line after the line
        specified & get the break point there */
     if (srcMode == SRC_CMODE && line > mod->ncLines) {

-       fprintf(stderr,"No line %d in file \"%s\".\n",
-               line,mod->c_name);
-       return ;
+        fprintf(stderr,"No line %d in file \"%s\".\n",
+                line,mod->c_name);
+        return ;

     }
     }

-    
+

     if (srcMode == SRC_AMODE && line > mod->ncLines) {
     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 ) ; 
-         line++ ) {
-       if (srcMode == SRC_CMODE) 
-           if (mod->cLines[line]->addr) {
-               clearUSERbp (mod->cLines[line]->addr);                    
-               break;
-           }
-       else
-           if (mod->asmLines[line]->addr) {
-               clearUSERbp (mod->asmLines[line]->addr);                          
-               break;
-           }
+        fprintf(stderr,"No line %d in file \"%s\".\n",
+                line,mod->c_name);
+        return ;
+    }
+
+    for ( ; line < (srcMode == SRC_CMODE ? mod->ncLines : mod->nasmLines ) ;
+          line++ ) {
+        if (srcMode == SRC_CMODE)
+            if (mod->cLines[line]->addr) {
+                clearUSERbp (mod->cLines[line]->addr);
+                break;
+            }
+        else
+            if (mod->asmLines[line]->addr) {
+                clearUSERbp (mod->asmLines[line]->addr);
+                break;
+            }

     }
 
     return;
     }
 
     return;


@@ -479,7 +482,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)
         {


@@ -487,7 +490,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;


@@ -504,7 +507,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);


@@ -515,9 +518,9 @@ DEFSETFUNC(funcWithNameModule)
         return 0;
 
     if (strcmp(func->sym->name,fname) == 0 &&
         return 0;
 
     if (strcmp(func->sym->name,fname) == 0 &&

-       strcmp(func->mod->c_name,mname) == 0) {
-       *funcp = func;
-       return 1;
+        strcmp(func->mod->c_name,mname) == 0) {
+        *funcp = func;
+        return 1;

     }
 
     return 0;
     }
 
     return 0;


@@ -533,17 +536,17 @@ DEFSETFUNC(funcInAddr)
     V_ARG(function **,funcp);
 
     if (*funcp)
     V_ARG(function **,funcp);
 
     if (*funcp)

-       return 0;
+        return 0;

 
     /* in the address range */
     if (func->sym->addr <= addr &&
 
     /* in the address range */
     if (func->sym->addr <= addr &&

-       func->sym->eaddr >= addr) {
-       
-       *funcp = func;
-       return 1;
+        func->sym->eaddr >= addr) {
+
+        *funcp = func;
+        return 1;

     }
 
     }
 

-    return 0;      
+    return 0;

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


@@ -552,14 +555,14 @@ 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 */
-       setBreakPoint (func->sym->addr , CODE , STEP , 
-                      stepBpCB ,func->mod->c_name , func->entryline);

 
 

-       return 1;
+        /* set the entry break point */
+        setBreakPoint (func->sym->addr , CODE , STEP ,
+                       stepBpCB ,func->mod->c_name , func->entryline);
+
+        return 1;

     }
 
     return 0;
     }
 
     return 0;


@@ -573,9 +576,9 @@ 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, 
-                  stepBpCB, mname, ep->line);
+
+    setBreakPoint (ep->addr, CODE, bptype,
+                   stepBpCB, mname, ep->line);

     return 1;
 }
 
     return 1;
 }
 


@@ -587,9 +590,9 @@ 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, 
-                  nextBpCB, mname, ep->line);
+
+    setBreakPoint (ep->addr, CODE, bptype,
+                   nextBpCB, mname, ep->line);

     return 1;
 }
 
     return 1;
 }
 


@@ -606,16 +609,16 @@ DEFSETFUNC(lineAtAddr)
 
     /* address must be an exact match */
     if (ep->addr == addr) {
 
     /* address must be an exact match */
     if (ep->addr == addr) {

-       *line = ep->line;
-       if (block)
-           *block = ep->block ;
-       if (level)
-           *level = ep->level ;
-       return 1;
+        *line = ep->line;
+        if (block)
+            *block = ep->block ;
+        if (level)
+            *level = ep->level ;
+        return 1;

     }
 
     return 0;
     }
 
     return 0;

-    
+

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


@@ -631,16 +634,16 @@ DEFSETFUNC(lineNearAddr)
 
     /* the line in which the address is */
     if (ep->addr <= addr) {
 
     /* the line in which the address is */
     if (ep->addr <= addr) {

-       *line = ep->line;
-       if (block)
-           *block = ep->block ;
-       if (level)
-           *level = ep->level ;
-       return 1;
+        *line = ep->line;
+        if (block)
+            *block = ep->block ;
+        if (level)
+            *level = ep->level ;
+        return 1;

     }
 
     return 0;
     }
 
     return 0;

-    
+

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


@@ -653,10 +656,10 @@ context *discoverContext (unsigned addr, function *func)
 
     /* find the function we are in */
     if (!func && !applyToSet(functions,funcInAddr,addr,&func)) {
 
     /* find the function we are in */
     if (!func && !applyToSet(functions,funcInAddr,addr,&func)) {

-        if (!applyToSet(functions,funcWithName,"main",&func) ||
+        if (!applyToSet(functions,funcWithName,"_main",&func) ||

             !applyToSet(modules,moduleLineWithAddr,addr,&mod,NULL))
         {
             !applyToSet(modules,moduleLineWithAddr,addr,&mod,NULL))
         {

-            fprintf(stderr, "Error?:discoverContext: cannot apply addr 0x%x\n",addr);
+            fprintf(stderr, "addr 0x%x in no module/function (runtime env?)\n",addr);

             return NULL;
         }
         currCtxt->func = func;
             return NULL;
         }
         currCtxt->func = func;


@@ -669,25 +672,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 = func->lline = line;
         else

-            currCtxt->cline = func->exitline;
-    }    
+            currCtxt->cline = -1;
+    }

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

-                  &line,NULL,NULL))
-       currCtxt->asmline = line;       
+                   &line,NULL,NULL))
+        currCtxt->asmline = line;

     else
     else

-       currCtxt->asmline = -1;
-        
+        currCtxt->asmline = -1;
+

     return currCtxt ;
 }
 
     return currCtxt ;
 }
 


@@ -696,63 +699,64 @@ 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;
         return;
     }
     if ( userinterrupt )
     {
         userinterrupt = 0;
         return;
     }

+    if ( gaddr == 0 )
+    {
+        function *func = NULL;;
+        if (applyToSet(functions,funcInAddr,gaddr,&func))
+            STACK_PUSH(callStack,func);
+    }

     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 )
+        if ( gaddr == 0 )

             gaddr = -1;
             gaddr = -1;

-               if ( gaddr == -1 || doingSteps == 1 )
+        if ( gaddr == -1 || doingSteps == 1 )

             goto top ;
     }
             goto top ;
     }

-    
+

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

-/* preparePrint - common parse function for                        */
+/* preparePrint - common parse function for  set variable,         */

 /*                output, print and display                        */
 /*-----------------------------------------------------------------*/
 static char *preparePrint(char *s, context *cctxt, int *fmt, symbol **sym)
 {
 /*                output, print and display                        */
 /*-----------------------------------------------------------------*/
 static char *preparePrint(char *s, context *cctxt, int *fmt, symbol **sym)
 {

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

     char save_ch ;
 
     *fmt = FMT_NON;
     *sym = NULL;
 
     char save_ch ;
 
     *fmt = FMT_NON;
     *sym = NULL;
 

-    while (isspace(*s)) s++;
-    if (!*s) 
+    s = trim(s);
+    if (!*s)

         return (char *)0;
 
         return (char *)0;
 

-    while (isspace(*bp)) bp--;
-    bp++ ;
-    *bp = '\0';
-

     if ( *s == '/' )
     {
         /* format of printout */
     if ( *s == '/' )
     {
         /* format of printout */


@@ -773,14 +777,15 @@ static char *preparePrint(char *s, context *cctxt, int *fmt, symbol **sym)
                 break;
         }
         s++;
                 break;
         }
         s++;

-        while (isspace(*s)) s++;
+        s = trim_left(s);

     }
     }

-    for ( bp = s; *bp && ( isalnum( *bp ) || *bp == '_'); bp++ );
+    for ( bp = s; *bp && ( isalnum( *bp ) || *bp == '_' || *bp == '$'); bp++ );

     save_ch = *bp;
     if ( *bp )
         *bp = '\0';
 
     save_ch = *bp;
     if ( *bp )
         *bp = '\0';
 

-    *sym = symLookup(s,cctxt);
+    if ( *s )
+        *sym = symLookup(s,cctxt);

     *bp = save_ch;
 
     if ( ! *sym )
     *bp = save_ch;
 
     if ( ! *sym )


@@ -788,11 +793,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 )


@@ -805,7 +810,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)
         {


@@ -815,12 +820,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 )
         {


@@ -828,7 +833,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;


@@ -848,14 +853,14 @@ static int cmdDisasm (char *s, context *cctxt, int args)
 
     if ( args > 0 )
     {
 
     if ( args > 0 )
     {

-        while (*s && isspace(*s)) s++;
+        s = trim_left(s);

 
         if ( isdigit(*s))
         {
             saddr = strtol(s,&s,0);
             if ( args > 1 )
             {
 
         if ( isdigit(*s))
         {
             saddr = strtol(s,&s,0);
             if ( args > 1 )
             {

-                while (*s && isspace(*s)) s++;
+                s = trim_left(s);

 
                 if ( isdigit(*s))
                     eaddr = strtol(s,0,0);
 
                 if ( isdigit(*s))
                     eaddr = strtol(s,0,0);


@@ -866,7 +871,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 )
         {


@@ -881,7 +886,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
         {


@@ -891,14 +896,14 @@ 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;

             }
         }
     }
     else
     {
         if ( args > 1 )
             }
         }
     }
     else
     {
         if ( args > 1 )

-            printf("Dump of assembler code from 0x%08x to 0x%08x:\n",saddr,eaddr);
+            printf("Dump of assembler code from 0x%08lx to 0x%08lx:\n",saddr,eaddr);

         found = 0;
         while ( saddr < eaddr )
         {
         found = 0;
         while ( saddr < eaddr )
         {


@@ -921,12 +926,20 @@ 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");
     }
     fprintf(stderr,"No function contains specified address.\n");

-    return 0; 
+    if( saddr >= 0 )
+    {
+        char lbuf[64];
+        sprintf(lbuf,"dis 0x%lx 0 %ld\n",saddr,( eaddr == -1 )?1L:eaddr-saddr);
+        sendSim(lbuf);
+        waitForSim(1000, NULL);
+        fputs(simResponse(),stdout);
+    }
+    return 0;

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


@@ -948,7 +961,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


@@ -956,42 +969,37 @@ 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) {

-       fprintf(stdout,"No symbol table is loaded.  Use the \"file\" command.\n");
-       return 0;
+        fprintf(stdout,"No symbol table is loaded.  Use the \"file\" command.\n");
+        return 0;

     }
     }

-    /* 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';
+    /* trim left and right */
+    s = trim(s);

 
     /* case a) nothing */
     /* if nothing given then current location : we know
        the current execution location from the currentContext */
     if (! *s ) {
 
 
     /* case a) nothing */
     /* if nothing given then current location : we know
        the current execution location from the currentContext */
     if (! *s ) {
 

-       /* if current context is known */
-       if (cctxt->func) {
+        /* if current context is known */
+        if (cctxt->func) {

         Dprintf(D_break, ("commonSetUserBp: a) cctxtaddr:%x \n",cctxt->addr));
         Dprintf(D_break, ("commonSetUserBp: a) cctxtaddr:%x \n",cctxt->addr));

-           if (srcMode == SRC_CMODE)
-               /* set the break point */
-               setBreakPoint ( cctxt->addr , CODE , bpType , userBpCB ,
-                               cctxt->func->mod->c_name, cctxt->cline);
-           else
-               setBreakPoint ( cctxt->addr , CODE , bpType , userBpCB ,
-                               cctxt->func->mod->asm_name, cctxt->asmline);
-               
-       }
-       else
-           fprintf(stderr,"No default breakpoint address now.\n");
-                       
-       goto ret ;
+            if (srcMode == SRC_CMODE)
+                /* set the break point */
+                setBreakPoint ( cctxt->addr , CODE , bpType , userBpCB ,
+                                cctxt->func->mod->c_name, cctxt->cline);
+            else
+                setBreakPoint ( cctxt->addr , CODE , bpType , userBpCB ,
+                                cctxt->func->mod->asm_name, cctxt->asmline);
+
+        }
+        else
+            fprintf(stderr,"No default breakpoint address now.\n");
+
+        goto ret ;

     }
     /* case g) *addr */
     if ( *s == '*' && isdigit(*(s+1)))
     }
     /* case g) *addr */
     if ( *s == '*' && isdigit(*(s+1)))


@@ -1003,17 +1011,17 @@ 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%08lx not exists in code.\n",braddr);

             }
             else
             {
             }
             else
             {

-                Dprintf(D_break, ("commonSetUserBp: g) addr:%x \n",braddr));
+                Dprintf(D_break, ("commonSetUserBp: g) addr:%lx \n",braddr));

                 setBreakPoint ( braddr , CODE , bpType , userBpCB ,
                             modul->c_name,line);
             }
             goto ret ;
         }
                 setBreakPoint ( braddr , CODE , bpType , userBpCB ,
                             modul->c_name,line);
             }
             goto ret ;
         }

-               else
+                else

         {
             int line = func->exitline;
             if ( !applyToSet(func->cfpoints,lineAtAddr,braddr,
         {
             int line = func->exitline;
             if ( !applyToSet(func->cfpoints,lineAtAddr,braddr,


@@ -1022,87 +1030,91 @@ static int commonSetUserBp(char *s, context *cctxt, char bpType)
             setBreakPoint ( braddr , CODE , bpType , userBpCB ,
                             func->mod->c_name,line);
         }
             setBreakPoint ( braddr , CODE , bpType , userBpCB ,
                             func->mod->c_name,line);
         }

-       goto ret ;
+        goto ret ;

     }
     /* case b) lineno */
     /* check if line number */
     if ( !strchr(s,':') && isdigit(*s)) {
     }
     /* case b) lineno */
     /* check if line number */
     if ( !strchr(s,':') && isdigit(*s)) {

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

     Dprintf(D_break, ("commonSetUserBp: b) line:%d \n",line));
     Dprintf(D_break, ("commonSetUserBp: b) line:%d \n",line));

+    if ( line < 0 )
+    {
+                fprintf(stdout,"linenumber <= 0\n");
+        goto ret;
+    }
+        /* 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
+        */
+        if (cctxt->func) {
+            if (!cctxt->func->mod) {
+                if (!applyToSet(functions,funcWithName,"main"))
+                    fprintf(stderr,"Function \"main\" not defined.\n");
+                else
+                    setBPatModLine(func->mod,line, bpType);
+            } else
+                setBPatModLine(cctxt->func->mod,line, bpType);
+        } else {
+                if (list_mod) {
+                        setBPatModLine(list_mod,line, bpType);
+                } else {
+                  fprintf(stdout,"Sdcdb fails to have module symbol context at %d\n", __LINE__);
+                }
+        }

 
 

-       /* 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 
-       */
-       if (cctxt->func) {
-           if (!cctxt->func->mod) {
-               if (!applyToSet(functions,funcWithName,"main"))
-                   fprintf(stderr,"Function \"main\" not defined.\n");
-               else 
-                   setBPatModLine(func->mod,line, bpType);
-           } else 
-               setBPatModLine(cctxt->func->mod,line, bpType);
-       } else {
-               if (list_mod) {
-                       setBPatModLine(list_mod,line, bpType);
-               } else {
-                 fprintf(stdout,"Sdcdb fails to have module symbol context at %d\n", __LINE__);
-               }
-       }
-       
-       goto ret;
+        goto ret;

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

-       
-       module *mod = NULL;
-       *bp = '\0';
-       
-       if (srcMode == SRC_CMODE) {
-           if (!applyToSet(modules,moduleWithCName,s,&mod)) {
-               fprintf (stderr,"No source file named %s.\n",s);
-               goto ret;
-           }
-       } else {
-           if (!applyToSet(modules,moduleWithAsmName,s,&mod)) {
-               fprintf (stderr,"No source file named %s.\n",s);
-               goto ret;
-           }
-       }
-               
-       /* case c) filename:lineno */
-       if (isdigit(*(bp +1))) {                         
+
+        module *mod = NULL;
+        *bp = '\0';
+
+        if (srcMode == SRC_CMODE) {
+            if (!applyToSet(modules,moduleWithCName,s,&mod)) {
+                fprintf (stderr,"No source file named %s.\n",s);
+                goto ret;
+            }
+        } else {
+            if (!applyToSet(modules,moduleWithAsmName,s,&mod)) {
+                fprintf (stderr,"No source file named %s.\n",s);
+                goto ret;
+            }
+        }
+
+        /* case c) filename:lineno */
+        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);       
-           goto ret;
-           
-       }
-       /* case d) filename:function */
-       if (!applyToSet(functions,funcWithNameModule,bp+1,s,&func)) 
-           fprintf(stderr,"Function \"%s\" not defined.\n",bp+1); 
-       else        
+            setBPatModLine (mod,atoi(bp+1)-1,bpType);
+            goto ret;
+
+        }
+        /* case d) filename:function */
+        if (!applyToSet(functions,funcWithNameModule,bp+1,s,&func))
+            fprintf(stderr,"Function \"%s\" not defined.\n",bp+1);
+        else

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

-           setBPatModLine (mod,
-                           (srcMode == SRC_CMODE ? 
-                            func->entryline :
-                            func->aentryline),bpType);
-       
-       goto ret;
-    }
-            
+            setBPatModLine (mod,
+                            (srcMode == SRC_CMODE ?
+                             func->entryline :
+                             func->aentryline),bpType);
+
+        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
     else

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

 
 

- ret:    
+ ret:

     return 0;
 }
 
     return 0;
 }
 


@@ -1127,22 +1139,18 @@ int cmdSetUserBp (char *s, context *cctxt)
 /*-----------------------------------------------------------------*/
 int cmdJump (char *s, context *cctxt)
 {
 /*-----------------------------------------------------------------*/
 int cmdJump (char *s, context *cctxt)
 {

-    char *bp ;
+    char *bp;

     function *func = NULL;
     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++;
-    
-    /* null terminate it after stripping trailing blanks*/
-    bp = s + strlen(s);
-    while (bp != s && isspace(*bp)) bp--;
-    *bp = '\0';
-    if (! *s ) 
+    /* trim left and right */
+    s = trim(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;


@@ -1161,13 +1169,13 @@ 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");
+                    fprintf(stderr,"Function not defined.\n");

             return 0;
         }
         if (line >= cctxt->func->entryline &&
             return 0;
         }
         if (line >= cctxt->func->entryline &&


@@ -1178,32 +1186,32 @@ int cmdJump (char *s, context *cctxt)
         }
         if (line >= cctxt->func->mod->ncLines )
         {
         }
         if (line >= cctxt->func->mod->ncLines )
         {

-                   fprintf(stderr,"line not in module.\n");
+                    fprintf(stderr,"line not in module.\n");

             return 0;
         }
         fprintf(stdout,"Warning line %d outside actual function.\n",line+1);
         simSetPC(cctxt->func->mod->cLines[line]->addr);
         return 0;
     }
             return 0;
         }
         fprintf(stdout,"Warning line %d outside actual function.\n",line+1);
         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 )
         {

-                   fprintf(stderr,"line not in module.\n");
+                    fprintf(stderr,"line not in module.\n");

             return 0;
         }
         if ( mod != cctxt->func->mod ||
             return 0;
         }
         if ( mod != cctxt->func->mod ||


@@ -1212,7 +1220,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;


@@ -1223,12 +1231,15 @@ 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 */
     {
         /* actual line */

-        if (printAsmLine(cctxt->func,cctxt->func->mod,
+        if ( cctxt->addr != INT_MAX )
+        {
+            if (printAsmLine(cctxt->func,cctxt->func->mod,

                          (long)cctxt->addr,(long)cctxt->addr))
                          (long)cctxt->addr,(long)cctxt->addr))

-            return 0; 
+            return 0;
+        }

     }
     return 0;
 }
     }
     return 0;
 }


@@ -1238,18 +1249,18 @@ int cmdListAsm (char *s, context *cctxt)
 /*-----------------------------------------------------------------*/
 int cmdSetOption (char *s, context *cctxt)
 {
 /*-----------------------------------------------------------------*/
 int cmdSetOption (char *s, context *cctxt)
 {

-    while (*s && isspace(*s)) s++;
+    s = trim_left(s);

     if (strncmp(s,"srcmode",7) == 0 ) {
     if (strncmp(s,"srcmode",7) == 0 ) {

-       if (srcMode == SRC_CMODE)
-           srcMode = SRC_AMODE;
-       else
-           srcMode = SRC_CMODE;
-       fprintf(stderr,"source mode set to '%s'\n", 
-               (srcMode == SRC_CMODE ? "C" : "asm"));
-       return 0;
+        if (srcMode == SRC_CMODE)
+            srcMode = SRC_AMODE;
+        else
+            srcMode = SRC_CMODE;
+        fprintf(stderr,"source mode set to '%s'\n",
+                (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 )


@@ -1258,13 +1269,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;


@@ -1275,18 +1286,18 @@ int cmdSetOption (char *s, context *cctxt)
         s = rs;
         while (*s && *s != '=') s++;
         *s++ = '\0';
         s = rs;
         while (*s && *s != '=') s++;
         *s++ = '\0';

-        while (isspace(*s)) *s++ = '\0';
-        if (*s)
+        s = trim_left(s);
+        if (*s && sym)

         {
         {

-                printOrSetSymValue(sym,cctxt,0,0,0,rs,s,'\0');
-                return 0;
+            printOrSetSymValue(sym,cctxt,0,0,0,rs,s,'\0');
+            return 0;

         }
         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;
 }


@@ -1297,8 +1308,8 @@ int cmdSetOption (char *s, context *cctxt)
 int cmdContinue (char *s, context *cctxt)
 {
     if (STACK_EMPTY(callStack)) {
 int cmdContinue (char *s, context *cctxt)
 {
     if (STACK_EMPTY(callStack)) {

-       fprintf(stdout,"The program is not being run.\n");
-       return 0;
+        fprintf(stdout,"The program is not being run.\n");
+        return 0;

     }
 
     fprintf(stdout,"Continuing.\n");
     }
 
     fprintf(stdout,"Continuing.\n");


@@ -1311,17 +1322,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 ;
     int bpnum, cnt ;

-    while (isspace(*s)) s++;
-    if (!*s ) 
+    s = trim_left(s);
+    if (!*s )

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

-    while (isspace(*s)) s++;
-    if (!*s ) 
+    s = trim_left(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;


@@ -1335,16 +1346,16 @@ 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 ;
     int bpnum ;

-    while (isspace(*s)) s++;
-    if (!*s ) 
+    s = trim_left(s);
+    if (!*s )

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

-    while (isspace(*s)) s++;
+    s = trim_left(s);

     if (*s)
         s = Safe_strdup(s);
     else
     if (*s)
         s = Safe_strdup(s);
     else


@@ -1357,12 +1368,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;
     int bpnum ;
     char *cmds,*line;

-    while (isspace(*s)) s++;
-    
-    if (!*s ) 
+    s = trim_left(s);
+
+    if (!*s )

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


@@ -1370,7 +1381,7 @@ int cmdCommands (char *s, context *cctxt)
     cmds = NULL;
     while ((line = getNextCmdLine()))
     {
     cmds = NULL;
     while ((line = getNextCmdLine()))
     {

-        while (isspace(*line)) line++;
+        line = trim_left(line);

         if (!strncmp(line,"end",3))
             break;
         if (! cmds )
         if (!strncmp(line,"end",3))
             break;
         if (! cmds )


@@ -1393,23 +1404,23 @@ int cmdCommands (char *s, context *cctxt)
 int cmdDelUserBp (char *s, context *cctxt)
 {
     int bpnum ;
 int cmdDelUserBp (char *s, context *cctxt)
 {
     int bpnum ;

-    while (isspace(*s)) s++;
-    
+    s = trim_left(s);
+

     if (!*s ) {
     if (!*s ) {

-       if (userBpPresent) {
-           char buffer[10];
-           fprintf (stdout,"Delete all breakpoints? (y or n) ");
-           fflush(stdout);
-           fgets(buffer,sizeof(buffer),stdin);
-           if (toupper(buffer[0]) == 'Y')
-               deleteUSERbp(-1);          
-       }
-       return 0;
-    }
-    
+        if (userBpPresent) {
+            char buffer[10];
+            fprintf (stdout,"Delete all breakpoints? (y or n) ");
+            fflush(stdout);
+            fgets(buffer,sizeof(buffer),stdin);
+            if (toupper(buffer[0]) == 'Y')
+                deleteUSERbp(-1);
+        }
+        return 0;
+    }
+

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

-       deleteUSERbp(bpnum);
+        deleteUSERbp(bpnum);

 
     return 0;
 }
 
     return 0;
 }


@@ -1420,12 +1431,12 @@ int cmdDelUserBp (char *s, context *cctxt)
 int cmdStepi (char *s, context *cctxt)
 {
 
 int cmdStepi (char *s, context *cctxt)
 {
 

-    if (STACK_EMPTY(callStack))
+    if (0 /*STACK_EMPTY(callStack)*/)

         fprintf(stdout,"The program is not being run.\n");
         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;
     }


@@ -1449,7 +1460,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);


@@ -1458,50 +1469,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);
                 }
             }


@@ -1522,13 +1533,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;
 }
 


@@ -1551,7 +1562,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);


@@ -1563,17 +1574,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 {


@@ -1582,26 +1593,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;
 }
 


@@ -1612,27 +1623,27 @@ int cmdRun (char *s, context *cctxt)
 {
     char buff[10];
     if (STACK_EMPTY(callStack)) {
 {
     char buff[10];
     if (STACK_EMPTY(callStack)) {

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

     if ( ! simactive )
     {
         fprintf(stdout,"No executable file specified.\nUse the \"file\" command.\n");
         return 0;
     }
     resetHitCount();
     if ( ! simactive )
     {
         fprintf(stdout,"No executable file specified.\nUse the \"file\" command.\n");
         return 0;
     }
     resetHitCount();

-       simGo(0);
+        simGo(0);

     } else {
     } else {

-       
-       fprintf(stdout,
-               "The program being debugged has been started already.\n");
-       fprintf(stdout,"Start it from the beginning? (y or n) ");
-       fflush(stdout);
-
-       fgets(buff,sizeof(buff),stdin);
-       if (toupper(buff[0]) == 'Y') {
-           simReset();
+
+        fprintf(stdout,
+                "The program being debugged has been started already.\n");
+        fprintf(stdout,"Start it from the beginning? (y or n) ");
+        fflush(stdout);
+
+        fgets(buff,sizeof(buff),stdin);
+        if (toupper(buff[0]) == 'Y') {
+            simReset();

         resetHitCount();
         resetHitCount();

-           simGo(0);
-       }
+            simGo(0);
+        }

     }
     showfull = 1;
     return 0;
     }
     showfull = 1;
     return 0;


@@ -1667,11 +1678,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);


@@ -1698,19 +1709,17 @@ int cmdListFunctions (char *s, context *cctxt)
     printf("[functions]\n");
     f = setFirstItem(functions);
     i = 0;
     printf("[functions]\n");
     f = setFirstItem(functions);
     i = 0;

-    for (;;) {
-      if (f == NULL)
-        break;
+    while (f != NULL) {

       if (our_verbose) {
       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 {

-        printf("<%s>", f->modName);
+        printf("<%s>", f->sym->name);

       }
       ++i;
       f = setNextItem(functions);
       }
       ++i;
       f = setNextItem(functions);


@@ -1720,7 +1729,7 @@ int cmdListFunctions (char *s, context *cctxt)
 }
 
 /*-----------------------------------------------------------------
 }
 
 /*-----------------------------------------------------------------

- cmdListModules - list functions.
+ cmdListModules - list modules.

 |-----------------------------------------------------------------*/
 int cmdListModules (char *s, context *cctxt)
 {
 |-----------------------------------------------------------------*/
 int cmdListModules (char *s, context *cctxt)
 {


@@ -1747,7 +1756,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) {


@@ -1789,15 +1798,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 *******************/


@@ -1815,7 +1824,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) {


@@ -1860,11 +1869,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;


@@ -1889,11 +1898,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);


@@ -1909,26 +1918,26 @@ 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,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);
-    fprintf(stdout,"PC  : 0x%04X  RegisterBank %d:\nR0-7:",ctxt->addr,(i>>3)&3);
+    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++ )
     {
     for ( j = 0; j < 8 ; j++ )
     {

-        val = simGetValue (j ,'R',1);
-        fprintf(stdout," 0x%02X",val);
+        val = simGetValue (j,'R',1);
+        fprintf(stdout," 0x%02lX",val);

     }
     fprintf(stdout,"\n");
     val = simGetValue (0xe0,'I',1);
     }
     fprintf(stdout,"\n");
     val = simGetValue (0xe0,'I',1);

-    fprintf(stdout,"ACC : 0x%02X %d %c\n",val,val,(isprint(val) ? val : '.'));
+    fprintf(stdout,"ACC : 0x%02lX %lu %c\n",val,val,(isprint(val) ? (char)val : '.'));

     val = simGetValue (0xf0,'I',1);
     val = simGetValue (0xf0,'I',1);

-    fprintf(stdout,"B   : 0x%02X %d %c\n",val,val,(isprint(val) ? val : '.'));
+    fprintf(stdout,"B   : 0x%02lX %lu %c\n",val,val,(isprint(val) ? (char)val : '.'));

     val = simGetValue (0x82,'I',2);
     val = simGetValue (0x82,'I',2);

-    fprintf(stdout,"DPTR: 0x%04X %d\n",val,val);
+    fprintf(stdout,"DPTR: 0x%04lX %lu\n",val,val);

     val = simGetValue (0x81,'I',1);
     val = simGetValue (0x81,'I',1);

-    fprintf(stdout,"SP  : 0x%02X\n",val);
+    fprintf(stdout,"SP  : 0x%02lX (0x%04lX)\n",val,simGetValue (val-1,'B',2));

     fprintf(stdout,"PSW : 0x%02X | CY : %c | AC : %c | OV : %c | P : %c\n",
             i,(i&0x80)?'1':'0',(i&0x40)?'1':'0',(i&4)?'1':'0',(i&1)?'1':'0');
     if ( all )
     fprintf(stdout,"PSW : 0x%02X | CY : %c | AC : %c | OV : %c | P : %c\n",
             i,(i&0x80)?'1':'0',(i&0x40)?'1':'0',(i&4)?'1':'0',(i&1)?'1':'0');
     if ( all )


@@ -1947,7 +1956,7 @@ static void infoRegisters( int all, context *ctxt)
             if (applyToSetFTrue(sfrsymbols,symWithAddr,i,'I',&sym))
             {
                 val = simGetValue (sym->addr,sym->addrspace,sym->size);
             if (applyToSetFTrue(sfrsymbols,symWithAddr,i,'I',&sym))
             {
                 val = simGetValue (sym->addr,sym->addrspace,sym->size);

-                fprintf(stdout,"%s : 0x%02x",sym->name,val);
+                fprintf(stdout,"%s : 0x%02lx",sym->name,val);

                 if ( !(i & 0x07 ))
                 {
                     for ( j = 0 ; j < 8 ; j++ )
                 if ( !(i & 0x07 ))
                 {
                     for ( j = 0 ; j < 8 ; j++ )


@@ -1979,9 +1988,9 @@ static void infoStack(context *ctxt)
     while ((func = STACK_WALK(callStack))) {
     Dprintf(D_break, ("break: infoStack: %s %p (%p)\n",func->sym->name, w_callStack,p_callStack));
 
     while ((func = STACK_WALK(callStack))) {
     Dprintf(D_break, ("break: infoStack: %s %p (%p)\n",func->sym->name, w_callStack,p_callStack));
 

-       fprintf(stdout,"#%d  0x%08x in %s () at %s:%d\n",i++,
-               func->laddr,func->sym->name,
-               func->mod->c_name,func->lline+1);
+        fprintf(stdout,"#%d  0x%08x in %s () at %s:%d\n",i++,
+                func->laddr,func->sym->name,
+                func->mod->c_name,func->lline+1);

     }
     if ( !i )
         fprintf(stdout,"no stack.\n");
     }
     if ( !i )
         fprintf(stdout,"no stack.\n");


@@ -1992,8 +2001,8 @@ static void infoStack(context *ctxt)
 /*-----------------------------------------------------------------*/
 int cmdWhere(char *s, context *cctxt)
 {
 /*-----------------------------------------------------------------*/
 int cmdWhere(char *s, context *cctxt)
 {

-       infoStack(cctxt);
-       return 0;
+        infoStack(cctxt);
+        return 0;

 }
 
 
 }
 
 


@@ -2003,26 +2012,27 @@ static int infomode = 0;
 /*-----------------------------------------------------------------*/
 int cmdInfo (char *s, context *cctxt)
 {
 /*-----------------------------------------------------------------*/
 int cmdInfo (char *s, context *cctxt)
 {

-    while (isspace(*s)) s++;
+    /* trim left and_right*/
+    s = trim(s);

 
     /* list all break points */
     if (strncmp(s,"break",5) == 0) {
 
     /* list all break points */
     if (strncmp(s,"break",5) == 0) {

-       listUSERbp();
-       return 0;
+        listUSERbp();
+        return 0;

     }
 
     /* info frame same as frame */
     }
 
     /* info frame same as frame */

-    if (strcmp(s,"frame") == 0) {
-       cmdFrame (s,cctxt);
-       return 0;
+    if (strncmp(s,"frame",5) == 0) {
+        cmdFrame (s+5,cctxt);
+        return 0;

     }
 
     if (strncmp(s,"line",4) == 0) {
     }
 
     if (strncmp(s,"line",4) == 0) {

-    infomode=1;
-       cmdListSrc (s+4,cctxt);
-       return 0;
+        infomode=1;
+        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' )


@@ -2031,14 +2041,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;


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

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

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


@@ -2069,19 +2079,19 @@ int cmdInfo (char *s, context *cctxt)
     }
     /* info stack display call stack */
     if (strcmp(s,"stack") == 0) {
     }
     /* info stack display call stack */
     if (strcmp(s,"stack") == 0) {

-       infoStack(cctxt);
-    showfull = 1;
-       return 0;
+        infoStack(cctxt);
+        showfull = 1;
+        return 0;

     }
 
     /* info stack display call stack */
     if (strcmp(s,"registers") == 0) {
         infoRegisters(0,cctxt);
     }
 
     /* info stack display call stack */
     if (strcmp(s,"registers") == 0) {
         infoRegisters(0,cctxt);

-           return 0;
+            return 0;

     }
 
     /* 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;


@@ -2111,9 +2121,9 @@ 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)
     if (simactive)

-       closeSimulator();
+        closeSimulator();

     return 1;
 }
 
     return 1;
 }
 


@@ -2121,7 +2131,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;


@@ -2129,8 +2139,8 @@ int cmdListSrc (char *s, context *cctxt)
     function *func = NULL;
 
 
     function *func = NULL;
 
 

-    while (*s && isspace(*s)) s++;
-    
+    s = trim_left(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


@@ -2140,118 +2150,118 @@ int cmdListSrc (char *s, context *cctxt)
        FILE:FUNCTION - function in file */
 
     if (*s) {
        FILE:FUNCTION - function in file */
 
     if (*s) {

-       /* case a) LINE */
-       if (isdigit(*s)) {
-           if (!cctxt || !cctxt->func || !cctxt->func->mod) {
-             if (!list_mod) {
-               fprintf(stdout,"Sdcdb fails to have a proper context at %d.\n", __LINE__);
-               return 0;
-             }
-           }
-           else
-             list_mod = cctxt->func->mod;
+        /* case a) LINE */
+        if (isdigit(*s)) {
+            if (!cctxt || !cctxt->func || !cctxt->func->mod) {
+              if (!list_mod) {
+                fprintf(stdout,"Sdcdb fails to have a proper context at %d.\n", __LINE__);
+                return 0;
+              }
+            }
+            else
+              list_mod = cctxt->func->mod;

         pline = strtol(s,&s,10) - 1;
         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
                 llines = listlines;
         }
             if ( llines > 0 )
                 llines -= pline+1;
             else
                 llines = listlines;
         }

-       }
-       else {
-           char *bp;
-           
-           /* if ':' present then FILE:LINE || FILE:FUNCTION */
-           if ((bp = strchr(s,':'))) {
-               *bp = '\0';
-               bp ++;
-               if (isdigit(*bp)) {
-                   /* FILE:LINE */
-                   list_mod=NULL;  /* bug fix 2-09-02, moduleWithCName expects mod to be null */
-                   if (srcMode == SRC_CMODE) {
-                       if (!applyToSet(modules,moduleWithCName,s,&list_mod)) {
-                           fprintf (stderr,"No c source file named %s.\n",s);
-                           return 0;
-                       }
-                   } else {
-                       if (!applyToSet(modules,moduleWithAsmName,s,&list_mod)) {
-                           fprintf (stderr,"No source file named %s.\n",s);
-                           return 0;
-                       }
-                   }
-                   pline = strtol(bp,&bp,10) - 1;
-            if (bp && (bp = strchr(bp,','))) 
+        }
+        else {
+            char *bp;
+
+            /* if ':' present then FILE:LINE || FILE:FUNCTION */
+            if ((bp = strchr(s,':'))) {
+                *bp = '\0';
+                bp ++;
+                if (isdigit(*bp)) {
+                    /* FILE:LINE */
+                    list_mod=NULL;  /* bug fix 2-09-02, moduleWithCName expects mod to be null */
+                    if (srcMode == SRC_CMODE) {
+                        if (!applyToSet(modules,moduleWithCName,s,&list_mod)) {
+                            fprintf (stderr,"No c source file named %s.\n",s);
+                            return 0;
+                        }
+                    } else {
+                        if (!applyToSet(modules,moduleWithAsmName,s,&list_mod)) {
+                            fprintf (stderr,"No source file named %s.\n",s);
+                            return 0;
+                        }
+                    }
+                    pline = strtol(bp,&bp,10) - 1;
+            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
                     llines = listlines;
             }
                 if ( llines > 0 )
                     llines -= pline+1;
                 else
                     llines = listlines;
             }

-               } else {
-                   /* FILE:FUCTION */
-                   if (!applyToSet(functions,funcWithNameModule,bp,s,&func)) {
-                       fprintf(stdout,"Function \"%s\" not defined.\n",bp);
-                       return 0;
-                   }
-                   list_mod = func->mod;
-                   if (srcMode == SRC_CMODE) {
-                       pline = func->entryline;
-                       llines = func->exitline - func->entryline + 1;
-                   } else {
-                       pline = func->aentryline;
-                       llines = func->aexitline - func->aentryline + 1;
-                   }
-               }
-           }
-           else {
-               /* FUNCTION */
-            if (*s == '\'') 
+                } else {
+                    /* FILE:FUCTION */
+                    if (!applyToSet(functions,funcWithNameModule,bp,s,&func)) {
+                        fprintf(stdout,"Function \"%s\" not defined.\n",bp);
+                        return 0;
+                    }
+                    list_mod = func->mod;
+                    if (srcMode == SRC_CMODE) {
+                        pline = func->entryline;
+                        llines = func->exitline - func->entryline + 1;
+                    } else {
+                        pline = func->aentryline;
+                        llines = func->aexitline - func->aentryline + 1;
+                    }
+                }
+            }
+            else {
+                /* FUNCTION */
+            if (*s == '\'')

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

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

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

-                
+

             }
             }

-               if (!applyToSet(functions,funcWithName,s,&func)) {
-                   fprintf(stderr,"Function \"%s\" not defined.\n",s); 
-                   return 0;
-               }
-               else {
-                   list_mod = func->mod;
-                   if (srcMode == SRC_CMODE) {
-                       pline = func->entryline;
-                       llines = func->exitline - func->entryline + 1; 
-                   } else {
-                       pline = func->aentryline;
-                       llines = func->aexitline - func->aentryline + 1; 
-                   }
-               }
-           }
-       }
+                if (!applyToSet(functions,funcWithName,s,&func)) {
+                    fprintf(stderr,"Function \"%s\" not defined.\n",s);
+                    return 0;
+                }
+                else {
+                    list_mod = func->mod;
+                    if (srcMode == SRC_CMODE) {
+                        pline = func->entryline;
+                        llines = func->exitline - func->entryline + 1;
+                    } else {
+                        pline = func->aentryline;
+                        llines = func->aexitline - func->aentryline + 1;
+                    }
+                }
+            }
+        }

     } else {
     } else {

-       /* if no line specified & we had listed
-          before then continue from that listing */
-       if (currline)
-           pline = currline ;
-       else {
-           if (!cctxt || !cctxt->func || !cctxt->func->mod) {
-             fprintf(stdout,"Missing context at %d. Try list filename:lineno\n", __LINE__);
-             return 0;
-           }
-           list_mod = cctxt->func->mod;
-           if (srcMode == SRC_CMODE)
-               pline = cctxt->cline;
-           else
-               pline = cctxt->asmline;
-       }
+        /* if no line specified & we had listed
+           before then continue from that listing */
+        if (currline)
+            pline = currline ;
+        else {
+            if (!cctxt || !cctxt->func || !cctxt->func->mod) {
+              fprintf(stdout,"Missing context at %d. Try list filename:lineno\n", __LINE__);
+              return 0;
+            }
+            list_mod = cctxt->func->mod;
+            if (srcMode == SRC_CMODE)
+                pline = cctxt->cline;
+            else
+                pline = cctxt->asmline;
+        }

     }
 
     if (!list_mod) {
     }
 
     if (!list_mod) {


@@ -2263,28 +2273,27 @@ int cmdListSrc (char *s, context *cctxt)
         return 0;
     if ( infomode )
     {
         return 0;
     if ( infomode )
     {

-        int firstaddr , lastaddr ;
-           if ( pline  >= list_mod->ncLines )
+        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;
             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 : "?",
                 func ? lastaddr -func->sym->addr : 0);
         llines = pline +1;
                 pline+1,
                 list_mod->c_name, lastaddr,
                 func ? func->sym->name : "?",
                 func ? lastaddr -func->sym->addr : 0);
         llines = pline +1;

-        while ( pline < list_mod->ncLines )
+        for ( ; pline < list_mod->ncLines; pline++ )

         {
         {

-            pline++;

             if ( list_mod->cLines[pline]->addr > lastaddr )
             {
                 lastaddr = list_mod->cLines[pline]->addr -1;
                 break;
             }
         }
             if ( list_mod->cLines[pline]->addr > lastaddr )
             {
                 lastaddr = list_mod->cLines[pline]->addr -1;
                 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);


@@ -2298,17 +2307,17 @@ int cmdListSrc (char *s, context *cctxt)
         return 0;
     }
     for ( i = 0 ; i < llines ; i++ ) {
         return 0;
     }
     for ( i = 0 ; i < llines ; i++ ) {

-       if (srcMode == SRC_CMODE) {
-           if ( (pline + i) >= list_mod->ncLines )
-               break;
-           fprintf(stdout,"%d\t%s",pline + i,
-                   list_mod->cLines[pline +i]->src);
-       } else {
-           if ( (pline + i) >= list_mod->nasmLines )
-               break;
-           fprintf(stdout,"%d\t%s",pline + i,
-                   list_mod->asmLines[pline +i]->src);
-       }
+        if (srcMode == SRC_CMODE) {
+            if ( (pline + i) >= list_mod->ncLines )
+                break;
+            fprintf(stdout,"%d\t%s",pline + i,
+                    list_mod->cLines[pline +i]->src);
+        } else {
+            if ( (pline + i) >= list_mod->nasmLines )
+                break;
+            fprintf(stdout,"%d\t%s",pline + i,
+                    list_mod->asmLines[pline +i]->src);
+        }

     }
     currline = pline + i ;
     return 0;
     }
     currline = pline + i ;
     return 0;


@@ -2317,9 +2326,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 {


@@ -2329,14 +2338,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
     else

-       if (IS_PTR(type))
-           v.val = strtol(val,NULL,0);
-       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 )


@@ -2349,7 +2358,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


@@ -2358,14 +2367,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);
     }


@@ -2375,20 +2384,20 @@ 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  };

-       char buf[40];
-       char negative = 0;
-       int charPos = 38;
+        char buf[40];
+        char negative = 0;
+        int charPos = 38;

     int radix;
 
     if ( fmt == FMT_NON || fmt == FMT_DEZ )
     int radix;
 
     if ( fmt == FMT_NON || fmt == FMT_DEZ )


@@ -2403,16 +2412,16 @@ static void printFmtInteger(char *deffmt,int fmt, long val,
         negative = 1;
     */
 
         negative = 1;
     */
 

-       if (!negative)
-           val = -val;
+        if (!negative)
+            val = -val;

 
 

-       buf[39] = '\0';
-    while (val <= -radix) 
+        buf[39] = '\0';
+    while (val <= -radix)

     {
     {

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

 
     switch ( fmt )
     {
 
     switch ( fmt )
     {


@@ -2430,7 +2439,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:


@@ -2442,9 +2451,9 @@ static void printFmtInteger(char *deffmt,int fmt, long val,
             buf[--charPos] = '0';
             break;
     }
             buf[--charPos] = '0';
             break;
     }

-       if (negative) {
-           buf[--charPos] = '-';
-       }
+        if (negative) {
+            buf[--charPos] = '-';
+        }

     fputs(&buf[charPos],stdout);
 }
 
     fputs(&buf[charPos],stdout);
 }
 


@@ -2454,29 +2463,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
     else

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

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


@@ -2484,7 +2490,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);


@@ -2494,7 +2500,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);


@@ -2510,11 +2516,11 @@ static void printValBasic(symbol *sym, link *type,
                     if (IS_BITVAR(etype))
                         fprintf(stdout,"%c",(v.val?'1':'0'));
                     else
                     if (IS_BITVAR(etype))
                         fprintf(stdout,"%c",(v.val?'1':'0'));
                     else

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

                 }
             }
                 }
             }

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

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


@@ -2531,45 +2537,45 @@ static void printValFunc (symbol *sym, int fmt)
 static void printArrayValue (symbol *sym,  link *type,
                              char space, unsigned int addr, int fmt)
 {
 static void printArrayValue (symbol *sym,  link *type,
                              char space, unsigned int addr, int fmt)
 {

-       link *elem_type = type->next;
-       int i;
-       
-       fprintf(stdout,"{");
-       for (i = 0 ; i < DCL_ELEM(type) ; i++) {                
-               if (IS_AGGREGATE(elem_type)) {
-                       printValAggregates(sym,elem_type,space,addr,fmt);                      
-               } else {
-                       printValBasic(sym,elem_type,space,addr,getSize(elem_type),fmt);
-               }
-               addr += getSize(elem_type);
-               if (i != DCL_ELEM(type) -1)
-                       fprintf(stdout,",");
-       }
+        link *elem_type = type->next;
+        int i;
+
+        fprintf(stdout,"{");
+        for (i = 0 ; i < DCL_ELEM(type) ; i++) {
+                if (IS_AGGREGATE(elem_type)) {
+                        printValAggregates(sym,elem_type,space,addr,fmt);
+                } else {
+                        printValBasic(sym,elem_type,space,addr,getSize(elem_type),fmt);
+                }
+                addr += getSize(elem_type);
+                if (i != DCL_ELEM(type) -1)
+                        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;
+        symbol *fields = SPEC_STRUCT(type)->fields;

     int first = 1;
     int first = 1;

-       fprintf(stdout," { ");
-       while (fields) {
-               fprintf(stdout,"%s%s = ",(first ? "": ", "),fields->name);
-               first = 0;
+        fprintf(stdout," { ");
+        while (fields) {
+                fprintf(stdout,"%s%s = ",(first ? "": ", "),fields->name);
+                first = 0;

         if (IS_AGGREGATE(fields->type)) {
         if (IS_AGGREGATE(fields->type)) {

-                       printValAggregates(fields,fields->type,space, addr, fmt);
-               } else {
-                       printValBasic(fields,fields->type,space,addr,getSize(fields->type), fmt);
-               }
-               addr += getSize(fields->type);
-               fields = fields->next;
-       }
-       fprintf(stdout,"}");
+                        printValAggregates(fields,fields->type,space, addr, fmt);
+                } else {
+                        printValBasic(fields,fields->type,space,addr,getSize(fields->type), fmt);
+                }
+                addr += getSize(fields->type);
+                fields = fields->next;
+        }
+        fprintf(stdout,"}");

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


@@ -2579,58 +2585,58 @@ static void printValAggregates (symbol *sym, link *type,
                                 char space,unsigned int addr, int fmt)
 {
 
                                 char space,unsigned int addr, int fmt)
 {
 

-       if (IS_ARRAY(type)) {
-               printArrayValue(sym, type, space, addr, fmt);
-               return ;
-       }
+        if (IS_ARRAY(type)) {
+                printArrayValue(sym, type, space, addr, fmt);
+                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;
                                 char *val, char cmp )
 {
     static char fmtChar[] = " todx ";
     static int stack = 1;

-       symbol *fields;
+        symbol *fields;

     link *type;
     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]);


@@ -2662,13 +2668,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));
             }


@@ -2679,7 +2685,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);


@@ -2694,7 +2700,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;


@@ -2703,7 +2709,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);


@@ -2716,7 +2722,7 @@ static int printOrSetSymValue (symbol *sym, context *cctxt,
     /* arrays & structures first */
     if (IS_AGGREGATE(type))
     {
     /* arrays & structures first */
     if (IS_AGGREGATE(type))
     {

-           if ( val )
+            if ( val )

         {
             fprintf(stdout,"Cannot set/compare aggregate variable\n");
             return 1;
         {
             fprintf(stdout,"Cannot set/compare aggregate variable\n");
             return 1;


@@ -2725,17 +2731,17 @@ static int printOrSetSymValue (symbol *sym, context *cctxt,
             printValAggregates(sym,type,sym->addrspace,addr,fmt);
     }
     else
             printValAggregates(sym,type,sym->addrspace,addr,fmt);
     }
     else

-       /* functions */
-       if (IS_FUNC(type))
+        /* functions */
+        if (IS_FUNC(type))

     {
     {

-           if ( !val )
+            if ( !val )

             printValFunc(sym,fmt);
         else
             return 1;
     }
             printValFunc(sym,fmt);
         else
             return 1;
     }

-       else
-    { 
-           if ( val )
+        else
+    {
+            if ( val )

         {
             unsigned long newval;
             newval = getValBasic(sym,type,val);
         {
             unsigned long newval;
             newval = getValBasic(sym,type,val);


@@ -2756,7 +2762,14 @@ static int printOrSetSymValue (symbol *sym, context *cctxt,
             }
             else
             {
             }
             else
             {

-                simSetValue(addr,sym->addrspace,size,newval);  
+                if ( sym->addrspace == 'I' && addr == 0xb8 )
+                {
+                    /* Symbol with address of IP */
+                    if ( cctxt ) cctxt->addr = newval;
+                    simSetPC(cctxt->addr);
+                }
+                else
+                    simSetValue(addr,sym->addrspace,size,newval);

                 return 1;
             }
         }
                 return 1;
             }
         }


@@ -2764,7 +2777,7 @@ static int printOrSetSymValue (symbol *sym, context *cctxt,
             printValBasic(sym,type,sym->addrspace,addr,size,fmt);
     }
     if ( flg > 0 ) fprintf(stdout,"\n");
             printValBasic(sym,type,sym->addrspace,addr,size,fmt);
     }
     if ( flg > 0 ) fprintf(stdout,"\n");

-       return 0;
+        return 0;

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


@@ -2774,18 +2787,18 @@ static void printStructInfo (structdef *sdef)
 {
     symbol *field = sdef->fields ;
     int i = 0 ;
 {
     symbol *field = sdef->fields ;
     int i = 0 ;

-    
+

     while (field) {
     while (field) {

-       i += field->offset;
-       field = field->next;
+        i += field->offset;
+        field = field->next;

     }
 
     fprintf(stdout,"%s %s {\n",(i ? "struct" : "union" ), sdef->tag);
     field = sdef->fields;
     while (field) {
     }
 
     fprintf(stdout,"%s %s {\n",(i ? "struct" : "union" ), sdef->tag);
     field = sdef->fields;
     while (field) {

-       printTypeInfo (field->type);
-       fprintf(stdout," %s ;\n",field->name);
-       field = field->next ;
+        printTypeInfo (field->type);
+        fprintf(stdout," %s ;\n",field->name);
+        field = field->next ;

     }
 
     fprintf(stdout,"}\n");
     }
 
     fprintf(stdout,"}\n");


@@ -2798,72 +2811,72 @@ static void printStructInfo (structdef *sdef)
 static void printTypeInfo(link *p)
 {
     if (!p)
 static void printTypeInfo(link *p)
 {
     if (!p)

-       return ;
+        return ;

 
     if (IS_DECL(p)) {
 
     if (IS_DECL(p)) {

-       switch (DCL_TYPE(p))  {
-       case FUNCTION:
-           printTypeInfo (p->next);
-           fprintf(stdout,"()");
-           break;
-       case ARRAY:
-           printTypeInfo (p->next);
-           fprintf(stdout,"[%d]",DCL_ELEM(p));
-           break;
-       
-       case IPOINTER:
-       case PPOINTER:
-       case POINTER:
-           printTypeInfo (p->next);
-           fprintf(stdout,"(_near *)");
-           break;
-
-       case FPOINTER:
-           printTypeInfo (p->next);
-           fprintf(stdout,"(_xdata *)");
-           break;
-
-       case CPOINTER:
-           printTypeInfo( p->next);
-           fprintf(stdout,"(_code *)");
-           break;
-           
-       case GPOINTER:
-           printTypeInfo( p->next);
-           fprintf(stdout,"(_generic *)");
-           break;                   
-       }
+        switch (DCL_TYPE(p))  {
+        case FUNCTION:
+            printTypeInfo (p->next);
+            fprintf(stdout,"()");
+            break;
+        case ARRAY:
+            printTypeInfo (p->next);
+            fprintf(stdout,"[%d]",DCL_ELEM(p));
+            break;
+
+        case IPOINTER:
+        case PPOINTER:
+        case POINTER:
+            printTypeInfo (p->next);
+            fprintf(stdout,"(_near *)");
+            break;
+
+        case FPOINTER:
+            printTypeInfo (p->next);
+            fprintf(stdout,"(_xdata *)");
+            break;
+
+        case CPOINTER:
+            printTypeInfo( p->next);
+            fprintf(stdout,"(_code *)");
+            break;
+
+        case GPOINTER:
+            printTypeInfo( p->next);
+            fprintf(stdout,"(_generic *)");
+            break;
+        }

     } else {
     } 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) : 
-              fputs("int ",stdout))) ;
-           break;
-       case V_FLOAT:
-            fputs("float ",stdout);
-            break;
+        switch (SPEC_NOUN(p)) { /* depending on the specifier type */
+        case V_INT:
+            (IS_LONG(p) ? fputs("long ",stdout) :
+             ( IS_SHORT(p) ? fputs("short ",stdout) :
+               fputs("int ",stdout))) ;
+            break;
+        case V_FLOAT:
+             fputs("float ",stdout);
+             break;

 
 

-       case V_CHAR:
-           fputs ("char ",stdout);
-           break;
+        case V_CHAR:
+            fputs ("char ",stdout);
+            break;

 
 

-       case V_VOID:
-           fputs("void ",stdout);
-           break;
+        case V_VOID:
+            fputs("void ",stdout);
+            break;

 
 

-       case V_STRUCT:
-           printStructInfo (SPEC_STRUCT(p));
-           break;
+        case V_STRUCT:
+            printStructInfo (SPEC_STRUCT(p));
+            break;

 
 

-       case V_SBIT:
-           fputs("sbit ",stdout);
-           break;
+        case V_SBIT:
+            fputs("sbit ",stdout);
+            break;

 
 

-       case V_BIT:
-           fprintf(stdout,": %d" ,SPEC_BLEN(p));       
-           break;
-       }
+        case V_BIT:
+            fprintf(stdout,": %d" ,SPEC_BLEN(p));
+            break;
+        }

     }
 }
 
     }
 }
 


@@ -2871,7 +2884,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;


@@ -2882,12 +2895,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 )
             {


@@ -2896,7 +2909,7 @@ int conditionIsTrue( char *s, context *cctxt)
             }
             s++ ;
         }
             }
             s++ ;
         }

-        while (isspace(*s)) *s++ = '\0';
+        s = trim_left(s);

         fmt = printOrSetSymValue(sym,cctxt,0,0,0,rs,s,cmp_char);
     }
     Safe_free(dup);
         fmt = printOrSetSymValue(sym,cctxt,0,0,0,rs,s,cmp_char);
     }
     Safe_free(dup);


@@ -2907,17 +2920,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;
 }
 


@@ -2925,17 +2938,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;
 }
 


@@ -2966,7 +2979,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,


@@ -2978,7 +2991,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;


@@ -2989,7 +3002,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++ ;


@@ -3005,11 +3018,11 @@ 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;
 

-    while (isspace(*s)) s++;
+    s = trim_left(s);

     if (!*s)
     {
         for (dsym = setFirstItem(dispsymbols);
     if (!*s)
     {
         for (dsym = setFirstItem(dispsymbols);


@@ -3017,7 +3030,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;


@@ -3025,15 +3038,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;


@@ -3043,35 +3056,32 @@ 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 ;

 
 

-    while (isspace(*s)) s++;
+    /* trim left and right */
+    s = trim(s);

     if (!*s) return 0;
     if (!*s) return 0;

-    while (isspace(*bp)) bp--;
-    bp++ ;
-    *bp = '\0';

 
     if ((sym = symLookup(s,cctxt))) {
 
     if ((sym = symLookup(s,cctxt))) {

-       printTypeInfo(sym->type);
-       fprintf(stdout,"\n");
+        printTypeInfo(sym->type);
+        fprintf(stdout,"\n");

     } else {
     } else {

-       fprintf(stdout,
-               "No symbol \"%s\" in current context.\n",
-               s);
+        fprintf(stdout,
+                "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


@@ -3082,98 +3092,93 @@ int cmdClrUserBp (char *s, context *cctxt)
     */
 
     if (!cctxt) {
     */
 
     if (!cctxt) {

-       fprintf(stdout,"No symbol table is loaded.  Use the \"file\" command.\n");
-       return 0;
+        fprintf(stdout,"No symbol table is loaded.  Use the \"file\" command.\n");
+        return 0;

     }
 
     }
 

-    /* 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';
+    /* trim left and right */
+    s = trim(s);

 
     /* case a) nothing */
     /* if nothing given then current location : we know
        the current execution location from the currentContext */
     if (! *s ) {
 
 
     /* case a) nothing */
     /* if nothing given then current location : we know
        the current execution location from the currentContext */
     if (! *s ) {
 

-       /* if current context is known */
-       if (cctxt->func) 
-           /* clear the break point @ current location */
-           clearUSERbp (cctxt->addr);
-       else
-           fprintf(stderr,"No default breakpoint address now.\n");
-                       
-       goto ret ;
+        /* if current context is known */
+        if (cctxt->func)
+            /* clear the break point @ current location */
+            clearUSERbp (cctxt->addr);
+        else
+            fprintf(stderr,"No default breakpoint address now.\n");
+
+        goto ret ;

     }
 
     /* case b) lineno */
     /* check if line number */
     if (isdigit(*s)) {
     }
 
     /* case b) lineno */
     /* check if line number */
     if (isdigit(*s)) {

-       /* get the lineno */
-       int line = atoi(s);
-
-       /* 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 
-       */
-       if (cctxt->func) {
-           if (!cctxt->func->mod) {
-               if (!applyToSet(functions,funcWithName,"main"))
-                   fprintf(stderr,"Function \"main\" not defined.\n");
-               else 
-                   clearBPatModLine(func->mod,line);
-           } else 
-               clearBPatModLine(cctxt->func->mod,line);                        
-       }
-       
-       goto ret;
+        /* get the lineno */
+        int line = atoi(s);
+
+        /* 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
+        */
+        if (cctxt->func) {
+            if (!cctxt->func->mod) {
+                if (!applyToSet(functions,funcWithName,"main"))
+                    fprintf(stderr,"Function \"main\" not defined.\n");
+                else
+                    clearBPatModLine(func->mod,line);
+            } else
+                clearBPatModLine(cctxt->func->mod,line);
+        }
+
+        goto ret;

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

-       
-       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 (isdigit(*(bp +1))) {                    
-        
-           clearBPatModLine (mod,atoi(bp+1));      
-           goto ret;
-           
-       }
-       /* case d) filename:function */
-       if (!applyToSet(functions,funcWithNameModule,bp+1,s,&func)) 
-           fprintf(stderr,"Function \"%s\" not defined.\n",bp+1); 
-       else
-           clearBPatModLine (mod,func->entryline);
-       
-       goto ret;
-    }
-            
+
+        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 (isdigit(*(bp +1))) {
+
+            clearBPatModLine (mod,atoi(bp+1));
+            goto ret;
+
+        }
+        /* case d) filename:function */
+        if (!applyToSet(functions,funcWithNameModule,bp+1,s,&func))
+            fprintf(stderr,"Function \"%s\" not defined.\n",bp+1);
+        else
+            clearBPatModLine (mod,func->entryline);
+
+        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
     else

-       clearBPatModLine(func->mod,func->entryline);
+        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) {


@@ -3191,14 +3196,27 @@ int cmdSimulator (char *s, context *cctxt)
 void setMainContext()
 {
     function *func = NULL;
 void setMainContext()
 {
     function *func = NULL;

-    currentFrame = 0; 
-    if (!applyToSet(functions,funcWithName,"main",&func) &&
-        !applyToSet(functions,funcWithName,"_main",&func))
-        return;
+    currentFrame = 0;
+    if (!applyToSet(functions,funcWithName,"_main",&func) &&
+        !applyToSet(functions,funcWithName,"main",&func))
+            return;

 
     discoverContext (func->sym->addr, func);
 }
 
     discoverContext (func->sym->addr, func);
 }

-    
+
+function *needExtraMainFunction()
+{
+    function *func = NULL;
+    if (!applyToSet(functions,funcWithName,"_main",&func))
+    {
+        if (applyToSet(functions,funcWithName,"main",&func))
+        {
+            return func;
+        }
+    }
+    return NULL;
+}
+

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


@@ -3236,14 +3254,14 @@ static void printFrame()
 /*-----------------------------------------------------------------*/
 int cmdUp(char *s, context *cctxt)
 {
 /*-----------------------------------------------------------------*/
 int cmdUp(char *s, context *cctxt)
 {

-    while (isspace(*s)) s++;
+    s = trim_left(s);

     if ( *s )
         currentFrame += strtol(s,0,10);
     else
         currentFrame++ ;
 
     printFrame();
     if ( *s )
         currentFrame += strtol(s,0,10);
     else
         currentFrame++ ;
 
     printFrame();

-       return 0;
+        return 0;

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


@@ -3251,24 +3269,24 @@ int cmdUp(char *s, context *cctxt)
 /*-----------------------------------------------------------------*/
 int cmdDown(char *s, context *cctxt)
 {
 /*-----------------------------------------------------------------*/
 int cmdDown(char *s, context *cctxt)
 {

-    while (isspace(*s)) s++;
+    s = trim_left(s);

     if ( *s )
         currentFrame -= strtol(s,0,10);
     else
         currentFrame-- ;
 
     printFrame();
     if ( *s )
         currentFrame -= strtol(s,0,10);
     else
         currentFrame-- ;
 
     printFrame();

-       return 0;
+        return 0;

 }
 /*-----------------------------------------------------------------*/
 /* 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++;
+    s = trim_left(s);

     if ( *s )
         currentFrame = strtol(s,0,10);
     printFrame();
     if ( *s )
         currentFrame = strtol(s,0,10);
     printFrame();


@@ -3281,24 +3299,24 @@ int cmdFrame (char *s, context *cctxt)
 int cmdFinish (char *s, context *ctxt)
 {
     if (STACK_EMPTY(callStack)) {
 int cmdFinish (char *s, context *ctxt)
 {
     if (STACK_EMPTY(callStack)) {

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

     }
 
     if (srcMode == SRC_CMODE) {
     }
 
     if (srcMode == SRC_CMODE) {

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

     } else {
     } else {

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

     }
 
     simGo(-1);
     showfull = 1;
     return 0;
     }
 
     simGo(-1);
     showfull = 1;
     return 0;

-    
+

 }
 
 
 }
 
 


@@ -3308,16 +3326,16 @@ int cmdFinish (char *s, context *ctxt)
 int cmdShow (char *s, context *cctxt)
 {
     /* skip white space */
 int cmdShow (char *s, context *cctxt)
 {
     /* skip white space */

-    while (*s && isspace(*s)) s++ ;
+    s = trim_left(s);

 
     if (strcmp(s,"copying") == 0) {
 
     if (strcmp(s,"copying") == 0) {

-       fputs(copying,stdout);
-       return 0;
+        fputs(copying,stdout);
+        return 0;

     }
     }

-    
+

     if (strcmp(s,"warranty") == 0) {
     if (strcmp(s,"warranty") == 0) {

-       fputs(warranty,stdout);
-       return 0;
+        fputs(warranty,stdout);
+        return 0;

     }
 
     return 0;
     }
 
     return 0;