NAME 
src/io/io_layers.c - IO Layer Handling
DESCRIPTION
The Parrot IO subsystem uses a per-interpreter stack to provide a layer-based approach to IO.
Each layer implements a subset of the ParrotIOLayerAPI vtable.
To find an IO function the layer stack is searched downwards until a non-NULL function pointer is found for that particular slot.
Layer and Stack Functions
FUNCDOC: PIO_base_new_layer
The default IO layer constructor.
Creates and returns a new ParrotIOLayer.
If a prototype *proto is supplied then its values will be copied to the new instance.
*/
#include "parrot/parrot.h" #include "parrot/io.h" #include "io_private.h"
/* HEADERIZER HFILE: include/parrot/io.h */
PARROT_API PARROT_MALLOC PARROT_CANNOT_RETURN_NULL ParrotIOLayer * PIO_base_new_layer(NULLOK(ParrotIOLayer *proto)) { ParrotIOLayer * const new_layer = mem_allocate_typed(ParrotIOLayer);
/*
* XXX use managed memory here ?
*/
if (proto) {
/* FIXME: Flag here to indicate whether to free strings */
new_layer->name = proto->name;
new_layer->flags = proto->flags;
new_layer->api = proto->api;
}
else {
new_layer->name = NULL;
new_layer->flags = 0;
new_layer->api = NULL;
}
new_layer->self = 0;
new_layer->up = NULL;
new_layer->down = NULL;
return new_layer;
}
/*
PIO_base_delete_layer
The default IO layer destructor. Frees the memory associated with *layer.
*/
PARROT_API void PIO_base_delete_layer(NULLOK(ParrotIOLayer *layer)) { if (layer != NULL) mem_sys_free(layer); }
/*
FUNCDOC: PIO_push_layer
Push a layer onto an IO object (*pmc) or the default stack.
FUNCDOC: PIO_push_layer_str
Push a layer onto an IO object (*pmc).
*/
PARROT_API INTVAL PIO_push_layer(PARROT_INTERP, NULLOK(PMC *pmc), NULLOK(ParrotIOLayer *layer)) { if (layer == NULL) return -1;
if (!PMC_IS_NULL(pmc)) {
ParrotIOLayer *t;
ParrotIO * const io = PMC_data_typed(pmc, ParrotIO *);
if (!io)
return -1;
/* Error( 1st layer must be terminal) */
if (io->stack == NULL && (layer->flags & PIO_L_TERMINAL) == 0)
return -1;
/* Check and see if this layer already is on stack
* This is a internals sanity check not a user level
* check, at least until I fix copy-on-write stacks.
* -Melvin
*/
for (t = io->stack; t; t = t->down) {
if (t == layer)
return -1;
}
/* if this is a global layer create a copy first */
if (!(io->stack->flags & PIO_L_LAYER_COPIED))
io->stack = PIO_copy_stack(io->stack);
layer->down = io->stack;
if (io->stack)
io->stack->up = layer;
io->stack = layer;
PMC_struct_val(pmc) = layer;
if (layer->api->Pushed)
(*layer->api->Pushed) (layer, io);
}
else {
ParrotIOLayer *t;
ParrotIOData * const d = interp->piodata;
if (d->default_stack == NULL && (layer->flags & PIO_L_TERMINAL) == 0) {
/* Error( 1st layer must be terminal) */
return -1;
}
/* Sanity check */
for (t = d->default_stack; t; t = t->down) {
if (t == layer)
return -1;
}
layer->down = d->default_stack;
if (d->default_stack)
d->default_stack->up = layer;
d->default_stack = layer;
return 0;
}
return -1;
}
PARROT_WARN_UNUSED_RESULT PARROT_CAN_RETURN_NULL PARROT_API ParrotIOLayer * PIO_get_layer(SHIM_INTERP, NOTNULL(const char *name)) { ParrotIOLayer **t;
for (t = pio_registered_layers; *t; ++t)
if (strcmp(name, (*t)->name) == 0)
return *t;
return NULL;
}
void PIO_push_layer_str(PARROT_INTERP, NOTNULL(PMC *pmc), NULLOK(STRING *ls)) { char * const cls = string_to_cstring(interp, ls); ParrotIOLayer * const l = PIO_get_layer(interp, cls); ParrotIOLayer * newlayer;
string_cstring_free(cls);
if (!l)
real_exception(interp, NULL, 1, "Layer not found");
/* make private copy */
newlayer = PIO_base_new_layer(l);
newlayer->flags |= PIO_L_LAYER_COPIED;
PIO_push_layer(interp, pmc, newlayer);
}
/*
FUNCDOC: PIO_pop_layer
Pop a layer from an IO object (*pmc) or the default stack.
FUNCDOC: PIO_pop_layer_str
Pop a layer from an IO object (*pmc) and return the name of the popped layer. The layer gets freed.
*/
PARROT_API PARROT_IGNORABLE_RESULT PARROT_CAN_RETURN_NULL ParrotIOLayer * PIO_pop_layer(PARROT_INTERP, NULLOK(PMC *pmc)) { ParrotIO * const io = PMC_data_typed(pmc, ParrotIO *);
if (!PMC_IS_NULL(pmc)) {
ParrotIOLayer *layer;
if (!io)
return 0;
/* if this is a global layer create a copy first */
if (!(io->stack->flags & PIO_L_LAYER_COPIED))
io->stack = PIO_copy_stack(io->stack);
layer = io->stack;
if (layer) {
io->stack = layer->down;
PMC_struct_val(pmc) = io->stack;
io->stack->up = 0;
layer->up = 0;
layer->down = 0;
if (layer->api->Popped)
(*layer->api->Popped) (layer, io);
return layer;
}
return layer;
}
/* Null io object - use default stack */
else {
ParrotIOData * const d = interp->piodata;
ParrotIOLayer * const layer = d->default_stack;
if (layer) {
d->default_stack = layer->down;
d->default_stack->up = NULL;
layer->up = 0;
layer->down = 0;
return layer;
}
}
return NULL;
}
PARROT_IGNORABLE_RESULT PARROT_CANNOT_RETURN_NULL STRING * PIO_pop_layer_str(PARROT_INTERP, NOTNULL(PMC *pmc)) { ParrotIOLayer * const layer = PIO_pop_layer(interp, pmc); STRING * const ls = string_make(interp, layer->name, strlen(layer->name), "iso-8859-1", 0); mem_sys_free(layer); return ls; }
/*
FUNCDOC: PIO_copy_stack
Primarily used to copy the default IO stack for a new IO object. Later we will do some funky copy-on-write stuff.
*/
PARROT_API PARROT_IGNORABLE_RESULT PARROT_CANNOT_RETURN_NULL ParrotIOLayer * PIO_copy_stack(NULLOK(ParrotIOLayer *stack)) { ParrotIOLayer *ptr_new = NULL; ParrotIOLayer *ptr_last = NULL; ParrotIOLayer **ptr_ptr_new = &ptr_new;
while (stack) {
*ptr_ptr_new = PIO_base_new_layer(stack);
(*ptr_ptr_new)->flags |= PIO_L_LAYER_COPIED;
(*ptr_ptr_new)->up = ptr_last;
stack = stack->down;
ptr_last = *ptr_ptr_new;
ptr_ptr_new = &((*ptr_ptr_new)->down);
}
return ptr_new;
}
/* * Local variables: * c-file-style: "parrot" * End: * vim: expandtab shiftwidth=4: */
