===================================================================
RCS file: /home/cvs/OpenXM/src/oxc/sm_ext.c,v
retrieving revision 1.8
retrieving revision 1.11
diff -u -p -r1.8 -r1.11
--- OpenXM/src/oxc/sm_ext.c	2000/12/03 14:32:40	1.8
+++ OpenXM/src/oxc/sm_ext.c	2016/04/01 18:12:39	1.11
@@ -1,5 +1,5 @@
 /* -*- mode: C; coding: euc-japan -*- */
-/* $OpenXM: OpenXM/src/oxc/sm_ext.c,v 1.7 2000/12/01 01:53:34 ohara Exp $ */
+/* $OpenXM: OpenXM/src/oxc/sm_ext.c,v 1.10 2003/05/07 04:00:30 ohara Exp $ */
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -11,9 +11,9 @@
 #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 int  sm_control_terminate();
+static int  sm_control_kill();
+static int  sm_control_reset_pid();
 
 static void pid_extend();
 static int  pid_lookup(pid_t pid);
@@ -41,7 +41,7 @@ static struct { int (*func_ptr)(); int key; } tbl_smcm
     {sm_pops,            SM_pops},
     {sm_control_reset_pid, SM_control_reset_connection_server},
     {sm_control_kill, SM_control_kill},
-    {NULL, NULL}
+    {NULL, 0}
 };
 
 extern OXFILE *stack_oxfp;
@@ -49,7 +49,7 @@ extern OXFILE *stack_oxfp;
 int (*sm_search_f(int code))()
 {
     int i;
-    for (i=0; tbl_smcmd[i].key != NULL; i++) {
+    for (i=0; tbl_smcmd[i].key != 0; i++) {
         if (code == tbl_smcmd[i].key) {
             return tbl_smcmd[i].func_ptr;
         }
@@ -73,7 +73,7 @@ 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()
+int sm_executeFunction()
 {
     int (*func)();
     int retcode = 0;
@@ -82,11 +82,12 @@ void sm_executeFunction()
         func = lookup_localfunction(((cmo_string *)ob)->s);
         if (func != NULL) {
             if ((retcode = func()) > 0) {
-                return;
+                return 0;
             }
         }
     }
     push_error(retcode, ob);
+    return 0;
 }
 
 /* getargs() set number of popped objects to argc. */
@@ -98,7 +99,7 @@ static int getargs(cmo ***args)
     cmo_int32 *m = (cmo_int32 *)pop();
 
     if (m->tag != CMO_INT32 || (argc = m->i) < 0) {
-        fprintf(stderr, "oxc: invalid arguments\n");
+        ox_printf("oxc: invalid arguments\n");
     }else {
         argv = (cmo **)malloc(sizeof(cmo *)*argc);
         for(i=0; i<argc; i++) {
@@ -196,81 +197,94 @@ cmo_error2 *type_checker(cmo *ob, int type)
     return NULL;
 }
 
-static int sm_control_spawn_main(int argc, cmo *argv[])
+int lf_oxc_open()
 {
-    char *cmd = ((cmo_string *)argv[0])->s;
-    int  port = ((cmo_int32 *)argv[1])->i;
-    pid_t pid = lf_oxc_open_main(cmd, port);
-    if (pid > 0) {
-        push(new_cmo_int32(pid));
-        pid_regist(pid);
-    }
-    return pid;
+    cmo_int32 *argc = (cmo_int32 *)pop();
+	if (argc->tag == CMO_INT32 && argc->i == 1) {
+		return sm_control_spawn();
+	}
+	push_error(-1, (cmo *)argc);
+	return -1;
 }
 
-int lf_oxc_open()
+int sm_control_spawn_typecheck(cmo_list *args, cmo_list *ports, cmo_int32 *port, cmo_string *sname)
 {
-    cmo **argv;
-    if (getargs(&argv) != 2 || 
-        type_checker(argv[0], CMO_STRING) != NULL 
-        || type_checker(argv[0], CMO_INT32) != NULL) {
-        fprintf(stderr, "oxc: invalid arguments\n");
-        return -1;
-    }
-    return sm_control_spawn_main(2, argv);
+	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 *argv[2];
-    argv[0] = pop();
-    argv[1] = pop();
+	cmo_list *args    = (cmo_list *)pop();
+	cmo_list *ports   = (cmo_list *)list_first_cmo(args);
+	cmo_int32 *port   = (cmo_int32 *)list_first_cmo(ports);
+	cmo_string *sname = (cmo_string *)list_nth(args, 1);
+	pid_t pid;
 
-    if (type_checker(argv[0], CMO_STRING) != NULL 
-        || type_checker(argv[0], CMO_INT32) != NULL) {
-        fprintf(stderr, "oxc: invalid arguments\n");
-        return -1;
-    }
-    return sm_control_spawn_main(2, argv);
+	if (sm_control_spawn_typecheck(args, ports, port, sname)) {
+		pid = lf_oxc_open_main(sname->s, (short)port->i);
+		if (pid > 0) {
+			push((cmo *)new_cmo_int32(pid));
+			pid_regist(pid);
+			ox_printf("oxc: spawns %s\n", sname->s);
+			return pid;
+		}
+	}
+	push_error(-1, (cmo *)args);
+	return 0;
+
 }
 
-void sm_mathcap()
+int sm_mathcap()
 {
     push((cmo *)oxf_cmo_mathcap(stack_oxfp));
+    return 0;
 }
 
-void sm_set_mathcap()
+int sm_set_mathcap()
 {
     cmo_mathcap *m = (cmo_mathcap *)pop();
     if (m->tag == CMO_MATHCAP) {
         oxf_mathcap_update(stack_oxfp, m);
     }else {
-        push_error(-1, m);
+        push_error(-1, (cmo *)m);
         /* an error object must be pushed */
     }
+    return 0;
 }
 
-static void sm_control_kill()
+static int sm_control_kill()
 {
     pid_kill_all();
+    return 0;
 }
 
-static void sm_control_terminate()
+static int sm_control_terminate()
 {
     cmo_int32 *m = (cmo_int32 *)pop();
     pid_t pid = m->i;
     if (m->tag != CMO_INT32 || !pid_kill(pid)) {
-        push_error(-1, m);
+        push_error(-1, (cmo *)m);
     }
+    return 0;
 }
 
-static void sm_control_reset_pid()
+static int sm_control_reset_pid()
 {
     cmo_int32 *m = (cmo_int32 *)pop();
     pid_t pid = m->i;
     if (m->tag != CMO_INT32 || !pid_reset(pid)) {
-        push_error(-1, m);
-        return;
+        push_error(-1, (cmo *)m);
+        return 0;
     }
     /* ... */
+    return 0;
 }