* Making the argument
*/
-cl_arg::cl_arg(long long lv):
+cl_arg::cl_arg(long lv):
cl_base()
{
i_value= lv;
* Getting value of the argument
*/
-long long
-cl_arg::get_ivalue(void)
+bool
+cl_arg::get_ivalue(long *value)
{
- return(i_value);
+ if (value)
+ *value= i_value;
+ return(DD_TRUE);
}
char *
*----------------------------------------------------------------------------
*/
-cl_cmd_int_arg::cl_cmd_int_arg(long long addr):
- cl_cmd_arg(addr)
+cl_cmd_arg::~cl_cmd_arg(void)
+{
+ if (interpreted_as_string)
+ {
+ if (value.string.string)
+ free(value.string.string);
+ }
+}
+
+bool
+cl_cmd_arg::as_address(void)
+{
+ return(get_address(&(value.address)));
+}
+
+bool
+cl_cmd_arg::as_number(void)
+{
+ return(get_ivalue(&(value.number)));
+}
+
+bool
+cl_cmd_arg::as_data(void)
+{
+ long l;
+ bool ret= get_ivalue(&l);
+ value.data= l;
+ return(ret);
+}
+
+bool
+cl_cmd_arg::as_memory(void)
+{
+ value.memory= uc->mem(s_value);
+ return(value.memory != 0);
+}
+
+bool
+cl_cmd_arg::as_hw(class cl_uc *uc)
+{
+ return(DD_FALSE);
+}
+
+bool
+cl_cmd_arg::as_string(void)
+{
+ char *s= get_svalue();
+ if (!s)
+ return(DD_FALSE);
+ if (is_string())
+ value.string.string= proc_escape(s, &value.string.len);
+ else
+ {
+ value.string.string= strdup(s);
+ value.string.len= strlen(s);
+ }
+ return(interpreted_as_string= value.string.string != NULL);
+}
+
+bool
+cl_cmd_arg::as_bit(class cl_uc *uc)
+{
+ return(get_bit_address(uc,
+ &(value.bit.mem),
+ &(value.bit.mem_address),
+ &(value.bit.mask)));
+}
+
+
+/* Interger number */
+
+cl_cmd_int_arg::cl_cmd_int_arg(class cl_uc *iuc, long addr):
+ cl_cmd_arg(iuc, addr)
{}
-cl_cmd_sym_arg::cl_cmd_sym_arg(char *sym):
- cl_cmd_arg(sym)
+bool
+cl_cmd_int_arg::get_address(t_addr *addr)
+{
+ long iv;
+
+ bool b= get_ivalue(&iv);
+ if (addr)
+ *addr= iv;
+ return(b);
+}
+
+bool
+cl_cmd_int_arg::get_bit_address(class cl_uc *uc, // input
+ class cl_mem **mem, // outputs
+ t_addr *mem_addr,
+ t_mem *bit_mask)
+{
+ t_addr bit_addr;
+
+ if (!get_address(&bit_addr))
+ return(DD_FALSE);
+ return(uc->extract_bit_address(bit_addr, mem, mem_addr, bit_mask));
+}
+
+bool
+cl_cmd_int_arg::as_string(void)
+{
+ value.string.string= (char*)malloc(100);
+ sprintf(value.string.string, "%ld", i_value);
+ value.string.len= strlen(value.string.string);
+ return(interpreted_as_string= value.string.string != NULL);
+}
+
+
+/* Symbol */
+
+cl_cmd_sym_arg::cl_cmd_sym_arg(class cl_uc *iuc, char *sym):
+ cl_cmd_arg(iuc, sym)
{}
-long
-cl_cmd_sym_arg::get_address(void)
+bool
+cl_cmd_sym_arg::as_string(void)
+{
+ char *s= get_svalue();
+ if (!s)
+ return(DD_FALSE);
+ value.string.string= strdup(s);
+ value.string.len= strlen(s);
+ return(interpreted_as_string= value.string.string != NULL);
+}
+
+bool
+cl_cmd_sym_arg::get_address(t_addr *addr)
{
struct name_entry *ne;
- if ((ne= get_name_entry(simulator->uc->sfr_tbl(),
+ if ((ne= get_name_entry(uc->sfr_tbl(),
get_svalue(),
- simulator->uc)) != NULL)
+ uc)) != NULL)
{
- return(ne->addr);
+ if (addr)
+ *addr= ne->addr;
+ return(1);
}
- return(-1);
+ return(0);
}
-cl_cmd_str_arg::cl_cmd_str_arg(char *str):
- cl_cmd_arg(str)
+bool
+cl_cmd_sym_arg::get_bit_address(class cl_uc *uc, // input
+ class cl_mem **mem, // outputs
+ t_addr *mem_addr,
+ t_mem *bit_mask)
+{
+ struct name_entry *ne;
+
+ if ((ne= get_name_entry(uc->bit_tbl(),
+ get_svalue(),
+ uc)) == NULL)
+ return(DD_FALSE);
+ return(uc->extract_bit_address(ne->addr, mem, mem_addr, bit_mask));
+}
+
+bool
+cl_cmd_sym_arg::as_address(void)
+{
+ struct name_entry *ne;
+ //printf("SYM %s as addr?\n",get_svalue());
+ if ((ne= get_name_entry(uc->sfr_tbl(), get_svalue(), uc)) != NULL)
+ {
+ value.address= ne->addr;
+ return(DD_TRUE);
+ }
+ return(DD_FALSE);
+}
+
+bool
+cl_cmd_sym_arg::as_hw(class cl_uc *uc)
+{
+ cl_hw *hw, *found;
+ int i= 0;
+
+ hw= found= uc->get_hw(get_svalue(), &i);
+ if (!hw)
+ return(DD_FALSE);
+ i++;
+ found= uc->get_hw(get_svalue(), &i);
+ if (found)
+ return(DD_FALSE);
+ value.hw= hw;
+ return(DD_TRUE);
+}
+
+
+/* String */
+
+cl_cmd_str_arg::cl_cmd_str_arg(class cl_uc *iuc, char *str):
+ cl_cmd_arg(iuc, str)
{}
-cl_cmd_bit_arg::cl_cmd_bit_arg(class cl_cmd_arg *asfr, class cl_cmd_arg *abit):
- cl_cmd_arg((long long)0)
+
+/* Bit */
+
+cl_cmd_bit_arg::cl_cmd_bit_arg(class cl_uc *iuc,
+ class cl_cmd_arg *asfr, class cl_cmd_arg *abit):
+ cl_cmd_arg(iuc, (long)0)
{
sfr= asfr;
bit= abit;
delete bit;
}
-long
-cl_cmd_bit_arg::get_address(void)
+bool
+cl_cmd_bit_arg::get_address(t_addr *addr)
{
if (sfr)
- return(sfr->get_address());
- return(-1);
+ return(sfr->get_address(addr));
+ return(0);
+}
+
+bool
+cl_cmd_bit_arg::get_bit_address(class cl_uc *uc, // input
+ class cl_mem **mem, // outputs
+ t_addr *mem_addr,
+ t_mem *bit_mask)
+{
+printf("**1\n");
+ if (mem)
+ *mem= uc->mem(MEM_SFR);
+printf("**2\n");
+ if (mem_addr)
+ {
+printf("**3\n");
+ if (!sfr ||
+ !sfr->get_address(mem_addr))
+ return(DD_FALSE);
+printf("**4\n");
+ }
+printf("**5\n");
+ if (bit_mask)
+ {
+printf("**6\n");
+ if (!bit)
+ return(DD_FALSE);
+printf("**7\n");
+ long l;
+ if (!bit->get_ivalue(&l) ||
+ l > 7)
+ return(DD_FALSE);
+printf("**8\n");
+ *bit_mask= 1 << l;
+ }
+printf("**9\n");
+ return(DD_TRUE);
+}
+
+
+/* Array */
+
+cl_cmd_array_arg::cl_cmd_array_arg(class cl_uc *iuc,
+ class cl_cmd_arg *aname,
+ class cl_cmd_arg *aindex):
+ cl_cmd_arg(iuc, (long)0)
+{
+ name = aname;
+ index= aindex;
+}
+
+cl_cmd_array_arg::~cl_cmd_array_arg(void)
+{
+ if (name)
+ delete name;
+ if (index)
+ delete index;
+}
+
+bool
+cl_cmd_array_arg::as_hw(class cl_uc *uc)
+{
+ char *n;
+ t_addr a;
+
+ if (name == 0 ||
+ index == 0 ||
+ (n= name->get_svalue()) == NULL ||
+ !index->get_address(&a))
+ return(DD_FALSE);
+
+ value.hw= uc->get_hw(n, a, NULL);
+ return(value.hw != NULL);
}
*----------------------------------------------------------------------------
*/
-cl_prg_arg::cl_prg_arg(char sn, char *ln, long long lv):
+cl_prg_arg::cl_prg_arg(char sn, char *ln, long lv):
cl_arg(lv)
{
short_name= sn;
projects / fw / sdcc / blobdiff