git.gag.com Git - fw/sdcc/blob - sim/ucsim/sim.src/arg.cc

   1 /*
   2  * Simulator of microcontrollers (arg.cc)
   3  *
   4  * Copyright (C) 1999,99 Drotos Daniel, Talker Bt.
   5  *
   6  * To contact author send email to drdani@mazsola.iit.uni-miskolc.hu
   7  *
   8  */
   9
  10 /* This file is part of microcontroller simulator: ucsim.
  11
  12 UCSIM is free software; you can redistribute it and/or modify
  13 it under the terms of the GNU General Public License as published by
  14 the Free Software Foundation; either version 2 of the License, or
  15 (at your option) any later version.
  16
  17 UCSIM is distributed in the hope that it will be useful,
  18 but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 GNU General Public License for more details.
  21
  22 You should have received a copy of the GNU General Public License
  23 along with UCSIM; see the file COPYING.  If not, write to the Free
  24 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  25 02111-1307, USA. */
  26 /*@1@*/
  27
  28 #include "ddconfig.h"
  29
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include "i_string.h"
  33
  34 // prj
  35 #include "globals.h"
  36
  37 // sim
  38 #include "simcl.h"
  39
  40 // cmd
  41 #include "cmdutil.h"
  42
  43 // local
  44 #include "argcl.h"
  45
  46
  47 /*
  48  * Making the argument
  49  */
  50
  51 cl_arg::cl_arg(long lv):
  52   cl_base()
  53 {
  54   i_value= lv;
  55   s_value= 0;
  56 }
  57
  58 cl_arg::cl_arg(char *sv):
  59   cl_base()
  60 {
  61   s_value= sv?strdup(sv):0;
  62 }
  63
  64 cl_arg::cl_arg(double fv):
  65   cl_base()
  66 {
  67   f_value= fv;
  68   s_value= 0;
  69 }
  70
  71 cl_arg::cl_arg(void *pv):
  72   cl_base()
  73 {
  74   p_value= pv;
  75   s_value= 0;
  76 }
  77
  78 cl_arg::~cl_arg(void)
  79 {
  80   if (s_value)
  81     free(s_value);
  82 }
  83
  84
  85 /*
  86  * Getting value of the argument
  87  */
  88
  89 bool
  90 cl_arg::get_ivalue(long *value)
  91 {
  92   if (value)
  93     *value= i_value;
  94   return(DD_TRUE);
  95 }
  96
  97 char *
  98 cl_arg::get_svalue(void)
  99 {
 100   return(s_value);
 101 }
 102
 103 double
 104 cl_arg::get_fvalue(void)
 105 {
 106   return(f_value);
 107 }
 108
 109 void *
 110 cl_arg::get_pvalue(void)
 111 {
 112   return(p_value);
 113 }
 114
 115
 116 /*
 117  * Command parameters
 118  *----------------------------------------------------------------------------
 119  */
 120
 121 cl_cmd_arg::~cl_cmd_arg(void)
 122 {
 123   if (interpreted_as_string)
 124     {
 125       if (value.string.string)
 126         free(value.string.string);
 127     }
 128 }
 129
 130 bool
 131 cl_cmd_arg::as_address(void)
 132 {
 133   return(get_address(&(value.address)));
 134 }
 135
 136 bool
 137 cl_cmd_arg::as_number(void)
 138 {
 139   return(get_ivalue(&(value.number)));
 140 }
 141
 142 bool
 143 cl_cmd_arg::as_data(void)
 144 {
 145   long l;
 146   bool ret= get_ivalue(&l);
 147   value.data= l;
 148   return(ret);
 149 }
 150
 151 bool
 152 cl_cmd_arg::as_memory(void)
 153 {
 154   value.memory= uc->mem(s_value);
 155   return(value.memory != 0);
 156 }
 157
 158 bool
 159 cl_cmd_arg::as_hw(class cl_uc *uc)
 160 {
 161   return(DD_FALSE);
 162 }
 163
 164 bool
 165 cl_cmd_arg::as_string(void)
 166 {
 167   char *s= get_svalue();
 168   if (!s)
 169     return(DD_FALSE);
 170   if (is_string())
 171     value.string.string= proc_escape(s, &value.string.len);
 172   else
 173     {
 174       value.string.string= strdup(s);
 175       value.string.len= strlen(s);
 176     }
 177   return(interpreted_as_string= value.string.string != NULL);
 178 }
 179
 180 bool
 181 cl_cmd_arg::as_bit(class cl_uc *uc)
 182 {
 183   return(get_bit_address(uc,
 184                          &(value.bit.mem),
 185                          &(value.bit.mem_address),
 186                          &(value.bit.mask)));
 187 }
 188
 189
 190 /* Interger number */
 191
 192 cl_cmd_int_arg::cl_cmd_int_arg(class cl_uc *iuc, long addr):
 193   cl_cmd_arg(iuc, addr)
 194 {}
 195
 196 bool
 197 cl_cmd_int_arg::get_address(t_addr *addr)
 198 {
 199   long iv;
 200
 201   bool b= get_ivalue(&iv);
 202   if (addr)
 203     *addr= iv;
 204   return(b);
 205 }
 206
 207 bool
 208 cl_cmd_int_arg::get_bit_address(class cl_uc *uc, // input
 209                                 class cl_mem **mem, // outputs
 210                                 t_addr *mem_addr,
 211                                 t_mem *bit_mask)
 212 {
 213   t_addr bit_addr;
 214
 215   if (!get_address(&bit_addr))
 216     return(DD_FALSE);
 217   return(uc->extract_bit_address(bit_addr, mem, mem_addr, bit_mask));
 218 }
 219
 220 bool
 221 cl_cmd_int_arg::as_string(void)
 222 {
 223   value.string.string= (char*)malloc(100);
 224   sprintf(value.string.string, "%ld", i_value);
 225   value.string.len= strlen(value.string.string);
 226   return(interpreted_as_string= value.string.string != NULL);
 227 }
 228
 229
 230 /* Symbol */
 231
 232 cl_cmd_sym_arg::cl_cmd_sym_arg(class cl_uc *iuc, char *sym):
 233   cl_cmd_arg(iuc, sym)
 234 {}
 235
 236 bool
 237 cl_cmd_sym_arg::as_string(void)
 238 {
 239   char *s= get_svalue();
 240   if (!s)
 241     return(DD_FALSE);
 242   value.string.string= strdup(s);
 243   value.string.len= strlen(s);
 244   return(interpreted_as_string= value.string.string != NULL);
 245 }
 246
 247 bool
 248 cl_cmd_sym_arg::get_address(t_addr *addr)
 249 {
 250   struct name_entry *ne;
 251
 252   if ((ne= get_name_entry(uc->sfr_tbl(),
 253                           get_svalue(),
 254                           uc)) != NULL)
 255     {
 256       if (addr)
 257         *addr= ne->addr;
 258       return(1);
 259     }
 260   return(0);
 261 }
 262
 263 bool
 264 cl_cmd_sym_arg::get_bit_address(class cl_uc *uc, // input
 265                                 class cl_mem **mem, // outputs
 266                                 t_addr *mem_addr,
 267                                 t_mem *bit_mask)
 268 {
 269   struct name_entry *ne;
 270
 271   if ((ne= get_name_entry(uc->bit_tbl(),
 272                           get_svalue(),
 273                           uc)) == NULL)
 274     return(DD_FALSE);
 275   return(uc->extract_bit_address(ne->addr, mem, mem_addr, bit_mask));
 276 }
 277
 278 bool
 279 cl_cmd_sym_arg::as_address(void)
 280 {
 281   struct name_entry *ne;
 282   //printf("SYM %s as addr?\n",get_svalue());
 283   if ((ne= get_name_entry(uc->sfr_tbl(), get_svalue(), uc)) != NULL)
 284     {
 285       value.address= ne->addr;
 286       return(DD_TRUE);
 287     }
 288   return(DD_FALSE);
 289 }
 290
 291 bool
 292 cl_cmd_sym_arg::as_hw(class cl_uc *uc)
 293 {
 294   cl_hw *hw, *found;
 295   int i= 0;
 296
 297   hw= found= uc->get_hw(get_svalue(), &i);
 298   if (!hw)
 299     return(DD_FALSE);
 300   i++;
 301   found= uc->get_hw(get_svalue(), &i);
 302   if (found)
 303     return(DD_FALSE);
 304   value.hw= hw;
 305   return(DD_TRUE);
 306 }
 307
 308
 309 /* String */
 310
 311 cl_cmd_str_arg::cl_cmd_str_arg(class cl_uc *iuc, char *str):
 312   cl_cmd_arg(iuc, str)
 313 {}
 314
 315
 316 /* Bit */
 317
 318 cl_cmd_bit_arg::cl_cmd_bit_arg(class cl_uc *iuc,
 319                                class cl_cmd_arg *asfr, class cl_cmd_arg *abit):
 320   cl_cmd_arg(iuc, (long)0)
 321 {
 322   sfr= asfr;
 323   bit= abit;
 324 }
 325
 326 cl_cmd_bit_arg::~cl_cmd_bit_arg(void)
 327 {
 328   if (sfr)
 329     delete sfr;
 330   if (bit)
 331     delete bit;
 332 }
 333
 334 bool
 335 cl_cmd_bit_arg::get_address(t_addr *addr)
 336 {
 337   if (sfr)
 338     return(sfr->get_address(addr));
 339   return(0);
 340 }
 341
 342 bool
 343 cl_cmd_bit_arg::get_bit_address(class cl_uc *uc, // input
 344                                 class cl_mem **mem, // outputs
 345                                 t_addr *mem_addr,
 346                                 t_mem *bit_mask)
 347 {
 348 printf("**1\n");
 349   if (mem)
 350     *mem= uc->mem(MEM_SFR);
 351 printf("**2\n");
 352   if (mem_addr)
 353     {
 354 printf("**3\n");
 355       if (!sfr ||
 356           !sfr->get_address(mem_addr))
 357         return(DD_FALSE);
 358 printf("**4\n");
 359     }
 360 printf("**5\n");
 361   if (bit_mask)
 362     {
 363 printf("**6\n");
 364       if (!bit)
 365         return(DD_FALSE);
 366 printf("**7\n");
 367       long l;
 368       if (!bit->get_ivalue(&l) ||
 369           l > 7)
 370         return(DD_FALSE);
 371 printf("**8\n");
 372       *bit_mask= 1 << l;
 373     }
 374 printf("**9\n");
 375   return(DD_TRUE);
 376 }
 377
 378
 379 /* Array */
 380
 381 cl_cmd_array_arg::cl_cmd_array_arg(class cl_uc *iuc,
 382                                    class cl_cmd_arg *aname,
 383                                    class cl_cmd_arg *aindex):
 384   cl_cmd_arg(iuc, (long)0)
 385 {
 386   name = aname;
 387   index= aindex;
 388 }
 389
 390 cl_cmd_array_arg::~cl_cmd_array_arg(void)
 391 {
 392   if (name)
 393     delete name;
 394   if (index)
 395     delete index;
 396 }
 397
 398 bool
 399 cl_cmd_array_arg::as_hw(class cl_uc *uc)
 400 {
 401   char *n;
 402   t_addr a;
 403
 404   if (name == 0 ||
 405       index == 0 ||
 406       (n= name->get_svalue()) == NULL ||
 407       !index->get_address(&a))
 408     return(DD_FALSE);
 409
 410   value.hw= uc->get_hw(n, a, NULL);
 411   return(value.hw != NULL);
 412 }
 413
 414
 415 /*
 416  * Program arguments
 417  *----------------------------------------------------------------------------
 418  */
 419
 420 cl_prg_arg::cl_prg_arg(char sn, char *ln, long lv):
 421   cl_arg(lv)
 422 {
 423   short_name= sn;
 424   long_name = ln?strdup(ln):0;
 425 }
 426
 427 cl_prg_arg::cl_prg_arg(char sn, char *ln, char *sv):
 428   cl_arg(sv)
 429 {
 430   short_name= sn;
 431   long_name = ln?strdup(ln):0;
 432 }
 433
 434 cl_prg_arg::cl_prg_arg(char sn, char *ln, double fv):
 435   cl_arg(fv)
 436 {
 437   short_name= sn;
 438   long_name = ln?strdup(ln):0;
 439 }
 440
 441 cl_prg_arg::cl_prg_arg(char sn, char *ln, void *pv):
 442   cl_arg(pv)
 443 {
 444   short_name= sn;
 445   long_name = ln?strdup(ln):0;
 446 }
 447
 448 cl_prg_arg::~cl_prg_arg(void)
 449 {
 450   if (long_name)
 451     free(long_name);
 452 }
 453
 454
 455 /* End of arg.cc */