X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=sim%2Fucsim%2Fcmd.src%2Fcmduc.cc;h=02330e4f1bc80dd3c666942a95f607aacff94095;hb=90f4aedaef8a2310573eef905f95c671f84e5cde;hp=3623bd7a539d98d2ec1937ae89a3427bdd4f9354;hpb=8c8f34ff4281a55d2f535335c02999246e9e12f2;p=fw%2Fsdcc

diff --git a/sim/ucsim/cmd.src/cmduc.cc b/sim/ucsim/cmd.src/cmduc.cc
index 3623bd7a..02330e4f 100644
--- 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,14 +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);
-	}
-      if (addr >= uc->get_mem_size(MEM_ROM))
-	addr= 0;
+        {
+          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 (!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);
@@ -153,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();
@@ -168,69 +172,78 @@ 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_mem *mem= 0;
+  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 (cmdline->syntax_match(uc, MEMORY))
+  else
     {
-      mem= params[0]->value.memory;
-      mem->dump(con);
+      if (!params[0] ||
+          !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);
+        }
+      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);
+      }
+      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);
+      }
+      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);
+      }
+      else
+        con->dd_printf("%s\n", short_help?short_help:"Error: wrong syntax\n");
     }
-  else if (cmdline->syntax_match(uc, MEMORY ADDRESS)) {
-    mem  = params[0]->value.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;
-    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;
-    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");
 
   return(DD_FALSE);;
 }
@@ -243,10 +256,10 @@ 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("i"));
+  cmdline->insert_param(0, new cl_cmd_sym_arg("iram"));
   cl_dump_cmd::do_work(uc, cmdline, con);
   return(0);
 }
@@ -259,10 +272,10 @@ 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("x"));
+  cmdline->insert_param(0, new cl_cmd_sym_arg("xram"));
   cl_dump_cmd::do_work(uc, cmdline, con);
   return(0);
 }
@@ -275,10 +288,10 @@ 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("r"));
+  cmdline->insert_param(0, new cl_cmd_sym_arg("rom"));
   cl_dump_cmd::do_work(uc, cmdline, con);
   return(0);
 }
@@ -291,10 +304,10 @@ 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("s"));
+  cmdline->insert_param(0, new cl_cmd_sym_arg("sfr"));
   cl_dump_cmd::do_work(uc, cmdline, con);
   return(0);
 }
@@ -307,13 +320,13 @@ 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) };
-  class cl_mem *rom= uc->mem(MEM_ROM);
+                                 cmdline->param(1) };
+  class cl_address_space *rom= uc->address_space(MEM_ROM_ID);
 
   if (!rom)
     return(DD_FALSE);
@@ -327,14 +340,14 @@ COMMAND_DO_WORK_UC(cl_dc_cmd)
     start= params[0]->value.address;
     end= params[1]->value.address;
   }
-  if (start >= rom->size)
+  if (start > rom->highest_valid_address())
     {
-      con->dd_printf("Error: start address is wrong\n");
+      con->dd_printf("Error: start address is too high\n");
       return(DD_FALSE);
     }
-  if (end >= rom->size)
+  if (end > rom->highest_valid_address())
     {
-      con->dd_printf("Error: end address is wrong\n");
+      con->dd_printf("Error: end address is too high\n");
       return(DD_FALSE);
     }
 
@@ -356,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) ;
@@ -394,30 +407,30 @@ COMMAND_DO_WORK_UC(cl_disassemble_cmd)
   if (!uc->there_is_inst())
     return(DD_FALSE);
   realstart= start;
-  class cl_mem *rom= uc->mem(MEM_ROM);
+  class cl_address_space *rom= uc->address_space(MEM_ROM_ID);
   if (!rom)
     return(DD_FALSE);
-  while (realstart < rom->size &&
-	 !uc->inst_at(realstart))
+  while (realstart <= rom->highest_valid_address() &&
+         !uc->inst_at(realstart))
     realstart= realstart+1;
   if (offset)
     {
       dir= (offset < 0)?-1:+1;
       while (offset)
-	{
-	  realstart= (realstart+dir) % rom->size;
-	  while (!uc->inst_at(realstart))
-	    realstart= (realstart+dir) % rom->size;
-	  offset+= -dir;
-	}
+        {
+          realstart= rom->inc_address(realstart, dir);
+          while (!uc->inst_at(realstart))
+            realstart= rom->inc_address(realstart, dir);
+          offset+= -dir;
+        }
     }
   
   while (lines)
     {
       uc->print_disass(realstart, con);
-      realstart= (realstart+1) % rom->size;
+      realstart= rom->inc_address(realstart, +1) + rom->start_address;
       while (!uc->inst_at(realstart))
-	realstart= (realstart+1) % rom->size;
+        realstart= rom->inc_address(realstart, +1) + rom->start_address;
       lines--;
     }
 
@@ -434,28 +447,28 @@ 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_mem *mem= 0;
+  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;
+    mem  = params[0]->value.memory.memory;
     start= params[1]->value.address;
     end  = params[2]->value.address;
     what = params[3]->value.number;
     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
@@ -472,29 +485,29 @@ 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_mem *mem= 0;
+  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;
+    mem= params[0]->value.memory.memory;
     t_mem *array= params[1]->value.data_list.array;
     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
@@ -505,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));
@@ -513,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));