[BACK]Return to sm_ext.c CVS log [TXT][DIR] Up to [local] / OpenXM / src / oxc

Diff for /OpenXM/src/oxc/sm_ext.c between version 1.10 and 1.12

version 1.10, 2003/05/07 04:00:30 version 1.12, 2016/04/02 15:01:46
Line 1 
Line 1 
 /* -*- mode: C; coding: euc-japan -*- */  /* -*- mode: C; coding: euc-japan -*- */
 /* $OpenXM: OpenXM/src/oxc/sm_ext.c,v 1.9 2000/12/14 01:35:58 ohara Exp $ */  /* $OpenXM: OpenXM/src/oxc/sm_ext.c,v 1.11 2016/04/01 18:12:39 ohara Exp $ */
   
 #include <stdio.h>  #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
Line 11 
Line 11 
 #include "sm.h"  #include "sm.h"
   
 static int  sm_control_spawn();  static int  sm_control_spawn();
 static void sm_control_terminate();  static int  sm_control_terminate();
 static void sm_control_kill();  static int  sm_control_kill();
 static void sm_control_reset_pid();  static int  sm_control_reset_pid();
   
 static void pid_extend();  static void pid_extend();
 static int  pid_lookup(pid_t pid);  static int  pid_lookup(pid_t pid);
 static int  pid_registed(pid_t pid);  static int  pid_registered(pid_t pid);
 static void pid_regist(pid_t pid);  static void pid_register(pid_t pid);
 static void pid_delete(pid_t pid);  static void pid_delete(pid_t pid);
 static int  pid_reset(pid_t pid);  static int  pid_reset(pid_t pid);
 static int  pid_kill(pid_t pid);  static int  pid_kill(pid_t pid);
 static void pid_kill_all();  static void pid_kill_all();
   
   #define IS_CMO_INT32(c)       ((c) && ((c)->tag == CMO_INT32))
   #define IS_CMO_STRING(c)      ((c) && ((c)->tag == CMO_STRING))
   #define IS_CMO_LIST(c)        ((c) && ((c)->tag == CMO_LIST))
   #define IS_CMO_LIST_LEN(c,n)  (IS_CMO_LIST(c) && (list_length((c)) >= (n)))
   
 /* ultra loose data base. */  /* ultra loose data base. */
 static struct { int (*func_ptr)(); char *key; } tbl_lfunc[] = {  static struct { int (*func_ptr)(); char *key; } tbl_lfunc[] = {
     {lf_oxc_open, "spawn"},      {lf_oxc_open, "spawn"},
Line 41  static struct { int (*func_ptr)(); int key; } tbl_smcm
Line 46  static struct { int (*func_ptr)(); int key; } tbl_smcm
     {sm_pops,            SM_pops},      {sm_pops,            SM_pops},
     {sm_control_reset_pid, SM_control_reset_connection_server},      {sm_control_reset_pid, SM_control_reset_connection_server},
     {sm_control_kill, SM_control_kill},      {sm_control_kill, SM_control_kill},
     {NULL, NULL}      {NULL, 0}
 };  };
   
 extern OXFILE *stack_oxfp;  extern OXFILE *stack_oxfp;
Line 49  extern OXFILE *stack_oxfp;
Line 54  extern OXFILE *stack_oxfp;
 int (*sm_search_f(int code))()  int (*sm_search_f(int code))()
 {  {
     int i;      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) {          if (code == tbl_smcmd[i].key) {
             return tbl_smcmd[i].func_ptr;              return tbl_smcmd[i].func_ptr;
         }          }
Line 73  Normally local functions push a return value to the st
Line 78  Normally local functions push a return value to the st
 but, if error occurs, then these return non-positive numbers and  but, if error occurs, then these return non-positive numbers and
 the sm_executeFunction push an error object.  the sm_executeFunction push an error object.
 */  */
 void sm_executeFunction()  int sm_executeFunction()
 {  {
     int (*func)();      int (*func)();
     int retcode = 0;      int retcode = 0;
Line 82  void sm_executeFunction()
Line 87  void sm_executeFunction()
         func = lookup_localfunction(((cmo_string *)ob)->s);          func = lookup_localfunction(((cmo_string *)ob)->s);
         if (func != NULL) {          if (func != NULL) {
             if ((retcode = func()) > 0) {              if ((retcode = func()) > 0) {
                 return;                  return 0;
             }              }
         }          }
     }      }
     push_error(retcode, ob);      push_error(retcode, ob);
       return 0;
 }  }
   
 /* getargs() set number of popped objects to argc. */  /* getargs() set number of popped objects to argc. */
