* sim/ucsim/cmd.src/newcmdposix.cc, sim/ucsim/cmd.src/newcmdposixcl.h,

[fw/sdcc] / sim / ucsim / cmd.src / cmduc.cc

diff --git a/sim/ucsim/cmd.src/cmduc.cc b/sim/ucsim/cmd.src/cmduc.cc
index cb3aa557b994dfbcbadb0fe1ce833dbeff0f3ffb..02330e4f1bc80dd3c666942a95f607aacff94095 100644 (file)
--- a/sim/ucsim/cmd.src/cmduc.cc
+++ b/sim/ucsim/cmd.src/cmduc.cc
@@ -43,29 +43,29 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 
 //int
 //cl_state_cmd::do_work(class cl_sim *sim,
-//                   class cl_cmdline *cmdline, class cl_console *con)
+//                    class cl_cmdline *cmdline, class cl_console_base *con)
 COMMAND_DO_WORK_UC(cl_state_cmd)
 {
   con->dd_printf("CPU state= %s PC= 0x%06x XTAL= %g\n",
-                get_id_string(cpu_states, uc->state),
-                uc->PC, 
-                uc->xtal);
+                 get_id_string(cpu_states, uc->state),
+                 uc->PC, 
+                 uc->xtal);
   con->dd_printf("Total time since last reset= %g sec (%lu clks)\n",
-                uc->get_rtime(), uc->ticks->ticks);
+                 uc->get_rtime(), uc->ticks->ticks);
   con->dd_printf("Time in isr = %g sec (%lu clks) %3.2g%%\n",
-                uc->isr_ticks->get_rtime(uc->xtal),
-                uc->isr_ticks->ticks,
-                (uc->ticks->ticks == 0)?0.0:
-                (100.0*((double)(uc->isr_ticks->ticks)/
-                        (double)(uc->ticks->ticks))));
+                 uc->isr_ticks->get_rtime(uc->xtal),
+                 uc->isr_ticks->ticks,
+                 (uc->ticks->ticks == 0)?0.0:
+                 (100.0*((double)(uc->isr_ticks->ticks)/
+                         (double)(uc->ticks->ticks))));
   con->dd_printf("Time in idle= %g sec (%lu clks) %3.2g%%\n",
-                uc->idle_ticks->get_rtime(uc->xtal),
-                uc->idle_ticks->ticks,
-                (uc->ticks->ticks == 0)?0.0:
-                (100.0*((double)(uc->idle_ticks->ticks)/
-                        (double)(uc->ticks->ticks))));
+                 uc->idle_ticks->get_rtime(uc->xtal),
+                 uc->idle_ticks->ticks,
+                 (uc->ticks->ticks == 0)?0.0:
+                 (100.0*((double)(uc->idle_ticks->ticks)/
+                         (double)(uc->ticks->ticks))));
   con->dd_printf("Max value of stack pointer= 0x%06x, avg= 0x%06x\n",
-                uc->sp_max, uc->sp_avg);
+                 uc->sp_max, uc->sp_avg);
   return(0);
 }
 
@@ -77,7 +77,7 @@ COMMAND_DO_WORK_UC(cl_state_cmd)
 
 //int
 //cl_file_cmd::do_work(class cl_sim *sim,
