git.gag.com Git - debian/cc1111/blob - sim/ucsim/sim.src/argcl.h

   1 /*
   2  * Simulator of microcontrollers (sim.src/argcl.h)
   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 #ifndef SIM_ARGCL_HEADER
  29 #define SIM_ARGCL_HEADER
  30
  31 // prj
  32 #include "pobjcl.h"
  33 #include "stypes.h"
  34
  35
  36 /*
  37  * Base type of arguments/parameters
  38  */
  39
  40 class cl_arg: public cl_base
  41 {
  42 public:
  43   union {
  44     long i_value;
  45     double f_value;
  46     void *p_value;
  47   };
  48   char *s_value;
  49
  50 public:
  51   cl_arg(long lv);
  52   cl_arg(const char *lv);
  53   cl_arg(double fv);
  54   cl_arg(void *pv);
  55   virtual ~cl_arg(void);
  56
  57   virtual bool get_ivalue(long *value);
  58   virtual char *get_svalue(void);
  59   virtual double get_fvalue(void);
  60   virtual void *get_pvalue(void);
  61   virtual bool get_bit_address(class cl_uc *uc, // input
  62                                class cl_address_space **mem, // outputs
  63                                t_addr *mem_addr,
  64                                t_mem *bit_mask) { return(DD_FALSE); }
  65 };
  66
  67
  68 /*
  69  * Command parameters
  70  */
  71
  72 class cl_cmd_arg: public cl_arg
  73 {
  74 public:
  75   //class cl_uc *uc;
  76   bool interpreted_as_string;
  77   union {
  78     long number;
  79     t_addr address;
  80     t_mem data;
  81     struct {
  82       class cl_memory *memory;
  83       class cl_address_space *address_space;
  84       class cl_memory_chip *memchip;
  85     } memory;
  86     class cl_hw *hw;
  87     struct {
  88       int len;
  89       char *string;
  90     } string;
  91     struct {
  92       t_mem *array;
  93       int len;
  94     } data_list;
  95     struct {
  96       class cl_address_space *mem;
  97       t_addr mem_address;
  98       t_mem mask;
  99     } bit;
 100   } value;
 101
 102 public:
 103   cl_cmd_arg(/*class cl_uc *iuc,*/ long i): cl_arg(i)
 104   { /*uc= iuc;*/ interpreted_as_string= DD_FALSE; }
 105   cl_cmd_arg(/*class cl_uc *iuc,*/ const char *s): cl_arg(s)
 106   { /*uc= iuc;*/ interpreted_as_string= DD_FALSE; }
 107   virtual ~cl_cmd_arg(void);
 108
 109   virtual int is_string(void) { return(DD_FALSE); }
 110   virtual bool get_address(class cl_uc *uc, t_addr *addr) { return(DD_FALSE); }
 111   virtual bool as_address(class cl_uc *uc);
 112   virtual bool as_number(void);
 113   virtual bool as_data(void);
 114   virtual bool as_string(void);
 115   virtual bool as_memory(class cl_uc *uc);
 116   virtual bool as_hw(class cl_uc *uc);
 117   virtual bool as_bit(class cl_uc *uc);
 118 };
 119
 120 class cl_cmd_int_arg: public cl_cmd_arg
 121 {
 122 public:
 123   cl_cmd_int_arg(/*class cl_uc *iuc,*/ long addr);
 124
 125   virtual bool get_address(class cl_uc *uc, t_addr *addr);
 126   virtual bool get_bit_address(class cl_uc *uc, // input
 127                                class cl_address_space **mem, // outputs
 128                                t_addr *mem_addr,
 129                                t_mem *bit_mask);
 130   virtual bool as_string(void);
 131 };
 132
 133 class cl_cmd_sym_arg: public cl_cmd_arg
 134 {
 135 public:
 136   cl_cmd_sym_arg(/*class cl_uc *iuc,*/ const char *sym);
 137
 138   virtual bool get_address(class cl_uc *uc, t_addr *addr);
 139   virtual bool get_bit_address(class cl_uc *uc, // input
 140                                class cl_address_space **mem, // outputs
 141                                t_addr *mem_addr,
 142                                t_mem *bit_mask);
 143   virtual bool as_address(class cl_uc *uc);
 144   virtual bool as_number(void) { return(DD_FALSE); }
 145   virtual bool as_string(void);
 146   virtual bool as_hw(class cl_uc *uc);
 147 };
 148
 149 class cl_cmd_str_arg: public cl_cmd_arg
 150 {
 151 public:
 152   cl_cmd_str_arg(/*class cl_uc *iuc,*/ const char *str);
 153
 154   virtual int is_string(void) { return(1); }
 155   virtual bool as_number(void) { return(DD_FALSE); }
 156 };
 157
 158 class cl_cmd_bit_arg: public cl_cmd_arg
 159 {
 160 public:
 161   class cl_cmd_arg *sfr, *bit;
 162
 163 public:
 164   cl_cmd_bit_arg(/*class cl_uc *iuc,*/
 165                  class cl_cmd_arg *asfr, class cl_cmd_arg *abit);
 166   virtual ~cl_cmd_bit_arg(void);
 167
 168   virtual bool get_address(class cl_uc *uc, t_addr *addr);
 169   virtual bool get_bit_address(class cl_uc *uc, // input
 170                                class cl_address_space **mem, // outputs
 171                                t_addr *mem_addr,
 172                                t_mem *bit_mask);
 173 };
 174
 175 class cl_cmd_array_arg: public cl_cmd_arg
 176 {
 177 public:
 178   class cl_cmd_arg *name_arg, *index;
 179
 180 public:
 181   cl_cmd_array_arg(/*class cl_uc *iuc,*/
 182                    class cl_cmd_arg *aname, class cl_cmd_arg *aindex);
 183   virtual ~cl_cmd_array_arg(void);
 184   virtual bool as_hw(class cl_uc *uc);
 185 };
 186
 187
 188 /*
 189  * Program arguments
 190  */
 191
 192 /*class cl_prg_arg: public cl_arg
 193 {
 194 public:
 195   char short_name;
 196   char *long_name;
 197
 198 public:
 199   cl_prg_arg(char sn, char *ln, long lv);
 200   cl_prg_arg(char sn, char *ln, char *lv);
 201   cl_prg_arg(char sn, char *ln, double fv);
 202   cl_prg_arg(char sn, char *ln, void *pv);
 203   virtual ~cl_prg_arg(void);
 204 };*/
 205
 206
 207 /*
 208  * List of arguments
 209  */
 210
 211 /*class cl_arguments: public cl_list
 212 {
 213 public:
 214   cl_arguments(void): cl_list(5, 5) {}
 215
 216   int arg_avail(char nam);
 217   int arg_avail(char *nam);
 218   virtual long get_iarg(char sname, char *lname);
 219   virtual char *get_sarg(char sname, char *lname);
 220   virtual double get_farg(char sname, char *lname);
 221   virtual void *get_parg(char sname, char *lname);
 222 };*/
 223
 224
 225 #endif
 226
 227 /* End of argcl.h */