Line 139  static int pid_lookup(pid_t pid)
Line 145  static int pid_lookup(pid_t pid)
     return -1;      return -1;
 }  }
   
 static int pid_registed(pid_t pid)  static int pid_registered(pid_t pid)
 {  {
     return pid_lookup(pid)+1;      return pid_lookup(pid)+1;
 }  }
   
 static void pid_regist(pid_t pid)  static void pid_register(pid_t pid)
 {  {
     if (pid_ptr >= pid_size) {      if (pid_ptr >= pid_size) {
         pids_extend();          pids_extend();
Line 162  static void pid_delete(pid_t pid)
Line 168  static void pid_delete(pid_t pid)
   
 static int pid_reset(pid_t pid)  static int pid_reset(pid_t pid)
 {  {
     if (pid_registed(pid)) {      if (pid_registered(pid)) {
         kill(pid, SIGUSR1);          kill(pid, SIGUSR1);
         return 1;          return 1;
     }      }
Line 171  static int pid_reset(pid_t pid)
Line 177  static int pid_reset(pid_t pid)
   
 static int pid_kill(pid_t pid)  static int pid_kill(pid_t pid)
 {  {
     if (pid_registed(pid)) {      if (pid_registered(pid)) {
         kill(pid, SIGKILL);          kill(pid, SIGKILL);
         pid_delete(pid);          pid_delete(pid);
         return 1;          return 1;
Line 198  cmo_error2 *type_checker(cmo *ob, int type)
Line 204  cmo_error2 *type_checker(cmo *ob, int type)
   
 int lf_oxc_open()  int lf_oxc_open()
 {  {
     cmo_int32 *argc = pop();      cmo_int32 *argc = (cmo_int32 *)pop();
         if (argc->tag == CMO_INT32 && argc->i == 1) {          if (argc->tag == CMO_INT32 && argc->i == 1) {
                 return sm_control_spawn();                  return sm_control_spawn();
         }          }
         push_error(-1, argc);          push_error(-1, (cmo *)argc);
         return -1;          return -1;
 }  }
   
 int sm_control_spawn_typecheck(cmo_list *args, cmo_list *ports, cmo_int32 *port, cmo_string *sname)  int sm_control_spawn_typecheck(cmo_list *args, int *portp, char **s)
 {  {
         char *cmd = sname->s;      cmo_int32 *port;
       cmo_string *name;
   
         return args->tag == CMO_LIST      if( IS_CMO_LIST_LEN(args,2) ) {
                 && list_length(args) > 1          name = (cmo_string *)list_nth(args, 1);
                 && ports->tag == CMO_LIST          args = (cmo_list *)list_first_cmo(args);
                 && list_length(ports) > 0          if( IS_CMO_STRING(name) && IS_CMO_LIST_LEN(args,1) ) {
                 && port->tag == CMO_INT32              port   = (cmo_int32 *)list_first_cmo(args);
                 && sname->tag == CMO_STRING              if( IS_CMO_INT32(port) && name->s && which(name->s, getenv("PATH")) != NULL) {
                 && cmd != NULL                  *portp = port->i;
                 && which(cmd, getenv("PATH")) != NULL;                  *s     = name->s;
                   return 1;
               }
           }
       }
       return 0;
 }  }
   
 static int sm_control_spawn()  static int sm_control_spawn()
 {  {
         cmo_list *args    = pop();      int port;
         cmo_list *ports   = list_first_cmo(args);      char *s;
         cmo_int32 *port   = list_first_cmo(ports);      pid_t pid;
         cmo_string *sname = list_nth(args, 1);      cmo *args = pop();
         pid_t pid;  
   
         if (sm_control_spawn_typecheck(args, ports, port, sname)) {      if (sm_control_spawn_typecheck((cmo_list *)args, &port, &s)) {
                 pid = lf_oxc_open_main(sname->s, port->i);          pid = lf_oxc_open_main(s, (short)port);
                 if (pid > 0) {          if (pid > 0) {
                         push(new_cmo_int32(pid));              push((cmo *)new_cmo_int32(pid));
                         pid_regist(pid);              pid_register(pid);
                         ox_printf("oxc: spawns %s\n", sname->s);              ox_printf("oxc: spawns %s\n", s);
                         return pid;              return pid;
                 }          }
         }      }
         push_error(-1, args);      push_error(-1, (cmo *)args);
         return 0;      return 0;
   
 }  }
   
 void sm_mathcap()  int sm_mathcap()
 {  {
     push((cmo *)oxf_cmo_mathcap(stack_oxfp));      push((cmo *)oxf_cmo_mathcap(stack_oxfp));
       return 0;
 }  }
   
 void sm_set_mathcap()  int sm_set_mathcap()
 {  {
     cmo_mathcap *m = (cmo_mathcap *)pop();      cmo_mathcap *m = (cmo_mathcap *)pop();
     if (m->tag == CMO_MATHCAP) {      if (m->tag == CMO_MATHCAP) {
         oxf_mathcap_update(stack_oxfp, m);          oxf_mathcap_update(stack_oxfp, m);
     }else {      }else {
         push_error(-1, m);          push_error(-1, (cmo *)m);
         /* an error object must be pushed */          /* an error object must be pushed */
     }      }
       return 0;
 }  }
   
 static void sm_control_kill()  static int sm_control_kill()
 {  {
     pid_kill_all();      pid_kill_all();
       return 0;
 }  }
   
 static void sm_control_terminate()  static int sm_control_terminate()
 {  {
     cmo_int32 *m = (cmo_int32 *)pop();      cmo_int32 *m = (cmo_int32 *)pop();
     pid_t pid = m->i;      pid_t pid = m->i;
     if (m->tag != CMO_INT32 || !pid_kill(pid)) {      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();      cmo_int32 *m = (cmo_int32 *)pop();
     pid_t pid = m->i;      pid_t pid = m->i;
     if (m->tag != CMO_INT32 || !pid_reset(pid)) {      if (m->tag != CMO_INT32 || !pid_reset(pid)) {
         push_error(-1, m);          push_error(-1, (cmo *)m);
         return;          return 0;
     }      }
     /* ... */      /* ... */
       return 0;
 }  }
Legend:
Removed from v.1.10  
changed lines
  Added in v.1.12
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>