PmReturn_t
obj_print(pPmObj_t pobj, uint8_t is_expr_repr, uint8_t is_nested)
{
PmReturn_t retval = PM_RET_OK;
C_ASSERT(pobj != C_NULL);
/* Something gets printed unless it's None in an unnested expression */
if (!((OBJ_GET_TYPE(pobj) == OBJ_TYPE_NON) && is_expr_repr && !is_nested))
{
gVmGlobal.somethingPrinted = C_TRUE;
}
switch (OBJ_GET_TYPE(pobj))
{
case OBJ_TYPE_NON:
if (!is_expr_repr || is_nested)
{
plat_putByte('N');
plat_putByte('o');
plat_putByte('n');
retval = plat_putByte('e');
}
break;
case OBJ_TYPE_INT:
retval = int_print(pobj);
break;
#ifdef HAVE_FLOAT
case OBJ_TYPE_FLT:
retval = float_print(pobj);
break;
#endif /* HAVE_FLOAT */
case OBJ_TYPE_STR:
retval = string_print(pobj, (is_expr_repr || is_nested));
break;
case OBJ_TYPE_TUP:
retval = tuple_print(pobj);
break;
case OBJ_TYPE_LST:
retval = list_print(pobj);
break;
case OBJ_TYPE_DIC:
retval = dict_print(pobj);
break;
case OBJ_TYPE_BOOL:
if (((pPmBoolean_t) pobj)->val == C_TRUE)
{
plat_putByte('T');
plat_putByte('r');
plat_putByte('u');
}
else
{
plat_putByte('F');
plat_putByte('a');
plat_putByte('l');
plat_putByte('s');
}
retval = plat_putByte('e');
break;
case OBJ_TYPE_CLI:
#ifdef HAVE_BYTEARRAY
{
pPmObj_t pobj2;
retval = dict_getItem((pPmObj_t)((pPmInstance_t)pobj)->cli_attrs,
PM_NONE,
(pPmObj_t *)&pobj2);
if ((retval == PM_RET_OK)
&& (OBJ_GET_TYPE(pobj2) == OBJ_TYPE_BYA))
{
retval = bytearray_print(pobj2);
break;
}
}
#endif /* HAVE_BYTEARRAY */
case OBJ_TYPE_COB:
case OBJ_TYPE_MOD:
case OBJ_TYPE_CLO:
case OBJ_TYPE_FXN:
case OBJ_TYPE_CIM:
case OBJ_TYPE_NIM:
case OBJ_TYPE_NOB:
case OBJ_TYPE_THR:
case OBJ_TYPE_CIO:
case OBJ_TYPE_MTH:
case OBJ_TYPE_SQI:
plat_putByte('<');
plat_putByte('o');
plat_putByte('b');
plat_putByte('j');
plat_putByte(' ');
plat_putByte('t');
plat_putByte('y');
plat_putByte('p');
plat_putByte('e');
plat_putByte(' ');
plat_putByte('0');
plat_putByte('x');
int_printHexByte(OBJ_GET_TYPE(pobj));
plat_putByte(' ');
plat_putByte('@');
plat_putByte(' ');
plat_putByte('0');
plat_putByte('x');
_int_printHex((intptr_t)pobj);
retval = plat_putByte('>');
break;
default:
/* Otherwise raise a TypeError */
PM_RAISE(retval, PM_RET_EX_TYPE);
break;
}
return retval;
}
PmReturn_t
obj_print(pPmObj_t pobj, uint8_t is_expr_repr, uint8_t is_nested)
{
PmReturn_t retval = PM_RET_OK;
C_ASSERT(pobj != C_NULL);
/* Something gets printed unless it's None in an unnested expression */
if (!((OBJ_GET_TYPE(pobj) == OBJ_TYPE_NON) && is_expr_repr && !is_nested))
{
gVmGlobal.somethingPrinted = C_TRUE;
}
switch (OBJ_GET_TYPE(pobj))
{
case OBJ_TYPE_NON:
if (!is_expr_repr || is_nested)
{
sli_puts((uint8_t *)"None");
}
break;
case OBJ_TYPE_INT:
retval = int_print(pobj);
break;
#ifdef HAVE_FLOAT
case OBJ_TYPE_FLT:
retval = float_print(pobj);
break;
#endif /* HAVE_FLOAT */
case OBJ_TYPE_STR:
retval = string_print(pobj, (is_expr_repr || is_nested));
break;
case OBJ_TYPE_TUP:
retval = tuple_print(pobj);
break;
case OBJ_TYPE_LST:
retval = list_print(pobj);
break;
case OBJ_TYPE_DIC:
retval = dict_print(pobj);
break;
case OBJ_TYPE_BOOL:
sli_puts(
(((pPmBoolean_t) pobj)->val == C_TRUE)
? (uint8_t *)"True"
: (uint8_t *)"False");
break;
case OBJ_TYPE_CLI:
#ifdef HAVE_BYTEARRAY
{
pPmObj_t pobj2;
retval = dict_getItem((pPmObj_t)((pPmInstance_t)pobj)->cli_attrs,
PM_NONE,
(pPmObj_t *)&pobj2);
if ((retval == PM_RET_OK)
&& (OBJ_GET_TYPE(pobj2) == OBJ_TYPE_BYA))
{
retval = bytearray_print(pobj2);
break;
}
}
#endif /* HAVE_BYTEARRAY */
case OBJ_TYPE_COB:
case OBJ_TYPE_MOD:
case OBJ_TYPE_CLO:
case OBJ_TYPE_FXN:
case OBJ_TYPE_CIM:
case OBJ_TYPE_NIM:
case OBJ_TYPE_NOB:
case OBJ_TYPE_THR:
case OBJ_TYPE_CIO:
case OBJ_TYPE_MTH:
case OBJ_TYPE_SQI:
{
uint8_t buf[17];
sli_puts((uint8_t *)"<obj type 0x");
sli_btoa16(OBJ_GET_TYPE(pobj), buf, sizeof(buf), C_TRUE);
sli_puts(buf);
sli_puts((uint8_t *)" @ 0x");
sli_ptoa16((intptr_t)pobj, buf, sizeof(buf), C_TRUE);
sli_puts(buf);
retval = plat_putByte('>');
break;
}
default:
/* Otherwise raise a TypeError */
PM_RAISE(retval, PM_RET_EX_TYPE);
break;
}
return retval;
}
void test_interpreter(void) {
test_setup();
dict_print();
fcell_t dlen = ctx_vars->tob_idx;
printf("TOB SZ: %s\n", ctx_vars->tob_str);
for (fcell_t i = 0; i < dlen; i++) {
putchar(ctx_vars->tob_str[i]);
}
printf("TOB DONE\n");
printf("ctx->rsp: %p\n", ctx_rsp);
printf("ctx->psp: %p\n", ctx_psp);
printf("ctx->vars: %p\n", ctx_vars);
printf("ctx->regs: %p\n", ctx_regs);
// Vars
int i, n;
fcell_xt* var[50] = {0};
i = 0; n = 4;
for (int j = 0; j < n; j++)
var[j] = forth_alloc_var();
// Colons
*var[i++] = (fcell_xt) dict_cfa(dict_find(7, "docolon"));
*var[i++] = (fcell_xt) dict_cfa(dict_find(9, "interpret"));
*var[i++] = dict_cfa(dict_find(4, "semi"));
ctx_vars->tib_str = "7 2 +";
ctx_vars->tib_len = 5;
ctx_vars->tib_idx = 0;
forth_eval(var[0]);
forth_flush_tob();
print_psp_info();
int cnt = forth_count();
fcell_t x = forth_pop();
TEST_CHECK_(1 == cnt, "Expected "CELL_FMT", got "CELL_FMT"", 1, cnt);
print_stack(); printf("... stack done\n");
TEST_CHECK_(x == 9, "Expected "CELL_FMT", got "CELL_FMT"", 9, x);
x = forth_pop();
cnt = forth_count();
TEST_CHECK_(0 == cnt, "Expected "CELL_FMT", got "CELL_FMT"", 0, cnt);
TEST_CHECK_(forth_errno() == FW_ERR_STACKUNDERFLOW,
"Expected "CELL_FMT", got "CELL_FMT"",
forth_errno(),
FW_ERR_STACKUNDERFLOW);
forth_clear();
TEST_CHECK_(forth_errno() == FW_OK,
"Expected "CELL_FMT", got "CELL_FMT"",
forth_errno(),
FW_OK);
printf(" >>>>>>>>>>>>>> basic test \n\n\n");
}
void test_colon(void) {
test_setup();
printf("\n<<<<<<<<<<<< TEST ':' <<<<<<<<<<<< \n\n");
printf("ctx->rsp: %p\n", ctx_rsp);
printf("ctx->psp: %p\n", ctx_psp);
printf("ctx->vars: %p\n", ctx_vars);
printf("ctx->regs: %p\n", ctx_regs);
// Vars
int i, n;
fcell_xt* var[50] = {0};
i = 0; n = 15;
for (int j = 0; j < n; j++)
var[j] = forth_alloc_var();
fword_t *entry_colon = dict_find(1, ":");
printf("colon: `:` %p \n", entry_colon);
TEST_CHECK_(entry_colon != NULL, "Expected non-null `:` word, got "CELL_FMT"", entry_colon);
printf("colon cfa: `:` %p\n", dict_cfa(entry_colon));
printf("xt_colon: `:` %p -> %p \n", xt_colon, *xt_colon);
int idx_interpret = i;
*var[i++] = (fcell_xt) dict_cfa(dict_find(7, "docolon"));
*var[i++] = (fcell_xt) dict_cfa(dict_find(9, "interpret"));
*var[i++] = dict_cfa(dict_find(4, "semi"));
(void)idx_interpret;
ctx_vars->tib_str = " : a 0x99 ;";
ctx_vars->tib_len = strlen(ctx_vars->tib_str);
ctx_vars->tib_idx = 0;
forth_eval(var[0]);
forth_flush_tob();
dict_print();
// Try running new word!
fword_t *entry_a = dict_find(1, "a");
TEST_CHECK_(entry_a != NULL, "Expected non-null `:` word, got %p for %s", entry_a, "entry_a");
printf("entry_a: %p\n", entry_a);
fcell_xt * cfa_a = (fcell_xt *) dict_cfa(entry_a);
TEST_CHECK_(cfa_a != NULL, "Expected non-null `:` word, got "CELL_FMT" for %s", cfa_a, "cfa_a");
printf("cfa_aa: %p\n", cfa_a);
fword_t *semicolon = dict_find(1, ";");
printf("semicolon: %p\n", semicolon);
fcell_t expi;
fcell_t expl;
fcell_t cnt;
fcell_t x;
fcell_t err;
// Good Case
ctx_vars->tib_str = "a 1 +";
ctx_vars->tib_len = 5;
ctx_vars->tib_idx = 0;
forth_eval(var[0]);
forth_flush_tob();
expi = 154;
expl = 1;
cnt = forth_count();
TEST_CHECK_(cnt == expl, "Expected "CELL_FMT", got "CELL_FMT"", expl, cnt);
x = forth_pop();
TEST_CHECK_(x == expi, "Expected "CELL_FMT", got "CELL_FMT"", expi, x);
err = forth_errno();
TEST_CHECK_(err == FW_OK, "Expected "CELL_FMT", got "CELL_FMT"", FW_OK, err);
// Bad Case
ctx_vars->tib_str = "b 1 +";
ctx_vars->tib_len = 5;
ctx_vars->tib_idx = 0;
forth_eval(var[0]);
forth_flush_tob();
expi = 0;
expl = 0;
cnt = forth_count();
TEST_CHECK_(cnt == expl, "Expected "CELL_FMT", got "CELL_FMT"", expl, cnt);
err = forth_errno();
TEST_CHECK_(err == FW_ERR_NOWORD, "Expected "CELL_FMT", got "CELL_FMT"", FW_ERR_NOWORD, err);
}
static void
test_dict(void) {
DictObject *mp = dict_cnew(10000, 0, 0, 0, 0, 0, 0, 0);
//DictObject *mp = dict_new();
char keybuf[100];
size_t valuebuf[] = { 1 };
dict_add(mp, "a", valuebuf);
dict_del(mp, "a");
dict_add(mp, "b", valuebuf);
dict_del(mp, "b");
dict_add(mp, "c", valuebuf);
dict_del(mp, "c");
dict_add(mp, "d", valuebuf);
dict_del(mp, "d");
dict_add(mp, "e", valuebuf);
dict_del(mp, "e");
dict_add(mp, "xffff", valuebuf);
*valuebuf = 123456789;
dict_set(mp, "test", valuebuf);
DictObject *copy = dict_copy(mp);
dict_print_by_value_desc(copy);
fprintf(stdout, "===above is copy===\n");
dict_free(copy);
*valuebuf = 1;
size_t *vp;
// while (fscanf(stdin, "%s", keybuf) == 1) {
// vp = dict_get(mp, keybuf);
// if (vp)
// *vp += 1;
// else
// dict_add(mp, keybuf, valuebuf);
// }
// this is another faster version
while (fscanf(stdin, "%s", keybuf) == 1) {
vp = dict_fget(mp, keybuf);
*vp += 1;
}
*valuebuf = 123456789;
dict_set(mp, "the", valuebuf);
*valuebuf = 145678999;
dict_set(mp, "xxx", valuebuf);
dict_del(mp, "xxx");
DictObject *mp2 = dict_new();
*valuebuf = 99999999;
dict_set(mp2, "xiangnan", valuebuf);
*valuebuf = 89999999;
dict_add(mp2, "laoma", valuebuf);
dict_update(mp, mp2);
dict_free(mp2);
//dict_print_by_value_desc(mp);
dict_print(mp);
void *key, *value;
IterObject *dio = iter(mp);
printf("\ntest iterw...\n");
while(iterw(dio, &key)) {
value = dict_get(mp, key);
fprintf(stdout, "%s\t%u\n", (char*)key, *(size_t*)value);
}
*valuebuf = 9888888;
dict_set(mp, "emacs", valuebuf);
iterf(dio);
printf("\nnow test dict_iterkv...\n");
while(dict_iterkv(dio, &key, &value)) {
fprintf(stdout, "%s\t%u\n", (char*)key, *(size_t*)value);
}
free(dio);
dict_clear(mp);
dict_clear(mp); //just for test
dict_free(mp);
}
