* debugger/mcs51/break.c, debugger/mcs51/cmd.c,

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

diff --git a/debugger/mcs51/cmd.c b/debugger/mcs51/cmd.c
index cda3f9f7be6364a9c7f065e4c34581bd87305f14..332ee2edaf58b512ee4345debeefa27c9b9f4dd6 100644 (file)
--- a/debugger/mcs51/cmd.c
+++ b/debugger/mcs51/cmd.c
@@ -1,35 +1,37 @@
 /*-------------------------------------------------------------------------
     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 <assert.h>

 #include "sdcdb.h"
 #include "symtab.h"
 #include "simi.h"
 #include "break.h"
 #include "cmd.h"
 #include "sdcdb.h"
 #include "symtab.h"
 #include "simi.h"
 #include "break.h"
 #include "cmd.h"

+#include "newalloc.h"

 
 /* default number of lines to list out */
 
 /* default number of lines to list out */

-int listLines = 16;
+#define LISTLINES 10
+static int listlines = LISTLINES;

 
 /* mainly used to retain a reference to the active module being
    listed.  May be used as a general context for other commands if
 
 /* mainly used to retain a reference to the active module being
    listed.  May be used as a general context for other commands if


@@ -327,12 +329,14 @@ static char *warranty=
 #endif
 
 static void printTypeInfo(link *);
 #endif
 
 static void printTypeInfo(link *);

-static void printValAggregates (symbol *,link *,char,unsigned int);
-static void setSymValue(symbol *sym, char *val, context *cctxt);
+static void printValAggregates (symbol *,link *,char,unsigned int,int);
+static  int printOrSetSymValue (symbol *sym, context *cctxt,
+                                int flg, int dnum, int fmt,
+                                char *rs, char *val, char cmp);

 
 int srcMode = SRC_CMODE ;
 
 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                       */
 /*-----------------------------------------------------------------*/
 /*-----------------------------------------------------------------*/
 /* funcWithName - returns function with name                       */
 /*-----------------------------------------------------------------*/


@@ -343,60 +347,87 @@ 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;
+}
+
+/*-----------------------------------------------------------------*/
+/* symWithAddr - look for symbol with sfr / sbit address           */
+/*-----------------------------------------------------------------*/
+DEFSETFUNC(symWithAddr)
+{
+    symbol *sym = item;
+    V_ARG(unsigned long,laddr);
+    V_ARG(int    ,laddrspace);
+    V_ARG(symbol **,rsym);
+
+    if (*rsym)
+        return 0;
+
+    if ( sym->addr == laddr &&
+         sym->addrspace == laddrspace )
+    {
+        *rsym = sym;
+        return 1;

     }
     }

-    
+

     return 0;
 }
 
 /*-----------------------------------------------------------------*/
 /* setBPatModLine - set break point at the line specified for the  */
 /*-----------------------------------------------------------------*/
     return 0;
 }
 
 /*-----------------------------------------------------------------*/
 /* setBPatModLine - set break point at the line specified for the  */
 /*-----------------------------------------------------------------*/

-static void setBPatModLine (module *mod, int line)
+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, USER, 
-                              userBpCB, mod->c_name, next_line);
-               return;
-//             break;
-           }
-       }
-       else {
-          if (mod->asmLines[next_line]->addr) {
-              setBreakPoint (mod->asmLines[next_line]->addr, CODE, USER, 
-                             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;
 }


@@ -409,29 +440,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;


@@ -452,14 +483,22 @@ 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)
         {
             *rmod = mod ;
             if (line )
     {
         if ( mod->asmLines[i]->addr == addr)
         {
             *rmod = mod ;
             if (line )

-                *line = mod->ncLines;
-            return 1;
+            {
+                *line = 0;
+                for ( i=0; i < mod->ncLines; i++ )
+                {
+                    if ( mod->cLines[i]->addr > addr)
+                        break;
+                    *line = i;
+                }
+                return 1;
+            }

         }
     }
 
         }
     }
 


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

-DEFSETFUNC(funcWithNameModule) 
+DEFSETFUNC(funcWithNameModule)

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


@@ -480,9 +519,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;


@@ -498,17 +537,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;

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


@@ -517,14 +556,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;


@@ -538,9 +577,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;
 }
 


@@ -552,9 +591,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;
 }
 


@@ -571,16 +610,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;

-    
+

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


@@ -596,33 +635,32 @@ 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;

-    
+

 }
 
 /*-----------------------------------------------------------------*/
 /* discoverContext - find out the current context of the bp        */
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/
 /* discoverContext - find out the current context of the bp        */
 /*-----------------------------------------------------------------*/

-context *discoverContext (unsigned addr)
+context *discoverContext (unsigned addr, function *func)

 {
 {

-    function *func = NULL;

     module   *mod  = NULL;
     int line = 0;
 
     /* find the function we are in */
     module   *mod  = NULL;
     int line = 0;
 
     /* find the function we are in */

-    if (!applyToSet(functions,funcInAddr,addr,&func)) {
-        if (!applyToSet(functions,funcWithName,"main") ||
-            !applyToSet(modules,moduleLineWithAddr,addr,&mod,&line))
+    if (!func && !applyToSet(functions,funcInAddr,addr,&func)) {
+        if (!applyToSet(functions,funcWithName,"_main",&func) ||
+            !applyToSet(modules,moduleLineWithAddr,addr,&mod,NULL))

         {
         {

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

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


@@ -635,22 +673,25 @@ context *discoverContext (unsigned addr)
         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 */
         /* find the c line number */

-        if(applyToSet(func->cfpoints,lineNearAddr,addr,
-                  &line,&currCtxt->block,&currCtxt->level)) 
+        if(applyToSet(func->cfpoints,lineAtAddr,addr,
+                  &line,&currCtxt->block,&currCtxt->level))
+            currCtxt->cline = func->lline = line;
+        else if(applyToSet(func->cfpoints,lineNearAddr,addr,
+                  &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 ;
 }
 


@@ -659,74 +700,105 @@ context *discoverContext (unsigned addr)
 /* 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;
     unsigned int addr ;
     context *ctxt;
     int rv;

-    static int initial_break_flag = 0;
-
- top:    
+    stopCommandList();
+ 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 */

-    ctxt = discoverContext (addr);
-    
+    currentFrame = 0;
+    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 (!initial_break_flag) {
-        initial_break_flag = 1;  // kludge to stop only at first run
-        fprintf(stdout, "Stopping at entry.  You can now list and set breakpoints\n");
-      }
-      else {
-               gaddr = -1;
-               goto top ;
-      }
+    if (!rv)
+    {
+        if ( gaddr == 0 )
+            gaddr = -1;
+        if ( gaddr == -1 || doingSteps == 1 )
+            goto top ;
+    }

 
 

-// notes: kpb
-// I took this out, after running "run" it would just keep re-running
-// even after a lot of break points hit.  For some reason above code
-// not triggering(dispatchCB).  This seems to be by design, startup adds
-// a bunch of breakpoints-but they are not USER breakpoints.  Perhaps the
-// debugger changed with its implementation of "go"("run").  It seems we
-// need to add a "next" or "step" followed by a "run"...
-// I added a "step" in simi.c when we want a resume function, this seems
-// to work.
-
-// still there is question of how do we stop it initially, since
-// it must be started before it can get a context.  If so, we would
-// want it to just run up to an initial entry point you'd think...
-// I don't see why we can't set breakpoints before an initial run,
-// this does not seem right to me.
-
-// line #'s are a bit off too.
-
-#if 0
-       gaddr = -1;
-       goto top ;
-#endif
+}
+
+/*-----------------------------------------------------------------*/
+/* preparePrint - common parse function for  set variable,         */
+/*                output, print and display                        */
+/*-----------------------------------------------------------------*/
+static char *preparePrint(char *s, context *cctxt, int *fmt, symbol **sym)
+{
+    char *bp;
+    char save_ch ;
+
+    *fmt = FMT_NON;
+    *sym = NULL;
+
+    s = trim(s);
+    if (!*s)
+        return (char *)0;
+
+    if ( *s == '/' )
+    {
+        /* format of printout */
+        switch ( *++s )
+        {
+            case 'x':
+                *fmt = FMT_HEX ;
+                break;
+            case 'o':
+                *fmt = FMT_OCT ;
+                break;
+            default:
+            case 'd':
+                *fmt = FMT_DEZ ;
+                break;
+            case 't':
+                *fmt = FMT_BIN ;
+                break;
+        }
+        s++;
+        s = trim_left(s);

     }
     }

-    
+    for ( bp = s; *bp && ( isalnum( *bp ) || *bp == '_' || *bp == '$'); bp++ );
+    save_ch = *bp;
+    if ( *bp )
+        *bp = '\0';
+
+    if ( *s )
+        *sym = symLookup(s,cctxt);
+    *bp = save_ch;
+
+    if ( ! *sym )
+        fprintf(stdout,"No symbol \"%s\" in current context.\n", s);
+    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 )


@@ -739,7 +811,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)
         {


@@ -749,12 +821,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 )
         {


@@ -762,7 +834,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;


@@ -782,14 +854,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);


@@ -800,7 +872,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 )
         {


@@ -815,7 +887,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
         {


@@ -825,14 +897,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 )
         {


@@ -855,12 +927,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                    */


@@ -878,14 +958,11 @@ int cmdDisasmF(char *s, context *cctxt)
     return cmdDisasm( s, cctxt, 2);
 }
 
     return cmdDisasm( s, cctxt, 2);
 }
 

-/*-----------------------------------------------------------------*/
-/* cmdSetUserBp - set break point at the user specified location   */
-/*-----------------------------------------------------------------*/
-int cmdSetUserBp (char *s, context *cctxt)
+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


@@ -893,41 +970,37 @@ int cmdSetUserBp (char *s, context *cctxt)
        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 (srcMode == SRC_CMODE)
-               /* set the break point */
-               setBreakPoint ( cctxt->addr , CODE , USER , userBpCB ,
-                               cctxt->func->mod->c_name, cctxt->cline);
-           else
-               setBreakPoint ( cctxt->addr , CODE , USER , userBpCB ,
-                               cctxt->func->mod->asm_name, cctxt->asmline);
-               
-       }
-       else
-           fprintf(stderr,"No default breakpoint address now.\n");
-                       
-       goto ret ;
+        /* if current context is known */
+        if (cctxt->func) {
+        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 ;

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


@@ -939,100 +1012,218 @@ int cmdSetUserBp (char *s, context *cctxt)
             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
             {

-                setBreakPoint ( braddr , CODE , USER , userBpCB ,
+                Dprintf(D_break, ("commonSetUserBp: g) addr:%lx \n",braddr));
+                setBreakPoint ( braddr , CODE , bpType , userBpCB ,

                             modul->c_name,line);
             }
             goto ret ;
         }
                             modul->c_name,line);
             }
             goto ret ;
         }

