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