PARROT_INLINE
PARROT_CANNOT_RETURN_NULL
PARROT_WARN_UNUSED_RESULT
static PMC *
get_pmc_proxy(PARROT_INTERP, INTVAL type)
{
ASSERT_ARGS(get_pmc_proxy)
PMC * type_class;
/* Check if not a PMC or invalid type number */
if (type > interp->n_vtable_max || type <= 0)
return PMCNULL;
type_class = interp->vtables[type]->pmc_class;
if (type != enum_class_Class
&& type_class->vtable->base_type == enum_class_Class) {
return type_class;
}
else {
PMC * const parrot_hll = Parrot_ns_get_namespace_keyed_str(interp, interp->root_namespace, CONST_STRING(interp, "parrot"));
PMC * const pmc_ns =
Parrot_ns_make_namespace_keyed_str(interp, parrot_hll,
interp->vtables[type]->whoami);
PMC * proxy = VTABLE_get_class(interp, pmc_ns);
/* Create proxy if not found */
if (PMC_IS_NULL(proxy)) {
proxy = Parrot_pmc_new_init_int(interp, enum_class_PMCProxy, type);
Parrot_pcc_invoke_method_from_c_args(interp, pmc_ns, CONST_STRING(interp, "set_class"), "P->", proxy);
}
return proxy;
}
}
void
Parrot_oo_extract_methods_from_namespace(PARROT_INTERP, ARGIN(PMC *self), ARGIN(PMC *ns))
{
ASSERT_ARGS(Parrot_oo_extract_methods_from_namespace)
PMC *methods, *vtable_overrides;
/* Pull in methods from the namespace, if any. */
if (PMC_IS_NULL(ns))
return;
/* Import any methods. */
Parrot_pcc_invoke_method_from_c_args(interp, ns, CONST_STRING(interp, "get_associated_methods"), "->P", &methods);
if (!PMC_IS_NULL(methods)) {
PMC * const iter = VTABLE_get_iter(interp, methods);
while (VTABLE_get_bool(interp, iter)) {
STRING * const meth_name = VTABLE_shift_string(interp, iter);
PMC * const meth_sub = VTABLE_get_pmc_keyed_str(interp, methods,
meth_name);
VTABLE_add_method(interp, self, meth_name, meth_sub);
}
}
/* Import any vtables. */
Parrot_pcc_invoke_method_from_c_args(interp, ns, CONST_STRING(interp, "get_associated_vtable_methods"), "->P", &vtable_overrides);
if (!PMC_IS_NULL(vtable_overrides)) {
PMC * const iter = VTABLE_get_iter(interp, vtable_overrides);
while (VTABLE_get_bool(interp, iter)) {
STRING * const vtable_index_str = VTABLE_shift_string(interp, iter);
PMC * const vtable_sub = VTABLE_get_pmc_keyed_str(interp,
vtable_overrides, vtable_index_str);
/* Look up the name of the vtable function from the index. */
const INTVAL vtable_index = Parrot_str_to_int(interp, vtable_index_str);
const char * const meth_c = Parrot_vtable_slot_names[vtable_index];
STRING * const vtable_name = Parrot_str_new(interp, meth_c, 0);
VTABLE_add_vtable_override(interp, self, vtable_name, vtable_sub);
}
}
}
PARROT_EXPORT
PARROT_WARN_UNUSED_RESULT
PARROT_CANNOT_RETURN_NULL
PMC *
Parrot_io_open_handle(PARROT_INTERP, ARGIN(PMC *pmc), ARGIN(STRING *path), ARGIN(STRING *mode))
{
ASSERT_ARGS(Parrot_io_open_handle)
PMC *filehandle;
const INTVAL typenum = Parrot_hll_get_ctx_HLL_type(interp,
Parrot_PMC_typenum(interp, "FileHandle"));
if (PMC_IS_NULL(pmc)) {
filehandle = Parrot_pmc_new(interp, typenum);
}
else
filehandle = pmc;
if (STRING_IS_NULL(path))
Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_PIO_ERROR,
"Cannot open filehandle, no path");
if (filehandle->vtable->base_type == typenum) {
INTVAL flags = Parrot_io_parse_open_flags(interp, mode);
PIOHANDLE os_handle;
/* TODO: a filehandle shouldn't allow a NULL path. */
PARROT_ASSERT(filehandle->vtable->base_type == typenum);
if (flags & PIO_F_PIPE) {
const int f_read = (flags & PIO_F_READ) != 0;
const int f_write = (flags & PIO_F_WRITE) != 0;
INTVAL pid;
if (f_read == f_write)
Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_PIO_ERROR,
"Invalid pipe mode: %X", flags);
os_handle = PIO_OPEN_PIPE(interp, path, flags, &pid);
/* Save the pid of the child, we'll wait for it when closing */
VTABLE_set_integer_keyed_int(interp, filehandle, 0, pid);
}
else {
if ((flags & (PIO_F_WRITE | PIO_F_READ)) == 0)
Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_OPERATION,
"Invalid mode for file open");
os_handle = PIO_OPEN(interp, path, flags);
if (os_handle == PIO_INVALID_HANDLE)
Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_PIO_ERROR,
"Unable to open filehandle from path '%Ss'", path);
flags |= PIO_F_FILE;
/* Set generic flag here if is a terminal then
* FileHandle can know how to setup buffering.
* STDIN, STDOUT, STDERR would be in this case
* so we would setup linebuffering.
*/
if (PIO_IS_TTY(interp, os_handle))
flags |= PIO_F_CONSOLE;
}
if (STRING_IS_NULL(mode))
mode = CONST_STRING(interp, "r");
else if (STRING_index(interp, mode, CONST_STRING(interp, "b"), 0) >= 0)
SETATTR_FileHandle_encoding(interp, filehandle, CONST_STRING(interp, "binary"));
SETATTR_FileHandle_os_handle(interp, filehandle, os_handle);
SETATTR_FileHandle_flags(interp, filehandle, flags);
SETATTR_FileHandle_filename(interp, filehandle, path);
SETATTR_FileHandle_mode(interp, filehandle, mode);
Parrot_io_setbuf(interp, filehandle, PIO_UNBOUND);
}
else
Parrot_pcc_invoke_method_from_c_args(interp, filehandle, CONST_STRING(interp, "open"), "SS->P", path, mode, &filehandle);
return filehandle;
}
