static void
generate_cast_expression(DVM_Executable *exe, Block *block,
Expression *expr, OpcodeBuf *ob)
{
generate_expression(exe, block, expr->u.cast.operand, ob);
switch (expr->u.cast.type) {
case INT_TO_DOUBLE_CAST:
generate_code(ob, expr->line_number, DVM_CAST_INT_TO_DOUBLE);
break;
case DOUBLE_TO_INT_CAST:
generate_code(ob, expr->line_number, DVM_CAST_DOUBLE_TO_INT);
break;
case BOOLEAN_TO_STRING_CAST:
generate_code(ob, expr->line_number, DVM_CAST_BOOLEAN_TO_STRING);
break;
case INT_TO_STRING_CAST:
generate_code(ob, expr->line_number, DVM_CAST_INT_TO_STRING);
break;
case DOUBLE_TO_STRING_CAST:
generate_code(ob, expr->line_number, DVM_CAST_DOUBLE_TO_STRING);
break;
default:
DBG_assert(0, ("expr->u.cast.type..%d", expr->u.cast.type));
}
}
static void
generate_identifier_expression(DVM_Executable *exe, Block *block,
Expression *expr, OpcodeBuf *ob)
{
if (expr->u.identifier.is_function) {
generate_code(ob, expr->line_number,
DVM_PUSH_FUNCTION,
expr->u.identifier.u.function->index);
return;
}
if (expr->u.identifier.u.declaration->is_local) {
generate_code(ob, expr->line_number,
DVM_PUSH_STACK_INT
+ get_opcode_type_offset(expr->u.identifier
.u.declaration
->type->basic_type),
expr->u.identifier.u.declaration->variable_index);
} else {
generate_code(ob, expr->line_number,
DVM_PUSH_STATIC_INT
+ get_opcode_type_offset(expr->u.identifier
.u.declaration
->type->basic_type),
expr->u.identifier.u.declaration->variable_index);
}
}
static void
generate_while_statement(DVM_Executable *exe, Block *block,
Statement *statement, OpcodeBuf *ob)
{
int loop_label;
WhileStatement *while_s = &statement->u.while_s;
loop_label = get_label(ob);
set_label(ob, loop_label);
generate_expression(exe, block, while_s->condition, ob);
while_s->block->parent.statement.break_label = get_label(ob);
while_s->block->parent.statement.continue_label = get_label(ob);
generate_code(ob, statement->line_number,
DVM_JUMP_IF_FALSE,
while_s->block->parent.statement.break_label);
generate_statement_list(exe, while_s->block,
while_s->block->statement_list, ob);
set_label(ob, while_s->block->parent.statement.continue_label);
generate_code(ob, statement->line_number, DVM_JUMP, loop_label);
set_label(ob, while_s->block->parent.statement.break_label);
}
static void
generate_boolean_expression(DVM_Executable *cf, Expression *expr,
OpcodeBuf *ob)
{
if (expr->u.boolean_value) {
generate_code(ob, expr->line_number, DVM_PUSH_INT_1BYTE, 1);
} else {
generate_code(ob, expr->line_number, DVM_PUSH_INT_1BYTE, 0);
}
}
/*
@function build_code
@desc generates the string codes given the tree
NOTE: makes use of the global variable root
*/
void generate_code(struct tnode* root,int depth)
{
int symbol;
int len; /*length of code*/
if(root->isleaf)
{
symbol=root->symbol;
len =depth;
while( len > 0)
{
//travese back up the tree
//adding 1 if child node has same
//symbol as root and is on the right.
//adding 0 if child node has same 'symbol'
//and is the left child node to the root
struct tnode * parent = NULL;
parent = root->parent;
parent->symbol = root->symbol;
if(parent == NULL)
{
len--;
continue;
}
if(parent->left->symbol ==root->symbol)
{
code[symbol][len -1] = '0';
}
else if(parent->right->symbol == root->symbol)
{
code[symbol][len -1] = '1';
}
len--;
root = parent;
}
printf("built code:%c,%s\n",symbol,code[symbol]);
}
else
{
generate_code(root->left,depth+1);
generate_code(root->right,depth+1);
}
}
static void
generate_logical_or_expression(DVM_Executable *exe, Block *block,
Expression *expr,
OpcodeBuf *ob)
{
int true_label;
true_label = get_label(ob);
generate_expression(exe, block, expr->u.binary_expression.left, ob);
generate_code(ob, expr->line_number, DVM_DUPLICATE);
generate_code(ob, expr->line_number, DVM_JUMP_IF_TRUE, true_label);
generate_expression(exe, block, expr->u.binary_expression.right, ob);
generate_code(ob, expr->line_number, DVM_LOGICAL_OR);
set_label(ob, true_label);
}
static void
generate_logical_and_expression(DVM_Executable *exe, Block *block,
Expression *expr,
OpcodeBuf *ob)
{
int false_label;
false_label = get_label(ob);
generate_expression(exe, block, expr->u.binary_expression.left, ob);
generate_code(ob, expr->line_number, DVM_DUPLICATE);
generate_code(ob, expr->line_number, DVM_JUMP_IF_FALSE, false_label);
generate_expression(exe, block, expr->u.binary_expression.right, ob);
generate_code(ob, expr->line_number, DVM_LOGICAL_AND);
set_label(ob, false_label);
}
static int generate_test(struct TestCase *test, int *test_i)
{
if (test->next)
generate_test(test->next, test_i);
*test_i += 1;
fprintf(fout, " subroutine funit_test%i(funit_passed_, funit_message_)\n",
*test_i);
fputs(" implicit none\n\n", fout);
fputs(" logical, intent(out) :: funit_passed_\n", fout);
fputs(" character(*), intent(out) :: funit_message_\n", fout);
if (test->need_array_iterator)
fputs(" integer :: funit_i_\n", fout);
fputs("\n", fout);
if (test->code) {
if (generate_code(test->code))
return -1;
}
fputs("\n funit_passed_ = .true.\n", fout);
fprintf(fout, " end subroutine funit_test%i\n\n", *test_i);
return 0;
}
/* Create header and code file. */
void
output_code (const char *const cfilename, const char *hfilename, const struct parsed_infile *const pf)
{
if (hfilename != 0)
{
char *filename_macro;
/* Determine filename macro. */
{
size_t i, len;
const char *read_ptr;
char *write_ptr;
if ((read_ptr = strrchr (hfilename, '/')) == 0 || *++read_ptr == '/')
read_ptr = hfilename;
len = strlen (read_ptr);
if (len > 2 && hfilename [len - 1] == 'h' && hfilename [len - 2] == '.')
len -= 2;
filename_macro = write_ptr = xmalloc (len + 1);
for (i = 0; i < len; ++i)
{
if (ISALNUM ((unsigned char)*read_ptr))
*write_ptr++ = TOUPPER ((unsigned char)*read_ptr);
else
*write_ptr++ = '_';
++read_ptr;
}
*write_ptr = '\0';
}
/* Generate header file. */
{
FILE *const f = fopen (hfilename, "w");
if (f == 0 || generate_header (f, filename_macro, pf) == -1 || fclose (f) == EOF)
{
fprintf (stderr, "%s: %s: %s\n", invocation_name, hfilename, strerror (errno));
exit (2);
}
}
free (filename_macro);
}
/* Generate code file. */
{
FILE *const f = cfilename != 0 ? fopen (cfilename, "w") : stdout;
if (f == 0 || generate_code (f, pf) == -1 || (cfilename != 0 && fclose (f) == EOF))
{
fprintf (stderr, "%s: %s: %s\n", invocation_name, cfilename != 0 ? cfilename : "STDOUT", strerror (errno));
exit (2);
}
}
}
static void
generate_pop_to_identifier(Declaration *decl, int line_number,
OpcodeBuf *ob)
{
if (decl->is_local) {
generate_code(ob, line_number,
DVM_POP_STACK_INT
+ get_opcode_type_offset(decl->type->basic_type),
decl->variable_index);
} else {
generate_code(ob, line_number,
DVM_POP_STATIC_INT
+ get_opcode_type_offset(decl->type->basic_type),
decl->variable_index);
}
}
const unsigned *
vec4_generator::generate_assembly(const cfg_t *cfg,
unsigned *assembly_size)
{
brw_set_default_access_mode(p, BRW_ALIGN_16);
generate_code(cfg);
return brw_get_program(p, assembly_size);
}
const unsigned *
vec4_generator::generate_assembly(exec_list *instructions,
unsigned *assembly_size)
{
brw_set_default_access_mode(p, BRW_ALIGN_16);
generate_code(instructions);
return brw_get_program(p, assembly_size);
}
static void
generate_double_expression(DVM_Executable *cf, Expression *expr,
OpcodeBuf *ob)
{
DVM_ConstantPool cp;
int cp_idx;
if (expr->u.double_value == 0.0) {
generate_code(ob, expr->line_number, DVM_PUSH_DOUBLE_0);
} else if (expr->u.double_value == 1.0) {
generate_code(ob, expr->line_number, DVM_PUSH_DOUBLE_1);
} else {
cp.tag = DVM_CONSTANT_DOUBLE;
cp.u.c_double = expr->u.double_value;
cp_idx = add_constant_pool(cf, &cp);
generate_code(ob, expr->line_number, DVM_PUSH_DOUBLE, cp_idx);
}
}
lua_candidate_action_wrapper_external(rca_context& context, const config& cfg, lua_ai_context &lua_ai_ctx)
: lua_candidate_action_wrapper_base(context,cfg), location_(cfg["location"])
{
std::string eval_code;
std::string exec_code;
generate_code(eval_code, exec_code);
evaluation_action_handler_ = boost::shared_ptr<lua_ai_action_handler>(resources::lua_kernel->create_lua_ai_action_handler(eval_code.c_str(),lua_ai_ctx));
execution_action_handler_ = boost::shared_ptr<lua_ai_action_handler>(resources::lua_kernel->create_lua_ai_action_handler(exec_code.c_str(),lua_ai_ctx));
}
static void
generate_return_statement(DVM_Executable *exe, Block *block,
Statement *statement, OpcodeBuf *ob)
{
DBG_assert(statement->u.return_s.return_value != NULL,
("return value is null."));
generate_expression(exe, block, statement->u.return_s.return_value, ob);
generate_code(ob, statement->line_number, DVM_RETURN);
}
/*
@function generate_code
@desc generates the string codes given the tree
NOTE: makes use of the global variable root
*/
void generate_code(struct tnode* root, int depth)
{
int symbol;
int len; /*length of code*/
int i = 0;
struct tnode * curr;
if (root->isleaf)
{
symbol = root->symbol;
len = depth;
/*start backwards*/
code[symbol][len] = 0;
/*
TODO: follow parent pointer to the top
to generate the code string
*/
curr = root;
while (!(curr->parent == NULL)) {
//루트에 도달할 때까지 돈다(부모가 NULL 이면 루트다)
if (curr->parent->left == curr) {
//현재 커서가 부모의 왼쪽 자식과 동일하다 : '0'
code[symbol][--len] = '0';
}
else if (curr->parent->right == curr) {
//현재 커서가 부모의 오른쪽 자식과 동일하다 : '1'
code[symbol][--len] = '1';
}
else {
//이건 삐꾸다
}
curr = curr->parent;
}
}
else
{
generate_code(root->left, depth + 1);
generate_code(root->right, depth + 1);
}
}
static void
generate_inc_dec_expression(DVM_Executable *exe, Block *block,
Expression *expr, ExpressionKind kind,
OpcodeBuf *ob, DVM_Boolean is_toplevel)
{
generate_expression(exe, block, expr->u.inc_dec.operand, ob);
if (kind == INCREMENT_EXPRESSION) {
generate_code(ob, expr->line_number, DVM_INCREMENT);
} else {
DBG_assert(kind == DECREMENT_EXPRESSION, ("kind..%d\n", kind));
generate_code(ob, expr->line_number, DVM_DECREMENT);
}
if (!is_toplevel) {
generate_code(ob, expr->line_number, DVM_DUPLICATE);
}
generate_pop_to_identifier(expr->u.inc_dec.operand
->u.identifier.u.declaration,
expr->line_number,
ob);
}
static void
generate_string_expression(DVM_Executable *cf, Expression *expr,
OpcodeBuf *ob)
{
DVM_ConstantPool cp;
int cp_idx;
cp.tag = DVM_CONSTANT_STRING;
cp.u.c_string = expr->u.string_value;
cp_idx = add_constant_pool(cf, &cp);
generate_code(ob, expr->line_number, DVM_PUSH_STRING, cp_idx);
}
static void
generate_int_expression(DVM_Executable *cf, Expression *expr,
OpcodeBuf *ob)
{
DVM_ConstantPool cp;
int cp_idx;
if (expr->u.int_value >= 0 && expr->u.int_value < 256) {
generate_code(ob, expr->line_number,
DVM_PUSH_INT_1BYTE, expr->u.int_value);
} else if (expr->u.int_value >= 0 && expr->u.int_value < 65536) {
generate_code(ob, expr->line_number,
DVM_PUSH_INT_2BYTE, expr->u.int_value);
} else {
cp.tag = DVM_CONSTANT_INT;
cp.u.c_int = expr->u.int_value;
cp_idx = add_constant_pool(cf, &cp);
generate_code(ob, expr->line_number, DVM_PUSH_INT, cp_idx);
}
}
/*
@function build_code
@desc generates the string codes given the tree
NOTE: makes use of the global variable root
*/
void generate_code(struct tnode* root,int depth) {
int symbol;
int len; /*length of code*/
if(root->isleaf) {
symbol = root->symbol;
len = depth;
code[symbol][len] = '\0';
while (root->parent != NULL) {
len--;
if (root->parent->right == root) {
code[symbol][len] = '1';
} else {
code[symbol][len] = '0';
}
root = root->parent;
}
printf("built code:%c,%s\n",symbol,code[symbol]);
} else {
generate_code(root->left,depth+1);
generate_code(root->right,depth+1);
}
}
static void
generate_function_call_expression(DVM_Executable *exe, Block *block,
Expression *expr, OpcodeBuf *ob)
{
FunctionCallExpression *fce = &expr->u.function_call_expression;
ArgumentList *arg_pos;
for (arg_pos = fce->argument; arg_pos; arg_pos = arg_pos->next) {
generate_expression(exe, block, arg_pos->expression, ob);
}
generate_expression(exe, block, fce->function, ob);
generate_code(ob, expr->line_number, DVM_INVOKE);
}
static void
generate_for_statement(DVM_Executable *exe, Block *block,
Statement *statement, OpcodeBuf *ob)
{
int loop_label;
ForStatement *for_s = &statement->u.for_s;
if (for_s->init) {
generate_expression_statement(exe, block, for_s->init, ob);
}
loop_label = get_label(ob);
set_label(ob, loop_label);
if (for_s->condition) {
generate_expression(exe, block, for_s->condition, ob);
}
for_s->block->parent.statement.break_label = get_label(ob);
for_s->block->parent.statement.continue_label = get_label(ob);
if (for_s->condition) {
generate_code(ob, statement->line_number,
DVM_JUMP_IF_FALSE,
for_s->block->parent.statement.break_label);
}
generate_statement_list(exe, for_s->block,
for_s->block->statement_list, ob);
set_label(ob, for_s->block->parent.statement.continue_label);
if (for_s->post) {
generate_expression_statement(exe, block, for_s->post, ob);
}
generate_code(ob, statement->line_number,
DVM_JUMP, loop_label);
set_label(ob, for_s->block->parent.statement.break_label);
}
/**
* Searches for a tag with the specified name in an outline item. If the tag
* exists and has a value, the function emits the value and returns 1.
* Otherwise, the function returns -1. Returns 0 for errors.
*/
int generate_lookup_tag(Pool *pool, FILE *out, AstLookup *p)
{
ListNode *tag;
for (tag = p->item->tags; tag; tag = tag->next) {
AstOutlineTag *t = ast_to_outline_tag(tag->d);
if (t->value && string_equal(t->name, p->name)) {
CHECK(generate_code(pool, out, t->value));
return 1;
}
}
return -1;
}
/**
* Performs code-generation into the output file given in the options.
*/
int main_generate(Pool *pool, ListNode *code, Options *opt)
{
String filename = string_copy(pool, opt->name_out);
FILE *file_out = fopen(filename.p, "wb");
if (!file_out) {
fprintf(stderr, "error: Could not open output file \"%s\"\n", filename.p);
return 1;
}
CHECK(generate_code(pool, file_out, code));
fclose(file_out);
return 1;
}
void
trvalue_integer::load(std::ostream& output, const std::string& reg)
{
/**
* @todo Evaluate the size of the value:
* * <=2 bytes; Use move.
* * <=3 bytes; Use push and pop.
* * =4 bytes; Need to store the value in the binary and retreive it.
*/
output << "\tpush\t\t";
generate_code(output);
output << '\n';
output << "\tpop\t\t" << reg << '\n';
}
lua_candidate_action_wrapper_external(rca_context& context, const config& cfg, lua_ai_context &lua_ai_ctx)
: lua_candidate_action_wrapper_base(context,cfg), location_(cfg["location"]), use_parms_(false)
{
if (cfg.has_attribute("exec_parms") || cfg.has_attribute("eval_parms")) {
use_parms_ = true;
exec_parms_ = cfg["exec_parms"].str();
eval_parms_ = cfg["eval_parms"].str();
}
std::string eval_code;
std::string exec_code;
generate_code(eval_code, exec_code);
evaluation_action_handler_ = std::shared_ptr<lua_ai_action_handler>(resources::lua_kernel->create_lua_ai_action_handler(eval_code.c_str(),lua_ai_ctx));
execution_action_handler_ = std::shared_ptr<lua_ai_action_handler>(resources::lua_kernel->create_lua_ai_action_handler(exec_code.c_str(),lua_ai_ctx));
}
static void
generate_expression_statement(DVM_Executable *exe, Block *block,
Expression *expr, OpcodeBuf *ob)
{
if (expr->kind == ASSIGN_EXPRESSION) {
generate_assign_expression(exe, block, expr, ob, DVM_TRUE);
} else if (expr->kind == INCREMENT_EXPRESSION
|| expr->kind == DECREMENT_EXPRESSION) {
generate_inc_dec_expression(exe, block, expr, expr->kind, ob,
DVM_TRUE);
} else {
generate_expression(exe, block, expr, ob);
generate_code(ob, expr->line_number, DVM_POP);
}
}
static void
generate_if_statement(DVM_Executable *exe, Block *block,
Statement *statement, OpcodeBuf *ob)
{
int if_false_label;
int end_label;
IfStatement *if_s = &statement->u.if_s;
Elsif *elsif;
generate_expression(exe, block, if_s->condition, ob);
if_false_label = get_label(ob);
generate_code(ob, statement->line_number,
DVM_JUMP_IF_FALSE, if_false_label);
generate_statement_list(exe, if_s->then_block,
if_s->then_block->statement_list, ob);
end_label = get_label(ob);
generate_code(ob, statement->line_number, DVM_JUMP, end_label);
set_label(ob, if_false_label);
for (elsif = if_s->elsif_list; elsif; elsif = elsif->next) {
generate_expression(exe, block, elsif->condition, ob);
if_false_label = get_label(ob);
generate_code(ob, statement->line_number, DVM_JUMP_IF_FALSE,
if_false_label);
generate_statement_list(exe, elsif->block,
elsif->block->statement_list, ob);
generate_code(ob, statement->line_number, DVM_JUMP, end_label);
set_label(ob, if_false_label);
}
if (if_s->else_block) {
generate_statement_list(exe, if_s->else_block,
if_s->else_block->statement_list,
ob);
}
set_label(ob, end_label);
}
void parse(char *filename)
{
struct Process *proc;
//proc=(struct Process*)malloc(sizeof(struct Process));
//if(proc==NULL) die("errore nell'allocare struct Process");
//proc->pt=NULL;
//proc->pc=NULL;
//proc->prev=NULL;
//proc->next=NULL;
proc=NULL;
read_file(filename,&proc);
add_environment_costants(proc);
if(output_mode>=OUTPUT_DEBUG) print_data(proc);
generate_code(proc);
}
int main(int argc, char **argv)
{
int ret;
if (argc < 2)
return 0;
if (strcmp(argv[1], "--login") == 0) {
if (argc < 3) {
printf("useage: %s --login password\n", argv[0]);
return 1;
}
ret = login(argv[2], strlen(argv[2]));
if (ret < 0) {
printf("door: login failed\n");
} else {
printf("door: login success\n");
}
} else if (strcmp(argv[1], "--decryp") == 0) {
ret = decryp((unsigned char*)"opendoor", 8);
if (ret)
printf("decryp failed\n");
else
printf("decryp success\n");
} else if (strcmp(argv[1], "--generate") == 0) {
if (argc < 4) {
printf("useage: %s --generate password output\n", argv[0]);
return 1;
}
generate_code((unsigned char*)argv[2], strlen(argv[2]), argv[3]);
} else if (strcmp(argv[1], "--verify") == 0) {
if (argc < 3) {
printf("useage: %s --verify password\n", argv[0]);
return 1;
}
if (verify_password((unsigned char*)argv[2], strlen(argv[2])) == 0)
printf("passed\n");
else
printf("failed\n");
} else if (strcmp(argv[1], "--clear") == 0) {
logout();
} else {
printf("useage: %s -[ldgv]\n", argv[0]);
}
return 0;
}
