INTVAL
Parrot_Run_OS_Command_Argv(PARROT_INTERP, PMC *cmdargs)
{
Parrot_warn(NULL, PARROT_WARNINGS_PLATFORM_FLAG,
"Parrot_Run_OS_Command_Argv not implemented");
return 0;
}
INTVAL
Parrot_Run_OS_Command(PARROT_INTERP, STRING *command)
{
Parrot_warn(NULL, PARROT_WARNINGS_PLATFORM_FLAG,
"Parrot_Run_OS_Command not implemented");
return 0;
}
FLOATVAL
Parrot_floatval_time(void)
{
/* unable to provide this level of precision under ANSI-C, so just fall
back to intval time for this. */
Parrot_warn(NULL, PARROT_WARNINGS_PLATFORM_FLAG, "Parrot_floatval_time not accurate");
return (FLOATVAL)Parrot_intval_time();
}
INTVAL
Parrot_Run_OS_Command_Argv(PARROT_INTERP, PMC *cmdargs)
{
DWORD status = 0;
STARTUPINFO si;
PROCESS_INFORMATION pi;
int pmclen;
int cmdlinelen = 1000;
int cmdlinepos = 0;
char *cmdline = (char *)mem_sys_allocate(cmdlinelen);
int i;
/* Ensure there's something in the PMC array. */
pmclen = VTABLE_elements(interp, cmdargs);
if (pmclen == 0)
Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_NOSPAWN,
"Empty argument array for spawnw");
/* Now build command line. */
for (i = 0; i < pmclen; i++) {
STRING * const s = VTABLE_get_string_keyed_int(interp, cmdargs, i);
char * const cs = Parrot_str_to_cstring(interp, s);
if (cmdlinepos + (int)s->strlen + 3 > cmdlinelen) {
cmdlinelen += s->strlen + 4;
cmdline = (char *)mem_sys_realloc(cmdline, cmdlinelen);
}
strcpy(cmdline + cmdlinepos, "\"");
strcpy(cmdline + cmdlinepos + 1, cs);
strcpy(cmdline + cmdlinepos + 1 + s->strlen, "\" ");
cmdlinepos += s->strlen + 3;
}
/* Start the child process. */
memset(&si, 0, sizeof (si));
si.cb = sizeof (si);
memset(&pi, 0, sizeof (pi));
if (!CreateProcess(NULL, cmdline, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi))
Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_NOSPAWN,
"Can't spawn child process");
WaitForSingleObject(pi.hProcess, INFINITE);
/* Get exit code. */
if (!GetExitCodeProcess(pi.hProcess, &status)) {
Parrot_warn(interp, PARROT_WARNINGS_PLATFORM_FLAG,
"Process completed: Failed to get exit code.");
}
/* Clean up. */
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
mem_sys_free(cmdline);
/* Return exit code left shifted by 8 for POSIX emulation. */
return status << 8;
}
static void
restore_context(PARROT_INTERP, ARGIN(Parrot_Context * const initialctx))
{
ASSERT_ARGS(restore_context)
Parrot_Context *curctx = CONTEXT(interp);
if (curctx != initialctx) {
Parrot_warn((interp), PARROT_WARNINGS_NONE_FLAG,
"popping context in Parrot_ext_try");
do {
Parrot_pop_context(interp);
curctx = CONTEXT(interp);
if (curctx == NULL)
PANIC(interp, "cannot restore context");
} while (curctx != initialctx);
}
}
INTVAL
Parrot_Run_OS_Command(PARROT_INTERP, STRING *command)
{
DWORD status = 0;
STARTUPINFO si;
PROCESS_INFORMATION pi;
char* const cmd = (char *)mem_sys_allocate(command->strlen + 4);
char* const shell = Parrot_getenv(interp, Parrot_str_new(interp, "ComSpec", strlen("ComSpec")));
char* const cmdin = Parrot_str_to_cstring(interp, command);
strcpy(cmd, "/c ");
strcat(cmd, cmdin);
Parrot_str_free_cstring(cmdin);
memset(&si, 0, sizeof (si));
si.cb = sizeof (si);
memset(&pi, 0, sizeof (pi));
/* Start the child process. */
if (!CreateProcess(shell, cmd, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi))
Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_NOSPAWN,
"Can't spawn child process");
WaitForSingleObject(pi.hProcess, INFINITE);
if (!GetExitCodeProcess(pi.hProcess, &status)) {
Parrot_warn(interp, PARROT_WARNINGS_PLATFORM_FLAG,
"Process completed: Failed to get exit code.");
}
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
Parrot_str_free_cstring(shell);
mem_sys_free(cmd);
/* Return exit code left shifted by 8 for POSIX emulation. */
return status << 8;
}
int
Parrot_dlclose(void *handle)
{
Parrot_warn(NULL, PARROT_WARNINGS_PLATFORM_FLAG, "Parrot_dlclose not implemented");
return 0;
}
void *
Parrot_dlsym(void *handle, const char *symbol)
{
Parrot_warn(NULL, PARROT_WARNINGS_PLATFORM_FLAG, "Parrot_dlsym not implemented");
return NULL;
}
void *
Parrot_dlopen(const char *filename, SHIM(Parrot_dlopen_flags flags))
{
Parrot_warn(NULL, PARROT_WARNINGS_PLATFORM_FLAG, "Parrot_dlopen not implemented");
return NULL;
}
void
Parrot_usleep(unsigned int microseconds)
{
Parrot_warn(NULL, PARROT_WARNINGS_PLATFORM_FLAG, "Parrot_usleep not implemented");
return;
}
struct PackFile *
Parrot_readbc(struct Parrot_Interp *interpreter, const char *filename)
{
#if PARROT_HAS_HEADER_UNISTD
off_t program_size, wanted;
#else
size_t program_size, wanted;
#endif
char *program_code;
struct PackFile *pf;
PMC * io = NULL;
INTVAL is_mapped = 0;
#ifdef PARROT_HAS_HEADER_SYSSTAT
struct stat file_stat;
#endif
#ifdef PARROT_HAS_HEADER_SYSMMAN
int fd = -1;
#endif
if (filename == NULL || strcmp(filename, "-") == 0) {
/* read from STDIN */
io = PIO_STDIN(interpreter);
/* read 1k at a time */
program_size = 0;
}
else {
#ifdef PARROT_HAS_HEADER_SYSSTAT
/* if we have stat(), get the actual file size so we can read it
* in one chunk. */
if (stat(filename, &file_stat)) {
PIO_eprintf(interpreter, "Parrot VM: Can't stat %s, code %i.\n",
filename, errno);
return NULL;
}
# ifndef PARROT_HAS_BROKEN_ISREG
/* S_ISREG is strangely broken my lcc/linux install (though it did
* once work */
if (!S_ISREG(file_stat.st_mode)) {
PIO_eprintf(interpreter, "Parrot VM: %s is not a normal file.\n",
filename);
return NULL;
}
# endif /* PARROT_HAS_BROKEN_ISREG */
program_size = file_stat.st_size;
#else /* PARROT_HAS_HEADER_SYSSTAT */
/* otherwise, we will read it 1k at a time */
program_size = 0;
#endif /* PARROT_HAS_HEADER_SYSSTAT */
#ifndef PARROT_HAS_HEADER_SYSMMAN
io = PIO_open(interpreter, NULL, filename, "<");
if (!io) {
PIO_eprintf(interpreter, "Parrot VM: Can't open %s, code %i.\n",
filename, errno);
return NULL;
}
#else /* PARROT_HAS_HEADER_SYSMMAN */
/* the file wasn't from stdin, and we have mmap available- use it */
io = NULL;
#endif /* PARROT_HAS_HEADER_SYSMMAN */
interpreter->current_file = string_make(interpreter, filename,
strlen(filename), NULL, 0, NULL);
}
#ifdef PARROT_HAS_HEADER_SYSMMAN
again:
#endif
/* if we've opened a file (or stdin) with PIO, read it in */
if (io != NULL) {
size_t chunk_size;
char *cursor;
INTVAL read_result;
chunk_size = program_size > 0 ? program_size : 1024;
program_code = (char *)mem_sys_allocate(chunk_size);
wanted = program_size;
program_size = 0;
if (!program_code) {
/* Whoops, out of memory. */
PIO_eprintf(interpreter,
"Parrot VM: Could not allocate buffer to read packfile from PIO.\n");
return NULL;
}
cursor = (char *)program_code;
while ((read_result =
PIO_read(interpreter, io, cursor, chunk_size)) > 0) {
program_size += read_result;
if (program_size == wanted)
break;
chunk_size = 1024;
program_code =
mem_sys_realloc(program_code, program_size + chunk_size);
if (!program_code) {
PIO_eprintf(interpreter,
"Parrot VM: Could not reallocate buffer while reading packfile from PIO.\n");
return NULL;
}
cursor = (char *)program_code + program_size;
}
if (read_result < 0) {
PIO_eprintf(interpreter,
"Parrot VM: Problem reading packfile from PIO.\n");
return NULL;
}
PIO_close(interpreter, io);
}
else {
/* if we've gotten here, we opted not to use PIO to read the file.
* use mmap */
#ifdef PARROT_HAS_HEADER_SYSMMAN
fd = open(filename, O_RDONLY | O_BINARY);
if (!fd) {
PIO_eprintf(interpreter, "Parrot VM: Can't open %s, code %i.\n",
filename, errno);
return NULL;
}
program_code =
mmap(0, program_size, PROT_READ, MAP_SHARED, fd, (off_t)0);
if (program_code == (void *)MAP_FAILED) {
Parrot_warn(interpreter, PARROT_WARNINGS_IO_FLAG,
"Parrot VM: Can't mmap file %s, code %i.\n",
filename, errno);
/* try again, now with IO reading the file */
io = PIO_open(interpreter, NULL, filename, "<");
if (!io) {
PIO_eprintf(interpreter,
"Parrot VM: Can't open %s, code %i.\n",
filename, errno);
return NULL;
}
goto again;
}
is_mapped = 1;
#else /* PARROT_HAS_HEADER_SYSMMAN */
PIO_eprintf(interpreter, "Parrot VM: uncaught error occurred reading "
"file or mmap not available.\n");
return NULL;
#endif /* PARROT_HAS_HEADER_SYSMMAN */
}
/* Now that we have the bytecode, let's unpack it. */
pf = PackFile_new(is_mapped);
if (!PackFile_unpack
(interpreter, pf, (opcode_t *)program_code, program_size)) {
PIO_eprintf(interpreter, "Parrot VM: Can't unpack packfile %s.\n",
filename);
return NULL;
}
#ifdef PARROT_HAS_HEADER_SYSMMAN
if (fd >= 0) {
close(fd); /* the man page states, it's ok to close a mmaped file */
}
#else
/* XXX Parrot_exec uses this
mem_sys_free(program_code); */
#endif
return pf;
}
UINTVAL
Parrot_getpid(void)
{
Parrot_warn(NULL, PARROT_WARNINGS_PLATFORM_FLAG, "Parrot_getpid unuseful in this platform");
return 0;
}
int
main(int argc, const char *argv[])
{
int nextarg;
Parrot_Interp interp;
PDB_t *pdb;
const char *scriptname = NULL;
interp = Parrot_interp_new(NULL);
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 * const filename = argv[nextarg];
if (*filename == '-') {
fprintf(stderr, "parrot_debugger takes no -x or --xxxx flag arguments\n");
exit(1);
}
else {
STRING * const filename_str = Parrot_str_new(interp, filename, 0);
PackFile * const pfraw = Parrot_pf_read_pbc_file(interp, filename_str);
Parrot_PackFile pf;
if (pfraw == NULL)
return 1;
pf = Parrot_pf_get_packfile_pmc(interp, pfraw, filename_str);
if (pf == NULL)
return 1;
Parrot_pf_set_current_packfile(interp, pf);
Parrot_pf_prepare_packfile_init(interp, pf);
}
}
else {
/* Generate some code to be able to enter into runloop */
STRING * const compiler_s = Parrot_str_new_constant(interp, "PIR");
PMC * const compiler = Parrot_interp_get_compiler(interp, compiler_s);
STRING * const source = Parrot_str_new_constant(interp,
".sub aux :main\nexit 0\n.end\n");
PMC * const code = Parrot_interp_compile_string(interp, compiler, source);
if (PMC_IS_NULL(code))
Parrot_warn(interp, PARROT_WARNINGS_NONE_FLAG,
"Unexpected compiler problem at debugger start");
}
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);
}
