void pair_dump(const pair_t * pair) {
printf("(");
object_dump(pair->first);
printf(", ");
object_dump(pair->second);
printf(")");
}
int table_dump(struct table *t) {
int i;
struct table_entry *r;
struct object *key_object, *value_object;
if (t == NULL) {
fprintf(stderr, "mvm: table not initialized!\n");
mvm_halt();
}
fprintf(stderr, "num_entries = %d\n", t->num_entries);
fprintf(stderr, "load_factor = %f\n", t->load_factor);
fprintf(stderr, "current_capacity = %d\n", t->current_capacity);
for (i = 0; i < t->current_capacity; i++) {
fprintf(stderr, "bucket %d =\n", i);
for (r = t->buckets[i]; r != NULL; r = r->next) {
key_object = heap_fetch_object(heap, r->key);
value_object = heap_fetch_object(heap, r->value);
fprintf(stderr, " (");
object_dump(key_object, 0);
fprintf(stderr, ", ");
object_dump(value_object, 0);
fprintf(stderr, ")\n");
}
}
return 0;
}
void object_dump(__int8 *instance, int *object_descriptor, BYTESTREAMPROC bsp) {
assert(bsp != NULL);
size_t embed = 0;
if (instance == NULL) return;
if (object_descriptor == NULL) return;
while (*object_descriptor != FE_EOO) {
_dump_dword(object_descriptor[0], bsp);
switch (object_descriptor[0]) {
case FE_BASIC:
instance += object_descriptor[1];
_dump_dword(object_descriptor[1], bsp);
_dump_binary(instance, object_descriptor[1], bsp);
object_descriptor += 2;
break;
case FE_ASZ:
while (*instance) {
bsp(*instance);
instance++;
}
object_descriptor++;
break;
case FE_WSZ:
while (*(__int16 *)instance) {
_dump_word(*(__int16 *)instance, bsp);
instance += 2;
}
object_descriptor++;
break;
case FE_EMBED:
_dump_dword(object_descriptor[1]/*no used*/, bsp);
embed = object_size(instance, object_descriptor);
object_dump(instance, (int *)(object_descriptor[1]), bsp);
instance += embed;
object_descriptor += 2;
break;
case FE_TRACE:
_dump_dword(object_descriptor[1]/*no used*/, bsp);
_dump_dword((int)(__int8 *)*(int *)instance/*no used*/, bsp);
if ((__int8 *)*(int *)instance != NULL) {
object_dump((__int8 *)*(int *)instance, (int *)(object_descriptor[1]), bsp);
}
instance += sizeof(int);
object_descriptor += 2;
break;
default:
assert(false);
object_descriptor++;
break;
}
}
_dump_dword(FE_EOO, bsp);
}
void test_ui_sdl_grath()
{
Sdl_Graph *sdl_grath;
allocator_t *allocator = allocator_get_default_alloc();
char *set_str;
cjson_t *root, *e, *s;
char buf[2048];
root = cjson_create_object();{
cjson_add_item_to_object(root, "Sdl_Graph", e = cjson_create_object());{
cjson_add_string_to_object(e, "name", "alan");
}
}
set_str = cjson_print(root);
sdl_grath = OBJECT_NEW(allocator, Sdl_Graph,set_str);
object_dump(sdl_grath, "Sdl_Graph", buf, 2048);
dbg_str(DBG_DETAIL,"Sdl_Graph dump: %s",buf);
object_destroy(sdl_grath);
free(set_str);
}
void test_ui_button()
{
Subject *subject;
allocator_t *allocator = allocator_get_default_alloc();
char *set_str;
char buf[2048];
set_str = gen_button_setting_str();
subject = OBJECT_NEW(allocator, Button,set_str);
object_dump(subject, "Button", buf, 2048);
dbg_str(DBG_DETAIL,"Button dump: %s",buf);
free(set_str);
}
void test_ui_component()
{
Subject *subject;
allocator_t *allocator = allocator_get_default_alloc();
char *set_str;
cjson_t *root, *e, *s;
char buf[2048];
root = cjson_create_object();{
cjson_add_item_to_object(root, "Component", e = cjson_create_object());{
cjson_add_item_to_object(e, "Subject", s = cjson_create_object());{
cjson_add_number_to_object(s, "x", 1);
cjson_add_number_to_object(s, "y", 25);
cjson_add_number_to_object(s, "width", 5);
cjson_add_number_to_object(s, "height", 125);
}
cjson_add_string_to_object(e, "name", "alan");
}
}
set_str = cjson_print(root);
/*
*subject = OBJECT_ALLOC(allocator,Component);
*object_set(subject, "Component", set_str);
*dbg_str(DBG_DETAIL,"x=%d y=%d width=%d height=%d",subject->x,subject->y,subject->width,subject->height);
*/
subject = OBJECT_NEW(allocator, Component,set_str);
/*
*dbg_str(DBG_DETAIL,"x=%d y=%d width=%d height=%d",subject->x,subject->y,subject->width,subject->height);
*dbg_str(DBG_DETAIL,"component nane=%s",((Component *)subject)->name);
*subject->move(subject);
*/
object_dump(subject, "Component", buf, 2048);
dbg_str(DBG_DETAIL,"Component dump: %s",buf);
free(set_str);
}
void test_ui_sdl_window()
{
Window *window;
Graph *g;
allocator_t *allocator = allocator_get_default_alloc();
char *set_str;
char buf[2048];
set_str = gen_window_setting_str();
window = OBJECT_NEW(allocator, Sdl_Window,set_str);
g = window->graph;
object_dump(window, "Sdl_Window", buf, 2048);
dbg_str(DBG_DETAIL,"Window dump: %s",buf);
dbg_str(DBG_DETAIL,"render draw test");
g->render_draw_image(g,0,0,window->background);
g->render_present(g);
sleep(2);
g->render_clear(g);
g->render_set_color(g,0xff,0x0,0xff,0xff);
g->render_draw_line(g,20,0,50,50);
g->render_set_color(g,0xff,0x0,0x0,0xff);
g->render_draw_rect(g,20,20,100,100);
/*
*g->render_fill_rect(g,20,20,100,100);
*/
g->render_present(g);
sleep(5);
object_destroy(window);
free(set_str);
}
void test_obj_map()
{
Map *map;
allocator_t *allocator = allocator_get_default_alloc();
char *set_str;
cjson_t *root, *e, *s;
char buf[2048];
root = cjson_create_object();{
cjson_add_item_to_object(root, "Map", e = cjson_create_object());{
cjson_add_string_to_object(e, "name", "alan");
}
}
set_str = cjson_print(root);
map = OBJECT_NEW(allocator, Map,set_str);
object_dump(map, "Map", buf, 2048);
dbg_str(OBJ_DETAIL,"Map dump: %s",buf);
free(set_str);
}
int main(int argc, const char *args[])
{
if (argc != 3)
{
printf("USAGE: %s [i|s|r] file\n", args[0]);
return -1;
}
char mode = args[1][0];
simple_stream_s s;
ast_node_t n;
interp_s __interp;
interp_t interp = &__interp;
object_t prog;
switch (mode)
{
case 'i':
case 's':
simple_stream_open(&s, fopen(args[2], "r"));
n = ast_simple_parse_char_stream((stream_in_f)simple_stream_in, &s);
simple_stream_close(&s);
if (n != NULL)
{
if (mode == 'i')
{
ast_dump(n, stdout);
ast_free(n);
break;
}
ast_syntax_parse(n, 0);
sematic_symref_analyse(n);
ast_dump(n, stdout);
ast_free(n);
}
break;
case 'r':
interp_initialize(interp, 16);
simple_stream_open(&s, fopen(args[2], "r"));
prog = interp_eval(interp, (stream_in_f)simple_stream_in, &s, NULL);
simple_stream_close(&s);
if (prog != NULL) interp_apply(interp, prog, 0, NULL);
int ex_argc = 0;
object_t *ex_args;
object_t ex_ret = NULL;
int i;
object_t __me = interp_object_new(interp);
__me->string = xstring_from_cstr("SEE interpreter", -1);
OBJECT_TYPE_INIT(__me, OBJECT_TYPE_STRING);
interp_protect(interp, __me);
while (1)
{
int r = interp_run(interp, ex_ret, &ex_argc, &ex_args);
if (r <= 0) break;
switch (r)
{
case VM_EXTERNAL_CALL:
ex_ret = OBJECT_NULL;
/* An example for handling external calls: display */
if (OBJECT_TYPE(ex_args[0]) == OBJECT_TYPE_STRING)
{
if (xstring_equal_cstr(ex_args[0]->string, "display", -1))
{
for (i = 1; i != ex_argc; ++ i)
{
object_dump(ex_args[i], stdout);
}
printf("\n");
}
}
/* The caller should unprotect the ex arguments by themself */
for (i = 0; i != ex_argc; ++ i)
interp_unprotect(interp, ex_args[i]);
break;
case VM_EXTERNAL_CONSTANT:
/* An example for handling external constant. */
/* remember that we should never create objects from
* heap for the external constant */
if (xstring_equal_cstr(interp->ex->exp->constant.name, "#answer-to-the-universe", -1))
ex_ret = INT_BOX(42);
else ex_ret = OBJECT_NULL;
break;
case VM_EXTERNAL_LOAD:
/* Handling external load */
ex_ret = OBJECT_NULL;
if (xstring_equal_cstr(interp->ex->exp->load.name, "me", -1))
{
ex_ret = __me;
}
break;
case VM_EXTERNAL_STORE:
/* Handler external store */
ex_ret = OBJECT_NULL;
if (xstring_equal_cstr(interp->ex->exp->store.name, "me", -1))
{
fprintf(stderr, "Setting ``me'' is impossible\n");
fprintf(stderr, "VALUE: \n");
object_dump(interp->ex->value, stderr);
fprintf(stderr, "\n");
}
break;
default:
ex_ret = OBJECT_NULL;
break;
}
}
interp_uninitialize(interp);
break;
default:
printf("ERROR OPTION\n");
return -1;
}
return 0;
}
