int main(SHIM(int argc), char *argv[]) { PackFile *pf; Interp *interp; PackFile_Segment *seg; interp = Parrot_new(NULL); pf = Parrot_pbc_read(interp, argv[1], PFOPT_UTILS); /* * add some more segments */ seg = PackFile_Segment_new_seg(interp, &pf->directory, PF_DIR_SEG, "dir2", 1); seg = PackFile_Segment_new_seg(interp, (PackFile_Directory*)seg, PF_BYTEC_SEG, "code", 1); seg = PackFile_Segment_new_seg(interp, &pf->directory, PF_DIR_SEG, "dir3", 1); /* * show these */ printf("%s\n", pf->directory.base.name); PackFile_map_segments(interp, &pf->directory, iter, (void*)2); Parrot_x_exit(interp, 0); }
/* temporary function for the thread-testing code. Unpack the arguments and invoke parse_file(). */ PARROT_CAN_RETURN_NULL void * process_file(ARGIN(void *a)) { /* unpack the arguments from the structure parser_args */ parser_args *args = (parser_args *)a; int flexdebug = args->flexdebug; FILE *infile = args->infile; char *filename = args->filename; int thr_id = args->thr_id; int flags = args->flags; PARROT_INTERP = Parrot_new(NULL); parse_file(interp, flexdebug, infile, filename, flags, thr_id, INIT_MACRO_SIZE, NULL); return NULL; }
int main(int argc, char *argv[]) { Parrot_Interp interpreter; char *filename, *disassemble; Parrot_PackFile pf; interpreter = Parrot_new(NULL); if (!interpreter) { return 1; } interpreter->lo_var_ptr = &interpreter; Parrot_init(interpreter); if (argc != 2) { fprintf(stderr, "Usage: disassemble programfile \n"); Parrot_exit(1); } filename = argv[1]; pf = Parrot_readbc(interpreter, filename); if (!pf) { return 1; } Parrot_loadbc(interpreter, pf); do_dis(interpreter); Parrot_exit(0); return 0; }
int main(int argc, const char **argv) { PackFile *pf; Interp *interp; const char *file = NULL; int terse = 0; int disas = 0; int convert = 0; int nums_only = 0; int options = PFOPT_UTILS; struct longopt_opt_info opt = LONGOPT_OPT_INFO_INIT; int status; if (argc < 2) help(); interp = Parrot_new(NULL); /* init and set top of stack */ Parrot_init_stacktop(interp, &status); while ((status = longopt_get(interp, argc, argv, opt_options, &opt)) > 0) { switch (opt.opt_id) { #if TRACE_PACKFILE case 'D': options += atoi(opt.opt_arg) << 2; break; #endif case 'h': options += PFOPT_HEADERONLY; break; case 't': terse = 1; break; case 'd': disas = 1; break; case 'o': file = opt.opt_arg; convert = 1; break; case 'n': nums_only = 1; break; case '?': default: help(); break; } } if (status == -1) help(); argc -= opt.opt_index; argv += opt.opt_index; pf = Parrot_pbc_read(interp, *argv, options); if (!pf) { printf("Can't read PBC\n"); return 1; } Parrot_pbc_load(interp, pf); if (convert) { size_t size = PackFile_pack_size(interp, interp->code->base.pf) * sizeof (opcode_t); opcode_t *pack = (opcode_t *)Parrot_gc_allocate_memory_chunk(interp, size); FILE *fp; if (!pack) { printf("out of mem\n"); exit(EXIT_FAILURE); } PackFile_pack(interp, interp->code->base.pf, pack); if (STREQ(file, "-")) fp = stdout; else if ((fp = fopen(file, "wb")) == 0) { printf("Couldn't open %s\n", file); exit(EXIT_FAILURE); } if ((1 != fwrite(pack, size, 1, fp))) { printf("Couldn't write %s\n", file); exit(EXIT_FAILURE); } fclose(fp); Parrot_gc_free_memory_chunk(interp, pack); Parrot_exit(interp, 0); } if (!nums_only) PackFile_header_dump(interp, pf); if (options & PFOPT_HEADERONLY) Parrot_exit(interp, 0); /* install a dumper function */ if (!terse) { pf->PackFuncs[PF_CONST_SEG].dump = const_dump; } if (disas) pf->PackFuncs[PF_BYTEC_SEG].dump = disas_dump; if (nums_only) { int i; for (i = PF_DIR_SEG + 1; i < PF_MAX_SEG; ++i) pf->PackFuncs[i].dump = null_dump; pf->PackFuncs[PF_DIR_SEG].dump = null_dir_dump; pf->PackFuncs[PF_BYTEC_SEG].dump = nums_dump; } /* do a directory dump, which dumps segs then */ PackFile_Segment_dump(interp, &pf->directory.base); Parrot_exit(interp, 0); }
int main(int argc, const char *argv[]) { int nextarg; Parrot_Interp interp; PDB_t *pdb; const char *scriptname = NULL; const unsigned char * configbytes = Parrot_get_config_hash_bytes(); const int configlength = Parrot_get_config_hash_length(); interp = Parrot_new(NULL); Parrot_set_executable_name(interp, Parrot_str_new(interp, argv[0], 0)); Parrot_set_configuration_hash_legacy(interp, configlength, configbytes); Parrot_debugger_init(interp); pdb = interp->pdb; pdb->state = PDB_ENTER; Parrot_block_GC_mark(interp); Parrot_block_GC_sweep(interp); nextarg = 1; if (argv[nextarg] && strcmp(argv[nextarg], "--script") == 0) { scriptname = argv [++nextarg]; ++nextarg; } if (argv[nextarg]) { const char *filename = argv[nextarg]; const char *ext = strrchr(filename, '.'); if (ext && STREQ(ext, ".pbc")) { Parrot_PackFile pf = Parrot_pbc_read(interp, filename, 0); if (!pf) return 1; Parrot_pbc_load(interp, pf); PackFile_fixup_subs(interp, PBC_MAIN, NULL); } else { STRING *errmsg = NULL; Parrot_PackFile pf = PackFile_new(interp, 0); Parrot_pbc_load(interp, pf); Parrot_compile_file(interp, filename, &errmsg); if (errmsg) Parrot_ex_throw_from_c_args(interp, NULL, 1, "%S", errmsg); PackFile_fixup_subs(interp, PBC_POSTCOMP, NULL); /* load the source for debugger list */ PDB_load_source(interp, filename); PackFile_fixup_subs(interp, PBC_MAIN, NULL); } } else { /* Generate some code to be able to enter into runloop */ STRING *compiler = Parrot_str_new_constant(interp, "PIR"); STRING *errstr = NULL; const char source []= ".sub aux :main\nexit 0\n.end\n"; Parrot_compile_string(interp, compiler, source, &errstr); if (!STRING_IS_NULL(errstr)) Parrot_io_eprintf(interp, "%Ss\n", errstr); } Parrot_unblock_GC_mark(interp); Parrot_unblock_GC_sweep(interp); if (scriptname) PDB_script_file(interp, scriptname); else PDB_printwelcome(); Parrot_runcore_switch(interp, Parrot_str_new_constant(interp, "debugger")); PDB_run_code(interp, argc - nextarg, argv + nextarg); Parrot_x_exit(interp, 0); }
/* =item C<int main(int argc, char *argv[])> Main compiler driver. =cut */ int main(int argc, char *argv[]) { char const * const program_name = argv[0]; int flexdebug = 0; int flags = 0; int execute = 0; char *filename = NULL; char *outputfile = NULL; const char *hdocoutfile = NULL; unsigned macrosize = INIT_MACRO_SIZE; PARROT_INTERP = Parrot_new(NULL); /* skip program name */ argc--; argv++; /* XXX test the parse_string() function. */ /* parse_string(".sub main :main\nprint 42\n.end\n", LEXER_FLAG_OUTPUTPBC, 0, INIT_MACRO_SIZE); return 0; */ /* XXX very basic argument handling; I'm too lazy to check out * the standard funtion for that, right now. This is a TODO. */ while (argc > 0 && argv[0][0] == '-') { switch (argv[0][1]) { case 'b': SET_FLAG(flags, LEXER_FLAG_OUTPUTPBC); break; case 'E': SET_FLAG(flags, LEXER_FLAG_PREPROCESS); break; case 'f': flexdebug = 1; break; case 'h': print_help(program_name); exit(EXIT_SUCCESS); /* asking for help doesn't make you a failure */ /* break; */ case 'H': SET_FLAG(flags, LEXER_FLAG_HEREDOCONLY); break; case 'm': if (argc > 1) { argc--; argv++; macrosize = atoi(argv[0]); } else { fprintf(stderr, "Missing argument for option '-m'\n"); exit(EXIT_FAILURE); } break; case 'n': SET_FLAG(flags, LEXER_FLAG_NOOUTPUT); break; case 'o': if (argc > 1) { /* there must be at least 2 more args, the output file, and an input */ argc--; argv++; outputfile = argv[0]; } else { fprintf(stderr, "Missing argument for option '-o'\n"); exit(EXIT_FAILURE); } break; case 'p': SET_FLAG(flags, LEXER_FLAG_EMIT_PASM); break; case 'r': SET_FLAG(flags, LEXER_FLAG_REGALLOC); break; case 'S': SET_FLAG(flags, LEXER_FLAG_NOSTRENGTHREDUCTION); break; case 'v': SET_FLAG(flags, LEXER_FLAG_VERBOSE); break; case 'W': SET_FLAG(flags, LEXER_FLAG_WARNINGS); break; case 'x': execute = 1; break; /* Only allow for debug flag if the generated parser supports it */ #ifdef YYDEBUG case 'y': yypirdebug = 1; break; #endif default: fprintf(stderr, "Unknown option: '%c'\n", argv[0][1]); exit(EXIT_FAILURE); } /* goto next command line argument */ argv++; argc--; } /* The following code is to test thread safety. If TEST_THREAD_SAFETY * is false, no threads are started; only the main thread will do * a parse. * For thread safety testing, the pthreads library is used. */ #ifdef TEST_THREAD_SAFETY { pthread_t threads[NUM_THREADS]; int i; for (i = 0; i < NUM_THREADS; i++) { FILE *infile = NULL; parser_args args; if (argc < 1) { /* no file specified, read from stdin */ infile = stdin; filename = NULL; } else { /* done handling arguments, open the file */ infile = open_file(argv[0], "r"); filename = argv[0]; } if (infile == NULL) { fprintf(stderr, "Failed to open file '%s'\n", argv[0]); exit(EXIT_FAILURE); } args.flexdebug = flexdebug; args.infile = infile; args.filename = filename; args.thr_id = i; args.flags = flags; pthread_create(&threads[i], NULL, process_file, &args); } /* wait for all threads to finish */ for (i = 0; i < NUM_THREADS; i++) pthread_join(threads[i], NULL); } #else { /* non-thread testing code; this is the normal case */ FILE *file = NULL; if (argc < 1) { fprintf(stderr, "pirc: no input specified\n"); exit(EXIT_FAILURE); } if (outputfile != NULL && TEST_FLAG(flags, LEXER_FLAG_HEREDOCONLY)) { file = open_file(outputfile, "w"); process_heredocs(interp, argv[0], file); fclose(file); return 0; } else if (TEST_FLAG(flags, LEXER_FLAG_HEREDOCONLY)) { process_heredocs(interp, argv[0], stdout); return 0; } else { hdocoutfile = "hdoctemp"; file = open_file(hdocoutfile, "w"); process_heredocs(interp, argv[0], file); fclose(file); } /* done handling arguments, open the file */ file = open_file(hdocoutfile, "r"); filename = argv[0]; if (file == NULL) { fprintf(stderr, "Failed to open file '%s'\n", argv[0]); exit(EXIT_FAILURE); } parse_file(interp, flexdebug, file, filename, flags, 0, macrosize, outputfile); /* fprintf(stderr, "done\n"); */ if (execute) runcode(interp, argc, argv); } #endif return 0; }
int main(int argc, char **argv) { long *opp; int dummy_var; struct Parrot_Interp * interpreter; struct PackFile * pf; opcode_t *code_start; INTVAL i; PMC *userargv; extern char *program_code; extern long opcode_map; extern int bytecode_offset; #if defined(JIT_CGP) extern void * exec_prederef_code; #endif extern int Parrot_exec_run; extern struct PackFile_Constant *exec_const_table; extern struct PackFile_Constant const_table; extern struct Parrot_Interp interpre; /* s. exec.c */ Parrot_exec_run = 1; /* s. packfile.c (PackFile_ConstTable_unpack()) */ exec_const_table = &const_table; interpreter = Parrot_new(NULL); if (!interpreter) { return 1; } Parrot_init(interpreter); run_native = run_compiled; /* TODO make also a shared variant of PackFile_new */ pf = PackFile_new(0); if (!PackFile_unpack(interpreter, pf, (opcode_t *)(&program_code), sizeof(&program_code))) { printf( "Can't unpack.\n" ); return 1; } Parrot_loadbc(interpreter, pf); setup_argv(interpreter, argc, argv); /* opcode_map has the offset of each opcode in the compiled code * this modifies it to be address of the opcode. */ opp = &opcode_map; for (i = 0; i < (int)interpre.code->cur_cs->base.size; i++) { opp[i] += (long)run_compiled; } #if defined(JIT_CGP) exec_init_prederef(interpreter, &exec_prederef_code); #endif Parrot_set_run_core(interpreter, PARROT_EXEC_CORE); interpreter->code->byte_code = (opcode_t *)&((&program_code)[bytecode_offset]); Parrot_exec_run = 0; runops(interpreter, 0); /* run_compiled(interpreter, (opcode_t *)&((&program_code)[bytecode_offset])); */ exit(0); }