-               else
+                else

         {
             int line = func->exitline;
         {
             int line = func->exitline;

-            applyToSet(func->cfpoints,lineNearAddr,braddr,&line,NULL,NULL);
-            setBreakPoint ( braddr , CODE , USER , userBpCB ,
+            if ( !applyToSet(func->cfpoints,lineAtAddr,braddr,
+                                  &line,NULL,NULL))
+                applyToSet(func->cfpoints,lineNearAddr,braddr,&line,NULL,NULL);
+            setBreakPoint ( braddr , CODE , bpType , userBpCB ,

                             func->mod->c_name,line);
         }
                             func->mod->c_name,line);
         }

-       goto ret ;
+        goto ret ;

     }
     /* case b) lineno */
     /* check if line number */
     }
     /* 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 
-                   setBPatModLine(func->mod,line);
-           } else 
-               setBPatModLine(cctxt->func->mod,line);
-       } else {
-               if (list_mod) {
-                       setBPatModLine(list_mod,line);
-               } else {
-                 fprintf(stdout,"Sdcdb fails to have module symbol context at %d\n", __LINE__);
-               }
-       }
-       
-       goto ret;
+    if ( !strchr(s,':') && isdigit(*s)) {
+        /* get the lineno */
+        int line = atoi(s) -1;
+    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__);
+                }
+        }
+
+        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))) {                    
-        
-           setBPatModLine (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        
-           setBPatModLine (mod,
-                           (srcMode == SRC_CMODE ? 
-                            func->entryline :
-                            func->aentryline));
-       
-       goto ret;
-    }
-            
+
+        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)));
+            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"));
+            setBPatModLine (mod,
+                            (srcMode == SRC_CMODE ?
+                             func->entryline :
+                             func->aentryline),bpType);
+
+        goto ret;
+    }
+

     /* case e) function */
     /* case e) function */

+    Dprintf(D_break, ("commonSetUserBp: e) \n"));

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

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

     else
     else

-       setBPatModLine(func->mod,
-                      (srcMode == SRC_CMODE ?
-                       func->entryline :
-                       func->aentryline));
+        setBPatModLine(func->mod,
+                       (srcMode == SRC_CMODE ?
+                        func->entryline :
+                        func->aentryline),bpType);
+
+ ret:
+    return 0;
+}
+
+/*-----------------------------------------------------------------*/
+/* cmdSetTmpUserBp - settempory break point at the user specified location   */
+/*-----------------------------------------------------------------*/
+int cmdSetTmpUserBp (char *s, context *cctxt)
+{
+    return commonSetUserBp(s, cctxt, TMPUSER );
+}
+
+/*-----------------------------------------------------------------*/
+/* cmdSetUserBp - set break point at the user specified location   */
+/*-----------------------------------------------------------------*/
+int cmdSetUserBp (char *s, context *cctxt)
+{
+    return commonSetUserBp(s, cctxt, USER );
+}
+
+/*-----------------------------------------------------------------*/
+/* cmdJump - set program counter                                   */
+/*-----------------------------------------------------------------*/
+int cmdJump (char *s, context *cctxt)
+{
+    char *bp;
+    function *func = NULL;
+    if (STACK_EMPTY(callStack))
+    {
+        fprintf(stdout,"The program is not running.\n");
+        return 0;
+    }

 
 

- ret:    
+    /* trim left and right */
+    s = trim(s);
+
+    if (! *s )
+    {
+        fprintf(stdout,"No argument: need line or *addr.\n");
+        return 0;
+    }
+    if ( *s == '*' && isdigit(*(s+1)))
+    {
+        unsigned int addr = atoi(s);
+        if (cctxt && cctxt->func &&
+            cctxt->func->sym->addr <= addr &&
+            cctxt->func->sym->eaddr >= addr)
+        {
+            simSetPC(addr);
+            return 0;
+        }
+        fprintf(stdout,"Warning addr 0x%x outside actual function.\n",addr);
+        simSetPC(addr);
+        return 0;
+    }
+    if (isdigit(*s))
+    {
+        /* get the lineno */
+        int line = atoi(s) -1;
+        if (!cctxt || !cctxt->func || !cctxt->func->mod)
+        {
+                    fprintf(stderr,"Function not defined.\n");
+            return 0;
+        }
+        if (line >= cctxt->func->entryline &&
+            line <= cctxt->func->exitline )
+        {
+            simSetPC(cctxt->func->mod->cLines[line]->addr);
+            return 0;
+        }
+        if (line >= cctxt->func->mod->ncLines )
+        {
+                    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;
+    }
+    if ((bp = strchr(s,':')))
+    {
+        int line;
+        module *mod = NULL;
+        *bp++ = '\0';
+        if (!applyToSet(modules,moduleWithCName,s,&mod))
+        {
+            fprintf (stderr,"No source file named %s.\n",s);
+            return 0;
+        }
+        if (!isdigit(*bp))
+        {
+            fprintf (stderr,"No line number.\n");
+            return 0;
+        }
+        line = atoi(bp) -1;
+        if (line >= mod->ncLines )
+        {
+                    fprintf(stderr,"line not in module.\n");
+            return 0;
+        }
+        if ( mod != cctxt->func->mod ||
+             line < cctxt->func->entryline ||
+             line > cctxt->func->exitline )
+        {
+            fprintf(stdout,"Warning line %d outside actual function.\n",
+                    line+1);
+        }
+        simSetPC(mod->cLines[line]->addr);
+    }

     return 0;
 }
 
     return 0;
 }
 


@@ -1041,12 +1232,15 @@ int cmdSetUserBp (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;
 }


@@ -1056,44 +1250,55 @@ 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)
+    {
+        listlines = strtol(s+9,0,0);
+        if ( listlines < LISTLINES )
+            listlines = LISTLINES;
+        return 0;

     }
 
     }
 

