git.gag.com Git - fw/sdcc/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(char *lv);
  53   cl_arg(double fv);
  54   cl_arg(void *pv);
  55   ~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_mem **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
  77   bool interpreted_as_string;
  78   union {
  79     long number;
  80     t_addr address;
  81     t_mem data;
  82     class cl_mem *memory;
  83     class cl_hw *hw;
  84     struct {
  85       int len;
  86       char *string;
  87     } string;
  88     struct {
  89       t_mem *array;
  90       int len;
  91     } data_list;
  92     struct {
  93       class cl_mem *mem;
  94       t_addr mem_address;
  95       t_mem mask;
  96     } bit;
  97   } value;
  98
  99 public:
 100   cl_cmd_arg(/*class cl_uc *iuc,*/ long i): cl_arg(i)
 101   { /*uc= iuc;*/ interpreted_as_string= DD_FALSE; }
 102   cl_cmd_arg(/*class cl_uc *iuc,*/ char *s): cl_arg(s)
 103   { /*uc= iuc;*/ interpreted_as_string= DD_FALSE; }
 104   ~cl_cmd_arg(void);
 105
 106   virtual int is_string(void) { return(DD_FALSE); }
 107   virtual bool get_address(class cl_uc *uc, t_addr *addr) { return(DD_FALSE); }
 108   virtual bool as_address(class cl_uc *uc);
 109   virtual bool as_number(void);
 110   virtual bool as_data(void);
 111   virtual bool as_string(void);
 112   virtual bool as_memory(class cl_uc *uc);
 113   virtual bool as_hw(class cl_uc *uc);
 114   virtual bool as_bit(class cl_uc *uc);
 115 };
 116
 117 class cl_cmd_int_arg: public cl_cmd_arg
 118 {
 119 public:
 120   cl_cmd_int_arg(/*class cl_uc *iuc,*/ long addr);
 121
 122   virtual bool get_address(class cl_uc *uc, t_addr *addr);
 123   virtual bool get_bit_address(class cl_uc *uc, // input
 124                                class cl_mem **mem, // outputs
 125                                t_addr *mem_addr,
 126                                t_mem *bit_mask);
 127   virtual bool as_string(void);
 128 };
 129
 130 class cl_cmd_sym_arg: public cl_cmd_arg
 131 {
 132 public:
 133   cl_cmd_sym_arg(/*class cl_uc *iuc,*/ char *sym);
 134
 135   virtual bool get_address(class cl_uc *uc, t_addr *addr);
 136   virtual bool get_bit_address(class cl_uc *uc, // input
 137                                class cl_mem **mem, // outputs
 138                                t_addr *mem_addr,
 139                                t_mem *bit_mask);
 140   virtual bool as_address(class cl_uc *uc);
 141   virtual bool as_string(void);
 142   virtual bool as_hw(class cl_uc *uc);
 143 };
 144
 145 class cl_cmd_str_arg: public cl_cmd_arg
 146 {
 147 public:
 148   cl_cmd_str_arg(/*class cl_uc *iuc,*/ char *str);
 149
 150   virtual int is_string(void) { return(1); }
 151 };
 152
 153 class cl_cmd_bit_arg: public cl_cmd_arg
 154 {
 155 public:
 156   class cl_cmd_arg *sfr, *bit;
 157
 158 public:
 159   cl_cmd_bit_arg(/*class cl_uc *iuc,*/
 160                  class cl_cmd_arg *asfr, class cl_cmd_arg *abit);
 161   ~cl_cmd_bit_arg(void);
 162
 163   virtual bool get_address(class cl_uc *uc, t_addr *addr);
 164   virtual bool get_bit_address(class cl_uc *uc, // input
 165                                class cl_mem **mem, // outputs
 166                                t_addr *mem_addr,
 167                                t_mem *bit_mask);
 168 };
 169
 170 class cl_cmd_array_arg: public cl_cmd_arg
 171 {
 172 public:
 173   class cl_cmd_arg *name, *index;
 174
 175 public:
 176   cl_cmd_array_arg(/*class cl_uc *iuc,*/
 177                    class cl_cmd_arg *aname, class cl_cmd_arg *aindex);
 178   ~cl_cmd_array_arg(void);
 179   virtual bool as_hw(class cl_uc *uc);
 180 };
 181
 182
 183 /*
 184  * Program arguments
 185  */
 186
 187 class cl_prg_arg: public cl_arg
 188 {
 189 public:
 190   char short_name;
 191   char *long_name;
 192
 193 public:
 194   cl_prg_arg(char sn, char *ln, long lv);
 195   cl_prg_arg(char sn, char *ln, char *lv);
 196   cl_prg_arg(char sn, char *ln, double fv);
 197   cl_prg_arg(char sn, char *ln, void *pv);
 198   ~cl_prg_arg(void);
 199 };
 200
 201
 202 /*
 203  * List of arguments
 204  */
 205
 206 class cl_arguments: public cl_list
 207 {
 208 public:
 209   cl_arguments(void): cl_list(5, 5) {}
 210
 211   int arg_avail(char name);
 212   int arg_avail(char *name);
 213   virtual long get_iarg(char sname, char *lname);
 214   virtual char *get_sarg(char sname, char *lname);
 215   virtual double get_farg(char sname, char *lname);
 216   virtual void *get_parg(char sname, char *lname);
 217 };
 218
 219
 220 #endif
 221
 222 /* End of argcl.h */