object *expand_clauses(object *clauses) {
object *first;
object *rest;
if (is_the_empty_list(clauses)) {
return false;
}
else {
first = car(clauses);
rest = cdr(clauses);
if (is_cond_else_clause(first)) {
if (is_the_empty_list(rest)) {
return sequence_to_exp(cond_actions(first));
}
else {
fprintf(stderr, "else clause isn't last cond->if");
exit(1);
}
}
else {
return make_if(cond_predicate(first),
sequence_to_exp(cond_actions(first)),
expand_clauses(rest));
}
}
}
static pSlipObject expand_clauses(pSlip gd, pSlipObject clauses)
{
pSlipObject first;
pSlipObject rest;
if (sIsObject_EmptyList(gd, clauses) == S_TRUE)
{
return gd->singleton_False;
}
else
{
first = car(clauses);
rest = cdr(clauses);
if (is_cond_else_clause(gd, first) == S_TRUE)
{
if (sIsObject_EmptyList(gd, rest) == S_TRUE)
{
return sequence_to_exp(gd, cond_actions(first));
}
else
{
throw_error(gd, "else clause isn't last cond->if");
return gd->singleton_False;
}
}
else
{
return make_if(gd, cond_predicate(first), sequence_to_exp(gd, cond_actions(first)), expand_clauses(gd, rest));
}
}
}
static ErlDrvData tun_start(ErlDrvPort port, char *args)
{
struct tun_state *state;
int fd;
int mode;
char dev_name[IFNAMSIZ];
state = (struct tun_state*) sys_alloc(sizeof(struct tun_state));
if (state == NULL) {
errno = ENOMEM; /* appropriate to set errno? */
return ERL_DRV_ERROR_ERRNO;
}
if (!parse_args(args, &mode, state->dev, IFNAMSIZ - 1)) {
return ERL_DRV_ERROR_BADARG;
}
fd = make_if(mode, state->dev);
if (fd < 0) {
return ERL_DRV_ERROR_GENERAL;
}
state->port = port;
state->fd = fd;
state->active = ACTIVE_FALSE;
set_input(state, 0);
return (ErlDrvData)state;
}
/* Build necessary code for an if statement */
void build_if_stmt(environment *env, NODE *node, int if_count, tac_quad *false_jump, tac_quad *loop_jump, int flag, int return_type) {
char *s_tmp;
value *val1, *val2, *temporary;
if (node==NULL || (type_of(node)!=IF && type_of(node)!=WHILE)) return;
/* LHS is condition */
val1 = make_simple(env, node->left, flag, return_type);
/* Generate if statement */
s_tmp = malloc(sizeof(char) * 25);
sprintf(s_tmp, "__if%dtrue", if_count);
append_code(make_if(val1, s_tmp));
/* Output false branch (i.e. else part) */
if (type_of(node->right)==ELSE) {
/* Build code for false part */
build_else_part(env, node->right, 0, flag, return_type);
}
/* Generate goto end of if statement */
if (false_jump != NULL) {
append_code(false_jump);
}
else {
s_tmp = malloc(sizeof(char) * 25);
sprintf(s_tmp, "__if%dend", if_count);
append_code(make_goto(s_tmp));
}
/* Generate label for start of true branch */
s_tmp = malloc(sizeof(char) * 25);
sprintf(s_tmp, "__if%dtrue", if_count);
append_code(make_label(s_tmp));
/* Output true branch */
if (type_of(node->right)==ELSE) {
/* Build code for true part */
build_else_part(env, node->right, 1, flag, return_type);
}
else {
/* True part is whole right branch */
make_simple(env, node->right, flag, return_type);
}
/* Check if extra loop jump has been specified (for WHILE loops etc) */
if (loop_jump) {
append_code(loop_jump);
}
/* Generate end of IF stmt label */
s_tmp = malloc(sizeof(char) * 25);
sprintf(s_tmp, "__if%dend", if_count);
append_code(make_label(s_tmp));
}
//one arg: clauses
static cellpoint expand_clauses(void)
{
if (is_true(is_null(args_ref(1)))){
reg = a_false;
}else {
args_push(car(args_ref(1)));
reg = is_cond_else_clause();
if (is_true(reg)){
reg = cdr(args_ref(1));
if(is_true(is_null(reg))){
//calls cond_actions
args_push(car(args_ref(1)));
reg = cond_actions();
//calls sequence_2_exp
args_push(reg);
reg = sequence_2_exp();
}else {
printf("Error: ELSE clause isn't last clause in cond expression.\n");
error_handler();
}
}else {
//calls cond_predicate
args_push(car(args_ref(1)));
reg = cond_predicate();
stack_push(&vars_stack, reg);
//calls sequence_2_exp
args_push(car(args_ref(1)));
reg = cond_actions();
args_push(reg);
reg = sequence_2_exp();
stack_push(&vars_stack, reg);
//calls expand_clauses to expand the rest clauses
args_push(cdr(args_ref(1)));
reg = expand_clauses();
//calls make_if
args_push(reg);
args_push(stack_pop(&vars_stack));
args_push(stack_pop(&vars_stack));
reg = make_if();
}
}
args_pop(1);
return reg;
}
object *expand_clauses(object *clauses) {
object *first;
object *rest;
if (is_empty(clauses))
return false;
first = car(clauses);
rest = cdr(clauses);
if (!is_cond_else_clause(first))
return make_if(cond_predicate(first), sequence_to_exp(cond_actions(first)), expand_clauses(rest));
if (is_empty(rest))
return sequence_to_exp(cond_actions(first));
fprintf(stderr, "else clause isn't last cond->if");
exit(EXIT_FAILURE);
}
static data_t *expand_clauses(const data_t *clauses) {
data_t *first, *rest;
if(clauses == NULL)
return make_symbol("#f");
first = car(clauses);
rest = cdr(clauses);
if(is_cond_else_clause(first)) {
if(rest == NULL) {
return sequence_to_exp(get_cond_actions(first));
} else {
printf("ELSE clause isn't last -- COND-IF");
return make_symbol("error");
}
}
return make_if(get_cond_predicate(first), sequence_to_exp(get_cond_actions(first)), expand_clauses(rest));
}
static object *expand_clauses(object *clauses)
{
if (is_empty_list(clauses)) {
return get_boolean(0);
} else {
object *first = car(clauses);
object *rest = cdr(clauses);
if (cond_predicate(first) == lookup_symbol("else")) {
if (is_empty_list(rest)) {
return sequence_to_exp(cond_actions(first));
} else {
error("else clause must be last in cond expression");
}
} else {
return make_if(cond_predicate(first),
sequence_to_exp(cond_actions(first)),
expand_clauses(rest));
}
}
}
sb_element_t *if_parse_e_f ( sb_token_t *tlist[], unsigned char i, sb_parse_match_rule_t *rule ) {
sb_element_t *condition, *truepath = NULL, *falsepath = NULL;
sb_element_t *e;
sbparse_return_t r;
condition = tlist [ i + 1 ] -> data.e;
// need to get the contained (TRUE PATH) listing..
//
if ( g_sb_debug ) {
printf ( "DESCEND\n" );
}
g_sb_indent += 1;
r = sbparse_buffer();
truepath = r.e;
g_sb_indent -= 1;
if ( ! truepath ) {
return ( NULL ); // failed to parse contained code, so just abort
}
// and check for a false path..
//
if ( r.tokentype == sbt_else ) {
if ( g_sb_debug ) {
printf ( "DESCEND-ELSE\n" );
}
g_sb_indent += 1;
r = sbparse_buffer();
falsepath = r.e;
g_sb_indent -= 1;
}
// build the if
//
e = make_if ( condition, truepath, falsepath );
return ( e );
}
static EXPRESSION *simplify_expression(MODULE *module, FUNCTION *func, BLOCK *block, EXPRESSION *expr, STATEMENT *before)
{
int i;
int source_line = CAST_TO_AST(expr)->source_line;
if (!has_graph(func) && is_short_circuit(expr))
{
TYPE *new_temp_type = CAST_TO_EXPRESSION(tree_get_child(expr, 0))->type;
EXPRESSION *new_temp = make_new_temp(module, func, new_temp_type, source_line);
STATEMENT *new_assign = make_assignment(new_temp, tree_get_child(expr, 0), source_line);
tree_add_before(CAST_TO_NODE(block), CAST_TO_NODE(new_assign), CAST_TO_NODE(before));
STATEMENT *new_assign2 = make_assignment(new_temp, tree_get_child(expr, 1), source_line);
EXPRESSION *new_cond = new_temp;
if (tree_is_type(expr, EXPR_OR))
new_cond = make_unary_expression(EXPR_NOT, new_cond, source_line);
STATEMENT *new_if = make_if(new_cond, make_block(NULL, new_assign2, 0), NULL, 0);
tree_add_before(CAST_TO_NODE(block), CAST_TO_NODE(new_if), CAST_TO_NODE(before));
return new_temp;
}
if (has_graph(func) && is_short_circuit(expr))
{
GRAPH *graph = func->graph;
EXPRESSION *sub0 = tree_get_child(expr, 0);
EXPRESSION *sub1 = tree_get_child(expr, 1);
STATEMENT *new_test = make_test(sub0, source_line);
EDGE_TYPE inner_type = tree_is_type(expr, EXPR_OR) ? EDGE_NO : EDGE_YES;
EDGE_TYPE outer_type = tree_is_type(expr, EXPR_OR) ? EDGE_YES : EDGE_NO;
add_vertex(graph, CAST_TO_NODE(new_test));
HASH *subhash = get_from_hash(graph->forward, before, sizeof(void *));
HASH_ITERATOR iter;
for (hash_iterator(subhash, &iter); hash_iterator_valid(&iter); hash_iterator_next(&iter))
{
EDGE_TYPE type = (EDGE_TYPE) iter.entry->data;
if (outer_type & type)
add_edge(graph, CAST_TO_NODE(new_test), iter.entry->key, type);
if (inner_type & type)
inner_type = type;
}
inject_before(graph, CAST_TO_NODE(new_test), CAST_TO_NODE(before), inner_type);
return sub1;
}
if (is_simple(expr))
return expr;
if (tree_is_type(expr, EXPR_CALL))
{
EXPRESSION *args = CAST_TO_EXPRESSION(tree_get_child(expr, 1));
args = atomise_expression(module, func, block, args, before);
tree_get_child(expr, 1) = args;
return expr;
}
for (i = 0; i < tree_num_children(expr); i++)
{
EXPRESSION *child = tree_get_child(expr, i);
if (!is_atomic(child))
{
TYPE *new_temp_type = CAST_TO_EXPRESSION(child)->type;
EXPRESSION *new_temp = make_new_temp(module, func, new_temp_type, CAST_TO_AST(child)->source_line);
STATEMENT *new_assign = make_assignment(new_temp, child, CAST_TO_AST(child)->source_line);
if (has_graph(func))
{
GRAPH *graph = func->graph;
add_vertex(graph, CAST_TO_NODE(new_assign));
inject_before(graph, CAST_TO_NODE(new_assign), CAST_TO_NODE(before), 0);
}
else
tree_add_before(CAST_TO_NODE(block), CAST_TO_NODE(new_assign), CAST_TO_NODE(before));
tree_get_child(expr, i) = new_temp;
}
}
return expr;
}
int Parser::expression(int pos, int status) {
int isputs = 0;
if(tok.skip("$")) { // global varibale
if(is_asgmt()) asgmt();
} else if(tok.skip("require")) {
make_require();
} else if(tok.skip("def")) { blocksCount++;
make_func();
} else if(tok.skip("module")) { blocksCount++;
module = tok.tok[tok.pos++].val;
eval(0, NON);
module = "";
} else if(funcs.inside == false && !tok.is("def", 1) &&
!tok.is("module", 1) && !tok.is("$", 1) &&
!tok.is(";", 1) && module == "") { // main func entry
funcs.inside = true;
funcs.now++;
funcs.append("main", ntv.count, 0); // append funcs
ntv.genas("push ebp");
ntv.genas("mov ebp esp");
uint32_t espBgn = ntv.count + 2; ntv.genas("sub esp 0");
ntv.gencode(0x8b); ntv.gencode(0x75); ntv.gencode(0x0c); // mov esi, 0xc(%ebp)
eval(0, BLOCK_NORMAL);
ntv.gencode(0x81); ntv.gencode(0xc4); ntv.gencode_int32(ADDR_SIZE * (var.focus().size() + 6)); // add %esp nn
ntv.gencode(0xc9);// leave
ntv.gencode(0xc3);// ret
ntv.gencode_int32_insert(ADDR_SIZE * (var.focus().size() + 6), espBgn);
funcs.inside = false;
} else if(is_asgmt()) {
asgmt();
} else if((isputs=tok.skip("puts")) || tok.skip("print")) {
do {
ExprType et = expr_entry();
ntv.genas("push eax");
if(et.is_type(T_STRING)) {
ntv.gencode(0xff); ntv.gencode(0x56); ntv.gencode(4);// call *0x04(esi) putString
} else {
ntv.gencode(0xff); ntv.gencode(0x16); // call (esi) putNumber
}
ntv.genas("add esp 4");
} while(tok.skip(","));
// for new line
if(isputs) {
ntv.gencode(0xff); ntv.gencode(0x56); ntv.gencode(8);// call *0x08(esi) putLN
}
} else if(tok.skip("for")) { blocksCount++;
asgmt();
if(!tok.skip(",")) error("error: %d: expected ','", tok.tok[tok.pos].nline);
make_while();
} else if(tok.skip("while")) { blocksCount++;
make_while();
} else if(tok.skip("return")) {
make_return();
} else if(tok.skip("if")) { blocksCount++;
make_if();
} else if(tok.skip("else")) {
uint32_t end;
ntv.gencode(0xe9); end = ntv.count; ntv.gencode_int32(0);// jmp while end
ntv.gencode_int32_insert(ntv.count - pos - 4, pos);
eval(end, BLOCK_NORMAL);
return 1;
} else if(tok.skip("elsif")) {
uint32_t endif, end;
ntv.gencode(0xe9); endif = ntv.count; ntv.gencode_int32(0);// jmp while end
ntv.gencode_int32_insert(ntv.count - pos - 4, pos);
expr_entry(); // if condition
ntv.gencode(0x83); ntv.gencode(0xf8); ntv.gencode(0x00);// cmp eax, 0
ntv.gencode(0x75); ntv.gencode(0x05); // jne 5
tok.skip(";");
ntv.gencode(0xe9); end = ntv.count; ntv.gencode_int32(0);// jmp while end
eval(end, BLOCK_NORMAL);
ntv.gencode_int32_insert(ntv.count - endif - 4, endif);
return 1;
} else if(tok.skip("break")) {
make_break();
} else if(tok.skip("end")) { blocksCount--;
if(status == NON) return 1;
if(status == BLOCK_NORMAL) {
ntv.gencode_int32_insert(ntv.count - pos - 4, pos);
} else if(status == BLOCK_FUNC) funcs.inside = false;
return 1;
} else if(!tok.skip(";")) {
expr_entry();
}
return 0;
}