-    if (strncmp(s,"variable ",9) == 0) 
+#ifdef SDCDB_DEBUG
+    if (strncmp(s,"debug ",6) == 0)
+    {
+        sdcdbDebug = strtol(s+6,0,0);
+        return 0;
+    }
+#endif
+    if (strncmp(s,"variable ",9) == 0)

     {
         symbol *sym ;
     {
         symbol *sym ;

-        char *val;
+        int fmt;
+        char *rs;

         s += 9;
         s += 9;

-        while (isspace(*s)) s++;
-        if (!*s) return 0;
-
-        val = s;
-        while (*val && !isspace(*val) && *val != '=') val++;
-        while (isspace(*val)) *val++ = '\0';
-        if (*val) *val++ = '\0';
-        if (*val)
+        if ( !( rs = preparePrint(s, cctxt, &fmt, &sym )))
+            return 0;
+        s = rs;
+        while (*s && *s != '=') s++;
+        *s++ = '\0';
+        s = trim_left(s);
+        if (*s && sym)

         {
         {

-            if ((sym = symLookup(s,cctxt))) 
-            {
-                setSymValue(sym,val,cctxt);
-                return 0;
-            }   
-            fprintf(stdout,"No symbol \"%s\" in current context.\n",s);
+            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;
 }


@@ -1103,9 +1308,9 @@ int cmdSetOption (char *s, context *cctxt)
 /*-----------------------------------------------------------------*/
 int cmdContinue (char *s, context *cctxt)
 {
 /*-----------------------------------------------------------------*/
 int cmdContinue (char *s, context *cctxt)
 {

-    if (!cctxt || !cctxt->func) {
-       fprintf(stdout,"The program is not being run.\n");
-       return 0;
+    if (STACK_EMPTY(callStack)) {
+        fprintf(stdout,"The program is not being run.\n");
+        return 0;

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


@@ -1114,30 +1319,131 @@ int cmdContinue (char *s, context *cctxt)
     return 0;
 }
 
     return 0;
 }
 

+/*-----------------------------------------------------------------*/
+/* cmdIgnore - set ignorecount for breakpoint                      */
+/*-----------------------------------------------------------------*/
+int cmdIgnore (char *s, context *cctxt)
+{
+    int bpnum, cnt ;
+    s = trim_left(s);
+    if (!*s )
+    {
+        fprintf(stdout,"Argument required (breakpoint number).\n");
+        return 0;
+    }
+    bpnum = strtol(s,&s,10);
+    s = trim_left(s);
+    if (!*s )
+    {
+        fprintf(stdout,"Second argument (specified ignore-count) is missing.");
+        return 0;
+    }
+    cnt = strtol(s,0,10);
+    setUserbpIgnCount(bpnum,cnt);
+    return 0;
+}
+
+/*-----------------------------------------------------------------*/
+/* cmdCondition - set condition for breakpoint                     */
+/*-----------------------------------------------------------------*/
+int cmdCondition (char *s, context *cctxt)
+{
+    int bpnum ;
+    s = trim_left(s);
+    if (!*s )
+    {
+        fprintf(stdout,"Argument required (breakpoint number).\n");
+        return 0;
+    }
+    bpnum = strtol(s,&s,10);
+    s = trim_left(s);
+    if (*s)
+        s = Safe_strdup(s);
+    else
+        s = NULL;
+    setUserbpCondition(bpnum,s);
+    return 0;
+}
+
+/*-----------------------------------------------------------------*/
+/* cmdCommands - set commands for breakpoint                       */
+/*-----------------------------------------------------------------*/
+int cmdCommands (char *s, context *cctxt)
+{
+    int bpnum ;
+    char *cmds,*line;
+    s = trim_left(s);
+
+    if (!*s )
+        bpnum = getLastBreakptNumber();
+    else
+        bpnum = strtol(s,0,10);
+
+    cmds = NULL;
+    while ((line = getNextCmdLine()))
+    {
+        line = trim_left(line);
+        if (!strncmp(line,"end",3))
+            break;
+        if (! cmds )
+        {
+            cmds = Safe_strdup(line);
+        }
+        else
+        {
+            cmds = Safe_realloc( cmds, strlen(cmds) + 1 + strlen(line));
+            strcat(cmds,line);
+        }
+    }
+    setUserbpCommand(bpnum,cmds);
+    return 0;
+}
+

 /*-----------------------------------------------------------------*/
 /* cmdDelUserBp - delete user break point                          */
 /*-----------------------------------------------------------------*/
 int cmdDelUserBp (char *s, context *cctxt)
 {
     int bpnum ;
 /*-----------------------------------------------------------------*/
 /* cmdDelUserBp - delete user break point                          */
 /*-----------------------------------------------------------------*/
 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];
+            char *res;
+
+            fprintf (stdout,"Delete all breakpoints? (y or n) ");
+            fflush(stdout);
+            res = fgets(buffer,sizeof(buffer),stdin);
+            assert(res == &buffer[0]);
+            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;
+}
+
+/*-----------------------------------------------------------------*/
+/* cmdStepi - single step exactly one instruction                   */
+/*-----------------------------------------------------------------*/
+int cmdStepi (char *s, context *cctxt)
+{

 
 

+    if (0 /*STACK_EMPTY(callStack)*/)
+        fprintf(stdout,"The program is not being run.\n");
+    else
+    {
+        doingSteps = 2;
+            simGo(2);
+        doingSteps = 0;
+        showfull = 1;
+    }

     return 0;
 }
 
     return 0;
 }
 


@@ -1148,158 +1454,169 @@ int cmdStep (char *s, context *cctxt)
 {
     function *func = NULL;
 
 {
     function *func = NULL;
 

-    if (!cctxt || !cctxt->func || !cctxt->func->mod) 
-       fprintf(stdout,"The program is not being run.\n");
+    if (STACK_EMPTY(callStack))
+        fprintf(stdout,"The program is not being run.\n");

     else {
     else {

-    int origSrcMode = srcMode;
-    if ( *s == 'i' )
-        srcMode = SRC_AMODE;
-       /* if we are @ the end of a function then set
-          break points at execution points of the
-          function in the call stack... */
-       if (cctxt->addr == cctxt->func->sym->eaddr) {
-           if ((func = STACK_PEEK(callStack))) {
-               if (srcMode == SRC_CMODE)
-                   applyToSet (func->cfpoints,setStepEPBp,STEP,
-                               func->mod->c_name);     
-               else
-                   applyToSet (func->afpoints,setStepEPBp,STEP,
-                               func->mod->asm_name);
-           }
-       } else {
-           /* 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 */
-           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);
-               
-               /* set a break point @ the current function's
-                  exit */
-               setBreakPoint (cctxt->func->sym->eaddr, CODE, STEP , 
-                              stepBpCB, cctxt->func->mod->c_name, 
-                              cctxt->func->exitline);
-               
-               /* now break point @ callers execution points */
-               if ((func = STACK_PPEEK(callStack))) {
-                   applyToSet (func->cfpoints,setStepEPBp,STEP,
-                               func->mod->c_name);     
-                   /* set bp @ callers exit point */
-                   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);
-               
-               /* set a break point @ the current function's
-                  exit */
-               setBreakPoint (cctxt->func->sym->eaddr, CODE, STEP , 
-                              stepBpCB, cctxt->func->mod->asm_name, 
-                              cctxt->func->aexitline);
-               
-               /* now break point @ callers execution points */
-               if ((func = STACK_PPEEK(callStack))) {
-                   
-                   applyToSet (func->afpoints,setStepEPBp,STEP,
-                               func->mod->asm_name);   
-                   
-                   /* set bp @ callers exit point */
-                   setBreakPoint (func->sym->eaddr, CODE, STEP , 
-                                  stepBpCB, func->mod->asm_name, 
-                                  func->aexitline);
-               }
-           }
-       }
-
-    srcMode = origSrcMode;
-       simGo(-1);
-    showfull = 1;
+        /* if we are @ the end of a function then set
+           break points at execution points of the
+           function in the call stack... */
+        if (cctxt->addr == cctxt->func->sym->eaddr) {
+            if ((func = STACK_PEEK(callStack))) {
+                if (srcMode == SRC_CMODE)
+                    applyToSet (func->cfpoints,setStepEPBp,STEP,
+                                func->mod->c_name);
+                else
+                    applyToSet (func->afpoints,setStepEPBp,STEP,
+                                func->mod->asm_name);
+            }
+        } else {
+            /* 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 */
+            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);
+
+                /* set a break point @ the current function's
+                   exit */
+                setBreakPoint (cctxt->func->sym->eaddr, CODE, STEP ,
+                               stepBpCB, cctxt->func->mod->c_name,
+                               cctxt->func->exitline);
+
+                /* now break point @ callers execution points */
+                if ((func = STACK_PPEEK(callStack))) {
+                    applyToSet (func->cfpoints,setStepEPBp,STEP,
+                                func->mod->c_name);
+                    /* set bp @ callers exit point */
+                    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);
+
+                /* set a break point @ the current function's
+                   exit */
+                setBreakPoint (cctxt->func->sym->eaddr, CODE, STEP ,
+                               stepBpCB, cctxt->func->mod->asm_name,
+                               cctxt->func->aexitline);
+
+                /* now break point @ callers execution points */
+                if ((func = STACK_PPEEK(callStack))) {
+
+                    applyToSet (func->afpoints,setStepEPBp,STEP,
+                                func->mod->asm_name);
+
+                    /* set bp @ callers exit point */
+                    setBreakPoint (func->sym->eaddr, CODE, STEP ,
+                                   stepBpCB, func->mod->asm_name,
+                                   func->aexitline);
+                }
+            }
+        }
+
+        doingSteps = 1;
+        simGo(2);
+        doingSteps = 0;
+        showfull = 1;

     }
     return 0;
 }
 
 /*-----------------------------------------------------------------*/
     }
     return 0;
 }
 
 /*-----------------------------------------------------------------*/

