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(class cl_uc *uc)
 132 {
 133   return(get_address(uc, &(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(class cl_uc *uc)
 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(class cl_uc *uc, 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(uc, &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(class cl_uc *uc, 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(class cl_uc *uc)
 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(class cl_uc *uc, t_addr *addr)
 336 {
 337   if (sfr)
 338     return(sfr->get_address(uc, 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   if (mem)
 349     *mem= uc->mem(MEM_SFR);
 350   if (mem_addr)
 351     {
 352       if (!sfr ||
 353           !sfr->get_address(uc, mem_addr))
 354         return(DD_FALSE);
 355     }
 356   if (bit_mask)
 357     {
 358       if (!bit)
 359         return(DD_FALSE);
 360       long l;
 361       if (!bit->get_ivalue(&l) ||
 362           l > 7)
 363         return(DD_FALSE);
 364       *bit_mask= 1 << l;
 365     }
 366   return(DD_TRUE);
 367 }
 368
 369
 370 /* Array */
 371
 372 cl_cmd_array_arg::cl_cmd_array_arg(/*class cl_uc *iuc,*/
 373                                    class cl_cmd_arg *aname,
 374                                    class cl_cmd_arg *aindex):
 375   cl_cmd_arg(/*iuc,*/ (long)0)
 376 {
 377   name = aname;
 378   index= aindex;
 379 }
 380
 381 cl_cmd_array_arg::~cl_cmd_array_arg(void)
 382 {
 383   if (name)
 384     delete name;
 385   if (index)
 386     delete index;
 387 }
 388
 389 bool
 390 cl_cmd_array_arg::as_hw(class cl_uc *uc)
 391 {
 392   char *n;
 393   t_addr a;
 394
 395   if (name == 0 ||
 396       index == 0 ||
 397       (n= name->get_svalue()) == NULL ||
 398       !index->get_address(uc, &a))
 399     return(DD_FALSE);
 400
 401   value.hw= uc->get_hw(n, a, NULL);
 402   return(value.hw != NULL);
 403 }
 404
 405
 406 /*
 407  * Program arguments
 408  *----------------------------------------------------------------------------
 409  */
 410
 411 cl_prg_arg::cl_prg_arg(char sn, char *ln, long lv):
 412   cl_arg(lv)
 413 {
 414   short_name= sn;
 415   long_name = ln?strdup(ln):0;
 416 }
 417
 418 cl_prg_arg::cl_prg_arg(char sn, char *ln, char *sv):
 419   cl_arg(sv)
 420 {
 421   short_name= sn;
 422   long_name = ln?strdup(ln):0;
 423 }
 424
 425 cl_prg_arg::cl_prg_arg(char sn, char *ln, double fv):
 426   cl_arg(fv)
 427 {
 428   short_name= sn;
 429   long_name = ln?strdup(ln):0;
 430 }
 431
 432 cl_prg_arg::cl_prg_arg(char sn, char *ln, void *pv):
 433   cl_arg(pv)
 434 {
 435   short_name= sn;
 436   long_name = ln?strdup(ln):0;
 437 }
 438
 439 cl_prg_arg::~cl_prg_arg(void)
 440 {
 441   if (long_name)
 442     free(long_name);
 443 }
 444
 445
 446 /*
 447  * List of arguments
 448  *----------------------------------------------------------------------------
 449  */
 450
 451 int
 452 cl_arguments::arg_avail(char name)
 453 {
 454   class cl_prg_arg *a;
 455   int i;
 456
 457   for (i= 0; i < count; i++)
 458     {
 459       a= (class cl_prg_arg *)(at(i));
 460       if (a->short_name == name)
 461         return(1);
 462     }
 463   return(0);
 464 }
 465
 466 int
 467 cl_arguments::arg_avail(char *name)
 468 {
 469   class cl_prg_arg *a;
 470   int i;
 471
 472   for (i= 0; i < count; i++)
 473     {
 474       a= (class cl_prg_arg *)(at(i));
 475       if (a->long_name &&
 476           strcmp(a->long_name, name) == 0)
 477         return(1);
 478     }
 479   return(0);
 480 }
 481
 482 long
 483 cl_arguments::get_iarg(char sname, char *lname)
 484 {
 485   class cl_prg_arg *a;
 486   int i;
 487
 488   for (i= 0; i < count; i++)
 489     {
 490       a= (class cl_prg_arg *)(at(i));
 491       if ((sname && a->short_name == sname) ||
 492           (lname && a->long_name && strcmp(a->long_name, lname) == 0))
 493         {
 494           long iv;
 495           if (a->get_ivalue(&iv))
 496             return(iv);
 497           else
 498             //FIXME
 499             return(0);
 500         }
 501     }
 502   return(0);
 503 }
 504
 505 char *
 506 cl_arguments::get_sarg(char sname, char *lname)
 507 {
 508   class cl_prg_arg *a;
 509   int i;
 510
 511   for (i= 0; i < count; i++)
 512     {
 513       a= (class cl_prg_arg *)(at(i));
 514       if ((sname && a->short_name == sname) ||
 515           (lname && a->long_name && strcmp(a->long_name, lname) == 0))
 516         return(a->get_svalue());
 517     }
 518   return(0);
 519 }
 520
 521
 522 double
 523 cl_arguments::get_farg(char sname, char *lname)
 524 {
 525   class cl_prg_arg *a;
 526   int i;
 527
 528   for (i= 0; i < count; i++)
 529     {
 530       a= (class cl_prg_arg *)(at(i));
 531       if ((sname && a->short_name == sname) ||
 532           (lname && a->long_name && strcmp(a->long_name, lname) == 0))
 533         return(a->get_fvalue());
 534     }
 535   return(0);
 536 }
 537
 538 void *
 539 cl_arguments::get_parg(char sname, char *lname)
 540 {
 541   class cl_prg_arg *a;
 542   int i;
 543
 544   for (i= 0; i < count; i++)
 545     {
 546       a= (class cl_prg_arg *)(at(i));
 547       if ((sname && a->short_name == sname) ||
 548           (lname && a->long_name && strcmp(a->long_name, lname) == 0))
 549         return(a->get_pvalue());
 550     }
 551   return(0);
 552 }
 553
 554
 555 /* End of arg.cc */