int main() {
FILE *ys = fopen("./sample.ys", "w");
int noRoot = 0; /* 0 means we will have a root */
symboltable_t *symtab;
list = NULL;
/* Build the tree */
error_out = stderr;
noRoot = yyparse();
if (parseError && (!noRoot))
fprintf(stderr, "WARNING: There were %d parse errors.\nParse tree may be ill-formed.\n", parseError);
if (noRoot)
fprintf(stderr, "Parsing reached fatal error. No AST was constructed\n");
/* Set up the symbol tree */
symtab = create_symboltable();
symtab = build_symboltable(symtab, root, root);
typecheck_ast(symtab, root);
int retval = typecheck_ast(symtab, root);
print_checked_ast(stdout, root, 0);
if (retval != 0) {
fprintf(stderr, "There were %d errors encountered in the parse tree. Aborting.\n", retval);
return 1;
}
print_ast(stdout, root, 0);
print_symtab(symtab);
code_gen(root, symtab);
print_symtab(symtab);
print_quad_list(stdout, list);
generate_assembly(ys, list, symtab);
return 0;
}
void run_code(const char* code) {
NExpression* root_expr = getAST(code);
if (root_expr == NULL) {
std::cout << "Root expression was null! Ahhhhhhhhhhhhh!" << std::endl;
return;
}
std::string error_str;
llvm::Module* module = new llvm::Module("top", llvm::getGlobalContext());
llvm::ExecutionEngine* execution_engine = llvm::EngineBuilder(module).setErrorStr(&error_str).setEngineKind(llvm::EngineKind::JIT).create();
CodeGen code_gen(module);
std::cout << "execution engine " << execution_engine << std::endl;
if (execution_engine == NULL) {
std::cout << "Unable to create execution engine." << std::endl;
return;
}
NFunction main_fn(root_expr, NType::int_ty());
// llvm::Value* root_val = root_expr->gen_code(&code_gen);
// std::cout << "Root val code:" << std::endl;
// root_val->dump();
llvm::Function* main_fn_val = (llvm::Function*) main_fn.gen_code(&code_gen);
std::cout << "Main fn code:" << std::endl;
main_fn_val->dump();
void* fn_ptr = execution_engine->getPointerToFunction(main_fn_val);
int32_t (*fn_ptr_native)() = (int32_t (*)()) fn_ptr;
int32_t ret = fn_ptr_native();
std::cout << "Main fn at " << fn_ptr << "; executed: " << ret << std::endl;
}
int main() {
int noRoot = 0; /* 0 means we will have a root */
symboltable_t *symtab;
list = NULL;
/* Build the tree */
error_out = stderr;
noRoot = yyparse();
if (parseError && (!noRoot))
fprintf(stderr, "WARNING: There were %d parse errors.\nParse tree may be ill-formed.\n", parseError);
if (noRoot)
fprintf(stderr, "Parsing reached fatal error. No AST was constructed\n");
/* Set up the symbol tree */
symtab = create_symboltable();
symtab = build_symboltable(symtab, root, root);
print_symtab(symtab);
print_ast(stdout, root, 0);
code_gen(root, symtab);
print_quad_list(stdout, list);
return 0;
}
virtual bool unparse_statement( SgStatement* stmt, SgUnparse_Info& info, UnparseFormat& f)
{
std::map<SgNode*, POETCode*>::const_iterator p = repl.find(stmt);
if (p == repl.end()) return false;
format=&f;
POETCode* c = (*p).second;
code_gen(out, c,0, 0, f.current_col());
return true;
}
void routine(ast* prog) {
// print Abstract Semantic Tree
print_ast_init();
print_ast(prog, 0);
print_ast_finish();
// Code style
print_ast_code_style(prog, 0);
// Type check
int res = type_check(prog);
if (res) {
return;
}
// Code gen
code_gen(prog);
}
/*----------------------------------------------------------------------------------------------*/
void Correlator::SamplePRN()
{
MIX *row;
int32_t lcv, lcv2, sv, k;
int32_t index;
float phase_step, phase;
k = 0;
for(sv = 0; sv < MAX_SV; sv++)
{
code_gen(&scratch[0], sv);
for(lcv = 0; lcv < 2*CODE_BINS+1; lcv++)
{
row = main_code_rows[k];
k++;
phase = -0.5 + (float)lcv/(float)CODE_BINS;
phase_step = CODE_RATE*INVERSE_SAMPLE_FREQUENCY;
for(lcv2 = 0; lcv2 < 2*SAMPS_MS; lcv2++)
{
index = (int32_t)floor(phase + CODE_CHIPS) % CODE_CHIPS;
if(scratch[index].i)
row[lcv2].i = row[lcv2].ni = 0x0001; /* Map 1 to 0x0000, and 0 to 0xffff for SIMD code */
else
row[lcv2].i = row[lcv2].ni = 0xffff;
row[lcv2].q = row[lcv2].nq = 0x0;
phase += phase_step;
}
}
}
}
void function_gen(char *name,struct ASTNode *body) {
int r1;
struct Gsymbol *g=GLookup(name);
fprintf(fp,"LL%d:\n",g->binding);
fprintf(fp,"PUSH BP\n");
fprintf(fp,"MOV BP SP\n");
struct Lsymbol *temp=LSymbolHead;
free_all_regs();
r1=get_reg();
while(temp) {
if(temp->ref==0) {
fprintf(fp,"PUSH R%d\n",r1);
}
temp=temp->next;
}
free_reg();
printf("ffefwefwef1\n");
code_gen(body);
r1=get_reg();
temp=LSymbolHead;
while(temp) {
if(temp->ref==0) {
fprintf(fp,"POP R%d\n",r1);
}
temp=temp->next;
}
free_reg();
free_all_regs();
fprintf(fp,"POP BP\n");
fprintf(fp,"RET\n");
}
void obj_code (uint4 src_lines, void *checksum_ctx)
{
int status;
rhdtyp rhead;
mline *mlx, *mly;
var_tabent *vptr;
int4 lnr_pad_len;
intrpt_state_t prev_intrpt_state;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
assert(!run_time);
obj_init();
/* Define the routine name global symbol. */
define_symbol(GTM_MODULE_DEF_PSECT, (mstr *)&int_module_name, 0);
memset(&rhead, 0, SIZEOF(rhead));
alloc_reg();
jmp_opto();
curr_addr = SIZEOF(rhdtyp);
cg_phase = CGP_APPROX_ADDR;
cg_phase_last = CGP_NOSTATE;
code_gen();
code_size = curr_addr;
cg_phase = CGP_ADDR_OPT;
shrink_jmps();
comp_lits(&rhead);
if ((cmd_qlf.qlf & CQ_MACHINE_CODE))
{
cg_phase = CGP_ASSEMBLY;
code_gen();
}
if (!(cmd_qlf.qlf & CQ_OBJECT))
return;
rhead.ptext_ptr = SIZEOF(rhead);
set_rtnhdr_checksum(&rhead, (gtm_rtn_src_chksum_ctx *)checksum_ctx);
rhead.vartab_ptr = code_size;
rhead.vartab_len = mvmax;
code_size += mvmax * SIZEOF(var_tabent);
rhead.labtab_ptr = code_size;
rhead.labtab_len = mlmax;
code_size += mlmax * SIZEOF(lab_tabent);
rhead.lnrtab_ptr = code_size;
rhead.lnrtab_len = src_lines;
rhead.compiler_qlf = cmd_qlf.qlf;
if (cmd_qlf.qlf & CQ_EMBED_SOURCE)
{
rhead.routine_source_offset = TREF(routine_source_offset);
rhead.routine_source_length = (uint4)(stringpool.free - stringpool.base) - TREF(routine_source_offset);
}
rhead.temp_mvals = sa_temps[TVAL_REF];
rhead.temp_size = sa_temps_offset[TCAD_REF];
code_size += src_lines * SIZEOF(int4);
lnr_pad_len = PADLEN(code_size, SECTION_ALIGN_BOUNDARY);
code_size += lnr_pad_len;
DEFER_INTERRUPTS(INTRPT_IN_OBJECT_FILE_COMPILE, prev_intrpt_state);
create_object_file(&rhead);
ENABLE_INTERRUPTS(INTRPT_IN_OBJECT_FILE_COMPILE, prev_intrpt_state);
cg_phase = CGP_MACHINE;
code_gen();
/* Variable table: */
vptr = (var_tabent *)mcalloc(mvmax * SIZEOF(var_tabent));
if (mvartab)
walktree(mvartab, cg_var, (char *)&vptr);
else
assert(0 == mvmax);
emit_immed((char *)vptr, mvmax * SIZEOF(var_tabent));
/* Label table: */
if (mlabtab)
walktree((mvar *)mlabtab, cg_lab, (char *)rhead.lnrtab_ptr);
else
assert(0 == mlmax);
/* External entry definitions: */
emit_immed((char *)&(mline_root.externalentry->rtaddr), SIZEOF(mline_root.externalentry->rtaddr)); /* line 0 */
for (mlx = mline_root.child; mlx; mlx = mly)
{
if (mlx->table)
emit_immed((char *)&(mlx->externalentry->rtaddr), SIZEOF(mlx->externalentry->rtaddr));
if (0 == (mly = mlx->child)) /* note assignment */
if (0 == (mly = mlx->sibling)) /* note assignment */
for (mly = mlx; ; )
{
if (0 == (mly = mly->parent)) /* note assignment */
break;
if (mly->sibling)
{
mly = mly->sibling;
break;
}
}
}
if (0 != lnr_pad_len) /* emit padding so literal text pool starts on proper boundary */
emit_immed(PADCHARS, lnr_pad_len);
# if !defined(__MVS__) && !defined(__s390__) /* assert not valid for instructions on OS390 */
assert(code_size == psect_use_tab[GTM_CODE]);
# endif
emit_literals();
DEFER_INTERRUPTS(INTRPT_IN_OBJECT_FILE_COMPILE, prev_intrpt_state);
finish_object_file();
ENABLE_INTERRUPTS(INTRPT_IN_OBJECT_FILE_COMPILE, prev_intrpt_state);
CLOSE_OBJECT_FILE(object_file_des, status);
if (-1 == status)
rts_error_csa(CSA_ARG(NULL) VARLSTCNT(8) ERR_SYSCALL, 5, RTS_ERROR_LITERAL("close()"), CALLFROM, errno);
/* Ready to make object visible. Rename from tmp name to real routine name */
RENAME_TMP_OBJECT_FILE(object_file_name);
}
void obj_code (uint4 src_lines, uint4 checksum)
{
rhdtyp rhead;
mline *mlx, *mly;
var_tabent *vptr;
int4 lnr_pad_len;
assert(!run_time);
obj_init();
/* Define the routine name global symbol. */
define_symbol(GTM_MODULE_DEF_PSECT, (mstr *)&int_module_name, 0);
memset(&rhead, 0, SIZEOF(rhead));
alloc_reg();
jmp_opto();
curr_addr = SIZEOF(rhdtyp);
cg_phase = CGP_APPROX_ADDR;
cg_phase_last = CGP_NOSTATE;
code_gen();
code_size = curr_addr;
cg_phase = CGP_ADDR_OPT;
shrink_jmps();
comp_lits(&rhead);
if ((cmd_qlf.qlf & CQ_MACHINE_CODE))
{
cg_phase = CGP_ASSEMBLY;
code_gen();
}
if (!(cmd_qlf.qlf & CQ_OBJECT))
return;
rhead.ptext_ptr = SIZEOF(rhead);
rhead.checksum = checksum;
rhead.vartab_ptr = code_size;
rhead.vartab_len = mvmax;
code_size += mvmax * SIZEOF(var_tabent);
rhead.labtab_ptr = code_size;
rhead.labtab_len = mlmax;
code_size += mlmax * SIZEOF(lab_tabent);
rhead.lnrtab_ptr = code_size;
rhead.lnrtab_len = src_lines;
rhead.compiler_qlf = cmd_qlf.qlf;
rhead.temp_mvals = sa_temps[TVAL_REF];
rhead.temp_size = sa_temps_offset[TCAD_REF];
code_size += src_lines * SIZEOF(int4);
lnr_pad_len = PADLEN(code_size, SECTION_ALIGN_BOUNDARY);
code_size += lnr_pad_len;
create_object_file(&rhead);
cg_phase = CGP_MACHINE;
code_gen();
/* Variable table: */
vptr = (var_tabent *)mcalloc(mvmax * SIZEOF(var_tabent));
if (mvartab)
walktree(mvartab, cg_var, (char *)&vptr);
else
assert(0 == mvmax);
emit_immed((char *)vptr, mvmax * SIZEOF(var_tabent));
/* Label table: */
if (mlabtab)
walktree((mvar *)mlabtab, cg_lab, (char *)rhead.lnrtab_ptr);
else
assert(0 == mlmax);
/* External entry definitions: */
emit_immed((char *)&(mline_root.externalentry->rtaddr), SIZEOF(mline_root.externalentry->rtaddr)); /* line 0 */
for (mlx = mline_root.child; mlx; mlx = mly)
{
if (mlx->table)
emit_immed((char *)&(mlx->externalentry->rtaddr), SIZEOF(mlx->externalentry->rtaddr));
if (0 == (mly = mlx->child)) /* note assignment */
if (0 == (mly = mlx->sibling)) /* note assignment */
for (mly = mlx; ; )
{
if (0 == (mly = mly->parent)) /* note assignment */
break;
if (mly->sibling)
{
mly = mly->sibling;
break;
}
}
}
if (0 != lnr_pad_len) /* emit padding so literal text pool starts on proper boundary */
emit_immed(PADCHARS, lnr_pad_len);
#if !defined(__MVS__) && !defined(__s390__) /* assert not valid for instructions on OS390 */
assert(code_size == psect_use_tab[GTM_CODE]);
#endif
emit_literals();
close_object_file();
}
void POETAstInterface::unparse(POETCode_ext* n, std::ostream& out, int align)
{
static SgUnparse_Info info;
static Unparser* roseUnparser = 0;
static POETCode* linebreak=ASTFactory::inst()->new_string("\n");
static POETCode* comma=ASTFactory::inst()->new_string(",");
static bool template_only=false;
static POETCode* left_over = 0;
SgNode * input = (SgNode*)n->get_content();
POETCode* res = POETAstInterface::find_Ast2POET(input);
if (res == n) {
if (template_only && input->variantT() == V_SgFunctionDeclaration)
{ left_over = LIST(n,left_over); }
else {
std::string res = input->unparseToCompleteString();
out << res;
}
}
else {
if (roseUnparser == 0) {
/* QY/2013: copied from the global unparseFile to use a different ostream and delegate*/
bool UseAutoKeyword = false;
bool generateLineDirectives = true;
bool useOverloadedOperators = false;
bool num = false;
bool _this = true;
bool caststring = false;
bool _debug = false;
bool _class = false;
bool _forced_transformation_format = false;
bool _unparse_includes = false;
Unparser_Opt roseOptions( UseAutoKeyword,
generateLineDirectives,
useOverloadedOperators,
num,
_this,
caststring,
_debug,
_class,
_forced_transformation_format,
_unparse_includes );
roseUnparser = new Unparser(&out, "", roseOptions);
}
switch (input->variantT()) {
case V_SgSourceFile:
{
SgSourceFile* f = isSgSourceFile(input);
info.set_current_scope(f->get_globalScope());
template_only = true;
code_gen(out, n->get_children(), 0, 0, align);
template_only = false;
if (left_over != 0) {
code_gen(out, left_over, 0, 0, align);
left_over = 0;
}
break;
}
case V_SgFunctionDeclaration:
if (template_only) { left_over = LIST(n, left_over); break; }
case V_SgTemplateInstantiationFunctionDecl:
{
SgFunctionDeclaration* d = isSgFunctionDeclaration(input);
roseUnparser->u_exprStmt->unparseAttachedPreprocessingInfo(d,info,PreprocessingInfo::before);
POETCode_ext_delegate repl(n, out);
roseUnparser->repl = &repl;
roseUnparser->u_exprStmt->unparseFuncDeclStmt(d, info);
break;
}
case V_SgFunctionDefinition:
{
SgStatement* d = isSgStatement(input);
POETCode_ext_delegate repl(n, out);
roseUnparser->repl = &repl;
roseUnparser->u_exprStmt->unparseStatement(d, info);
assert(n->get_children() != n);
out << "{"; code_gen(out, linebreak, 0, 0, align + 2);
code_gen(out, n->get_children(), 0, linebreak, align+2);
code_gen(out, linebreak, 0, 0, align); out << "}";
break;
}
case V_SgPragmaDeclaration:
{
out << "#pragma ";
POETTuple* c = dynamic_cast<POETTuple*>(n->get_children());
assert(c != 0);
code_gen(out, c->get_entry(0));
roseUnparser->cur << " "; roseUnparser->cur.insert_newline(1,align);
code_gen(out, c->get_entry(1), 0, 0, align);
break;
}
case V_SgForStatement:
{
out << "for (" ;
POETTuple* c = dynamic_cast<POETTuple*>(n->get_children());
assert(c != 0);
code_gen(out, c->get_entry(0));
code_gen(out, c->get_entry(1)); out << ";";
code_gen(out, c->get_entry(2)); out << ")";
break;
}
case V_SgExprStatement:
code_gen(out, n->get_children(), 0, 0, align);
out << ";";
break;
case V_SgTemplateInstantiationMemberFunctionDecl: break;
default:
std::cerr << "Unsupported unparsing for : " << input->class_name() << input->unparseToString() << "\n";
//assert(0);
}
}
}
int main(int argc, char** argv)
{
//argc == 2 --> only the source file is given
//argc == 4 --> source file and target C file is given
if (argc != 2 && argc != 4) { //only 2 and 4 is accepted
print_usage(argv[0]);
return -1;
//if the output file is given, flag must be -o
} else if (argc == 4 && std::string(argv[2]) != "-o") {
std::cout << "Error: Output file must be given after -o flag"
<< std::endl;
return -2;
}
//argc == 2 or argc == 4
const std::string Source_name = argv[1];
const std::string Default_output_name = strip_extensions(Source_name) +".c";
// if we have only one cmd argument, produce a result with a default name.
const std::string Output_name = (argc == 2) ? Default_output_name : argv[3];
//preprocessor strips comments from the file without deleting any line
//this way, line numbers are preserved
Preprocessor pp;
const std::string Preprocessed_name = pp.remove_comments(Source_name);
//we work on the preprocessed file
std::ifstream source_file(Preprocessed_name.c_str());
if (!source_file) {
std::cout << Preprocessed_name << " couldn't be opened" << std::endl;
return -3;
}
SymbolTable sym_table;
Lexer lexer; //lexer tokenizes the source file
Parser parser(&sym_table); //parser does the syntax check
SemanticAnalyzer sem_analyze(&sym_table); //semantic checks
//generates the code. Does semantic checks on expressions
CodeGenerator code_gen(&sym_table);
std::string line; //holds the current line
int line_count = 0;
//stores the whole file as lines. Each line is a vector of tokens and a
//statement type and the line number. See definitions.hpp for more info
std::vector<stmt_with_info> source_as_tokens;
Regex empty_line_rgx(R"(^[[:space:]]*$)");
while (std::getline(source_file, line)) {
++line_count;
//whenever we see an empty line, we go to the next line
if (!empty_line_rgx.search(line)) {
try {
//tokenize the current line
auto token_vec = lexer.tokenize(line);
if (token_vec.empty()) {
continue;
}
//parser does syntax check on the token vector and returns
//what kind of statement this particular token vector is
auto stmt_category = parser.parse(token_vec);
source_as_tokens.emplace_back(token_vec, stmt_category, line_count);
} catch (std::runtime_error e) {
//embed line info to the error and quit the program
//no file is generated up to this point. Thus, no extra cleanup
std::cout << "Error (Line " << line_count << "): " <<
e.what() << std::endl;
return -4;
}
static void _parse_input(CTX *ctx)
{
static char *params = NULL;
int c = getch();
switch( c ) {
case KEY_UP:
_list_scroll( ctx, SCROLL_UP, 1 );
break;
case KEY_DOWN:
_list_scroll( ctx, SCROLL_DOWN, 1 );
break;
case KEY_NPAGE:
_list_scroll( ctx, SCROLL_DOWN, ctx->rows - 4 );
break;
case KEY_PPAGE:
_list_scroll( ctx, SCROLL_UP, ctx->rows - 4 );
break;
case '\n': /* edit & compile code */
{
char *func = ll_access( ctx->symbols.func, ctx->symbols.selected_offset );
char *sig = ll_access( ctx->symbols.sig, ctx->symbols.selected_offset );
char *lib = ll_access( ctx->symbols.lib, ctx->symbols.selected_offset );
/* check for signature */
/* the assumption here is that the sig by this stage has been validated elsewhere */
if( memcmp( sig, "??", 2 ) != 0 ) { /* has signature */
char path[500];
sprintf( path,
"%s/.preloader/%s-%s.%s.c",
getenv("HOME"),
ctx->hash,
_strip_path( ctx->filename ),
func );
/* check if file exists */
struct stat s;
/* populate if file doesn't exist or is empty */
if( stat( path, &s ) < 0 || !s.st_size ) {
FILE *f = fopen( path, "a" );
if( f ) {
char *code = code_gen( func, sig, _strip_path( lib ) );
if( code ) {
fwrite( code, 1, strlen( code ), f );
N_FREE( code );
}
fclose(f);
}
}
/* TODO: hard-coded to vim now; allow editor selection through config */
_exec_target( "vim", path, NULL, EXEC_NOPROMPT );
/* compile code */
/* remove previous object file */
char obj_path[500];
strncpy( obj_path, path, sizeof( obj_path )- 1 );
obj_path[strlen( obj_path ) - 1] = '\0';
strncat( obj_path, "o", sizeof( obj_path ) - 1);
_exec_target( "rm -f", obj_path, NULL, EXEC_NOPROMPT );
/* compile PIC code */
strncat( path, " -o ", sizeof( path ) - 1);
strncat( path, obj_path, sizeof( path ) - 1);
_exec_target( "gcc -fPIC -c", path, NULL, EXEC_NOPROMPT );
/* check if object file is present */
if( stat( obj_path, &s ) < 0 ) {
/* compilation failed */
_exec_target( "echo", "Compilation failed! Please fix errors.", NULL, EXEC_PROMPT );
ctx->symbols.flags[ctx->symbols.selected_offset] |= SYMBOL_INVALID;
ctx->symbols.flags[ctx->symbols.selected_offset] &= ~SYMBOL_SELECTED;
} else {
/* compilation succeeded */
ctx->symbols.flags[ctx->symbols.selected_offset] &= ~SYMBOL_INVALID;
}
} else { /* no signature */
_show_notification( ctx, "Please first enter a signature for this function!" );
}
}
break;
case 's': /* edit function signature */
{
char *sig = _get_input( ctx,
"function signature",
(char *)ll_access( ctx->symbols.sig,
ctx->symbols.selected_offset ) );
if( ( sig = _validate_sig( sig ) ) )
database_add_sig( ctx->db,
(char *)ll_access( ctx->symbols.func,
ctx->symbols.selected_offset ),
sig );
/* refresh sig list */
ctx->symbols.sig = database_get_sigs( ctx->db, &ctx->symbols.num_sigs );
}
break;
case 0x20: /* select symbol for preloading */
if( ctx->symbols.flags[ctx->symbols.selected_offset] & SYMBOL_INVALID ) {
_show_notification( ctx, "Could not compile this wrapper. Please check code!" );
} else {
ctx->symbols.flags[ctx->symbols.selected_offset] ^= SYMBOL_SELECTED;
}
break;
case 'r': /* enter params then execute */
/* todo: check if function with invalid code is selected */
{
char tmp[300];
sprintf( tmp, "'%s' args", _strip_path( ctx->filename ) );
params = _get_input( ctx, tmp, params );
}
case 'R': /* execute with previous params */
/* todo: check if function with invalid code is selected */
_exec_target( ctx->filename, params, NULL, EXEC_PROMPT );
break;
case 'q':
ctx->running = 0;
break;
}
}
int code_gen (struct ASTNode * root) {
int l1,l2,r,r1,r2,r3,r4,bind;
struct Fieldlist *field;
if(!root)
return 0;
switch(root->node) {
case NODETYPE_MUL :
r1=code_gen(root->ptr1);
GetVal(root->ptr1,r1);
r2=code_gen(root->ptr2);
GetVal(root->ptr2,r2);
fprintf(fp,"MUL R%d R%d\n",r1,r2);
free_reg();
return r1;
case NODETYPE_PLUS :
r1=code_gen(root->ptr1);
GetVal(root->ptr1,r1);
r2=code_gen(root->ptr2);
GetVal(root->ptr2,r2);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
free_reg();
return r1;
case NODETYPE_MINUS :
r1=code_gen(root->ptr1);
GetVal(root->ptr1,r1);
r2=code_gen(root->ptr2);
GetVal(root->ptr2,r2);
fprintf(fp,"SUB R%d R%d\n",r1,r2);
free_reg();
return r1;
case NODETYPE_MOD :
r1=code_gen(root->ptr1);
GetVal(root->ptr1,r1);
r2=code_gen(root->ptr2);
GetVal(root->ptr2,r2);
fprintf(fp,"MOD R%d R%d\n",r1,r2);
free_reg();
return r1;
case NODETYPE_DIV :
r1=code_gen(root->ptr1);
GetVal(root->ptr1,r1);
r2=code_gen(root->ptr2);
GetVal(root->ptr2,r2);
fprintf(fp,"DIV R%d R%d\n",r1,r2);
free_reg();
return r1;
case NODETYPE_FIELD_END:
r1=code_gen(root->ptr1);
field=IsField(root->ptr1->type,root->ptr2->name);
r2=get_reg();
fprintf(fp,"MOV R%d %d\n",r2,field->field_num);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
free_reg();
return r1;
case NODETYPE_FIELD:
r1=code_gen(root->ptr1);
field=IsField(root->ptr1->type,root->ptr2->name);
r2=get_reg();
fprintf(fp,"MOV R%d %d\n",r2,field->field_num);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
fprintf(fp,"MOV R%d [R%d]\n",r1,r1);
free_reg();
return r1;
case NODETYPE_ASGN_PAIR:
printf("frienas");
if(root->ptr2->node==NODETYPE_FUNC)
{
r1=code_gen(root->ptr2);
fprintf(fp, "// im here\n");
if(root->ptr1->Lentry)
{
r2=get_reg();
r3=get_reg();
fprintf(fp,"MOV R%d %d\n",r2,root->ptr1->Lentry->binding);
fprintf(fp,"MOV R%d BP\n",r3);
fprintf(fp,"ADD R%d R%d\n",r2,r3);
fprintf(fp,"MOV [R%d] [R%d]\n",r2,r1);
fprintf(fp,"INR R%d\n",r2);
fprintf(fp,"INR R%d\n",r1);
fprintf(fp,"MOV [R%d] [R%d]\n",r2,r1);
free_reg();
free_reg();
}
else
{ r2=get_reg();
fprintf(fp,"MOV R%d %d\n",r2,root->ptr1->Lentry->binding);
fprintf(fp,"MOV [R%d] [R%d]\n",r2,r1);
fprintf(fp,"INR R%d\n",r2);
fprintf(fp,"INR R%d\n",r1);
fprintf(fp,"MOV [R%d] [R%d]\n",r2,r1);
free_reg();
}
}
if(root->ptr1->Lentry && root->ptr2->Lentry)
{
printf("sfsf\n");
r1=get_reg();
r2=get_reg();
fprintf(fp,"MOV R%d %d\n",r1,root->ptr1->Lentry->binding);
fprintf(fp,"MOV R%d BP\n",r2);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
r3=get_reg();
fprintf(fp,"MOV R%d %d\n",r2,root->ptr2->Lentry->binding);
fprintf(fp,"MOV R%d BP\n",r3);
fprintf(fp,"ADD R%d R%d\n",r2,r3);
free_reg();
fprintf(fp,"MOV [R%d] [R%d]\n",r1,r2);
fprintf(fp,"INR R%d\n",r1);
fprintf(fp,"INR R%d\n",r2);
fprintf(fp,"MOV [R%d] [R%d]\n",r1,r2);
free_reg();
free_reg();
}
else if(root->ptr1->Gentry && root->ptr2->Lentry)
{
r1=get_reg();
r2=get_reg();
fprintf(fp,"MOV R%d %d\n",r1,root->ptr1->Gentry->binding);
r3=get_reg();
fprintf(fp,"MOV R%d %d\n",r2,root->ptr2->Lentry->binding);
fprintf(fp,"MOV R%d BP\n",r3);
fprintf(fp,"ADD R%d R%d\n",r2,r3);
free_reg();
fprintf(fp,"MOV [R%d] [R%d]\n",r1,r2);
fprintf(fp,"INR R%d\n",r1);
fprintf(fp,"INR R%d\n",r2);
fprintf(fp,"MOV [R%d] [R%d]\n",r1,r2);
free_reg();
free_reg();
}
else if(root->ptr1->Lentry && root->ptr2->Gentry)
{
printf("sfsf44\n");
r1=get_reg();
r2=get_reg();
fprintf(fp,"MOV R%d %d\n",r1,root->ptr1->Lentry->binding);
fprintf(fp,"MOV R%d BP\n",r2);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
fprintf(fp,"MOV R%d %d\n",r2,root->ptr2->Gentry->binding);
fprintf(fp,"MOV [R%d] [R%d]\n",r1,r2);
fprintf(fp,"INR R%d\n",r1);
fprintf(fp,"INR R%d\n",r2);
fprintf(fp,"MOV [R%d] [R%d]\n",r1,r2);
free_reg();
free_reg();
}
else if(root->ptr1->Gentry && root->ptr2->Gentry)
{
r1=get_reg();
r2=get_reg();
fprintf(fp,"MOV R%d %d\n",r1,root->ptr1->Gentry->binding);
fprintf(fp,"MOV R%d %d\n",r2,root->ptr2->Gentry->binding);
fprintf(fp,"MOV [R%d] [R%d]\n",r1,r2);
fprintf(fp,"INR R%d\n",r1);
fprintf(fp,"INR R%d\n",r2);
fprintf(fp,"MOV [R%d] [R%d]\n",r1,r2);
free_reg();
free_reg();
}
return 0;
case NODETYPE_FST:
printf("sfs\n");
if(root->ptr1->Lentry)
{
r1=get_reg();
r2=get_reg();
printf("sfs\n");
fprintf(fp,"MOV R%d %d\n",r1,root->ptr1->Lentry->binding);
fprintf(fp,"MOV R%d BP\n",r2);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
free_reg();
}
else if(root->ptr1->Gentry)
{ r1=get_reg();
printf("sfs2\n");
fprintf(fp,"MOV R%d %d\n",r1,root->ptr1->Gentry->binding);
}
if(root->ptr2->Lentry)
{
printf("erewr\n");
r2=get_reg();
r3=get_reg();
fprintf(fp,"MOV R%d %d\n",r2,root->ptr2->Lentry->binding);
fprintf(fp,"MOV R%d BP\n",r3);
fprintf(fp,"ADD R%d R%d\n",r2,r3);
free_reg();
if(root->ptr2->Lentry->ref=1)
{
fprintf(fp,"MOV R%d [R%d]\n",r2,r2);
}
fprintf(fp,"MOV [R%d] [R%d]\n",r1,r2);
free_reg();
free_reg();
}
else if(root->ptr2->Gentry)
{
printf("erewr2\n");
r2=get_reg();
fprintf(fp,"MOV R%d %d\n",r2,root->ptr2->Gentry->binding);
free_reg();
fprintf(fp,"MOV [R%d] [R%d]\n",r1,r2);
free_reg();
free_reg();
}
return 0;
case NODETYPE_SND:
if(root->ptr1->Lentry)
{
r1=get_reg();
r2=get_reg();
fprintf(fp,"MOV R%d %d\n",r1,root->ptr1->Lentry->binding);
fprintf(fp,"MOV R%d BP\n",r2);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
free_reg();
}
else if(root->ptr1->Gentry)
{ r1=get_reg();
fprintf(fp,"MOV R%d %d\n",r1,root->ptr1->Gentry->binding);
}
if(root->ptr2->Lentry)
{
r2=get_reg();
r3=get_reg();
fprintf(fp,"MOV R%d %d\n",r2,root->ptr2->Lentry->binding);
fprintf(fp,"MOV R%d BP\n",r3);
fprintf(fp,"ADD R%d R%d\n",r2,r3);
if(root->ptr2->Lentry->ref=1)
{
fprintf(fp,"MOV R%d [R%d]\n",r2,r2);
fprintf(fp, "DCR R%d\n",r2);
}
else
fprintf(fp, "INR R%d\n",r2);
free_reg();
fprintf(fp,"MOV [R%d] [R%d]\n",r1,r2);
free_reg();
free_reg();
}
else if(root->ptr2->Gentry)
{
r2=get_reg();
fprintf(fp,"MOV R%d %d\n",r2,root->ptr2->Gentry->binding);
fprintf(fp, "INR R%d\n",r2);
free_reg();
fprintf(fp,"MOV [R%d] [R%d]\n",r1,r2);
free_reg();
free_reg();
}
return 0;
case NODETYPE_PAIR:
r1=code_gen(root->ptr2);
r2=code_gen(root->ptr3);
r3=get_reg();
if(root->ptr1->Lentry)
{
r4=get_reg();
fprintf(fp,"MOV R%d %d\n",r3,root->ptr1->Lentry->binding);
fprintf(fp,"MOV R%d BP\n",r4);
fprintf(fp,"ADD R%d R%d\n",r3,r4);
free_reg();
fprintf(fp,"MOV [R%d] R%d\n",r3,r1);
fprintf(fp,"INR R%d\n",r3);
fprintf(fp,"MOV [R%d] R%d\n",r3,r2);
free_reg();
free_reg();
free_reg();
}
else if(root->ptr1->Gentry)
{
fprintf(fp,"MOV R%d %d\n",r3,root->ptr1->Gentry->binding);
fprintf(fp,"MOV [R%d] R%d\n",r3,r1);
fprintf(fp,"INR R%d\n",r3);
fprintf(fp,"MOV [R%d] R%d\n",r3,r2);
free_reg();
free_reg();
}
return 0;
case NODETYPE_MAIN:
printf("ffefwefwef\n");
fprintf(fp,"START\n");
fprintf(fp,"MOV SP 1750\n");
fprintf(fp,"MOV BP SP\n");
r1 = get_reg();
struct Lsymbol *Ltemp = LSymbolHead;
while(Ltemp != NULL){
if(Ltemp->ref==0){
fprintf(fp,"PUSH R%d\n",r1);
Ltemp = Ltemp->next;
}
}
fprintf(fp,"MAIN:\n");
free_reg();
code_gen(root->ptr1);
fprintf(fp,"HALT\n");
return 0;
case NODETYPE_ALLOC:
if(root->ptr1->node==NODETYPE_FIELD_END) {
r1=code_gen(root->ptr1);
fprintf(fp,"PUSH R0\n");
fprintf(fp,"PUSH R0\nPUSH R1\nPUSH R2\n");
fprintf(fp,"CALL LL2\n");
fprintf(fp,"POP R2\nPOP R1\nPOP R0\n");
r2=get_reg();
fprintf(fp,"POP R%d\n",r2);
fprintf(fp,"MOV [R%d] R%d\n",r1,r2);
free_reg();
free_reg();
}
else {
r1=get_reg();
r2=get_reg();
if(root->ptr1->Lentry) {
fprintf(fp,"MOV R%d BP\n",r1);
fprintf(fp,"MOV R%d %d\n",r2,root->ptr1->Lentry->binding);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
if(root->ptr1->Lentry->ref==2)
fprintf(fp,"MOV R%d [R%d]\n",r1,r1);
}
else {
fprintf(fp,"MOV R%d %d\n",r1,root->ptr1->Gentry->binding);
if(root->ptr1->ptr1) {
r2=code_gen(root->ptr1->ptr1);
fprintf(fp,"ADD R%d R%d\n",r1,r2);}
}
fprintf(fp,"PUSH R0\n");
fprintf(fp,"PUSH R0\nPUSH R1\nPUSH R2\n");
fprintf(fp,"CALL LL2\n");
fprintf(fp,"POP R2\nPOP R1\nPOP R0\n");
fprintf(fp,"POP R%d\n",r2);
fprintf(fp,"MOV [R%d] R%d\n ",r1,r2);
free_reg();
free_reg();
}
return 0;
case NODETYPE_INITIAL:
fprintf(fp,"PUSH R0\nPUSH R1\nPUSH R2\n");
fprintf(fp,"CALL LL0\n");
fprintf(fp,"POP R2\nPOP R1\nPOP R0\n");
return 0;
case NODETYPE_FREE:
if(root->ptr1->node==NODETYPE_FIELD_END) {
r1=code_gen(root->ptr1);
fprintf(fp,"PUSH R0\n");
fprintf(fp,"PUSH R1\nPUSH R2\nPUSH R3\n");
fprintf(fp,"PUSH R%d\n",r1);
fprintf(fp,"MOV R%d [R%d]\n",r1,r1);
fprintf(fp,"PUSH R%d\n",r1);
fprintf(fp,"CALL LL1\n");
fprintf(fp,"POP R%d\n",r1);
fprintf(fp,"POP R%d\n",r1);
fprintf(fp,"POP R3\nPOP R2\nPOP R1\nPOP R0\n");
free_reg();
}
else {
r1=get_reg();
r2=get_reg();
if(root->ptr1->Lentry) {
fprintf(fp,"MOV R%d BP\n",r1);
fprintf(fp,"MOV R%d %d\n",r2,root->ptr1->Lentry->binding);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
if(root->ptr1->Lentry->ref==2) {
fprintf(fp,"MOV R%d [R%d]\n",r1,r1);
}
}
else {
fprintf(fp,"MOV R%d %d\n",r1,root->ptr1->Gentry->binding);
if(root->ptr1->ptr1) {
r2=code_gen(root->ptr1->ptr1);
fprintf(fp,"ADD R%d R%d\n",r1,r2);}
}
fprintf(fp,"PUSH R0\n");
fprintf(fp,"PUSH R1\nPUSH R2\nPUSH R3\n");
fprintf(fp,"PUSH R%d\n",r1);
fprintf(fp,"MOV R%d [R%d]\n",r1,r1);
fprintf(fp,"PUSH R%d\n",r1);
fprintf(fp,"CALL LL1\n");
fprintf(fp,"POP R%d\n",r1);
fprintf(fp,"POP R%d\n",r1);
fprintf(fp,"POP R3\nPOP R2\nPOP R1\nPOP R0\n");
free_reg();
free_reg();
}
return 0;
case NODETYPE_LT :
r1=code_gen(root->ptr1);
GetVal(root->ptr1,r1);
r2=code_gen(root->ptr2);
GetVal(root->ptr2,r2);
fprintf(fp,"LT R%d R%d\n",r1,r2);
free_reg();
return r1;
case NODETYPE_FUNC:
;
fprintf(fp," // Before funtion call\n\n\n");
r=functioncall_gen(root);
return r;
case NODETYPE_LEAF:
r1=get_reg();
fprintf(fp,"MOV R%d %d\n",r1,root->val);
return r1;
case NODETYPE_LE :
r1=code_gen(root->ptr1);
GetVal(root->ptr1,r1);
r2=code_gen(root->ptr2);
GetVal(root->ptr2,r2);
fprintf(fp,"LE R%d R%d\n",r1,r2);
free_reg();
return r1;
case NODETYPE_AND:
r1 = code_gen(root->ptr1);
GetVal(root->ptr1,r1);
r2 = code_gen(root->ptr2);
GetVal(root->ptr2,r2);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
fprintf(fp,"MOV R%d 2\n",r2);
fprintf(fp,"EQ R%d R%d\n",r1,r2);
free_reg();
return r1;
break;
case NODETYPE_OR:
r1 = code_gen(root->ptr1);
GetVal(root->ptr1,r1);
r2 = code_gen(root->ptr2);
GetVal(root->ptr2,r2);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
fprintf(fp,"MOV R%d 0\n",r2);
fprintf(fp,"GE R%d R%d\n",r1,r2);
free_reg();
return r1;
break;
case NODETYPE_GE :
r1=code_gen(root->ptr1);
GetVal(root->ptr1,r1);
r2=code_gen(root->ptr2);
GetVal(root->ptr2,r2);
fprintf(fp,"GE R%d R%d\n",r1,r2);
free_reg();
return r1;
case NODETYPE_EQ :
r1=code_gen(root->ptr1);
GetVal(root->ptr1,r1);
r2=code_gen(root->ptr2);
GetVal(root->ptr2,r2);
fprintf(fp,"EQ R%d R%d\n",r1,r2);
free_reg();
return r1;
case NODETYPE_NE :
r1=code_gen(root->ptr1);
GetVal(root->ptr1,r1);
r2=code_gen(root->ptr2);
GetVal(root->ptr2,r2);
fprintf(fp,"NE R%d R%d\n",r1,r2);
free_reg();
return r1;
case NODETYPE_GT :
r1=code_gen(root->ptr1);
GetVal(root->ptr1,r1);
r2=code_gen(root->ptr2);
GetVal(root->ptr2,r2);
fprintf(fp,"GT R%d R%d\n",r1,r2);
free_reg();
return r1;
case NODETYPE_ID:
r1=get_reg();
if(root->ptr1==NULL) {
if(root->Lentry) {
bind=root->Lentry->binding;
r2=get_reg();
fprintf(fp,"MOV R%d BP\n",r1);
fprintf(fp,"MOV R%d %d\n",r2,bind);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
fprintf(fp,"MOV R%d [R%d]\n",r1,r1);
if(root->Lentry->ref==2){
fprintf(fp,"MOV R%d [R%d]\n",r1,r1);
}
free_reg();
return r1;
}
else {
bind=root->Gentry->binding;
r2=get_reg();
fprintf(fp,"MOV R%d %d\n",r2,bind);
fprintf(fp,"MOV R%d [R%d]\n",r1,r2);
free_reg();
return r1;
}
}
else {
bind=root->Gentry->binding;
r2=code_gen(root->ptr1);
fprintf(fp,"MOV R%d %d\n",r1,bind);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
free_reg();
fprintf(fp,"MOV R%d [R%d]\n",r1,r1);
return r1;
}
break;
case NODETYPE_BODY:
printf("hi1\n");
code_gen(root->ptr1);
printf("hi2\n");
code_gen(root->ptr2);
printf("hi3\n");
break;
case NODETYPE_ASGN:
r2=code_gen(root->ptr2);
if(root->ptr2->node==NODETYPE_FIELD_END) {
fprintf(fp,"MOV R%d [R%d]\n",r2,r2);
}
if(root->ptr1->node!=NODETYPE_FIELD_END) {
if(root->ptr1->ptr1) {
bind=root->ptr1->Gentry->binding;
r1=code_gen(root->ptr1->ptr1);
r3=get_reg();
fprintf(fp,"MOV R%d %d\n",r3,bind);
fprintf(fp,"ADD R%d R%d\n",r1,r3);
fprintf(fp,"MOV [R%d] R%d\n ",r1,r2);
free_reg();
free_reg();
free_reg();
}else {
if(root->ptr1->Lentry) {
bind=root->ptr1->Lentry->binding;
r1=get_reg();
r3=get_reg();
fprintf(fp,"MOV R%d BP\n",r1);
fprintf(fp,"MOV R%d %d\n",r3,bind);
fprintf(fp,"ADD R%d R%d\n",r1,r3);
if(root->ptr1->Lentry->ref==2)
fprintf(fp,"MOV R%d [R%d] \n",r1,r1);
free_reg();
fprintf(fp,"MOV [R%d] R%d\n",r1,r2);
free_reg();
free_reg();
}
else {
bind=root->ptr1->Gentry->binding;
fprintf(fp,"MOV [%d] R%d\n ",bind,r2);
free_reg();
}
}
}
else {
r1=code_gen(root->ptr1);
fprintf(fp,"MOV [R%d] R%d\n ",r1,r2);
free_reg();
free_reg();
}
return 0;
break;
case NODETYPE_READ:
if(root->ptr1->node==NODETYPE_FIELD_END) {
r1=code_gen(root->ptr1);
r2=get_reg();
fprintf(fp,"IN R%d\n",r2);
fprintf(fp,"MOV [R%d] R%d\n",r1,r2);
free_reg();
free_reg();
return 0;
}
if(root->ptr1->Lentry) {
r1=get_reg();
r2=get_reg();
fprintf(fp,"MOV R%d BP\n",r1);
bind=root->ptr1->Lentry->binding;
fprintf(fp,"MOV R%d %d\n",r2,bind);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
fprintf(fp,"IN R%d\n",r2);
if(root->ptr1->Lentry->ref == 2){
fprintf(fp,"MOV R%d [R%d]\n",r1,r1);
}
fprintf(fp,"MOV [R%d] R%d\n",r1,r2);
free_reg();
free_reg();
}
else {
if(root->ptr1->ptr1) {
bind=root->ptr1->Gentry->binding;
r3=get_reg();
fprintf(fp,"MOV R%d %d\n",r3,bind);
r1=code_gen(root->ptr1->ptr1);
fprintf(fp,"ADD R%d R%d\n",r3,r1);
r2=get_reg();
fprintf(fp,"IN R%d\n",r2);
fprintf(fp,"MOV [R%d] R%d\n",r3,r2);
free_reg();
free_reg();
free_reg();
}
else {
bind=root->ptr1->Gentry->binding;
r1=get_reg();
fprintf(fp,"MOV R%d %d\n",r1,bind);
r2=get_reg();
fprintf(fp,"IN R%d\n",r2);
fprintf(fp,"MOV [R%d] R%d\n",r1,r2);
free_reg();
free_reg();
}
}
return 0;
break;
case NODETYPE_WRITE:
r1=code_gen(root->ptr1);
if(root->ptr1->node==NODETYPE_FIELD_END)
fprintf(fp,"MOV R%d [R%d]\n",r1,r1);
fprintf(fp,"OUT R%d\n",r1);
free_reg();
return 0;
case NODETYPE_RET_PAIR:
printf("//oooopp\n");
r1=get_reg();
printf("hello\n");
bind=root->ptr1->Lentry->binding;
printf(fp,"//hell00o\n");
r2=get_reg();
r3=get_reg();
fprintf(fp,"MOV R%d BP\n",r2);
fprintf(fp,"MOV R%d %d\n",r1,bind);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
fprintf(fp,"MOV R%d %d\n",r3,2);
fprintf(fp,"SUB R%d R%d\n",r2,r3);
fprintf(fp,"MOV [R%d] R%d\n",r2,r1);
free_reg();
free_reg();
free_reg();
printf("hello1\n");
break;
case NODETYPE_RET:
r=code_gen(root->ptr1);
if(root->ptr1->node==NODETYPE_FIELD_END)
fprintf(fp,"MOV R%d [R%d]\n",r,r);
r1=get_reg();
fprintf(fp,"MOV R%d BP\n",r1);
r2=get_reg();
fprintf(fp,"MOV R%d 2\n",r2);
fprintf(fp,"SUB R%d R%d\n",r1,r2);
free_reg();
fprintf(fp,"MOV [R%d] R%d\n",r1,r);
free_reg();
free_reg();
break;
case NODETYPE_WHILE :
l1=get_label();
l2=get_label();
fprintf(fp,"\n//while\n");
fprintf(fp,"label%d:\n",l1);
r1=code_gen(root->ptr1);
fprintf(fp,"JZ R%d,label%d\n",r1,l2);
free_reg();
code_gen(root->ptr2);
fprintf(fp,"JMP label%d\n",l1);
fprintf(fp,"\n\n");
fprintf(fp,"label%d:\n",l2);
break;
case NODETYPE_IF :
fprintf(fp,"\n\n//if\n");
l1=get_label();
r1=code_gen(root->ptr1);
fprintf(fp,"JZ R%d label%d\n",r1,l1);
free_reg();
code_gen(root->ptr2);
fprintf(fp,"label%d:\n",l1);
break;
case NODETYPE_IFELSE :
fprintf(fp, "\n\n //ifelse\n\n");
l1=get_label();
l2=get_label();
r1=code_gen(root->ptr1);
fprintf(fp,"JZ R%d label%d\n",r1,l1);
free_reg();
code_gen(root->ptr2);
fprintf(fp,"JMP label%d\n",l2);
fprintf(fp,"label%d:\n",l1);
code_gen(root->ptr3);
fprintf(fp,"label%d:\n",l2);
break;
case NODETYPE_SLIST :
code_gen(root->ptr1);
code_gen(root->ptr2);
break;
}
}
int functioncall_gen(struct ASTNode *root) {
int r,r1,r2,r3,r4,c=0;
struct Gsymbol *g=GLookup(root->name);
struct ArgStruct *list=g->arglist;
struct ASTNode *templist=root->arglist;
//Saving the values in the registers;
while(c<=reg) {
fprintf(fp,"PUSH R%d\n",c);
c++;
}
c--;
while(templist) {
if(list->passType==1) {
r=code_gen(templist->ptr2);
if(templist->ptr2->node==NODETYPE_FIELD_END)
fprintf(fp,"MOV R%d [R%d]\n",r,r);
fprintf(fp,"PUSH R%d\n",r);
free_reg();
}
else {
if(templist->ptr2->node==NODETYPE_FIELD_END) {
r=code_gen(templist->ptr2);
fprintf(fp,"PUSH R%d\n",r);
free_reg();
}
else if(templist->ptr2->Lentry) {
if(strcmp(templist->ptr2->type->name,"pair")==0)
{
r1=get_reg();
r2=get_reg();
fprintf(fp,"MOV R%d BP\n",r1);
fprintf(fp,"MOV R%d %d\n",r2,templist->ptr2->Lentry->binding);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
fprintf(fp,"PUSH R%d\n",r1);
}
else
{
r1=get_reg();
r2=get_reg();
fprintf(fp,"MOV R%d BP\n",r1);
fprintf(fp,"MOV R%d %d\n",r2,templist->ptr2->Lentry->binding);
fprintf(fp,"ADD R%d R%d\n",r1,r2);
free_reg();
if(templist->ptr2->Lentry->ref==2) {
fprintf(fp,"MOV R%d [R%d]\n",r1,r1);
}
fprintf(fp,"PUSH R%d\n",r1);
free_reg();
}
}
else {
r=get_reg();
fprintf(fp,"MOV R%d %d\n",r,templist->ptr2->Gentry->binding);
if(templist->ptr2->ptr1) {
r2=code_gen(templist->ptr2->ptr1);
fprintf(fp,"ADD R%d R%d\n",r,r2);
free_reg();
}
fprintf(fp,"PUSH R%d\n",r);
free_reg();
}
}
templist=templist->ptr1;
list=list->next;
}
r=get_reg();
fprintf(fp,"PUSH R%d\n",r);
free_reg();
fprintf(fp,"CALL LL%d\n",g->binding);
reg=c;
r=get_reg();
fprintf(fp,"POP R%d\n",r);
r1=get_reg();
list=g->arglist;
while(list) {
fprintf(fp,"POP R%d\n",r1);
list=list->next;
}
free_reg();
while(c>=0) {
fprintf(fp,"POP R%d\n",c);
c--;
}
return r;
}
*
* 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 <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <time.h>
#include <locale.h>
#include "db_funcs.h"
#include "log_funcs.h"
void make_media(media_t* new, medium_t type, const char* name, const char* location) {
new->code = code_gen(type,name);
new->type = type;
strcpy(new->name,name);
strcpy(new->location,location);
new->update = time(NULL);
}
void make_book(book_t* new, uint32_t code, medium_t type, genre_t genre,
const char* isbn, const char* title, const char* author_last,
const char* author_first, const char* author_rest) {
new->code = code;
new->type = type;
new->genre = genre;
strcpy(new->isbn,isbn);
strcpy(new->title,title);
strcpy(new->author_last,author_last);