-/* cmdNext - next executable C statement file                      */
+/* cmdNexti - next instruction but proceed function call           */

 /*-----------------------------------------------------------------*/
 /*-----------------------------------------------------------------*/

-int cmdNext (char *s, context *cctxt)
+int cmdNexti (char *s, context *cctxt)
+{
+    if (STACK_EMPTY(callStack))
+        fprintf(stdout,"The program is not being run.\n");
+    else
+    {
+        doingSteps = 2;
+            simGo(1);
+        doingSteps = 0;
+        showfull = 1;
+    }
+    return 0;
+}
+
+/*-----------------------------------------------------------------*/
+/* cmdNext - next executable C statement file                      */
+/*-----------------------------------------------------------------*/
+int cmdNext (char *s, context *cctxt)

 {
     function *func = NULL;
     /* next is almost the same as step except we don't
        we don't set break point for all function entry
        points */
 {
     function *func = NULL;
     /* next is almost the same as step except we don't
        we don't set break point for all function entry
        points */

-    if (!cctxt || !cctxt->func || !cctxt->func->mod) 
-       fprintf(stdout,"The program is not being run.\n");
+    if (STACK_EMPTY(callStack))
+        fprintf(stdout,"The program is not being run.\n");

     else {
     else {

-    int origSrcMode = srcMode;
-    if ( *s == 'i' )
-        srcMode = SRC_AMODE;
-       
-       /* if we are @ the end of a function then set
-          break points at execution points of the
-          function in the call stack... */
-       if (cctxt->addr == cctxt->func->sym->eaddr) {
-           if ((func = STACK_PEEK(callStack))) {
-               if (srcMode == SRC_CMODE)
-                   applyToSet (func->cfpoints,setStepEPBp,STEP,
-                               func->mod->c_name);     
-               else
-                   applyToSet (func->afpoints,setStepEPBp,STEP,
-                              func->mod->asm_name);
-           }
-       } else {
-           if (srcMode == SRC_CMODE) {
-               /* for all execution points in this function */
-               applyToSet(cctxt->func->cfpoints,setNextEPBp,NEXT,
-                          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, 
-                              cctxt->func->exitline);
-               
-               /* now break point @ callers execution points */        
-               if ((func = STACK_PPEEK(callStack))) {
-                   applyToSet (func->cfpoints,setNextEPBp,NEXT ,
-                               func->mod->c_name);     
-                   /* set bp @ callers exit point */
-                   setBreakPoint (func->sym->eaddr, CODE, NEXT , 
-                                  stepBpCB, func->mod->c_name, 
-                                  func->exitline);
-               }
-           } else {
-               /* for all execution points in this function */
-               applyToSet(cctxt->func->afpoints,setNextEPBp,NEXT,
-                          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, 
-                              cctxt->func->aexitline);
-               
-               /* now break point @ callers execution points */        
-               if ((func = STACK_PPEEK(callStack))) {
-                   applyToSet (func->cfpoints,setNextEPBp,NEXT ,
-                               func->mod->asm_name);   
-                   /* set bp @ callers exit point */
-                   setBreakPoint (func->sym->eaddr, CODE, NEXT , 
-                                  stepBpCB, func->mod->asm_name, 
-                                  func->aexitline);
-               }
-           }
-        srcMode = origSrcMode;
-           simGo(-1);  
+        /* if we are @ the end of a function then set
+           break points at execution points of the
+           function in the call stack... */
+        if (cctxt->addr == cctxt->func->sym->eaddr) {
+            if ((func = STACK_PEEK(callStack))) {
+                if (srcMode == SRC_CMODE)
+                    applyToSet (func->cfpoints,setStepEPBp,NEXT,
+                                func->mod->c_name);
+                else
+                    applyToSet (func->afpoints,setStepEPBp,NEXT,
+                                func->mod->asm_name);
+            }
+        } else {
+            if (srcMode == SRC_CMODE) {
+                /* for all execution points in this function */
+                applyToSet(cctxt->func->cfpoints,setNextEPBp,NEXT,
+                           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,
+                               cctxt->func->exitline);
+
+                /* now break point @ callers execution points */
+                if ((func = STACK_PPEEK(callStack))) {
+                    applyToSet (func->cfpoints,setNextEPBp,NEXT ,
+                                func->mod->c_name);
+                    /* set bp @ callers exit point */
+                    setBreakPoint (func->sym->eaddr, CODE, NEXT ,
+                                   stepBpCB, func->mod->c_name,
+                                   func->exitline);
+                }
+            } else {
+                /* for all execution points in this function */
+                applyToSet(cctxt->func->afpoints,setNextEPBp,NEXT,
+                           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,
+                               cctxt->func->aexitline);
+
+                /* now break point @ callers execution points */
+                if ((func = STACK_PPEEK(callStack))) {
+                    applyToSet (func->cfpoints,setNextEPBp,NEXT ,
+                                func->mod->asm_name);
+                    /* set bp @ callers exit point */
+                    setBreakPoint (func->sym->eaddr, CODE, NEXT ,
+                                   stepBpCB, func->mod->asm_name,
+                                   func->aexitline);
+                }
+            }
+        }
+        doingSteps = 1;
+        simGo(1);
+        doingSteps = 0;

         showfull = 1;
         showfull = 1;

-       }
-    srcMode = origSrcMode;
-    }    
+    }

     return 0;
 }
 
     return 0;
 }
 


@@ -1309,26 +1626,30 @@ int cmdNext (char *s, context *cctxt)
 int cmdRun (char *s, context *cctxt)
 {
     char buff[10];
 int cmdRun (char *s, context *cctxt)
 {
     char buff[10];

-    if (!cctxt || !cctxt->func || !cctxt->func->mod) {
-       fprintf(stdout,"Starting program\n");
+    if (STACK_EMPTY(callStack)) {
+        fprintf(stdout,"Starting program\n");

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

-       simGo(0);
+    resetHitCount();
+        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();
-           simGo(0);
-       }
+        char *res;
+
+        fprintf(stdout,
+                "The program being debugged has been started already.\n");
+        fprintf(stdout,"Start it from the beginning? (y or n) ");
+        fflush(stdout);
+
+        res = fgets(buff,sizeof(buff),stdin);
+        assert(res == &buff[0]);
+        if (toupper(buff[0]) == 'Y') {
+            simReset();
+        resetHitCount();
+            simGo(0);
+        }

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


@@ -1363,11 +1684,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);


@@ -1394,19 +1715,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);


@@ -1416,7 +1735,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)
 {


@@ -1443,7 +1762,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) {


@@ -1485,15 +1804,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 *******************/


@@ -1511,7 +1830,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) {


@@ -1556,11 +1875,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;


@@ -1585,11 +1904,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);


@@ -1600,6 +1919,69 @@ static void infoSymbols(context *ctxt)
 
 }
 
 
 }
 

