=================================================================== RCS file: /home/cvs/OpenXM/src/oxc/sm_ext.c,v retrieving revision 1.4 retrieving revision 1.9 diff -u -p -r1.4 -r1.9 --- OpenXM/src/oxc/sm_ext.c 2000/11/28 04:52:05 1.4 +++ OpenXM/src/oxc/sm_ext.c 2000/12/14 01:35:58 1.9 @@ -1,44 +1,71 @@ /* -*- mode: C; coding: euc-japan -*- */ -/* $OpenXM: OpenXM/src/oxc/sm_ext.c,v 1.3 2000/11/28 04:02:56 ohara Exp $ */ +/* $OpenXM: OpenXM/src/oxc/sm_ext.c,v 1.8 2000/12/03 14:32:40 ohara Exp $ */ #include #include #include #include +#include #include #include #include "sm.h" +static int sm_control_spawn(); +static void sm_control_terminate(); +static void sm_control_kill(); +static void sm_control_reset_pid(); + +static void pid_extend(); +static int pid_lookup(pid_t pid); +static int pid_registed(pid_t pid); +static void pid_regist(pid_t pid); +static void pid_delete(pid_t pid); +static int pid_reset(pid_t pid); +static int pid_kill(pid_t pid); +static void pid_kill_all(); + /* ultra loose data base. */ -static db db_localfunc[] = { +static struct { int (*func_ptr)(); char *key; } tbl_lfunc[] = { + {lf_oxc_open, "spawn"}, {lf_oxc_open, "oxc_open"}, {NULL, NULL} }; -static db db_sm[] = { +static struct { int (*func_ptr)(); int key; } tbl_smcmd[] = { + {sm_control_spawn, SM_control_spawn_server}, + {sm_control_terminate, SM_control_terminate_server}, {sm_executeFunction, SM_executeFunction}, {sm_mathcap, SM_mathcap}, {sm_set_mathcap, SM_setMathCap}, {sm_popCMO, SM_popCMO}, {sm_pops, SM_pops}, + {sm_control_reset_pid, SM_control_reset_connection_server}, + {sm_control_kill, SM_control_kill}, {NULL, NULL} }; -__inline__ -static int (*db_search(void *key, db *dbs, int (*cmp)(void *, void *)))() +extern OXFILE *stack_oxfp; + +int (*sm_search_f(int code))() { - while (dbs->key != NULL) { - if (cmp(key, dbs->key) == 0) { - return dbs->func_ptr; + int i; + for (i=0; tbl_smcmd[i].key != NULL; i++) { + if (code == tbl_smcmd[i].key) { + return tbl_smcmd[i].func_ptr; } - dbs++; } return NULL; } static int (*lookup_localfunction(char *name))() { - return db_search(name, db_localfunc, strcmp); + int i; + for (i=0; tbl_lfunc[i].key != NULL; i++) { + if (strcmp(name, tbl_lfunc[i].key) == 0) { + return tbl_lfunc[i].func_ptr; + } + } + return NULL; } /* @@ -46,15 +73,15 @@ Normally local functions push a return value to the st but, if error occurs, then these return non-positive numbers and the sm_executeFunction push an error object. */ -void sm_executeFunction(OXFILE *oxfp) +void sm_executeFunction() { - int (*func)(OXFILE *); + int (*func)(); int retcode = 0; cmo *ob = pop(); if (ob->tag == CMO_STRING) { func = lookup_localfunction(((cmo_string *)ob)->s); if (func != NULL) { - if ((retcode = func(oxfp)) > 0) { + if ((retcode = func()) > 0) { return; } } @@ -82,11 +109,27 @@ static int getargs(cmo ***args) return argc; } -static int pids[1024] = {0}; +#define MAX_PROCESS 1024 + +/* Process Table */ +static pid_t *pids = NULL; static int pid_ptr = 0; +static int pid_size = 0; -int pid_lookup(int pid) +static void pids_extend() { + int size2 = pid_size + MAX_PROCESS; + pid_t *pids2 = (pid_t *)malloc(sizeof(pid_t)*size2); + if (pids != NULL) { + memcpy(pids2, pids, sizeof(pid_t)*pid_size); + free(pids); + } + pid_size = size2; + pids = pids2; +} + +static int pid_lookup(pid_t pid) +{ int i; for(i=0; i= pid_size) { + pids_extend(); } - return 0; + pids[pid_ptr++] = pid; } -void pid_delete(int pid) +static void pid_delete(pid_t pid) { int i = pid_lookup(pid); if (i >= 0 && i != --pid_ptr) { @@ -118,78 +160,125 @@ void pid_delete(int pid) } } -int lf_oxc_open() +static int pid_reset(pid_t pid) { - cmo **argv; - char *cmd; - int port; - int pid; + if (pid_registed(pid)) { + kill(pid, SIGUSR1); + return 1; + } + return 0; +} - if (getargs(&argv) != 2 || argv[0]->tag != CMO_STRING - || argv[1]->tag != CMO_INT32) { - fprintf(stderr, "oxc: invalid arguments\n"); - return -1; +static int pid_kill(pid_t pid) +{ + if (pid_registed(pid)) { + kill(pid, SIGKILL); + pid_delete(pid); + return 1; } + return 0; +} - cmd = ((cmo_string *)argv[0])->s; - port = ((cmo_int32 *)argv[1])->i; - pid = lf_oxc_open_main(cmd, port); - if (pid > 0) { - push(new_cmo_int32(pid)); - pid_regist(pid); +/* Killing all child processes */ +static void pid_kill_all() +{ + while(pid_ptr > 0) { + kill(pids[--pid_ptr], SIGKILL); } - return pid; } -void sm_mathcap(OXFILE *oxfp) +cmo_error2 *type_checker(cmo *ob, int type) { - push((cmo *)oxf_cmo_mathcap(oxfp)); +/* cmo_error2 *err_ob; */ + if (ob->tag != type) { + /* push and return an error object */ + } + return NULL; } -void sm_set_mathcap(OXFILE *oxfp) +int lf_oxc_open() { + cmo_int32 *argc = pop(); + if (argc->tag == CMO_INT32 && argc->i == 1) { + return sm_control_spawn(); + } + push_error(-1, argc); + return -1; +} + +int sm_control_spawn_typecheck(cmo_list *args, cmo_list *ports, cmo_int32 *port, cmo_string *sname) +{ + char *cmd = sname->s; + + return args->tag == CMO_LIST + && list_length(args) > 1 + && ports->tag == CMO_LIST + && list_length(ports) > 0 + && port->tag == CMO_INT32 + && sname->tag == CMO_STRING + && cmd != NULL + && which(cmd, getenv("PATH")) != NULL; +} + +static int sm_control_spawn() +{ + cmo_list *args = pop(); + cmo_list *ports = list_first_cmo(args); + cmo_int32 *port = list_first_cmo(ports); + cmo_string *sname = list_nth(args, 1); + pid_t pid; + + if (sm_control_spawn_typecheck(args, ports, port, sname)) { + pid = lf_oxc_open_main(sname->s, port->i); + if (pid > 0) { + push(new_cmo_int32(pid)); + pid_regist(pid); + fprintf(stderr, "oxc: spawns %s\n", sname->s); + return pid; + } + } + push_error(-1, args); + return 0; + +} + +void sm_mathcap() +{ + push((cmo *)oxf_cmo_mathcap(stack_oxfp)); +} + +void sm_set_mathcap() +{ cmo_mathcap *m = (cmo_mathcap *)pop(); if (m->tag == CMO_MATHCAP) { - oxf_mathcap_update(oxfp, m); + oxf_mathcap_update(stack_oxfp, m); }else { push_error(-1, m); /* an error object must be pushed */ } } -void sm_control_kill(OXFILE *oxfp) +static void sm_control_kill() { - cmo_int32 *m = (cmo_int32 *)pop(); - int pid = m->i; - if (m->tag != CMO_INT32 || !pid_registed(pid)) { - push_error(-1, m); - }else { - kill(pid, SIGKILL); - pid_delete(pid); - } + pid_kill_all(); } -void sm_control_reset(OXFILE *oxfp) +static void sm_control_terminate() { cmo_int32 *m = (cmo_int32 *)pop(); - int pid = m->i; - if (m->tag != CMO_INT32 || !pid_registed(pid)) { + pid_t pid = m->i; + if (m->tag != CMO_INT32 || !pid_kill(pid)) { push_error(-1, m); - }else { - kill(pid, SIGUSR1); } } -void sm_control_spawn_server(OXFILE *oxfp); -void sm_control_terminate_server(OXFILE *oxfp); - -static int intcmp(int key1, int key2) +static void sm_control_reset_pid() { - return key1 != key2; -} - - -int (*sm_search_f(int code))() -{ - return db_search(code, db_sm, intcmp); + cmo_int32 *m = (cmo_int32 *)pop(); + pid_t pid = m->i; + if (m->tag != CMO_INT32 || !pid_reset(pid)) { + push_error(-1, m); + return; + } + /* ... */ }