void pike_module_exit(void)
{
#ifdef HAVE_SHADOW_H
#ifdef RUNNING_BSD
free_program(shadow_program);
#endif /* RUNNING_BSD */
#endif /* HAVE_SHADOW_H */
free_program(dir_program);
free_program(quota_program);
#ifdef HAVE_PAM
free_program(pam_program);
#endif
}
unsigned int create_program_link(unsigned int sdr0, ...)
{
unsigned int prog, sdr;
va_list ap;
if(!(prog = create_program())) {
return 0;
}
attach_shader(prog, sdr0);
if(glGetError()) {
return 0;
}
va_start(ap, sdr0);
while((sdr = va_arg(ap, unsigned int))) {
attach_shader(prog, sdr);
if(glGetError()) {
return 0;
}
}
va_end(ap);
if(link_program(prog) == -1) {
free_program(prog);
return 0;
}
return prog;
}
static void cleanup_compilation(void *ignored)
{
struct program *p = end_program();
if (p) {
free_program(p);
}
}
/* Restore and exit module */
void pike_module_exit( void )
{
free_program(parsehttp_program);
free_string(STRS(data));
free_string(STRS(file));
free_string(STRS(method));
free_string(STRS(protocol));
free_string(STRS(query));
free_string(STRS(raw_url));
}
void exit_pike_searching(void)
{
if(pike_search_program)
{
free_program(pike_search_program);
pike_search_program=0;
}
if(memsearch_cache)
{
free_mapping(memsearch_cache);
memsearch_cache=0;
}
}
void
db_destroy_object(Objid oid)
{
Object *o = dbpriv_find_object(oid);
Verbdef *v, *w;
int i;
db_priv_affected_callable_verb_lookup();
if (!o)
panic("DB_DESTROY_OBJECT: Invalid object!");
if (o->location != NOTHING || o->contents != NOTHING
|| o->parent != NOTHING || o->child != NOTHING)
panic("DB_DESTROY_OBJECT: Not a barren orphan!");
if (is_user(oid)) {
Var t;
t.type = TYPE_OBJ;
t.v.obj = oid;
all_users = setremove(all_users, t);
}
free_str(o->name);
for (i = 0; i < o->propdefs.cur_length; i++) {
/* As an orphan, the only properties on this object are the ones
* defined on it directly, so these two arrays must be the same length.
*/
free_str(o->propdefs.l[i].name);
free_var(o->propval[i].var);
}
if (o->propval)
myfree(o->propval, M_PVAL);
if (o->propdefs.l)
myfree(o->propdefs.l, M_PROPDEF);
for (v = o->verbdefs; v; v = w) {
if (v->program)
free_program(v->program);
free_str(v->name);
w = v->next;
myfree(v, M_VERBDEF);
}
myfree(objects[oid], M_OBJECT);
objects[oid] = 0;
}
//frees old state and inits a new state
void new_state(pState state){
free_program(state);
state->currentTemp = 75;
state->setTemp = 175;
state->power = OFF;
state->heater = OFF;
state->currentStep = -1;
state->smoke = OFF;
state->ambientTemp = 75;
// bzero(state->history, sizeof(unsigned short int) * HISTSIZE);
state->historyPosition = 0;
state->finished = FALSE;
state->currentTime = 0;
reset_sensors(state);
return;
}
int main() {
unsigned int initial_values[4] = { 0, 0, 500, 600 };
URMVM *vm = new_vm();
URMProgram *program = preconfigure_program_loop((unsigned int*)&initial_values, 4, 1);
unsigned int results = 0;
unsigned int *result_registers = NULL;
FILE *file = fopen("misc/program.txt", "r");
if(file == NULL) {
printf("Unable to open file!\n");
}
parse(program, file);
#if 0
unsigned int i = 0;
for(; i < program->instructions; ++i) {
printf("instruction %u: %d\n", i, program->instruction_list[i]->instruction);
unsigned int j = 0;
for(; j < program->instruction_list[i]->args; ++j) {
printf("arg %u: %d\n", j, program->instruction_list[i]->arg_list[j]);
}
}
for(i = 0; i < program->errors; ++i) {
printf("error: %s\n", program->error_list[i]);
}
#endif
if(start_program(vm, program, &result_registers, &results)) {
printf("Results:\n");
int i = 0;
for(; i < results; ++i) {
printf ("Register %u, result %u\n", i, result_registers[i]);
}
} else {
printf("Error in execution!\n");
}
fclose(file);
free(result_registers);
free_program(program);
free(program);
free_vm(vm);
free(vm);
return 0;
}
static package
bf_eval(Var arglist, Byte next, void *data, Objid progr)
{
package p;
if (next == 1) {
if (!is_programmer(progr)) {
free_var(arglist);
p = make_error_pack(E_PERM);
} else {
Var errors;
Program *program = parse_list_as_program(arglist, &errors);
free_var(arglist);
if (program) {
free_var(errors);
if (setup_activ_for_eval(program))
p = make_call_pack(2, 0);
else {
free_program(program);
p = make_error_pack(E_MAXREC);
}
} else {
Var r;
r = new_list(2);
r.v.list[1].type = TYPE_INT;
r.v.list[1].v.num = 0;
r.v.list[2] = errors;
p = make_var_pack(r);
}
}
} else { /* next == 2 */
Var r;
r = new_list(2);
r.v.list[1].type = TYPE_INT;
r.v.list[1].v.num = 1;
r.v.list[2] = arglist;
p = make_var_pack(r);
}
return p;
}
/* Call the pike_module_exit() callbacks for the dynamic modules. */
void exit_dynamic_load(void)
{
#ifdef USE_DYNAMIC_MODULES
struct module_list * volatile tmp;
JMP_BUF recovery;
for (tmp = dynamic_module_list; tmp; tmp = tmp->next)
{
if(SETJMP(recovery))
call_handle_error();
else
(*tmp->exit)();
UNSETJMP(recovery);
free_program(tmp->module_prog);
tmp->module_prog = NULL;
free_string(tmp->name);
tmp->name = NULL;
}
#endif
}
static package
bf_set_verb_code(Var arglist, Byte next, void *vdata, Objid progr)
{ /* (object, verb-desc, code) */
Objid oid = arglist.v.list[1].v.obj;
Var desc = arglist.v.list[2];
Var code = arglist.v.list[3];
int i;
Program *program;
db_verb_handle h;
Var errors;
enum error e;
for (i = 1; i <= code.v.list[0].v.num; i++)
if (code.v.list[i].type != TYPE_STR) {
free_var(arglist);
return make_error_pack(E_TYPE);
}
if ((e = validate_verb_descriptor(desc)) != E_NONE
|| (e = E_INVARG, !valid(oid))) {
free_var(arglist);
return make_error_pack(e);
}
h = find_described_verb(oid, desc);
if (!h.ptr) {
free_var(arglist);
return make_error_pack(E_VERBNF);
} else if (!is_programmer(progr) || !db_verb_allows(h, progr, VF_WRITE)) {
free_var(arglist);
return make_error_pack(E_PERM);
}
program = parse_list_as_program(code, &errors);
if (program) {
if (task_timed_out)
free_program(program);
else
db_set_verb_program(h, program);
}
free_var(arglist);
return make_var_pack(errors);
}
sph_model::~sph_model()
{
free_arrays();
free_program();
}
void pike_module_exit(void)
{
free_program(inflate_program);
free_program(deflate_program);
}
void source_pikestream_exit( )
{
free_program( callback_program );
}
ShaderProgram::~ShaderProgram()
{
free_program();
}
/* Module exit... */
void exit_nbio(void) {
free_program(nbio_program);
}
void exit_stdio_port(void)
{
free_program( port_program );
}
/*! @decl program load_module(string module_name)
*!
*! Load a binary module.
*!
*! This function loads a module written in C or some other language
*! into Pike. The module is initialized and any programs or constants
*! defined will immediately be available.
*!
*! When a module is loaded the C function @tt{pike_module_init()@} will
*! be called to initialize it. When Pike exits @tt{pike_module_exit()@}
*! will be called. These two functions @b{must@} be available in the module.
*!
*! @note
*! The current working directory is normally not searched for
*! dynamic modules. Please use @expr{"./name.so"@} instead of just
*! @expr{"name.so"@} to load modules from the current directory.
*/
void f_load_module(INT32 args)
{
extern int global_callable_flags;
void *module;
modfun init, exit;
struct module_list *new_module;
struct pike_string *module_name;
ONERROR err;
module_name = Pike_sp[-args].u.string;
if((Pike_sp[-args].type != T_STRING) ||
(module_name->size_shift) ||
string_has_null(module_name)) {
Pike_error("Bad argument 1 to load_module()\n");
}
{
struct module_list *mp;
for (mp = dynamic_module_list; mp; mp = mp->next)
if (mp->name == module_name && mp->module_prog) {
pop_n_elems(args);
ref_push_program(mp->module_prog);
return;
}
}
/* Removing RTLD_GLOBAL breaks some PiGTK themes - Hubbe */
/* Using RTLD_LAZY is faster, but makes it impossible to
* detect linking problems at runtime..
*/
module=dlopen(module_name->str,
RTLD_NOW /*|RTLD_GLOBAL*/ );
if(!module)
{
struct object *err_obj = low_clone (module_load_error_program);
#define LOADERR_STRUCT(OBJ) \
((struct module_load_error_struct *) (err_obj->storage + module_load_error_offset))
const char *err = dlerror();
if (err) {
if (err[strlen (err) - 1] == '\n')
push_string (make_shared_binary_string (err, strlen (err) - 1));
else
push_text (err);
}
else
push_constant_text ("Unknown reason");
add_ref (LOADERR_STRUCT (err_obj)->path = Pike_sp[-args - 1].u.string);
add_ref (LOADERR_STRUCT (err_obj)->reason = Pike_sp[-1].u.string);
if (Pike_sp[-args].u.string->len < 1024) {
throw_error_object (err_obj, "load_module", Pike_sp - args - 1, args,
"load_module(\"%s\") failed: %s\n",
module_name->str, Pike_sp[-1].u.string->str);
} else {
throw_error_object (err_obj, "load_module", Pike_sp - args - 1, args,
"load_module() failed: %s\n",
Pike_sp[-1].u.string->str);
}
}
#ifdef PIKE_DEBUG
{
struct module_list *mp;
for (mp = dynamic_module_list; mp; mp = mp->next)
if (mp->module == module && mp->module_prog) {
fprintf(stderr, "load_module(): Module loaded twice:\n"
"Old name: %s\n"
"New name: %s\n",
mp->name->str, module_name->str);
pop_n_elems(args);
ref_push_program(mp->module_prog);
return;
}
}
#endif /* PIKE_DEBUG */
init = CAST_TO_FUN(dlsym(module, "pike_module_init"));
if (!init) {
init = CAST_TO_FUN(dlsym(module, "_pike_module_init"));
if (!init) {
dlclose(module);
Pike_error("pike_module_init missing in dynamic module \"%S\".\n",
module_name);
}
}
exit = CAST_TO_FUN(dlsym(module, "pike_module_exit"));
if (!exit) {
exit = CAST_TO_FUN(dlsym(module, "_pike_module_exit"));
if (!exit) {
dlclose(module);
Pike_error("pike_module_exit missing in dynamic module \"%S\".\n",
module_name);
}
}
#if defined(__NT__) && defined(_M_IA64)
{
fprintf(stderr, "pike_module_init: 0x%p\n"
" func: 0x%p\n"
" gp: 0x%p\n",
init, ((void **)init)[0], ((void **)init)[1]);
fprintf(stderr, "pike_module_exit: 0x%p\n"
" func: 0x%p\n"
" gp: 0x%p\n",
exit, ((void **)exit)[0], ((void **)exit)[1]);
}
#endif /* __NT__ && _M_IA64 */
new_module=ALLOC_STRUCT(module_list);
new_module->next=dynamic_module_list;
dynamic_module_list=new_module;
new_module->module=module;
copy_shared_string(new_module->name, Pike_sp[-args].u.string);
new_module->module_prog = NULL;
new_module->init=init;
new_module->exit=exit;
enter_compiler(new_module->name, 1);
start_new_program();
global_callable_flags|=CALLABLE_DYNAMIC;
#ifdef PIKE_DEBUG
{ struct svalue *save_sp=Pike_sp;
#endif
SET_ONERROR(err, cleanup_compilation, NULL);
#if defined(__NT__) && defined(_M_IA64)
fprintf(stderr, "Calling pike_module_init()...\n");
#endif /* __NT__ && _M_IA64 */
(*(modfun)init)();
#if defined(__NT__) && defined(_M_IA64)
fprintf(stderr, "pike_module_init() done.\n");
#endif /* __NT__ && _M_IA64 */
UNSET_ONERROR(err);
#ifdef PIKE_DEBUG
if(Pike_sp != save_sp)
Pike_fatal("load_module(%s) left %ld droppings on stack!\n",
module_name->str,
PTRDIFF_T_TO_LONG(Pike_sp - save_sp));
}
#endif
pop_n_elems(args);
{
struct program *p = end_program();
exit_compiler();
if (p) {
if (
#if 0
p->num_identifier_references
#else /* !0 */
1
#endif /* 0 */
) {
push_program(p);
add_ref(new_module->module_prog = Pike_sp[-1].u.program);
} else {
/* No identifier references -- Disabled module. */
free_program(p);
push_undefined();
}
} else {
/* Initialization failed. */
new_module->exit();
dlclose(module);
dynamic_module_list = new_module->next;
free_string(new_module->name);
free(new_module);
Pike_error("Failed to initialize dynamic module \"%S\".\n",
module_name);
}
}
}
void source_system_memory_exit( )
{
if (shm_program) {
free_program( shm_program );
}
}