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);