+/*-----------------------------------------------------------------*/
+/* infoRegisters - print register information                      */
+/*-----------------------------------------------------------------*/
+static void infoRegisters( int all, context *ctxt)
+{
+    static int regaddrs[] = {0x81,0x82,0x83,0xb8,0xd0,0xe0,0xf0,0};
+    unsigned long val;
+    int i,j,*r;
+
+    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++ )
+    {
+        val = simGetValue (j,'R',1);
+        fprintf(stdout," 0x%02lX",val);
+    }
+    fprintf(stdout,"\n");
+    val = simGetValue (0xe0,'I',1);
+    fprintf(stdout,"ACC : 0x%02lX %lu %c\n",val,val,(isprint(val) ? (char)val : '.'));
+    val = simGetValue (0xf0,'I',1);
+    fprintf(stdout,"B   : 0x%02lX %lu %c\n",val,val,(isprint(val) ? (char)val : '.'));
+    val = simGetValue (0x82,'I',2);
+    fprintf(stdout,"DPTR: 0x%04lX %lu\n",val,val);
+    val = simGetValue (0x81,'I',1);
+    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,"Special Function Registers:\n");
+        r = regaddrs;
+        for ( i = 0x80 ; i < 0x100 ; i++ )
+        {
+            symbol *sym = NULL;
+            if ( *r && *r == i )
+            {
+                /* skip normal registers */
+                r++ ;
+                continue;
+            }
+            if (applyToSetFTrue(sfrsymbols,symWithAddr,i,'I',&sym))
+            {
+                val = simGetValue (sym->addr,sym->addrspace,sym->size);
+                fprintf(stdout,"%s : 0x%02lx",sym->name,val);
+                if ( !(i & 0x07 ))
+                {
+                    for ( j = 0 ; j < 8 ; j++ )
+                    {
+                        sym = NULL;
+                        if (applyToSetFTrue(sfrsymbols,symWithAddr,i+j,'J',&sym))
+                        {
+                            //val = simGetValue (sym->addr,sym->addrspace,sym->size);
+                            fprintf(stdout," %s=%c",sym->name,(val&1)? '1':'0');
+                        }
+                        val >>= 1;
+                    }
+                }
+                fprintf(stdout,"\n");
+            }
+        }
+    }
+}
+

 /*-----------------------------------------------------------------*/
 /* infoStack - print call stack information                        */
 /*-----------------------------------------------------------------*/
 /*-----------------------------------------------------------------*/
 /* infoStack - print call stack information                        */
 /*-----------------------------------------------------------------*/


@@ -1610,12 +1992,14 @@ static void infoStack(context *ctxt)
 
     STACK_STARTWALK(callStack) ;
     while ((func = STACK_WALK(callStack))) {
 
     STACK_STARTWALK(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%04x %s () at %s:%d\n",i++,
-               func->laddr,func->sym->name,
-               func->mod->c_name,func->lline);
+        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");

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


@@ -1623,26 +2007,10 @@ static void infoStack(context *ctxt)
 /*-----------------------------------------------------------------*/
 int cmdWhere(char *s, context *cctxt)
 {
 /*-----------------------------------------------------------------*/
 int cmdWhere(char *s, context *cctxt)
 {

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

 }
 
 }
 

-/*-----------------------------------------------------------------*/
-/* cmdUp -  Up command                                             */
-/*-----------------------------------------------------------------*/
-int cmdUp(char *s, context *cctxt)
-{
-       return 0;
-}
-
-/*-----------------------------------------------------------------*/
-/* cmdDown - down command                                          */
-/*-----------------------------------------------------------------*/
-int cmdDown(char *s, context *cctxt)
-{
-       return 0;
-}

 
 static int infomode = 0;
 /*-----------------------------------------------------------------*/
 
 static int infomode = 0;
 /*-----------------------------------------------------------------*/


@@ -1650,48 +2018,89 @@ 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);
-    showfull = 1;
-       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)
+    {
+        module *m;
+        if ( s[6] == 's' )
+        {
+            int k = 0;
+            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);
+                k = 1;
+            }
+            fprintf(stdout,"\n");
+        }
+        else
+        {
+            if (!cctxt || !cctxt->func || !cctxt->func->mod)
+            {
+                fprintf(stdout,"No source file loaded\n");
+                return 0;
+            }
+            m = cctxt->func->mod;
+            fprintf(stdout,"Current source file is %s\n",m->c_name);
+            fprintf(stdout,"Located in %s\n",m->cfullname);
+            fprintf(stdout,"Contains %d lines.\nSource language is c.\n",
+                    m->ncLines);
+        }
+        return 0;
+    }
+    if (strcmp(s,"functions") == 0)
+    {
+        function *f;
+        module *m = NULL;
+        fprintf(stdout,"All defined functions:\n");
+        for ( f = setFirstItem(functions); f ; f = setNextItem(functions))
+        {
+            if ( f->mod != m )
+            {
+                m = f->mod;
+                fprintf(stdout,"\nFile %s\n", m->c_name);
+            }
+            fprintf(stdout,"%s();\n",f->sym->name);
+        }
+        return 0;

     }
     }

-

     /* 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) {
     }
 
     /* info stack display call stack */
     if (strcmp(s,"registers") == 0) {

-       fprintf(stdout,"%s",simRegs());
-       return 0;
+        infoRegisters(0,cctxt);
+            return 0;

     }
 
     /* info stack display call stack */
     }
 
     /* info stack display call stack */

-    if (strcmp(s,"all-registers") == 0) {
-       fprintf(stdout,"%s",simRegs());
-       fprintf(stdout,"Special Function Registers:\n");
-    sendSim("ds 0x80 0x100\n");
-    waitForSim(100,NULL);
-    fprintf(stdout,simResponse());
-       return 0;
+    if (strcmp(s,"all-registers") == 0)
+    {
+        infoRegisters(1,cctxt);
+        return 0;

     }
 
     /* info stack display call stack */
     }
 
     /* info stack display call stack */


@@ -1718,9 +2127,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;
 }
 


@@ -1728,241 +2137,402 @@ 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;

-    int llines = listLines;
+    int llines = listlines;
+    function *func = NULL;
+
+
+    s = trim_left(s);

 
 

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

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

+       FILE:LINE,LASTLINE  + last line

        FUNCTION      - list a function
        FILE:FUNCTION - function in file */
 
     if (*s) {
        FUNCTION      - list a function
        FILE:FUNCTION - function in file */
 
     if (*s) {

-       /* case a) LINE */
-       if (isdigit(*s)) {
-           sscanf(s,"%d",&pline);
-           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;
-       }
-       else {
-           char *bp;
-           function *func = NULL;
-           
-           /* 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;
-                       }
-                   }
-                   sscanf(bp,"%d",&pline);
-               } 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 (!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; 
-                   }
-               }
-           }
-       }
+        /* 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;
+        if (s && (s = strchr(s,',')))
+        {
+            /* LINE,LASTLINE */
+            llines = strtol(s+1,0,10);
+            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,',')))
+            {
+                /* FILE:LINE,LASTLINE */
+                llines = strtol(bp+1,0,10);
+                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 == '\'')
+            {
+                /* 'FUNCTION' */
+                s++ ;
+                if ((bp = strrchr(s,'\'')))
+                {
+                    *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;
+                    }
+                }
+            }
+        }

     } 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) {
       fprintf(stdout,"Sdcdb fails to have a valid module context at %d.\n", __LINE__);
       return 0;
     }
     }
 
     if (!list_mod) {
       fprintf(stdout,"Sdcdb fails to have a valid module context at %d.\n", __LINE__);
       return 0;
     }

-    
-    if (llines > listLines) llines = listLines;

 
 