-//                  class cl_cmdline *cmdline, class cl_console *con)
+//                   class cl_cmdline *cmdline, class cl_console_base *con)
 COMMAND_DO_WORK_UC(cl_file_cmd)
 {
   char *fname= 0;
@@ -103,7 +103,7 @@ COMMAND_DO_WORK_UC(cl_file_cmd)
 
 //int
 //cl_dl_cmd::do_work(class cl_sim *sim,
-//                class cl_cmdline *cmdline, class cl_console *con)
+//                 class cl_cmdline *cmdline, class cl_console_base *con)
 COMMAND_DO_WORK_UC(cl_dl_cmd)
 {
   long l;
@@ -122,7 +122,7 @@ COMMAND_DO_WORK_UC(cl_dl_cmd)
 
 //int
 //cl_pc_cmd::do_work(class cl_sim *sim,
-//                class cl_cmdline *cmdline, class cl_console *con)
+//                 class cl_cmdline *cmdline, class cl_console_base *con)
 COMMAND_DO_WORK_UC(cl_pc_cmd)
 {
   t_addr addr;
@@ -131,18 +131,18 @@ COMMAND_DO_WORK_UC(cl_pc_cmd)
   if (params[0])
     {
       if (!(params[0]->get_address(uc, &addr)))
-       {
-         con->dd_printf("Error: wrong parameter\n");
-         return(DD_FALSE);
-       }
+        {
+          con->dd_printf("Error: wrong parameter\n");
+          return(DD_FALSE);
+        }
       class cl_address_space *rom= uc->address_space(MEM_ROM_ID);
       if (rom)
-       {
-         if (addr > rom->highest_valid_address())
-           addr= rom->highest_valid_address();
-       }
+        {
+          if (addr > rom->highest_valid_address())
+            addr= rom->highest_valid_address();
+        }
       if (!uc->inst_at(addr))
-       con->dd_printf("Warning: maybe not instruction at 0x%06x\n", addr);
+        con->dd_printf("Warning: maybe not instruction at 0x%06x\n", addr);
       uc->PC= addr;
     }
   uc->print_disass(uc->PC, con);
@@ -157,7 +157,7 @@ COMMAND_DO_WORK_UC(cl_pc_cmd)
 
 //int
 //cl_reset_cmd::do_work(class cl_sim *sim,
-//                   class cl_cmdline *cmdline, class cl_console *con)
+//                    class cl_cmdline *cmdline, class cl_console_base *con)
 COMMAND_DO_WORK_UC(cl_reset_cmd)
 {
   uc->reset();
@@ -172,77 +172,77 @@ COMMAND_DO_WORK_UC(cl_reset_cmd)
 
 //int
 //cl_dump_cmd::do_work(class cl_sim *sim,
-//                  class cl_cmdline *cmdline, class cl_console *con)
+//                   class cl_cmdline *cmdline, class cl_console_base *con)
 COMMAND_DO_WORK_UC(cl_dump_cmd)
 {
   class cl_memory *mem= 0;
   long bpl= 8;
   t_addr start= 0, end;
   class cl_cmd_arg *params[4]= { cmdline->param(0),
-                                cmdline->param(1),
-                                cmdline->param(2),
-                                cmdline->param(3) };
+                                 cmdline->param(1),
+                                 cmdline->param(2),
+                                 cmdline->param(3) };
 
   if (params[0] &&
       params[0]->as_bit(uc))
     {
       int i= 0;
       while (params[0] &&
-            params[0]->as_bit(uc))
-       {
-         t_mem m;
-         mem= params[0]->value.bit.mem;
-         m= mem->read(params[0]->value.bit.mem_address);
-         char *sn=
-           uc->symbolic_bit_name((t_addr)-1,
-                                 mem,
-                                 params[0]->value.bit.mem_address,
-                                 params[0]->value.bit.mask);
-         con->dd_printf("%10s ", sn?sn:"");
-         con->dd_printf(mem->addr_format, params[0]->value.bit.mem_address);
-         con->dd_printf(" ");
-         con->dd_printf(mem->data_format, m);
-         con->dd_printf(" %c\n", (m&(params[0]->value.bit.mask))?'1':'0');
-         i++;
-         params[0]= cmdline->param(i);
-       }
+             params[0]->as_bit(uc))
+        {
+          t_mem m;
+          mem= params[0]->value.bit.mem;
+          m= mem->read(params[0]->value.bit.mem_address);
+          char *sn=
+            uc->symbolic_bit_name((t_addr)-1,
+                                  mem,
+                                  params[0]->value.bit.mem_address,
+                                  params[0]->value.bit.mask);
+          con->dd_printf("%10s ", sn?sn:"");
+          con->dd_printf(mem->addr_format, params[0]->value.bit.mem_address);
+          con->dd_printf(" ");
+          con->dd_printf(mem->data_format, m);
+          con->dd_printf(" %c\n", (m&(params[0]->value.bit.mask))?'1':'0');
+          i++;
+          params[0]= cmdline->param(i);
+        }
       if (params[0])
-       con->dd_printf("%s\n", short_help?short_help:"Error: wrong syntax\n");
+        con->dd_printf("%s\n", short_help?short_help:"Error: wrong syntax\n");
     }
   else
     {
       if (!params[0] ||
-         !params[0]->as_memory(uc))
-       {
-         con->dd_printf("No memory specified. Use \"info memory\" for available memories\n");
-         return(DD_FALSE);
-       }
+          !params[0]->as_memory(uc))
+        {
+          con->dd_printf("No memory specified. Use \"info memory\" for available memories\n");
+          return(DD_FALSE);
+        }
       if (cmdline->syntax_match(uc, MEMORY))
-       {
-         mem= params[0]->value.memory.memory;
-         mem->dump(con);
-       }
+        {
+          mem= params[0]->value.memory.memory;
+          mem->dump(con);
+        }
       else if (cmdline->syntax_match(uc, MEMORY ADDRESS)) {
-       mem  = params[0]->value.memory.memory;
-       start= params[1]->value.address;
-       end  = start+10*8-1;
-       mem->dump(start, end, bpl, con);
+        mem  = params[0]->value.memory.memory;
+        start= params[1]->value.address;
+        end  = start+10*8-1;
+        mem->dump(start, end, bpl, con);
       }
       else if (cmdline->syntax_match(uc, MEMORY ADDRESS ADDRESS)) {
-       mem  = params[0]->value.memory.memory;
-       start= params[1]->value.address;
-       end  = params[2]->value.address;
-       mem->dump(start, end, bpl, con);
+        mem  = params[0]->value.memory.memory;
+        start= params[1]->value.address;
+        end  = params[2]->value.address;
+        mem->dump(start, end, bpl, con);
       }
       else if (cmdline->syntax_match(uc, MEMORY ADDRESS ADDRESS NUMBER)) {
-       mem  = params[0]->value.memory.memory;
-       start= params[1]->value.address;
-       end  = params[2]->value.address;
-       bpl  = params[3]->value.number;
-       mem->dump(start, end, bpl, con);
+        mem  = params[0]->value.memory.memory;
+        start= params[1]->value.address;
+        end  = params[2]->value.address;
+        bpl  = params[3]->value.number;
+        mem->dump(start, end, bpl, con);
       }
       else
-       con->dd_printf("%s\n", short_help?short_help:"Error: wrong syntax\n");
+        con->dd_printf("%s\n", short_help?short_help:"Error: wrong syntax\n");
     }
 
   return(DD_FALSE);;
@@ -256,7 +256,7 @@ COMMAND_DO_WORK_UC(cl_dump_cmd)
 
 //int
 //cl_di_cmd::do_work(class cl_sim *sim,
-//                class cl_cmdline *cmdline, class cl_console *con)
+//                 class cl_cmdline *cmdline, class cl_console_base *con)
 COMMAND_DO_WORK_UC(cl_di_cmd)
 {
   cmdline->insert_param(0, new cl_cmd_sym_arg("iram"));
@@ -272,7 +272,7 @@ COMMAND_DO_WORK_UC(cl_di_cmd)
 
 //int
 //cl_dx_cmd::do_work(class cl_sim *sim,
-//                class cl_cmdline *cmdline, class cl_console *con)
+//                 class cl_cmdline *cmdline, class cl_console_base *con)
 COMMAND_DO_WORK_UC(cl_dx_cmd)
 {
   cmdline->insert_param(0, new cl_cmd_sym_arg("xram"));
@@ -288,7 +288,7 @@ COMMAND_DO_WORK_UC(cl_dx_cmd)
 
 //int
 //cl_dch_cmd::do_work(class cl_sim *sim,
-//                 class cl_cmdline *cmdline, class cl_console *con)
+//                  class cl_cmdline *cmdline, class cl_console_base *con)
 COMMAND_DO_WORK_UC(cl_dch_cmd)
 {
   cmdline->insert_param(0, new cl_cmd_sym_arg("rom"));
@@ -304,7 +304,7 @@ COMMAND_DO_WORK_UC(cl_dch_cmd)
 
 //int
 //cl_ds_cmd::do_work(class cl_sim *sim,
-//                class cl_cmdline *cmdline, class cl_console *con)
+//                 class cl_cmdline *cmdline, class cl_console_base *con)
 COMMAND_DO_WORK_UC(cl_ds_cmd)
 {
   cmdline->insert_param(0, new cl_cmd_sym_arg("sfr"));
@@ -320,12 +320,12 @@ COMMAND_DO_WORK_UC(cl_ds_cmd)
 
 //int
 //cl_dc_cmd::do_work(class cl_sim *sim,
-//                class cl_cmdline *cmdline, class cl_console *con)
+//                 class cl_cmdline *cmdline, class cl_console_base *con)
 COMMAND_DO_WORK_UC(cl_dc_cmd)
 {
   t_addr start= last, end= last+20;
   class cl_cmd_arg *params[2]= { cmdline->param(0),
-                                cmdline->param(1) };
+                                 cmdline->param(1) };
   class cl_address_space *rom= uc->address_space(MEM_ROM_ID);
 
   if (!rom)
@@ -369,15 +369,15 @@ static int disass_last_stop= 0;
 
 //int
 //cl_disassemble_cmd::do_work(class cl_sim *sim,
-//                         class cl_cmdline *cmdline, class cl_console *con)
+//                          class cl_cmdline *cmdline, class cl_console_base *con)
 COMMAND_DO_WORK_UC(cl_disassemble_cmd)
 {
   t_addr start, realstart;
   int offset= -1, dir, lines= 20;
   class cl_cmd_arg *params[4]= { cmdline->param(0),
-                                cmdline->param(1),
-                                cmdline->param(2),
-                                cmdline->param(3) };
+                                 cmdline->param(1),
+                                 cmdline->param(2),
+                                 cmdline->param(3) };
 
   start= disass_last_stop;
   if (params[0] == 0) ;
@@ -411,18 +411,18 @@ COMMAND_DO_WORK_UC(cl_disassemble_cmd)
   if (!rom)
     return(DD_FALSE);
   while (realstart <= rom->highest_valid_address() &&
-        !uc->inst_at(realstart))
+         !uc->inst_at(realstart))
     realstart= realstart+1;
   if (offset)
     {
       dir= (offset < 0)?-1:+1;
       while (offset)
-       {
-         realstart= rom->inc_address(realstart, dir);
-         while (!uc->inst_at(realstart))
-           realstart= rom->inc_address(realstart, dir);
-         offset+= -dir;
-       }
+        {
+          realstart= rom->inc_address(realstart, dir);
+          while (!uc->inst_at(realstart))
+            realstart= rom->inc_address(realstart, dir);
+          offset+= -dir;
+        }
     }
   
   while (lines)
@@ -430,7 +430,7 @@ COMMAND_DO_WORK_UC(cl_disassemble_cmd)
       uc->print_disass(realstart, con);
       realstart= rom->inc_address(realstart, +1) + rom->start_address;
       while (!uc->inst_at(realstart))
-       realstart= rom->inc_address(realstart, +1) + rom->start_address;
+        realstart= rom->inc_address(realstart, +1) + rom->start_address;
       lines--;
     }
 
@@ -447,16 +447,16 @@ COMMAND_DO_WORK_UC(cl_disassemble_cmd)
 
 //int
 //cl_fill_cmd::do_work(class cl_sim *sim,
-//                  class cl_cmdline *cmdline, class cl_console *con)
+//                   class cl_cmdline *cmdline, class cl_console_base *con)
 COMMAND_DO_WORK_UC(cl_fill_cmd)
 {
   class cl_memory *mem= 0;
   t_mem what= 0;
   t_addr start= 0, end;
   class cl_cmd_arg *params[4]= { cmdline->param(0),
-                                cmdline->param(1),
-                                cmdline->param(2),
-                                cmdline->param(3) };
+                                 cmdline->param(1),
+                                 cmdline->param(2),
+                                 cmdline->param(3) };
 
   if (cmdline->syntax_match(uc, MEMORY ADDRESS ADDRESS NUMBER)) {
     mem  = params[0]->value.memory.memory;
@@ -466,9 +466,9 @@ COMMAND_DO_WORK_UC(cl_fill_cmd)
     t_addr i;
     for (i= start; i <= end; i++)
       {
-       t_mem d;
-       d= what;
-       mem->write(i, d);
+        t_mem d;
+        d= what;
+        mem->write(i, d);
       }
   }
   else
@@ -485,12 +485,12 @@ COMMAND_DO_WORK_UC(cl_fill_cmd)
 
 int
 cl_where_cmd::do_real_work(class cl_uc *uc,
-                          class cl_cmdline *cmdline, class cl_console *con,
-                          bool case_sensitive)
+                           class cl_cmdline *cmdline, class cl_console_base *con,
+                           bool case_sensitive)
 {
   class cl_memory *mem= 0;
   class cl_cmd_arg *params[2]= { cmdline->param(0),
-                                cmdline->param(1) };
+                                 cmdline->param(1) };
 
   if (cmdline->syntax_match(uc, MEMORY DATALIST)) {
     mem= params[0]->value.memory.memory;
@@ -498,16 +498,16 @@ cl_where_cmd::do_real_work(class cl_uc *uc,
     int len= params[1]->value.data_list.len;
     if (!len)
       {
-       con->dd_printf("Error: nothing to search for\n");
-       return(DD_FALSE);
+        con->dd_printf("Error: nothing to search for\n");
+        return(DD_FALSE);
       }
     t_addr addr= 0;
     bool found= mem->search_next(case_sensitive, array, len, &addr);
     while (found)
       {
-       mem->dump(addr, addr+len-1, 8, con);
-       addr++;
-       found= mem->search_next(case_sensitive, array, len, &addr);
+        mem->dump(addr, addr+len-1, 8, con);
+        addr++;
+        found= mem->search_next(case_sensitive, array, len, &addr);
       }
   }
   else
@@ -518,7 +518,7 @@ cl_where_cmd::do_real_work(class cl_uc *uc,
 
 //int
 //cl_where_cmd::do_work(class cl_sim *sim,
-//                   class cl_cmdline *cmdline, class cl_console *con)
+//                    class cl_cmdline *cmdline, class cl_console_base *con)
 COMMAND_DO_WORK_UC(cl_where_cmd)
 {
   return(do_real_work(uc, cmdline, con, DD_FALSE));
@@ -526,7 +526,7 @@ COMMAND_DO_WORK_UC(cl_where_cmd)
 
 //int
 //cl_Where_cmd::do_work(class cl_sim *sim,
-//                   class cl_cmdline *cmdline, class cl_console *con)
+//                    class cl_cmdline *cmdline, class cl_console_base *con)
 COMMAND_DO_WORK_UC(cl_Where_cmd)
 {
   return(do_real_work(uc, cmdline, con, DD_TRUE));