int construct_tree(NODE* root, char *input_string, int index)
{
if(input_string == NULL)
{
return NULL;
}
if(input_string[index-1]=='\0' || input_string[index-1]=='$')
{
root->left_child = NULL;
root->right_child = NULL;
return index;
}
int result;
result = create_number(input_string,index);
if(result!=NULL)
{
NODE *temp = (NODE*)malloc(sizeof(NODE));
temp->data = result;
root->left_child = temp;
}
else if(result==NULL)
{
root->left_child = NULL;
}
if(root->left_child!=NULL)
{
index = next_element_in_string(input_string,index);
index = construct_tree(root->left_child,input_string,index);
}
index = next_element_in_string(input_string,index);
result = create_number(input_string,index);
if(result!=NULL)
{
NODE *temp = (NODE*)malloc(sizeof(NODE));
temp->data = result;
root->right_child = temp;
}
else if(result==NULL)
{
root->right_child = NULL;
}
if(root->right_child!=NULL)
{
index = next_element_in_string(input_string,index);
index = construct_tree(root->right_child,input_string,index);
return index;
}
else if(root->right_child==NULL)
{
return index;
}
}
void test_array_to_tree_convertor()
{
char input[4][36] = {"1,2,3,4","1,2","1,2,3","1,2,3,4,5,6,7,8,9,10,11,12,13,14,15"};
char output[4][52] = {
"3,2,1,$,-,4,$",
"2,1,$",
"2,1,$,3,$",
"8,4,2,1,$,3,$,6,5,$,7,$,12,10,9,$,11,$,14,13,$,15,$"
};
int iter_loop, index;
for(iter_loop=0;iter_loop<4;iter_loop++)
{
printf("%d-->",iter_loop+1);
NODE *root1 = string_to_tree_converter(input[iter_loop]);
NODE *root2 = (NODE*)malloc(sizeof(NODE));
index = next_element_in_string(output[iter_loop],0);
root2->data = create_number(output[iter_loop],index);
index = next_element_in_string(output[iter_loop],index);
construct_tree(root2,output[iter_loop],index);
(tree_comparator(root1,root2) == 1)?(printf("ACCEPTED\n")):(printf("REJECTED\n"));
delete_tree(root1);
delete_tree(root2);
}
}
int parse_factor(CALC_ELEMENT ** e)
{
PARSE_SYMBOL s = get_symbol();
switch (s) {
case PARSE_NUMBER:
*e = create_number(get_current_number());
accept(s);
return 0;
break;
case PARSE_X:
*e = create_x();
accept(s);
return 0;
break;
case PARSE_LOG:
return parse_log(e);
break;
case PARSE_LPAREN:
return parse_paren_expr(e);
break;
default:
parser_error("\'number\', \'x\', \'log\' or \'(\'");
return -1;
}
}
/* Create IP address(mask) from a number - num
* This function creates a string as IP address from an integer value - for instance /25.
* It checks if the number is big enough to contain a multiple of 8, if it is the one part of IP address is 255
* If its not, it creates a nubmer that has the specified number of 1's at the begginig.
*/
void create_mask(int num, char *mask){
int parts[4] = {0, 0, 0, 0};
int i = 0;
while(i < 4){
if(num <= 0){
parts[i] = 0;
}
else if(num % 8 == 0){
parts[i] = 255;
}
else{
if(num / 8 >= 1){
parts[i] = 255;
}
else{
parts[i] = create_number(num%8);
}
}
num = num - 8;
i++;
}
//std::cout << parts[0] << "." << parts[1] << "." << parts[2] << "." << parts[3] << std::endl;
snprintf(mask, 15, "%d.%d.%d.%d", parts[0], parts[1], parts[2], parts[3]);
}
void MAXIMUM_NODE_IN_TREE()
{
char input[5][52] = {
"1,$",
"2,4,1,$,-,3,$",
"1,2,$,-",
"1,3,$,2,$",
"14,1,4,2,$,6,$,10,8,$,12,$,13,3,15,$,5,$,9,7,$,11,$"
};
int expected_output[6] = {1,4,2,3,15};
int iter_loop, index;
for(iter_loop=0;iter_loop<5;iter_loop++)
{
NODE *root = (NODE*)malloc(sizeof(NODE));
index = next_element_in_string(input[iter_loop],0);
root->data = create_number(input[iter_loop],index);
index = next_element_in_string(input[iter_loop],index);
construct_tree(root,input[iter_loop],index);
int previous_value = root->data;
Inorder(root,&previous_value);
(expected_output[iter_loop]==previous_value)?printf("ACCEPTED\n"):printf("REJECTED\n");
delete_tree(root);
}
}
void test_calc_bad(void)
{
CALC_ELEMENT *t1, *t2;
/* division by zero, simple */
t1 = create_number(9.0);
t2 = create_number(0.0);
t1 = create_bin_op('/', t1, t2);
CU_ASSERT_NOT_EQUAL(calculate(&t1), 0);
CU_ASSERT_EQUAL(t1->status & STATUS_CALC_DIV_BY_ZERO,
STATUS_CALC_DIV_BY_ZERO);
free_calc_element(t1);
/* division by zero, complex */
t1 = create_bin_op('/', create_number(4.0),
create_bin_op('-', create_number(2.0),
create_number(2.0)));
CU_ASSERT_NOT_EQUAL(calculate(&t1), 0);
CU_ASSERT_EQUAL(t1->status & STATUS_CALC_DIV_BY_ZERO,
STATUS_CALC_DIV_BY_ZERO);
free_calc_element(t1);
/* log zero */
t1 = create_log(create_number(0.0));
CU_ASSERT_NOT_EQUAL(calculate(&t1), 0);
CU_ASSERT_EQUAL(t1->status & STATUS_CALC_DOMAIN, STATUS_CALC_DOMAIN);
free_calc_element(t1);
/* log less than zero */
t1 = create_log(create_number(-3.0));
CU_ASSERT_NOT_EQUAL(calculate(&t1), 0);
CU_ASSERT_EQUAL(t1->status & STATUS_CALC_DOMAIN, STATUS_CALC_DOMAIN);
free_calc_element(t1);
/* log zero, complex */
t1 = create_log(create_bin_op
('*', create_number(0.0), create_number(28.0)));
CU_ASSERT_NOT_EQUAL(calculate(&t1), 0);
CU_ASSERT_EQUAL(t1->status & STATUS_CALC_DOMAIN, STATUS_CALC_DOMAIN);
free_calc_element(t1);
/* x in the expression, simple */
t1 = create_x();
CU_ASSERT_NOT_EQUAL(calculate(&t1), 0);
CU_ASSERT_EQUAL(t1->status & STATUS_X_PRESENT, STATUS_X_PRESENT);
free_calc_element(t1);
/* x in the expression, complex */
t1 = create_bin_op('-', create_x(), create_number(17));
CU_ASSERT_NOT_EQUAL(calculate(&t1), 0);
CU_ASSERT_EQUAL(t1->status & STATUS_X_PRESENT, STATUS_X_PRESENT);
free_calc_element(t1);
}
void test_number_cf(void)
{
CALC_ELEMENT *t1 = create_number(15.0);
CU_ASSERT_PTR_NOT_NULL(t1);
CU_ASSERT_EQUAL(t1->calc_t, CALC_NUM);
CU_ASSERT_EQUAL(t1->status, 0);
CU_ASSERT_EQUAL(t1->value, 15.0);
CU_ASSERT_PTR_NULL(t1->left);
CU_ASSERT_PTR_NULL(t1->right);
free_calc_element(t1);
}
static HRESULT NumberConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, DISPPARAMS *dp,
VARIANT *retv, jsexcept_t *ei, IServiceProvider *sp)
{
VARIANT num;
HRESULT hres;
TRACE("\n");
switch(flags) {
case INVOKE_FUNC:
if(!arg_cnt(dp)) {
if(retv) {
V_VT(retv) = VT_I4;
V_I4(retv) = 0;
}
return S_OK;
}
hres = to_number(ctx, get_arg(dp, 0), ei, &num);
if(FAILED(hres))
return hres;
if(retv)
*retv = num;
break;
case DISPATCH_CONSTRUCT: {
jsdisp_t *obj;
if(arg_cnt(dp)) {
hres = to_number(ctx, get_arg(dp, 0), ei, &num);
if(FAILED(hres))
return hres;
}else {
V_VT(&num) = VT_I4;
V_I4(&num) = 0;
}
hres = create_number(ctx, &num, &obj);
if(FAILED(hres))
return hres;
var_set_jsdisp(retv, obj);
break;
}
default:
FIXME("unimplemented flags %x\n", flags);
return E_NOTIMPL;
}
return S_OK;
}
//0 arg -> return number 0 to 1 (float)
//1 arg -> return number 0 to n (int)
//2 arg -> return number a to b (int)
static DexRef builtin_rand(DexRef* args, size_t n) {
const char* NAME = "rand";
if (n > 2) {
arg_amnt_err(NAME, n, 0, 2);
return NONE;
}
if (n == 0) {
return create_number(twist_state.genrand_res53());
} else if (n == 1) {
int max;
if (!dex_econv(&max, args[0], NAME)) {
return NONE;
} else {
if (max <= 0)
arg_type_err(NAME,"int (greater than 0)");
size_t st = twist_state.genrand_int32();
return create_number(st % max);
}
} else {
int min, max;
if (!dex_econv(&min, args[0], NAME) || !dex_econv(&max, args[1], NAME)) {
return NONE;
} else {
if (min > max) {
int t = min;
min = max;
max = t;
} else if (min == max) {
return create_number(min);
}
size_t st = twist_state.genrand_int32();
return create_number(min + int(st % (max - min)));
}
}
return NONE;
}
static HRESULT NumberConstr_value(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
jsval_t *r)
{
double n;
HRESULT hres;
TRACE("\n");
switch(flags) {
case INVOKE_FUNC:
if(!argc) {
if(r)
*r = jsval_number(0);
return S_OK;
}
hres = to_number(ctx, argv[0], &n);
if(FAILED(hres))
return hres;
if(r)
*r = jsval_number(n);
break;
case DISPATCH_CONSTRUCT: {
jsdisp_t *obj;
if(argc) {
hres = to_number(ctx, argv[0], &n);
if(FAILED(hres))
return hres;
} else {
n = 0;
}
hres = create_number(ctx, n, &obj);
if(FAILED(hres))
return hres;
*r = jsval_obj(obj);
break;
}
default:
FIXME("unimplemented flags %x\n", flags);
return E_NOTIMPL;
}
return S_OK;
}
void test_convert_string_to_tree()
{
char input[9][104] = {"([8,8],[4,8],[2,4],[1,2],[3,2],[6,4],[5,6],[7,6],[12,8],[10,12],[9,10],[11,10],[14,12],[13,14],[15,14])",
"([8,8],[4,8],[2,4],[6,4],[5,6],[7,6],[12,8],[10,12],[9,10],[11,10],[14,12],[13,14],[15,14])",
"([8,8],[4,8],[2,4],[1,2],[3,2],[6,4],[5,6],[7,6],[12,8],[10,12],[9,10],[11,10])",
"([5,5],[4,5],[2,4],[1,4],[3,5],[6,3],[7,3])",
"([5,5],[4,5],[3,5],[6,3],[7,3])",
"([5,5],[4,5],[2,4],[1,4],[3,5])",
"([1,1],[2,1],[3,1])",
"([5,5])",
"([1,1],[2,1])"
};
char output[9][86] = {"8,4,2,1,$,3,$,6,5,$,7,$,12,10,9,$,11,$,14,13,$,15,$",
"8,4,2,$,6,5,$,7,$,12,10,9,$,11,$,14,13,$,15,$",
"8,4,2,1,$,3,$,6,5,$,7,$,12,10,9,$,11,$,-",
"5,4,2,$,1,$,3,6,$,7,$",
"5,4,$,3,6,$,7,$",
"5,4,2,$,1,$,3,$",
"1,2,$,3,$",
"5,$",
"1,2,$,-"
};
int iter_loop,index;
for(iter_loop=0;iter_loop<9;iter_loop++)
{
printf("%d-->",iter_loop+1);
if(input[iter_loop]==NULL || output[iter_loop]==NULL)
{
printf("INVALID INPUT");
continue;
}
NODE *root1;
root1 = driver_for_convert_string_to_tree(input[iter_loop]);
NODE *root2 = (NODE*)malloc(sizeof(NODE));
index = next_element_in_string(output[iter_loop],0);
root2->data = create_number(output[iter_loop],index);
index = next_element_in_string(output[iter_loop],index);
construct_tree(root2,output[iter_loop],index);
(tree_comparator(root1,root2)==1)?printf("ACCEPTED\n"):printf("REJECTED\n");
delete_tree(root1);
delete_tree(root2);
}
}
GuiObject *add_number(GuiWindow * win, int type, int x, int y, int seg_length, char *mask)
{
GuiObject *number;
int i;
check_window(win, "add_number");
number = (GuiObject *) malloc(sizeof(GuiObject));
if (number == NULL)
error("Cannot allocate memory for number.");
number->win = win;
number->x = number->x_min = x;
number->y = number->y_min = y;
number->objclass = NUMBER;
number->active = TRUE;
number->pressed = FALSE;
number->hide = FALSE;
number->type = type;
number->fg_col = NUMBER_FORE;
number->bg_col1 = BLACK;
number->width = 0;
for (i = 0;i < strlen(mask);i++)
if (mask[i] == ' ')
number->width += 13;
else
number->width += bigfont_width[mask[i] - ' '];
number->height = bigfont_height;
number->x_max = x + number->width - 1;
number->y_max = y + number->height - 1;
number->align = ALIGN_LEFT;
sprintf(number->label, "%s", mask);
number->info[0] = '\0'; /* make string length zero */
number->data[0] = (char *) malloc(number->width * number->height);
if (number->data[0] == NULL)
error("Cannot allocate memory for number.");
number->data[1] = NULL; /* don't use second data-block */
create_number(number);
add_object(number);
return number;
}
void test_traversal()
{
char input[10][53] = {"8,-4,2,1,$,3,$,6,5,$,7,$,12,10,9,$,11,$,14,13,$,15,$",
"8,4,2,$,6,5,$,7,$,12,10,9,$,11,$,14,13,$,15,$",
"8,4,2,1,$,3,$,6,5,$,7,$,12,10,9,$,11,$,-",
"5,4,2,$,1,$,3,6,$,7,$",
"5,4,$,3,6,$,7,$",
"5,4,2,$,1,$,3,$",
"1,2,$,3,$",
"5,$",
"1,2,$,-",
'\0'
};
int output[10][16] ={
{8,-4,2,1,3,6,5,7,12,10,9,11,14,13,15},
{8,4,2,6,5,7,12,10,9,11,14,13,15},
{8,4,2,1,3,6,5,7,12,10,9,11},
{5,4,2,1,3,6,7},
{5,4,3,6,7},
{5,4,2,1,3},
{1,2,3},
{5},
{1,2},
NULL
};
int iter_loop;
for(iter_loop=0;iter_loop<10;iter_loop++)
{
int index;
NODE *root = (NODE*)malloc(sizeof(NODE));
index = next_element_in_string(input[iter_loop],0);
root->data = create_number(input[iter_loop],index);
index = next_element_in_string(input[iter_loop],index);
construct_tree(root,input[iter_loop],index);
int *traversal_array;
traversal_array = driver_of_traverse_arrays(root);
(compare_arrays(traversal_array,output[iter_loop]) == 1)?printf("ACCEPTED\n"):printf("REJECTED\n");
free(traversal_array);
delete_tree(root);
}
}
void test_tree_construction()
{
char inorder[5][36] = { "8,4,9,2,10,5,11,1,12,6,13,3,14,7,15",
"1,2,3,4",
"1,2,3",
"1,2,3,4,5,6,7,8,9,10,11,12,13,14,15",
"1,2"
};
char preorder[5][36] = { "1,2,4,8,9,5,10,11,3,6,12,13,7,14,15",
"2,1,3,4",
"2,1,3",
"8,4,2,1,3,6,5,7,12,10,9,11,14,13,15",
"1,2"
};
char expected_tree[5][52] = {"1,2,4,8,$,9,$,5,10,$,11,$,3,6,12,$,13,$,7,14,$,15,$",
"2,1,$,3,-,4,$",
"2,1,$,3,$",
"8,4,2,1,$,3,$,6,5,$,7,$,12,10,9,$,11,$,14,13,$,15,$",
"1,-,2,$"
};
int iter_loop;
for(iter_loop=0;iter_loop<5;iter_loop++)
{
printf("%d-->",iter_loop+1);
int preorder_index = 0;
int *inorder_array = string_to_array(inorder[iter_loop]);
int *preorder_array = string_to_array(preorder[iter_loop]);
NODE *head = construct_tree_from_inorder_preorder(inorder_array,preorder_array,0,array_length(inorder_array)-1,&preorder_index);
NODE *root = (NODE*)malloc(sizeof(NODE));
int index;
index = next_element_in_string(expected_tree[iter_loop],0);
root->data = create_number(expected_tree[iter_loop],index);
index = next_element_in_string(expected_tree[iter_loop],index);
construct_tree(root,expected_tree[iter_loop],index);
(1==tree_comparator(head,root))?printf("ACCEPTED\n"):printf("REJECTED\n");
delete_tree(head);
free(inorder_array);
free(preorder_array);
}
}
/* ECMA-262 3rd Edition 9.9 */
HRESULT to_object(exec_ctx_t *ctx, VARIANT *v, IDispatch **disp)
{
DispatchEx *dispex;
HRESULT hres;
switch(V_VT(v)) {
case VT_BSTR:
hres = create_string(ctx->parser->script, V_BSTR(v), SysStringLen(V_BSTR(v)), &dispex);
if(FAILED(hres))
return hres;
*disp = (IDispatch*)_IDispatchEx_(dispex);
break;
case VT_I4:
case VT_R8:
hres = create_number(ctx->parser->script, v, &dispex);
if(FAILED(hres))
return hres;
*disp = (IDispatch*)_IDispatchEx_(dispex);
break;
case VT_DISPATCH:
IDispatch_AddRef(V_DISPATCH(v));
*disp = V_DISPATCH(v);
break;
case VT_BOOL:
hres = create_bool(ctx->parser->script, V_BOOL(v), &dispex);
if(FAILED(hres))
return hres;
*disp = (IDispatch*)_IDispatchEx_(dispex);
break;
default:
FIXME("unsupported vt %d\n", V_VT(v));
return E_NOTIMPL;
}
return S_OK;
}
void test_log_cf(void)
{
CALC_ELEMENT *t1 = create_number(1.0);
t1 = create_log(t1);
CU_ASSERT_PTR_NOT_NULL(t1);
CU_ASSERT_EQUAL(t1->calc_t, CALC_LOG);
CU_ASSERT_EQUAL(t1->status, 0);
CU_ASSERT_EQUAL(t1->value, 1.0);
CU_ASSERT_PTR_NOT_NULL(t1->left);
CU_ASSERT_PTR_NULL(t1->right);
free_calc_element(t1);
t1 = create_x();
t1 = create_log(t1);
CU_ASSERT_PTR_NOT_NULL(t1);
CU_ASSERT_EQUAL(t1->calc_t, CALC_LOG);
CU_ASSERT_EQUAL(t1->status, STATUS_X_PRESENT | STATUS_X_IN_LOG);
CU_ASSERT_EQUAL(t1->value, 1.0);
CU_ASSERT_PTR_NOT_NULL(t1->left);
CU_ASSERT_PTR_NULL(t1->right);
free_calc_element(t1);
}
void test_bad_axb(void)
{
CALC_ELEMENT *t1, *t2, *t3;
double a, b;
/* log */
t2 = create_number(6.0);
t1 = create_log(t2);
CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), -1);
free_calc_element(t1);
/* bin op different from + */
t2 = create_number(-9.0);
t3 = create_x();
t1 = create_bin_op('*', t2, t3);
CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), -1);
free_calc_element(t1);
/* two numbers */
t2 = create_number(2.0);
t3 = create_number(4.2);
t1 = create_bin_op('+', t2, t3);
CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), -1);
free_calc_element(t1);
/* two xs */
t2 = create_x();
t3 = create_x();
t1 = create_bin_op('*', t2, t3);
CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), -1);
free_calc_element(t1);
/* something wonky, like 4 * 3 + 2 */
t2 = create_number(4);
t3 = create_number(3);
t2 = create_bin_op('*', t2, t3);
t3 = create_number(2);
t1 = create_bin_op('+', t2, t3);
CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), -1);
free_calc_element(t1);
}
/* ECMA-262 3rd Edition 9.9 */
HRESULT to_object(script_ctx_t *ctx, jsval_t val, IDispatch **disp)
{
jsdisp_t *dispex;
HRESULT hres;
switch(jsval_type(val)) {
case JSV_STRING:
hres = create_string(ctx, get_string(val), &dispex);
if(FAILED(hres))
return hres;
*disp = to_disp(dispex);
break;
case JSV_NUMBER:
hres = create_number(ctx, get_number(val), &dispex);
if(FAILED(hres))
return hres;
*disp = to_disp(dispex);
break;
case JSV_OBJECT:
if(get_object(val)) {
*disp = get_object(val);
IDispatch_AddRef(*disp);
}else {
jsdisp_t *obj;
hres = create_object(ctx, NULL, &obj);
if(FAILED(hres))
return hres;
*disp = to_disp(obj);
}
break;
case JSV_BOOL:
hres = create_bool(ctx, get_bool(val), &dispex);
if(FAILED(hres))
return hres;
*disp = to_disp(dispex);
break;
case JSV_UNDEFINED:
case JSV_NULL:
WARN("object expected\n");
return throw_type_error(ctx, JS_E_OBJECT_EXPECTED, NULL);
case JSV_VARIANT:
switch(V_VT(get_variant(val))) {
case VT_ARRAY|VT_VARIANT:
hres = create_vbarray(ctx, V_ARRAY(get_variant(val)), &dispex);
if(FAILED(hres))
return hres;
*disp = to_disp(dispex);
break;
default:
FIXME("Unsupported %s\n", debugstr_variant(get_variant(val)));
return E_NOTIMPL;
}
break;
}
return S_OK;
}
void test_canon_calc_good(void)
{
CALC_ELEMENT *t1, *t2;
/* single number */
t1 = create_number(12.0);
CU_ASSERT_PTR_NOT_NULL(t1);
CU_ASSERT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_PTR_NOT_NULL(t1);
CU_ASSERT_EQUAL(t1->calc_t, CALC_NUM);
CU_ASSERT_EQUAL(t1->status, 0);
CU_ASSERT_EQUAL(t1->value, 12.0);
CU_ASSERT_PTR_NULL(t1->left);
CU_ASSERT_PTR_NULL(t1->right);
free_calc_element(t1);
/* addition */
t1 = create_number(2.0);
t2 = create_number(-3.5);
t1 = create_bin_op('+', t1, t2);
CU_ASSERT_PTR_NOT_NULL(t1);
CU_ASSERT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_PTR_NOT_NULL(t1);
CU_ASSERT_EQUAL(t1->calc_t, CALC_NUM);
CU_ASSERT_EQUAL(t1->status, 0);
CU_ASSERT_EQUAL(t1->value, -1.5);
CU_ASSERT_PTR_NULL(t1->left);
CU_ASSERT_PTR_NULL(t1->right);
free_calc_element(t1);
/* substraction */
t1 = create_number(-3.0);
t2 = create_number(-4.25);
t1 = create_bin_op('-', t1, t2);
CU_ASSERT_PTR_NOT_NULL(t1);
CU_ASSERT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_PTR_NOT_NULL(t1);
CU_ASSERT_EQUAL(t1->calc_t, CALC_NUM);
CU_ASSERT_EQUAL(t1->status, 0);
CU_ASSERT_EQUAL(t1->value, 1.25);
CU_ASSERT_PTR_NULL(t1->left);
CU_ASSERT_PTR_NULL(t1->right);
free_calc_element(t1);
/* multiplication */
t1 = create_number(4);
t2 = create_number(1.25);
t1 = create_bin_op('*', t1, t2);
CU_ASSERT_PTR_NOT_NULL(t1);
CU_ASSERT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_PTR_NOT_NULL(t1);
CU_ASSERT_EQUAL(t1->calc_t, CALC_NUM);
CU_ASSERT_EQUAL(t1->status, 0);
CU_ASSERT_EQUAL(t1->value, 5.0);
CU_ASSERT_PTR_NULL(t1->left);
CU_ASSERT_PTR_NULL(t1->right);
free_calc_element(t1);
/* division */
t1 = create_number(8.0);
t2 = create_number(16.0);
t1 = create_bin_op('/', t1, t2);
CU_ASSERT_PTR_NOT_NULL(t1);
CU_ASSERT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_PTR_NOT_NULL(t1);
CU_ASSERT_EQUAL(t1->calc_t, CALC_NUM);
CU_ASSERT_EQUAL(t1->status, 0);
CU_ASSERT_EQUAL(t1->value, 0.5);
CU_ASSERT_PTR_NULL(t1->left);
CU_ASSERT_PTR_NULL(t1->right);
free_calc_element(t1);
/* natural logarithm */
t1 = create_number(1.0);
t1 = create_log(t1);
CU_ASSERT_PTR_NOT_NULL(t1);
CU_ASSERT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_PTR_NOT_NULL(t1);
CU_ASSERT_EQUAL(t1->calc_t, CALC_NUM);
CU_ASSERT_EQUAL(t1->status, 0);
CU_ASSERT_EQUAL(t1->value, 0.0);
CU_ASSERT_PTR_NULL(t1->left);
CU_ASSERT_PTR_NULL(t1->right);
free_calc_element(t1);
t1 = create_number(M_E);
t1 = create_log(t1);
CU_ASSERT_PTR_NOT_NULL(t1);
CU_ASSERT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_PTR_NOT_NULL(t1);
CU_ASSERT_EQUAL(t1->calc_t, CALC_NUM);
CU_ASSERT_EQUAL(t1->status, 0);
CU_ASSERT_EQUAL(t1->value, 1.0);
CU_ASSERT_PTR_NULL(t1->left);
CU_ASSERT_PTR_NULL(t1->right);
free_calc_element(t1);
/* a slightly more complex example (3 + (4 - 1)) * 5 */
t1 = create_number(4);
t2 = create_number(1);
t2 = create_bin_op('-', t1, t2);
t1 = create_number(3);
t1 = create_bin_op('+', t1, t2);
t2 = create_number(5);
t1 = create_bin_op('*', t1, t2);
CU_ASSERT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_PTR_NOT_NULL(t1);
CU_ASSERT_EQUAL(t1->calc_t, CALC_NUM);
CU_ASSERT_EQUAL(t1->status, 0);
CU_ASSERT_EQUAL(t1->value, 30.0);
CU_ASSERT_PTR_NULL(t1->left);
CU_ASSERT_PTR_NULL(t1->right);
free_calc_element(t1);
}
NODE* string_to_linked_list(char *input_array)
{
if(input_array == NULL)
{
return NULL;
}
int data;
int iter_loop=0, iter_loop2=0;
NODE *head=NULL, *temp=NULL;
while(input_array[iter_loop]!='\0')
{
while(input_array[iter_loop2]!=',' && input_array[iter_loop2]!='\0')
{
iter_loop2++;
}
data = create_number(input_array, iter_loop, iter_loop2-1);
if(data == NULL)
{
if(input_array[iter_loop2]!='\0')
{
iter_loop2++;
}
else if(input_array[iter_loop2]=='\0')
{
return NULL;
}
iter_loop = iter_loop2;
continue;
}
head = create_node(data);
temp = head;
temp->next = NULL;
if(input_array[iter_loop2]!='\0')
{
iter_loop2++;
}
iter_loop = iter_loop2;
break;
}
while(input_array[iter_loop]!='\0')
{
while(input_array[iter_loop2]!=',' && input_array[iter_loop2]!='\0')
{
iter_loop2++;
}
data = create_number(input_array, iter_loop, iter_loop2-1);
if(data == NULL)
{
if(input_array[iter_loop2]!='\0')
{
iter_loop2++;
}
else if(input_array[iter_loop2]=='\0')
{
return NULL;
}
iter_loop = iter_loop2;
continue;
}
NODE *new_node = create_node(data);
temp->next = new_node;
temp = new_node;
temp->next = NULL;
if(input_array[iter_loop2]=='\0')
{
break;
}
else if(input_array[iter_loop2]!='\0')
{
iter_loop = ++iter_loop2;
}
}
return head;
}
void test_canon_x(void)
{
CALC_ELEMENT *t1;
double a, b;
/* addition x + a * x */
t1 = create_bin_op('+', create_x(),
create_bin_op('*', create_number(2.5), create_x()));
CU_ASSERT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_EQUAL(t1->calc_t, CALC_X);
CU_ASSERT_EQUAL(t1->status, STATUS_X_PRESENT);
CU_ASSERT_EQUAL(t1->value, 3.5);
free_calc_element(t1);
/* addition a * x + b */
t1 = create_bin_op('+',
create_bin_op('*', create_number(1.25), create_x()),
create_number(14));
CU_ASSERT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_EQUAL(t1->calc_t, CALC_BIN_OP);
CU_ASSERT_EQUAL(t1->status, STATUS_X_PRESENT);
CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), 0);
CU_ASSERT_EQUAL(a, 1.25);
CU_ASSERT_EQUAL(b, 14);
free_calc_element(t1);
/* addition a * x + b + c */
t1 = create_bin_op('+',
create_bin_op('+',
create_bin_op('*', create_number(0.75),
create_x()),
create_number(6)),
create_number(-3.5));
CU_ASSERT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_EQUAL(t1->calc_t, CALC_BIN_OP);
CU_ASSERT_EQUAL(t1->status, STATUS_X_PRESENT);
CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), 0);
CU_ASSERT_EQUAL(a, 0.75);
CU_ASSERT_EQUAL(b, 2.5);
free_calc_element(t1);
/* addition (a1 * x + b1) + (a2 * x + b2) */
t1 = create_bin_op('+', create_ax_b(9.0, -1.25), create_ax_b(2.0, 6.5));
CU_ASSERT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_EQUAL(t1->calc_t, CALC_BIN_OP);
CU_ASSERT_EQUAL(t1->status, STATUS_X_PRESENT);
CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), 0);
CU_ASSERT_EQUAL(a, 11.0);
CU_ASSERT_EQUAL(b, 5.25);
free_calc_element(t1);
/* multiplication a * x */
t1 = create_bin_op('*', create_x(), create_number(-9.0));
CU_ASSERT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_EQUAL(t1->calc_t, CALC_X);
CU_ASSERT_EQUAL(t1->status, STATUS_X_PRESENT);
CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), 0);
CU_ASSERT_EQUAL(a, -9.0);
CU_ASSERT_EQUAL(b, 0);
free_calc_element(t1);
/* multiplication x * a */
t1 = create_bin_op('*', create_number(7.5), create_x());
CU_ASSERT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_EQUAL(t1->calc_t, CALC_X);
CU_ASSERT_EQUAL(t1->status, STATUS_X_PRESENT);
CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), 0);
CU_ASSERT_EQUAL(a, 7.5);
CU_ASSERT_EQUAL(b, 0);
free_calc_element(t1);
/* multiplication c * (a * x + b) */
t1 = create_bin_op('*', create_number(19), create_ax_b(4, -0.5));
CU_ASSERT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_EQUAL(t1->calc_t, CALC_BIN_OP);
CU_ASSERT_EQUAL(t1->status, STATUS_X_PRESENT);
CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), 0);
CU_ASSERT_EQUAL(a, 76);
CU_ASSERT_EQUAL(b, -9.5);
free_calc_element(t1);
/* multiplication (a * x + b) * c */
t1 = create_bin_op('*', create_ax_b(-6, 4.5), create_number(0.5));
CU_ASSERT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_EQUAL(t1->calc_t, CALC_BIN_OP);
CU_ASSERT_EQUAL(t1->status, STATUS_X_PRESENT);
CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), 0);
CU_ASSERT_EQUAL(a, -3.0);
CU_ASSERT_EQUAL(b, 2.25);
free_calc_element(t1);
/* multiplication x * x */
t1 = create_bin_op('*', create_x(), create_x());
CU_ASSERT_NOT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_EQUAL(t1->calc_t, CALC_BIN_OP);
CU_ASSERT_EQUAL(t1->status, STATUS_X_NON_LINEAR | STATUS_X_PRESENT);
free_calc_element(t1);
/* multiplication x * (a * x + b) */
t1 = create_bin_op('*', create_x(), create_x());
CU_ASSERT_NOT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_EQUAL(t1->calc_t, CALC_BIN_OP);
CU_ASSERT_EQUAL(t1->status, STATUS_X_NON_LINEAR | STATUS_X_PRESENT);
free_calc_element(t1);
/* multiplication (2*x - (2*x - 3)) * (3x - 4) - false square, actually linear */
t1 = create_bin_op('*', create_bin_op('-', create_ax_b(2.0, 0.0),
create_ax_b(2, -3)),
create_ax_b(3.0, -4.0));
CU_ASSERT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_EQUAL(t1->calc_t, CALC_BIN_OP);
CU_ASSERT_EQUAL(get_ax_b(t1, &a, &b), 0);
CU_ASSERT_EQUAL(a, 9.0);
CU_ASSERT_EQUAL(b, -12.0);
free_calc_element(t1);
/* division x / a */
t1 = create_bin_op('/', create_x(), create_number(2.0));
CU_ASSERT_NOT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_EQUAL(t1->calc_t, CALC_BIN_OP);
CU_ASSERT_EQUAL(t1->status, STATUS_X_IN_DIV | STATUS_X_PRESENT);
free_calc_element(t1);
/* log (ax + b) */
t1 = create_log(create_ax_b(9.0, -3.0));
CU_ASSERT_NOT_EQUAL(canonical_form(&t1), 0);
CU_ASSERT_EQUAL(t1->calc_t, CALC_LOG);
CU_ASSERT_EQUAL(t1->status, STATUS_X_IN_LOG | STATUS_X_PRESENT);
free_calc_element(t1);
}
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.*/
#include "../types/funcs/dexbuiltin.h"
#include "math.h"
#include "../types/dexnum.h"
#include "../types/dexstr.h"
#include "objdefutil.h"
#include "../libs/rand/mtwist.h"
#include "../objdef/dex_conv.h"
static DexRef DSTR_MATHCPP = create_string("math.cpp");
DexRef DNUM_PI = create_number(PI), DNUM_E = create_number(E);
DexRef DNUM_NEG_ONE = create_number(-1), DNUM_ONE = create_number(1), DNUM_ZERO = create_number(0);
//0 arg -> return number 0 to 1 (float)
//1 arg -> return number 0 to n (int)
//2 arg -> return number a to b (int)
static DexRef builtin_rand(DexRef* args, size_t n) {
const char* NAME = "rand";
if (n > 2) {
arg_amnt_err(NAME, n, 0, 2);
return NONE;
}
if (n == 0) {
return create_number(twist_state.genrand_res53());
void test_binop_cf(void)
{
/* + */
CALC_ELEMENT *e1 = create_number(3.0), *e2 = create_number(-4.0);
CALC_ELEMENT *expr = create_bin_op('+', e1, e2);
CU_ASSERT_PTR_NOT_NULL(expr);
CU_ASSERT_EQUAL(expr->calc_t, CALC_BIN_OP);
CU_ASSERT_EQUAL(expr->bin_op, '+');
CU_ASSERT_EQUAL(expr->status, 0);
CU_ASSERT_EQUAL(expr->value, 1.0);
CU_ASSERT_PTR_NOT_NULL(expr->left);
CU_ASSERT_PTR_NOT_NULL(expr->right);
free_calc_element(expr);
/* - */
e1 = create_number(-7.0);
e2 = create_number(9.0);
expr = create_bin_op('-', e1, e2);
CU_ASSERT_PTR_NOT_NULL(expr);
CU_ASSERT_EQUAL(expr->calc_t, CALC_BIN_OP);
CU_ASSERT_EQUAL(expr->bin_op, '+');
CU_ASSERT_EQUAL(expr->status, 0);
CU_ASSERT_EQUAL(expr->value, 1.0);
CU_ASSERT_PTR_NOT_NULL(expr->left);
CU_ASSERT_PTR_NOT_NULL(expr->right);
CU_ASSERT_EQUAL(expr->right->value, -9.0);
free_calc_element(expr);
/* * */
e1 = create_number(3.0);
e2 = create_number(11.5);
expr = create_bin_op('*', e1, e2);
CU_ASSERT_PTR_NOT_NULL(expr);
CU_ASSERT_EQUAL(expr->calc_t, CALC_BIN_OP);
CU_ASSERT_EQUAL(expr->bin_op, '*');
CU_ASSERT_EQUAL(expr->status, 0);
CU_ASSERT_EQUAL(expr->value, 1.0);
CU_ASSERT_PTR_NOT_NULL(expr->left);
CU_ASSERT_PTR_NOT_NULL(expr->right);
free_calc_element(expr);
/* /, only numbers */
e1 = create_number(-7.0);
e2 = create_number(5.0);
expr = create_bin_op('/', e1, e2);
CU_ASSERT_PTR_NOT_NULL(expr);
CU_ASSERT_EQUAL(expr->calc_t, CALC_BIN_OP);
CU_ASSERT_EQUAL(expr->bin_op, '/');
CU_ASSERT_EQUAL(expr->status, 0);
CU_ASSERT_EQUAL(expr->value, 1.0);
CU_ASSERT_PTR_NOT_NULL(expr->left);
CU_ASSERT_PTR_NOT_NULL(expr->right);
free_calc_element(expr);
/* /, with an x */
e1 = create_x();
e2 = create_number(2.0);
expr = create_bin_op('/', e1, e2);
CU_ASSERT_PTR_NOT_NULL(expr);
CU_ASSERT_EQUAL(expr->calc_t, CALC_BIN_OP);
CU_ASSERT_EQUAL(expr->bin_op, '/');
CU_ASSERT_EQUAL(expr->status, STATUS_X_PRESENT | STATUS_X_IN_DIV);
CU_ASSERT_EQUAL(expr->value, 1.0);
CU_ASSERT_PTR_NOT_NULL(expr->left);
CU_ASSERT_PTR_NOT_NULL(expr->right);
free_calc_element(expr);
}
Link interpret(Link codeblock_link , Link This, Link Arg){
CallEnv env = callenv_new_root( codeblock_link, This, Arg);
LinkStack stack = env->stack;
Link b = NULL;
Link link = NULL;
Link parent = NULL;
Link child_key = NULL;
Link pusher = NULL; // Anything in this variable gets pushed onto the stack
Link trapped = NULL; // This is the last critical caught by the trap operator
int delta = 0; // jump delta
/* Main interpreter loop */
while(1){
switch( *(env->current++) ){
case INTRO:
env->current+=4;
break;
case ALLOC_MODULE:
delta = read_offset(env);
env->module->global_vars = linkarray_new(delta);
break;
case ALLOC_LOCAL:
delta = read_offset(env);
env->local = linkarray_new(delta);
break;
case NO_OP:
break;
case RETURN: // if there is something on the env->stack stack pop it off and return it, if not return null link
if ( stack_length(stack) - env->stack_offset ){
pusher = stack_pop(stack);
}else{
pusher = object_create(Global->null_type);
}
goto done;
case RAISE: // if there is something on the stack stack pop it off and return it, if not return null link
if ( stack_length(stack) - env->stack_offset ){
pusher = create_critical(stack_pop(stack));
}else{
pusher = create_critical(object_create(Global->null_type));
}
goto done;
case PUSH_LEX:
delta = read_offset(env);
//fprintf(stderr , "push lex [%i] %p\n", delta,env->function->value.codeblock->lexicals);
pusher = link_dup(env->function->value.codeblock->lexicals->vars[delta]);
break;
case STORE_LEX:
delta = read_offset(env);
//fprintf(stderr , "storing lex [%i] %p\n", delta,env->function->value.codeblock->lexicals);
b = env->function->value.codeblock->lexicals->vars[delta];
if (b){
if ( (b->type == Global->function_type) &&
(b->value.codeblock->lexicals == env->function->value.codeblock->lexicals)
) b->value.codeblock->lexical_cycles--;
link_free(b);
}
b = link_dup(stack_peek(stack));
if ( (b->type == Global->function_type) &&
(b->value.codeblock->lexicals == env->function->value.codeblock->lexicals)
) b->value.codeblock->lexical_cycles++;
env->function->value.codeblock->lexicals->vars[delta] = b;
break;
case DEF:
if (env->Def) link_free(env->Def);
env->Def = stack_pop(env->stack);
pusher = link_dup(env->Def);
break;
case PUSH_DEF:
if ( ! env->Def){
pusher = exception("NoDefObject",NULL, NULL);
}
pusher = link_dup(env->Def);
break;
case ALLOC_LEXICAL:
delta = read_offset(env);
lexicals_alloc( env->function, delta);
//env->lexical_root = 1;
break;
case STORE_ARG:
delta = read_offset(env);
if (env->Arg->value.array->length > delta){
retry_store_arg:
env->Arg->value.array->links[delta] = link_dup( stack_peek(stack) );
}else{
array_push(env->Arg, NULL);
goto retry_store_arg;
}
break;
case PUSH_ARG:
delta = read_offset(env);
if (env->Arg->value.array->length > delta){
pusher = link_dup( env->Arg->value.array->links[delta]);
}else{
pusher = exception("ArgsIndexOutOfBounds", NULL, NULL);
}
break;
case STORE_GVAR:
delta = read_offset(env);
if (env->module->global_vars->links[delta]){
link_free(env->module->global_vars->links[delta]);
}
env->module->global_vars->links[delta] = link_dup( stack_peek(stack) );
break;
case STORE_VAR:
delta = read_offset(env);
if (env->local->links[delta]){
link_free(env->local->links[delta]);
}
env->local->links[delta] = link_dup( stack_peek(stack) );
break;
case STORE_CHILD:
link = stack_pop(stack); // value
child_key = stack_pop(stack); // key to find the child
parent = stack_pop(stack); // parent to look in
pusher = object_addChild(parent, link, child_key);
goto STORE_COMMON;
case STORE_ATTR:
link = stack_pop(stack); // value
child_key = stack_pop(stack); // key to find the child
parent = stack_pop(stack); // parent to look in
pusher = addAttr(parent, link,child_key);
goto STORE_COMMON;
STORE_COMMON:
if (! pusher){
pusher = exception("AssignError", NULL, NULL);
link_free(link);
}
link_free(child_key);
link_free(parent);
break;
case LT:
delta = compare(env);
pusher = create_numberi( (delta < 0) ? 1 : 0 );
break;
case GT:
delta = compare(env);
pusher = create_numberi( (delta > 0) ? 1 : 0 );
break;
case EQ:
delta = compare(env);
pusher = create_numberi( (delta == 0) ? 1 : 0 );
break;
case NE:
delta = compare(env);
pusher = create_numberi( (delta == 0) ? 0 : 1 );
break;
case LE:
delta = compare(env);
pusher = create_numberi( (delta <= 0) ? 1 : 0 );
break;
case GE:
delta = compare(env);
pusher = create_numberi( (delta >= 0) ? 1 : 0 );
break;
case CMP:
delta = compare(env);
pusher = create_numberi( delta );
break;
case OR:
case AND:
break;
case SUB:
b = stack_pop(env->stack);
link = stack_pop(env->stack);
if ( (link->type == Global->number_type) && (link->type == b->type)){
pusher = create_number(link->value.number - b->value.number);
link_free(link);
link_free(b);
break;
}
pusher = object_op_minus(link,b);
link_free(link);
link_free(b);
break;
case ADD:
b = stack_pop(env->stack);
link = stack_pop(env->stack);
if ( (link->type == Global->number_type) && (link->type == b->type)){
pusher = create_number(link->value.number + b->value.number);
link_free(link);
link_free(b);
break;
}
pusher = object_op_plus(link,b);
link_free(link);
link_free(b);
break;
case DIV:
binary_op(env , object_op_divide);
break;
case MULT:
binary_op(env , object_op_multiply);
break;
case MOD:
binary_op(env , object_op_modulus);
break;
case POW:
binary_op(env , object_op_power);
break;
case NEG:
unary_op(env, object_op_neg);
break;
case NOT:
link = stack_pop(stack);
pusher = create_numberi( (object_is_true(link)) ? 0 : 1 );
link_free(link);
break;
case TEST:
case ELSE:
break;
case DO:
delta = read_offset(env);
link = codeblock_literal2( env->function->value.codeblock->parent, delta );
if (env->function->value.codeblock->lexicals) {
lexicals_attach( env->function->value.codeblock->lexicals, link);
}
env = callenv_new_doblock(env,link);
break;
case PUSH_ARRAY:
delta = read_offset(env);
pusher = array_new_subarray( stack , delta);
break;
case CALL:
link = stack_pop(stack); // the arguments in an array
b = stack_pop(stack); // the function that gets called
parent = link_dup(env->This); // caller
goto CALL_COMMON;
case CALL_ATTR:
link = stack_pop(stack); // arguments
child_key = stack_pop(stack); // name of the function
parent = stack_pop(stack); // caller
b = getAttr(parent,child_key); // the function that gets called
link_free(child_key); // no longer need the attributes key
if (! b) {
pusher = exception("AttrNotFound", NULL, NULL);
break;
}
goto CALL_COMMON;
case CALL_CHILD:
link = stack_pop(stack); // ARG
child_key = stack_pop(stack);
parent = stack_pop(stack); // THIS
b = object_getChild(parent,child_key);
link_free(child_key);
goto CALL_COMMON;
CALL_COMMON:
/* function type so we can call it inline */
if (b->type == Global->function_type){
env = callenv_new_function(env, b, parent, link); // ce , func,this, arg
/* Not a CodeBlock so we have to use its virtual call function */
}else{
pusher = object_call(b, parent, link);// function, caller, args
link_free(link);
if (parent) link_free(parent);
link_free(b);
if (! pusher) pusher = object_create(Global->null_type);
}
break;
case DEL_CHILD:
child_key = stack_pop(stack); // key to find the child
parent = stack_pop(stack); // parent to look in
/* delete child from container */
pusher = object_delChild(parent,child_key);
if (! pusher) pusher = exception("ChildNotFound", object_getString(child_key), NULL);
link_free(child_key);
link_free(parent);
break;
case DEL_ATTR:
child_key = stack_pop(stack); // key to find the child
parent = stack_pop(stack); // parent to look in
/* delete attr from container */
pusher = delAttr(parent,child_key);
if (! pusher) pusher = exception("AttrNotFound", object_getString(child_key), NULL);
link_free(child_key);
link_free(parent);
break;
case GET_CHILD:
child_key = stack_pop(stack); // key to find the child
parent = stack_pop(stack); // parent to look in
pusher = object_getChild(parent, child_key);
if (! pusher) pusher = exception("ChildNotFound", object_getString(child_key), NULL);
link_free(parent);
link_free(child_key);
break;
case GET_ATTR:
child_key = stack_pop(stack); // key to find the child
parent = stack_pop(stack); // parent to look in
pusher = getAttr(parent, child_key);
if (! pusher) pusher = exception("AttrNotFound", object_getString(child_key), NULL);
link_free(parent);
link_free(child_key);
break;
case TRAP:
break;
case CLEAR:
for ( delta = stack_length( stack ) ; delta > env->stack_offset ; delta--){
link_free( stack_pop(stack) );
}
break;
case STOP:
break;
done:
case END:
for ( delta = stack_length( stack ) ; delta > env->stack_offset ; delta--){
link_free( stack_pop(stack) );
}
addBacktrace(pusher, env->function, env->linenum);
env = callenv_free(env);
if (! env) goto end;
if (! pusher) pusher = object_create(Global->null_type);
break;
/* JUMPS */
case JIT: /* Jump if true */
delta = read_offset(env);
link = stack_peek(stack);
if ( link->type->is_true(link) ) env->current = env->start+delta;
break;
case JIF: /* Jump if false */
delta = read_offset(env);
link = stack_peek(stack);
if ( ! link->type->is_true(link) ) env->current = env->start+delta;
break;
case JIF_POP: /* Pop value then jump if value is false, */
delta = read_offset(env);
link = stack_pop(stack);
if ( ! link->type->is_true(link) ) env->current = env->start+delta;
link_free(link);
break;
case JUMP: /* Absolute jump */
delta = read_offset(env);
env->current = env->start + delta;
break;
case JINC: /* Jump If Not Critical */
delta = read_offset(env);
env->current = env->start+delta;
break;
jinc_critical:
delta = read_offset(env);
if (trapped) link_free(trapped);
trapped = pusher->value.link;
pusher->value.link = NULL;
link_free(pusher);
pusher = NULL;
break;
case PUSH_NULL:
pusher = create_null();
break;
case PUSH_NUM:
pusher = create_number( *((number_t *)env->current) );
env->current+= sizeof(number_t);
break;
case PUSH_STR:
delta = read_offset(env);
pusher = create_string_literal( env->start + delta );
break;
case PUSH_GVAR:
delta = read_offset(env);
pusher = link_dup(env->module->global_vars->links[delta]);
if (! pusher){
pusher = exception("GlobalVariableUsedBeforeSet",NULL,NULL);
}
break;
case PUSH_VAR:
delta = read_offset(env);
pusher = link_dup(env->local->links[delta]);
if (! pusher){
pusher = exception("VariableUsedBeforeSet",NULL,NULL);;
}
break;
case PUSH_BLOCK:
delta = read_offset(env);
pusher = codeblock_literal2( env->function->value.codeblock->parent, delta );
if (env->function->value.codeblock->lexicals) {
lexicals_attach( env->function->value.codeblock->lexicals, pusher);
}
break;
case PUSH_SYS:
pusher = link_dup(Global->SYS_MODULE);
break;
case PUSH_MODULE:
pusher = link_dup( env->function->value.codeblock->parent);
break;
case TYPEOF:
link = stack_pop(stack);
pusher = link_dup( link->type->type_link);
link_free(link);
break;
case PUSH_THIS:
pusher = link_dup(env->This);
break;
case PUSH_SELF:
pusher = link_dup(env->Self);
break;
case PUSH_ARGS:
pusher = link_dup(env->Arg);
break;
case PUSH_TRAPPED:
pusher = trapped ? link_dup(trapped) : object_create(Global->null_type);
break;
case POP:
link_free( stack_pop(stack) );
break;
case LINE:
env->linenum = read_offset(env);
break;
default:
fprintf(stderr," UNRECOGNIZED OPCODE ERROR %i\n", *(env->current));
fprintf(stderr," near line %i\n", (int)(env->linenum));
exit(1);
break;
}
if (pusher) {
if ( is_critical( pusher ) ){
if ( *(env->current) == JINC) goto jinc_critical;
goto done;
}
stack_push(stack , pusher);
pusher = NULL;
}
}
end:
if (trapped) link_free(trapped);
return pusher;
}
void update_number(GuiObject * obj)
{
check_object(obj, "obj", "update_number");
create_number(obj);
}
