===================================================================
RCS file: /home/cvs/OpenXM/src/oxc/sm_ext.c,v
retrieving revision 1.3
retrieving revision 1.5
diff -u -p -r1.3 -r1.5
--- OpenXM/src/oxc/sm_ext.c	2000/11/28 04:02:56	1.3
+++ OpenXM/src/oxc/sm_ext.c	2000/11/28 18:11:42	1.5
@@ -1,10 +1,11 @@
 /* -*- mode: C; coding: euc-japan -*- */
-/* $OpenXM: OpenXM/src/oxc/sm_ext.c,v 1.2 2000/11/18 06:03:42 ohara Exp $ */
+/* $OpenXM: OpenXM/src/oxc/sm_ext.c,v 1.4 2000/11/28 04:52:05 ohara Exp $ */
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <string.h>
+#include <sys/types.h>
 #include <signal.h>
 #include <ox_toolkit.h>
 #include "sm.h"
@@ -18,8 +19,12 @@ static db db_localfunc[] = {
 static db db_sm[] = {
     {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_pid},
+	{sm_control_kill_pid, SM_control_kill_pid},
+	{sm_control_kill, SM_control_kill},
     {NULL, NULL}
 };
 
@@ -48,17 +53,17 @@ the sm_executeFunction push an error object.
 void sm_executeFunction(OXFILE *oxfp)
 {
     int (*func)(OXFILE *);
-	int retcode = 0;
+    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) {
-				return;
-			}
+                return;
+            }
         }
     }
-	push_error(retcode, ob);
+    push_error(retcode, ob);
 }
 
 /* getargs() set number of popped objects to argc. */
@@ -67,7 +72,7 @@ static int getargs(cmo ***args)
     cmo **argv;
     int i;
     int argc = -1;
-    cmo_int32 *m = pop();
+    cmo_int32 *m = (cmo_int32 *)pop();
 
     if (m->tag != CMO_INT32 || (argc = m->i) < 0) {
         fprintf(stderr, "oxc: invalid arguments\n");
@@ -78,103 +83,152 @@ static int getargs(cmo ***args)
         }
         *args = argv;
     }
-	return argc;
+    return argc;
 }
 
-static int pids[1024] = {0};
+#define MAX_PROCESS 1024
+
+static pid_t *pids = NULL;
 static int pid_ptr = 0;
+static int pid_size = 0;
 
-int pid_lookup(int pid)
+void pids_extend()
 {
-	int i;
-	for(i=0; i<pid_ptr; i++) {
-		if (pids[i] == pid) {
-			return i;
-		}
-	}
-	return -1;
+    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;
 }
 
-int pid_registed(int pid)
+int pid_lookup(pid_t pid)
 {
-	return pid_lookup(pid)+1;
+    int i;
+    for(i=0; i<pid_ptr; i++) {
+        if (pids[i] == pid) {
+            return i;
+        }
+    }
+    return -1;
 }
 
-int pid_regist(int pid)
+int pid_registed(pid_t pid)
 {
-	if (pid_ptr < 1024) {
-		pids[pid_ptr++] = pid;
-		return pid;
+    return pid_lookup(pid)+1;
+}
+
+void pid_regist(pid_t pid)
+{
+    if (pid_ptr >= pid_size) {
+		pids_extend();
+    }
+	pids[pid_ptr++] = pid;
+}
+
+void pid_delete(pid_t pid)
+{
+    int i = pid_lookup(pid);
+    if (i >= 0 && i != --pid_ptr) {
+        pids[i] = pids[pid_ptr];
+    }
+}
+
+int pid_reset(pid_t pid)
+{
+	if (pid_registed(pid)) {
+		kill(pid, SIGUSR1);
+		return 1;
 	}
 	return 0;
 }
 
-void pid_delete(int pid)
+int pid_kill(pid_t pid)
 {
-	int i = pid_lookup(pid);
-	if (i >= 0 && i != --pid_ptr) {
-		pids[i] = pids[pid_ptr];
+	if (pid_registed(pid)) {
+		kill(pid, SIGKILL);
+		pid_delete(pid);
+		return 1;
 	}
+	return 0;
 }
 
+/* Killing all child processes */
+void pid_kill_all()
+{
+	while(pid_ptr > 0) {
+        kill(pids[--pid_ptr], SIGKILL);
+	}
+}
+
 int lf_oxc_open()
 {
     cmo **argv;
     char *cmd;
     int port;
-    int pid;
+    pid_t pid;
 
     if (getargs(&argv) != 2 || argv[0]->tag != CMO_STRING
-		|| argv[1]->tag != CMO_INT32) {
-		fprintf(stderr, "oxc: invalid arguments\n");
+        || argv[1]->tag != CMO_INT32) {
+        fprintf(stderr, "oxc: invalid arguments\n");
         return -1;
     }
 
-	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);
-	}
-	return pid;
+    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);
+    }
+    return pid;
 }
 
 void sm_mathcap(OXFILE *oxfp)
 {
-	cmo_mathcap *m = pop();
-	if (m->tag == CMO_MATHCAP) {
-		oxf_mathcap_update(oxfp, m);
-	}else {
-		push_error(-1, m);
-		/* an error object must be pushed */
-	}
+    push((cmo *)oxf_cmo_mathcap(oxfp));
 }
 
+void sm_set_mathcap(OXFILE *oxfp)
+{
+    cmo_mathcap *m = (cmo_mathcap *)pop();
+    if (m->tag == CMO_MATHCAP) {
+        oxf_mathcap_update(oxfp, m);
+    }else {
+        push_error(-1, m);
+        /* an error object must be pushed */
+    }
+}
+
 void sm_control_kill(OXFILE *oxfp)
 {
-	cmo_int32 *m = 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)
+void sm_control_kill_pid(OXFILE *oxfp)
 {
-	cmo_int32 *m = pop();
-	int pid = m->i;
-	if (m->tag != CMO_INT32 || !pid_registed(pid)) {
-		push_error(-1, m);
-	}else {
-		kill(pid, SIGUSR1);
-	}
+    cmo_int32 *m = (cmo_int32 *)pop();
+    pid_t pid = m->i;
+    if (m->tag != CMO_INT32 || !pid_kill(pid)) {
+        push_error(-1, m);
+    }
 }
 
-void sm_control_start_engin(OXFILE *oxfp);
+void sm_control_reset_pid(OXFILE *oxfp)
+{
+    cmo_int32 *m = (cmo_int32 *)pop();
+    pid_t pid = m->i;
+    if (m->tag != CMO_INT32 || !pid_reset(pid)) {
+        push_error(-1, m);
+		return;
+    }
+	/* ... */
+}
+
+void sm_control_spawn_server(OXFILE *oxfp);
+void sm_control_terminate_server(OXFILE *oxfp);
 
 static int intcmp(int key1, int key2)
 {