+    if ( pline < 0 )
+        return 0;

     if ( infomode )
     {
     if ( infomode )
     {

-           fprintf(stdout,"Line %d of \"%s\" starts at address 0x%08x.\n",pline,
-                   list_mod->c_name, list_mod->cLines[pline]->addr);
+        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;
+            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;
+        for ( ; pline < list_mod->ncLines; pline++ )
+        {
+            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",
+                lastaddr,
+                func ? func->sym->name : "?",
+                func ? lastaddr -func->sym->addr : 0);

         infomode=0;
         infomode=0;

+        if ( func )
+            fprintf(stdout,"\032\032%s:%d:1:beg:0x%08x\n",
+                    func->mod->cfullname,
+                    llines,firstaddr);
+        else
+            showfull=1;

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

-static void setValBasic(symbol *sym, char *val)
+static unsigned long getValBasic(symbol *sym, link *type, char *val)

 {
 {

-    union 
-    {          
-        float f;     
+    char *s;
+    union
+    {
+        float f;

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

-            short    lo;
-            short    hi;
+            unsigned short    lo;
+            unsigned short    hi;

         } i;
         unsigned char b[4];
     }v;
 
         } i;
         unsigned char b[4];
     }v;
 

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

     else
     else

-       if (IS_PTR(sym->type))
-           v.sval = strtol(val,NULL,0);
-       else
+        if (IS_PTR(type))
+            v.val = strtol(val,NULL,0);
+        else

     {
     {

-           if (IS_SPEC(sym->type) && IS_INTEGRAL(sym->type)) 
+            if (IS_INTEGRAL(type))

         {
         {

-            if (IS_CHAR(sym->etype))
-            { 
-                v.b[0] = val[0];
+            link *etype;
+            if ( type->next )
+                etype = type->next;
+            else
+                etype = type;
+            if (IS_CHAR(etype))
+            {
+                if (( s = strchr(val,'\'')))
+                {
+                    if ( s[1] == '\\' )
+                        v.b[0] = strtol(s+2,NULL,8);
+                    else
+                        v.b[0] = s[1];
+                }
+                else
+                {
+                    v.b[0] = strtol(val,NULL,0);
+                }

             }
             else
             }
             else

-                if (IS_INT(sym->etype)) 
-                    if (IS_LONG(sym->etype))
-                        if (SPEC_USIGN(sym->etype))
-                            v.val = strtol(val,NULL,0);
-                        else
-                            v.sval = strtol(val,NULL,0);
+                if (IS_INT(etype))
+                    if (IS_LONG(etype))
+                        v.val = strtol(val,NULL,0);

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

-                    v.sval = strtol(val,NULL,0);
-           } 
+                    v.val = strtol(val,NULL,0);
+            }

         else
         else

-            v.sval = strtol(val,NULL,0);
+            v.val = strtol(val,NULL,0);

     }
     }

-    simSetValue(sym->addr,sym->addrspace,sym->size,v.sval);    
+    return v.val;
+}
+
+/*-----------------------------------------------------------------*/
+/* printFmtInteger - print value in bin,oct,dez or hex             */
+/*-----------------------------------------------------------------*/
+static void printFmtInteger(char *deffmt,int fmt, long val,
+                            int sign, int size)
+{
+    static char digits[] =
+    {
+        '0' , '1' , '2' , '3' , '4' , '5' ,
+        '6' , '7' , '8' , '9' , 'a' , 'b' ,
+        'c' , 'd' , 'e' , 'f' , 'g' , 'h'
+    };
+    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;
+    int radix;
+
+    if ( fmt == FMT_NON || fmt == FMT_DEZ )
+    {
+        fprintf(stdout,deffmt,val);
+        return;
+    }
+    radix = radixOfFormat[fmt];
+
+    /*
+    if ( sign && val < 0 )
+        negative = 1;
+    */
+
+        if (!negative)
+            val = -val;
+
+        buf[39] = '\0';
+    while (val <= -radix)
+    {
+            buf[charPos--] = digits[-(val % radix)];
+            val = val / radix;
+        }
+        buf[charPos] = digits[-val];
+
+    switch ( fmt )
+    {
+        case FMT_OCT:
+            radix = olenOfSize[size];
+            break;
+        case FMT_HEX:
+            radix = size << 1;
+            break;
+        case FMT_BIN:
+            radix = size << 3;
+            break;
+    }
+
+    while (charPos > 39 - radix )
+    {
+        buf[--charPos] = '0';
+    }
+    switch ( fmt )
+    {
+        case FMT_OCT:
+            if ( buf[charPos] != '0' )
+                buf[--charPos] = '0';
+            break;
+        case FMT_HEX:
+            buf[--charPos] = 'x';
+            buf[--charPos] = '0';
+            break;
+    }
+        if (negative) {
+            buf[--charPos] = '-';
+        }
+    fputs(&buf[charPos],stdout);

 }
 
 /*-----------------------------------------------------------------*/
 /* printValBasic - print value of basic types                      */
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/
 /* printValBasic - print value of basic types                      */
 /*-----------------------------------------------------------------*/

-static void printValBasic(symbol *sym,unsigned addr,char mem, int size)
-{
-    union {    
-       float f;     
-       unsigned long val;
-       long         sval;
-       struct {
-           short    lo;
-           short    hi;
-       } i;
-       unsigned char b[4];
-    }v;
+static void printValBasic(symbol *sym, link *type,
+                          char mem, unsigned addr,int size, int fmt)
+{

     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(sym->type))   
-       fprintf(stdout,"%f",v.f);    
+    if (IS_FLOAT(type))
+        fprintf(stdout,"%f",v.f);

     else
     else

-       if (IS_PTR(sym->type))
-           fprintf(stdout,"0x%x",v.val);
-       else
-           if (IS_SPEC(sym->type) && IS_INTEGRAL(sym->type)) {
-               if (IS_CHAR(sym->etype))
-        { 
-                   if ( isprint(v.val))
-                fprintf(stdout,"%d 0x%x '%c'",v.val,v.val,v.val);
-            else
-                fprintf(stdout,"%d 0x%x '\\%o'",v.val,v.val,v.val);
-               }
+        if (IS_PTR(type))
+            fprintf(stdout,"0x%*lx",size<<1,v.val);

         else
         else

-                   if (IS_INT(sym->etype)) 
-                       if (IS_LONG(sym->etype))
-                           if (SPEC_USIGN(sym->etype))
-                               fprintf(stdout,"%d 0x%x",v.val,v.val);
-                           else
-                               fprintf(stdout,"%d 0x%x",v.sval,v.sval);
-                       else
-                           fprintf(stdout,"%d 0x%x",v.i.lo,v.i.lo);
-                   else
-                       fprintf(stdout,"0x%x",v.val);
-           } else
-               fprintf(stdout,"0x%x",v.val);
-               
-    
+        if (IS_INTEGRAL(type))
+        {
+            link *etype;
+            if ( type->next )
+                etype = type->next;
+            else
+                etype = type;
+            if (IS_CHAR(etype))
+            {
+                if ( isprint(v.val))
+                    printFmtInteger((SPEC_USIGN(etype)?"0x%02x":"'%c'"),
+                                    fmt,(long)v.val,0,size);
+                else
+                    printFmtInteger((SPEC_USIGN(etype)?"0x%02x":"'\\%o'"),
+                                    fmt,(long)v.val,0,size);
+            }
+            else
+            {
+                if (IS_INT(etype))
+                    if (IS_LONG(etype))
+                        if (SPEC_USIGN(etype))
+                            printFmtInteger("%u",fmt,(long)v.val,0,size);
+                        else
+                            printFmtInteger("%d",fmt,(long)v.sval,1,size);
+                    else
+                        if (SPEC_USIGN(etype))
+                            printFmtInteger("%u",fmt,(long)v.i.lo,0,size);
+                        else
+                            printFmtInteger("%d",fmt,(long)v.i.lo,1,size);
+                else
+                {
+                    if (IS_BITVAR(etype))
+                        fprintf(stdout,"%c",(v.val?'1':'0'));
+                    else
+                        fprintf(stdout,"0x%0*lx",size<<1,v.val);
+                }
+            }
+            } else
+            fprintf(stdout,"0x%0*lx",size<<1,v.val);

 }
 
 /*-----------------------------------------------------------------*/
 /* printValFunc  - prints function values                          */
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/
 /* printValFunc  - prints function values                          */
 /*-----------------------------------------------------------------*/

-static void printValFunc (symbol *sym)
+static void printValFunc (symbol *sym, int fmt)

 {
     fprintf(stdout,"print function not yet implemented");
 }
 {
     fprintf(stdout,"print function not yet implemented");
 }


@@ -1970,141 +2540,250 @@ static void printValFunc (symbol *sym)
 /*-----------------------------------------------------------------*/
 /* printArrayValue - will print the values of array elements       */
 /*-----------------------------------------------------------------*/
 /*-----------------------------------------------------------------*/
 /* printArrayValue - will print the values of array elements       */
 /*-----------------------------------------------------------------*/

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

 {
 {

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

 {
 {

-       symbol *fields = SPEC_STRUCT(type)->fields;
-
-       fprintf(stdout," { ");
-       while (fields) {
-               fprintf(stdout,"%s = ",fields->name);
-               if (IS_AGGREGATE(fields->type)) {
-                       printValAggregates(fields,fields->type,space, addr);
-               } else {
-                       printValBasic(fields,addr,space,getSize(fields->type));
-               }
-               addr += getSize(fields->type);
-               fields = fields->next;
-       }
-       fprintf(stdout,"}");
+        symbol *fields = SPEC_STRUCT(type)->fields;
+    int first = 1;
+        fprintf(stdout," { ");
+        while (fields) {
+                fprintf(stdout,"%s%s = ",(first ? "": ", "),fields->name);
+                first = 0;
+        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 - print value of aggregates                  */
 /*-----------------------------------------------------------------*/
 }
 
 /*-----------------------------------------------------------------*/
 /* printValAggregates - print value of aggregates                  */
 /*-----------------------------------------------------------------*/

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

 {
 
 {
 

-       if (IS_ARRAY(type)) {
-               printArrayValue(sym, space, addr);
-               return ;
-       }
+        if (IS_ARRAY(type)) {
+                printArrayValue(sym, type, space, addr, fmt);
+                return ;
+        }

 
 

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

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

-/* setSymValue - set     value of a symbol                         */
+/* printOrSetSymValue - print or set value of a symbol             */

 /*-----------------------------------------------------------------*/
 /*-----------------------------------------------------------------*/

-static void setSymValue(symbol *sym, char *val, context *cctxt)
+static int printOrSetSymValue (symbol *sym, context *cctxt,
+                                int flg, int dnum, int fmt, char *rs,
+                                char *val, char cmp )

 {
 {

-    if (sym->isonstack) 
+    static char fmtChar[] = " todx ";
+    static int stack = 1;
+        symbol *fields;
+    link *type;
+    unsigned int  addr;
+    int size, n;
+    char *s, *s2;
+    char save_ch, save_ch2;
+
+    /* if it is on stack then compute address & fall thru */
+    if (sym->isonstack)

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

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

         {
             fprintf(stdout,"cannot determine stack frame\n");
         {
             fprintf(stdout,"cannot determine stack frame\n");

-            return ;
+            return 1;

         }
 
         sym->addr = simGetValue(bp->addr,bp->addrspace,bp->size)
         }
 
         sym->addr = simGetValue(bp->addr,bp->addrspace,bp->size)

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

     }
     }

-    /* arrays & structures first */
-    if (IS_AGGREGATE(sym->type))
-       {
-    }
-    else
-       /* functions */
-       if (IS_FUNC(sym->type))
-    {
-    }
-       else
-    {
-        setValBasic(sym,val);
-    }
-}

 
 

-/*-----------------------------------------------------------------*/
-/* printSymValue - print value of a symbol                         */
-/*-----------------------------------------------------------------*/
-static void printSymValue (symbol *sym, context *cctxt, int flg, int dnum)
-{
-    static int stack = 1;
-    unsigned long val;
-    /* if it is on stack then compute address & fall thru */
-    if (sym->isonstack) {
-       symbol *bp = symLookup("bp",cctxt);
-       if (!bp) {
-           fprintf(stdout,"cannot determine stack frame\n");
-           return ;
-       }
-
-       sym->addr = simGetValue(bp->addr,bp->addrspace,bp->size)
-         + 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: 
-            fprintf(stdout,"%d: %s = ",dnum,sym->name);
+        case 2:
+            fprintf(stdout,"%d: ", dnum);
+            if ( fmt != FMT_NON )
+                fprintf(stdout,"/%c ",fmtChar[fmt]);
+            fprintf(stdout,"%s%s = ",sym->name,rs);
+            break;
+    }
+
+    addr = sym->addr;
+    type = sym->type;
+    size = sym->size;
+
+    while ( *rs )
+    {
+        if ( *rs == '[' && IS_ARRAY(type))
+        {
+            s = rs+1;
+            while ( *rs && *rs != ']' ) rs++ ;
+            save_ch = *rs;
+            *rs = '\0' ;
+            if ( ! isdigit(*s ))
+            {
+                /* index seems a variable */
+                for ( s2 = s; *s2 && ( isalnum( *s2 ) || *s2 == '_'); s2++ );
+                save_ch2 = *s2;
+                if ( *s2 )
+                    *s2 = '\0';
+                fields = symLookup(s,cctxt);
+                *s2 = save_ch2;
+                if ( ! fields )
+                {
+                    fprintf(stdout,"Unknown variable \"%s\" for index.\n", s);
+                    return 1;
+                }
+                /* arrays & structures first */
+                if (! IS_INTEGRAL(fields->type))
+                {
+                    fprintf(stdout,"Wrong type of variable \"%s\" for index \n", s);
+                    return 1;
+                }
+                n = simGetValue(fields->addr,fields->addrspace,getSize(fields->type));
+            }
+            else
+            {
+                n = strtol(s,0,0);
+            }
+            if ( n < 0 || n >= DCL_ELEM(type))
+            {
+                fprintf(stdout,"Wrong index %d.\n", n);
+                return 1;
+            }
+            type = type->next;
+            size = getSize(type);
+            addr += size * n;
+            *rs++ = save_ch;
+        }
+        else if ( *rs == '.' && IS_STRUCT(type))
+        {
+            s = rs+1;
+            /* search structure element */
+            for ( rs = s; *rs && ( isalnum( *rs ) || *rs == '_'); rs++ );
+            save_ch = *rs;
+            if ( *rs )
+                *rs = '\0';
+            for (fields = SPEC_STRUCT(type)->fields; fields; fields = fields->next)
+            {
+                if (!(strcmp(s,fields->name)))
+                    break;
+            }
+            *rs = save_ch;
+            if ( ! fields )
+            {
+                fprintf(stdout,"Unknown field \"%s\" of structure\n", s);
+                return 1;
+            }
+            type = fields->type;
+            size = getSize(type);
+            addr += fields->offset;
+        }
+        else

             break;
     }
             break;
     }

+

     /* arrays & structures first */
     /* arrays & structures first */

-    if (IS_AGGREGATE(sym->type))
-       printValAggregates(sym,sym->type,sym->addrspace,sym->addr);
+    if (IS_AGGREGATE(type))
+    {
+            if ( val )
+        {
+            fprintf(stdout,"Cannot set/compare aggregate variable\n");
+            return 1;
+        }
+        else
+            printValAggregates(sym,type,sym->addrspace,addr,fmt);
+    }

     else
     else

-       /* functions */
-       if (IS_FUNC(sym->type))
-           printValFunc(sym);
-       else 
-           printValBasic(sym,sym->addr,sym->addrspace,sym->size);
+        /* functions */
+        if (IS_FUNC(type))
+    {
+            if ( !val )
+            printValFunc(sym,fmt);
+        else
+            return 1;
+    }
+        else
+    {
+            if ( val )
+        {
+            unsigned long newval;
+            newval = getValBasic(sym,type,val);
+
+            if ( cmp )
+            {
+                unsigned long lval;
+                lval = simGetValue(addr,sym->addrspace,size);
+                switch ( cmp )
+                {
+                    case '<' : return ( lval <  newval ? 1:0 ); break;
+                    case '>' : return ( lval >  newval ? 1:0 ); break;
+                    case 'l' : return ( lval <= newval ? 1:0 ); break;
+                    case 'g' : return ( lval >= newval ? 1:0 ); break;
+                    case '=' : return ( lval == newval ? 1:0 ); break;
+                    case '!' : return ( lval != newval ? 1:0 ); break;
+                }
+            }
+            else
+            {
+                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;
+            }
+        }
+        else
+            printValBasic(sym,type,sym->addrspace,addr,size,fmt);
+    }

     if ( flg > 0 ) fprintf(stdout,"\n");
     if ( flg > 0 ) fprintf(stdout,"\n");

-           //fprintf(stdout,"(BASIC %x,%c,%d)\n",sym->addr,sym->addrspace,sym->size);
-       
+        return 0;

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


@@ -2114,18 +2793,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");


@@ -2138,95 +2817,125 @@ 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;
+        }

     }
 }
 
     }
 }
 

+/*-----------------------------------------------------------------*/
+/* conditionIsTrue - compare variable with constant value        */
+/*-----------------------------------------------------------------*/
+int conditionIsTrue( char *s, context *cctxt)
+{
+    symbol *sym = NULL;
+    int fmt;
+    char *rs, *dup, cmp_char;
+    dup = s = Safe_strdup(s);
+    if ( !( rs = preparePrint(s, cctxt, &fmt, &sym )) || !sym)
+        fmt = 1;
+    else if (!( s =  strpbrk(rs,"<>=!")))
+        fmt = 1;
+    else
+    {
+        cmp_char = *s;
+        *s++ = '\0';
+        if ( *s == '=' )
+        {
+            /* if <= or >= an other char is used
+             * == or !=  not checked in switch
+             */
+            switch( cmp_char )
+            {
+                case '>': cmp_char = 'g' ; break;
+                case '<': cmp_char = 'l' ; break;
+            }
+            s++ ;
+        }
+        s = trim_left(s);
+        fmt = printOrSetSymValue(sym,cctxt,0,0,0,rs,s,cmp_char);
+    }
+    Safe_free(dup);
+    return fmt;
+}
+

 /*-----------------------------------------------------------------*/
 /* cmdPrint - print value of variable                              */
 /*-----------------------------------------------------------------*/
 int cmdPrint (char *s, context *cctxt)
 /*-----------------------------------------------------------------*/
 /* cmdPrint - print value of variable                              */
 /*-----------------------------------------------------------------*/
 int cmdPrint (char *s, context *cctxt)

-{   
+{

     symbol *sym ;
     symbol *sym ;

-    char *bp = s+strlen(s) -1;
-
-    while (isspace(*s)) s++;
-    if (!*s) return 0;
-    while (isspace(*bp)) bp--;
-    bp++ ;
-    *bp = '\0';
+    int fmt;
+    char *rs;
+    if ( !( rs = preparePrint(s, cctxt, &fmt, &sym )))
+        return 0;

 
 

-    if ((sym = symLookup(s,cctxt))) {
-       printSymValue(sym,cctxt,1,0);
-    } else {
-       fprintf(stdout,
-               "No symbol \"%s\" in current context.\n",              
-               s);
+    if ( sym )
+    {
+        printOrSetSymValue(sym,cctxt,1,0,fmt,rs,NULL,'\0');

     }
     return 0;
 }
     }
     return 0;
 }


@@ -2235,32 +2944,20 @@ 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 ;
     symbol *sym ;

-    char *bp = s+strlen(s) -1;
-
-    while (isspace(*s)) s++;
-    if (!*s) return 0;
-    while (isspace(*bp)) bp--;
-    bp++ ;
-    *bp = '\0';
+    int fmt;
+    char *rs;
+    if ( !( rs = preparePrint(s, cctxt, &fmt, &sym )))
+        return 0;

 
 

-    if ((sym = symLookup(s,cctxt))) {
-       printSymValue(sym,cctxt,0,0);
-    } else {
-       fprintf(stdout,
-               "No symbol \"%s\" in current context.",        
-               s);
+    if ( sym )
+    {
+        printOrSetSymValue(sym,cctxt,0,0,fmt,rs,NULL,'\0');

     }
     return 0;
 }
 
     }
     return 0;
 }
 

-typedef struct _dsymbol
-{
-    char *name;
-    int  dnum;
-} dsymbol;
-

 /** find display entry with this number */
 
 DEFSETFUNC(dsymWithNumber)
 /** find display entry with this number */
 
 DEFSETFUNC(dsymWithNumber)


@@ -2288,10 +2985,11 @@ 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)))
     {
         if ( (sym = symLookup(dsym->name,cctxt)))

-            printSymValue(sym,cctxt,2,dsym->dnum);            
+            printOrSetSymValue(sym,cctxt,2,dsym->dnum,dsym->fmt,
+                               dsym->rs,NULL,'\0');

     }
 }
 
     }
 }
 


@@ -2299,33 +2997,26 @@ 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)

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

     static int dnum = 1;
     static int dnum = 1;

-
-    while (isspace(*s)) s++;
-    if (!*s)
+    symbol *sym ;
+    int fmt;
+    char *rs;
+    if ( !( rs = preparePrint(s, cctxt, &fmt, &sym )))

     {
         displayAll(cctxt);
         return 0;
     }
     {
         displayAll(cctxt);
         return 0;
     }

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

 
 

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

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

+        dsym->fmt  = fmt;
+        dsym->rs   = gc_strdup(rs);

         addSetHead(&dispsymbols,dsym);
     }
         addSetHead(&dispsymbols,dsym);
     }

-    else
-    {
-        fprintf(stdout,"No symbol \"%s\" in current context.\n",              
-                s);
-    }

     return 0;
 }
 
     return 0;
 }
 


@@ -2333,26 +3024,35 @@ 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)
     {
     if (!*s)
     {

+        for (dsym = setFirstItem(dispsymbols);
+             dsym;
+             dsym = setNextItem(dispsymbols))
+        {
+            Safe_free(dsym->rs);
+            Safe_free(dsym);
+        }

         deleteSet(&dispsymbols);
         return 0;
     }
     while ( s && *s )
     {
         dnum = strtol(s,&s,10);
         deleteSet(&dispsymbols);
         return 0;
     }
     while ( s && *s )
     {
         dnum = strtol(s,&s,10);

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

         {
             deleteSetItem(&dispsymbols,dsym);
         {
             deleteSetItem(&dispsymbols,dsym);

-        } 
+            Safe_free(dsym->rs);
+            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;


@@ -2362,35 +3062,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


@@ -2401,99 +3098,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) {


@@ -2508,23 +3199,103 @@ int cmdSimulator (char *s, context *cctxt)
     return 0;
 }
 
     return 0;
 }
 

+void setMainContext()
+{
+    function *func = NULL;
+    currentFrame = 0;
+    if (!applyToSet(functions,funcWithName,"_main",&func) &&
+        !applyToSet(functions,funcWithName,"main",&func))
+            return;
+
+    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;
+    function *func     = NULL;
+    function *lastfunc = NULL;
+
+    if ( currentFrame < 0 )
+    {
+        currentFrame = 0;
+        fprintf(stdout,"Bottom (i.e., innermost) frame selected; you cannot go down.\n");
+        return;
+    }
+    STACK_STARTWALK(callStack) ;
+    for ( i = 0; i <= currentFrame ; i++ )
+    {
+        func = STACK_WALK(callStack);
+        if ( !func )
+        {
+            currentFrame = i-1;
+            fprintf(stdout,"Initial frame selected; you cannot go up.\n");
+            return;
+        }
+    }
+    fprintf(stdout,"#%d  0x%08x in %s () at %s:%d\n",
+            currentFrame,func->laddr,func->sym->name,func->mod->c_name,func->lline+1);
+    fprintf(stdout,"\032\032%s:%d:1:beg:0x%08x\n",
+            func->mod->cfullname,func->lline+1,func->laddr);
+
+    discoverContext (func->laddr, func);
+}
+
+
+/*-----------------------------------------------------------------*/
+/* cmdUp -  Up command                                             */
+/*-----------------------------------------------------------------*/
+int cmdUp(char *s, context *cctxt)
+{
+    s = trim_left(s);
+    if ( *s )
+        currentFrame += strtol(s,0,10);
+    else
+        currentFrame++ ;
+
+    printFrame();
+        return 0;
+}
+
+/*-----------------------------------------------------------------*/
+/* cmdDown - down command                                          */
+/*-----------------------------------------------------------------*/
+int cmdDown(char *s, context *cctxt)
+{
+    s = trim_left(s);
+    if ( *s )
+        currentFrame -= strtol(s,0,10);
+    else
+        currentFrame-- ;
+
+    printFrame();
+        return 0;
+}

 /*-----------------------------------------------------------------*/
 /* cmdFrame - Frame command                                        */
 /*-----------------------------------------------------------------*/
 int cmdFrame (char *s, context *cctxt)
 /*-----------------------------------------------------------------*/
 /* cmdFrame - Frame command                                        */
 /*-----------------------------------------------------------------*/
 int cmdFrame (char *s, context *cctxt)

-{   
-    function *func ;
-
-    if ((func = STACK_PEEK(callStack))) {
-       fprintf(stdout,"#0  %s () at %s:%d\n",
-               func->sym->name,func->mod->c_name,cctxt->cline);
+{
+    function *func = NULL;
+    int framenr = 0;

 
 

-       if (cctxt->cline < func->mod->ncLines)      
-           fprintf(stdout,"%d\t%s",
-                   cctxt->cline,
-                   func->mod->cLines[cctxt->cline]->src);
-    } else
-       fprintf(stdout,"No stack.\n");
+    s = trim_left(s);
+    if ( *s )
+        currentFrame = strtol(s,0,10);
+    printFrame();

     return 0;
 }
 
     return 0;
 }
 


@@ -2533,24 +3304,25 @@ int cmdFrame (char *s, context *cctxt)
 /*-----------------------------------------------------------------*/
 int cmdFinish (char *s, context *ctxt)
 {
 /*-----------------------------------------------------------------*/
 int cmdFinish (char *s, context *ctxt)
 {

-    if (!ctxt || ! ctxt->func) {
-       fprintf(stdout,"The program is not running.\n");
-       return 0;
+    if (STACK_EMPTY(callStack)) {
+        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);
     }
 
     simGo(-1);

+    showfull = 1;

     return 0;
     return 0;

-    
+

 }
 
 
 }
 
 


@@ -2560,16 +3332,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;