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

Diff for /OpenXM/src/ox_ntl/oxserv.c between version 1.2 and 1.3

version 1.2, 2003/11/08 12:34:00 version 1.3, 2003/11/15 09:06:20
Line 1 
Line 1 
 /* $OpenXM: OpenXM/src/ox_ntl/oxserv.c,v 1.1 2003/11/03 03:11:21 iwane Exp $ */  /* $OpenXM: OpenXM/src/ox_ntl/oxserv.c,v 1.2 2003/11/08 12:34:00 iwane Exp $ */
   
 #include <stdio.h>  #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
 #include <errno.h>  #include <errno.h>
 #include <signal.h>  #include <signal.h>
   #include <setjmp.h>
   
 #include "oxserv.h"  #include "oxserv.h"
 #include "oxstack.h"  #include "oxstack.h"
   
   #include "gc/gc.h"
   
 #define DPRINTF(x)      printf x; fflush(stdout)  #define DPRINTF(x)      printf x; fflush(stdout)
   
 #if 0  #define FP      stdout
   #define EPRINTF(x)      fprintf x; fflush(FP)
   
   #if 1
 /*===========================================================================*  /*===========================================================================*
  * for DEBUG   * for DEBUG
  *===========================================================================*/   *===========================================================================*/
Line 38  dprintf(const char *fmt, ...)
Line 43  dprintf(const char *fmt, ...)
 /*===========================================================================*  /*===========================================================================*
  * MACRO   * MACRO
  *===========================================================================*/   *===========================================================================*/
 #define MOXSERV_GET_CMO_TAG(m)  ((G_getCmoTag == NULL) ? m->tag : G_getCmoTag(m))  #define oxserv_get_cmo_tag(m)   ((G_getCmoTag == NULL) ? m->tag : G_getCmoTag(m))
   
   
 #define oxserv_delete_cmo(c)         \  #define oxserv_delete_cmo(c)         \
 do {                                 \  do {                                 \
         if (G_DeleteCmo != NULL)     \          if (c != NULL) {             \
               if (G_DeleteCmo != NULL) \
                 G_DeleteCmo(c);      \                  G_DeleteCmo(c);      \
         else                         \              else                     \
                 c = NULL;            \                  c = NULL;            \
           }                            \
 } while (0)  } while (0)
   
   
   
 /*===========================================================================*  /*===========================================================================*
  * Global Variables.   * Global Variables.
  *===========================================================================*/   *===========================================================================*/
Line 58  do {                                 \
Line 64  do {                                 \
 static OXFILE *G_oxfilep = NULL;  static OXFILE *G_oxfilep = NULL;
 static cmo_mathcap *G_oxserv_mathcap = NULL;  static cmo_mathcap *G_oxserv_mathcap = NULL;
   
   /* signal */
   sigset_t        G_oxserv_sigusr1;
   static jmp_buf  G_jmpbuf;
   
 /* User Function */  /* User Function */
 static void (*G_userExecuteFunction)(const char *, cmo **, int) = NULL;  static void (*G_userExecuteFunction)(const char *, cmo **, int) = NULL;
 static void (*G_userExecuteStringParser)(const char *) = NULL;  static void (*G_userExecuteStringParser)(const char *) = NULL;
Line 68  static void (*G_DeleteCmo)(cmo *) = NULL;
Line 78  static void (*G_DeleteCmo)(cmo *) = NULL;
   
 static int  (*G_getCmoTag)(cmo *) = NULL;  static int  (*G_getCmoTag)(cmo *) = NULL;
   
   
 /*===========================================================================*  /*===========================================================================*
    * CMO_ERROR2
    *===========================================================================*/
   #define new_cmo_error2_string(msg) new_cmo_error2((cmo *)new_cmo_string(msg))
   
   
   static void
   oxserv_push_errormes(char *msg)
   {
           EPRINTF((FP, "%s\n", msg));
           oxstack_push((cmo *)new_cmo_error2_string(msg));
   }
   
   /*===========================================================================*
    * synchronized malloc
    *===========================================================================*/
   void *
   oxserv_malloc(size_t size)
   {
           void *ptr;
   
           BLOCK_INPUT();
           ptr = GC_malloc(size);
           UNBLOCK_INPUT();
   
           return (ptr);
   }
   
   void
   oxserv_free(void *ptr, size_t size)
   {
           /* nothing */
   }
   
   void *
   oxserv_realloc(void *org, size_t old, size_t size)
   {
           void *ptr;
   
           BLOCK_INPUT();
           ptr = GC_realloc(org, size);
           UNBLOCK_INPUT();
   
           return (ptr);
   }
   
   
   
   /*===========================================================================*
  * OX_SERVER   * OX_SERVER
  *===========================================================================*/   *===========================================================================*/
   
Line 83  static int  (*G_getCmoTag)(cmo *) = NULL;
Line 142  static int  (*G_getCmoTag)(cmo *) = NULL;
 static void  static void
 oxserv_sm_popCMO(OXFILE *fd)  oxserv_sm_popCMO(OXFILE *fd)
 {  {
         cmo *m = oxstack_pop();          cmo *m, *n;
           m = oxstack_pop();
         if (m == NULL) {          if (m == NULL) {
                   EPRINTF((FP, "stack underflow in popCMO\n"));
                 m = new_cmo_null();                  m = new_cmo_null();
         } else if (G_convertCmo) {          } else if (G_convertCmo) {
                 m = G_convertCmo(m);                  n = G_convertCmo(m);
                   if (m != n)
                           oxserv_delete_cmo(m);
                   m = n;
         }          }
   
         send_ox_cmo(fd, m);          send_ox_cmo(fd, m);
Line 110  oxserv_sm_popString(OXFILE *fd)
Line 174  oxserv_sm_popString(OXFILE *fd)
         cmo *m = oxstack_pop();          cmo *m = oxstack_pop();
         cmo_string *m_str;          cmo_string *m_str;
   
         if (m == NULL)          if (m == NULL) {
                   EPRINTF((FP, "stack underflow in popString\n"));
                 m = new_cmo_null();                  m = new_cmo_null();
           }
   
         str = new_string_set_cmo(m);          str = new_string_set_cmo(m);
   
Line 141  oxserv_sm_pops()
Line 207  oxserv_sm_pops()
         int i;          int i;
   
         c = (cmo_int32 *)oxstack_pop(); /* suppose */          c = (cmo_int32 *)oxstack_pop(); /* suppose */
           if (c == NULL) {
                   EPRINTF((FP, "stack underflow in pops\n"));
                   return ;
           }
   
         n = oxstack_get_stack_pointer();          n = oxstack_get_stack_pointer();
         if (c->i < n)          if (c->i < n)
Line 286  static void
Line 356  static void
 oxserv_sm_executeStringByLocalParserInBatchMode(void)  oxserv_sm_executeStringByLocalParserInBatchMode(void)
 {  {
         cmo_string *str = (cmo_string *)oxstack_peek();          cmo_string *str = (cmo_string *)oxstack_peek();
           if (str == NULL) {
                   oxserv_push_errormes("stack underflow in executeStringByLocalParserInBatchMode");
                   return ;
           }
         G_userExecuteStringParser(str->s);          G_userExecuteStringParser(str->s);
 }  }
   
Line 301  static void
Line 375  static void
 oxserv_sm_executeStringByLocalParser(void)  oxserv_sm_executeStringByLocalParser(void)
 {  {
         cmo_string *str = (cmo_string *)oxstack_pop();          cmo_string *str = (cmo_string *)oxstack_pop();
           if (str == NULL) {
                   oxserv_push_errormes("stack underflow in executeStringByLocalParser");
                   return ;
           }
         G_userExecuteStringParser(str->s);          G_userExecuteStringParser(str->s);
 }  }
   
Line 320  oxserv_sm_executeFunction(void)
Line 398  oxserv_sm_executeFunction(void)
         int i;          int i;
         cmo_string *name = (cmo_string *)oxstack_pop();          cmo_string *name = (cmo_string *)oxstack_pop();
         cmo_int32 *cnt = (cmo_int32 *)oxstack_pop();          cmo_int32 *cnt = (cmo_int32 *)oxstack_pop();
         cmo **arg = (cmo **)malloc(cnt->i * sizeof(cmo *));          cmo **arg;
   
           arg = (cmo **)malloc(cnt->i * sizeof(cmo *));
   
           if (name == NULL || cnt == NULL) {
                   oxserv_push_errormes("stack underflow in executeFunction");
                   return ;
           }
   
         for (i = 0; i < cnt->i; i++) {          for (i = 0; i < cnt->i; i++) {
                 arg[i] = oxstack_pop();                  arg[i] = oxstack_pop();
                   if (arg[i] == NULL) {
                           oxserv_push_errormes("stack underflow in executeFunction");
                           return ;
                   }
         }          }
   
         /* user function */          /* user function */
Line 351  static void
Line 440  static void
 oxserv_sm_pushCMOtag()  oxserv_sm_pushCMOtag()
 {  {
         cmo *c = oxstack_peek();          cmo *c = oxstack_peek();
         cmo_int32 *tag = new_cmo_int32(MOXSERV_GET_CMO_TAG(c));          cmo_int32 *tag = new_cmo_int32(oxserv_get_cmo_tag(c));
         oxstack_push((cmo *)tag);          oxstack_push((cmo *)tag);
 }  }
   
   
   /*****************************************************************************
    * -- SM_dupErrors --
    *
    * PARAM : NONE
    * RETURN: NONE
    *****************************************************************************/
 static void  static void
 oxserv_sm_dupErrors()  oxserv_sm_dupErrors()
 {  {
Line 375  oxserv_sm_dupErrors()
Line 470  oxserv_sm_dupErrors()
         oxstack_push((cmo *)list);          oxstack_push((cmo *)list);
 }  }
   
   
   
   
   /*****************************************************************************
    * -- SM_control_reset_connection -- signal handler for SIGUSR1 --
    *
    * PARAM : NONE
    * RETURN: NONE
    *****************************************************************************/
 static void  static void
 oxserv_sm_control_reset_connection(int sig)  oxserv_sm_control_reset_connection(int sig)
 {  {
         int tag;          int tag;
         OXFILE *fd = G_oxfilep;          OXFILE *fd = G_oxfilep;
   
         DPRINTF(("reset -- start\n"));          DPRINTF(("reset -- start ==> "));
         send_ox_tag(fd, OX_SYNC_BALL);          send_ox_tag(fd, OX_SYNC_BALL);
   
         oxstack_init_stack();          oxstack_init_stack();
   
         for (;;) {          for (;;) {
                 tag = receive_ox_tag(fd);                  tag = receive_ox_tag(fd);
                 DPRINTF(("[%d=0x%x]", tag, tag));                  DPRINTF(("[OX:%d=0x%x]", tag, tag));
                 if (tag == OX_SYNC_BALL)                  if (tag == OX_SYNC_BALL)
                         break;                          break;
                 if (tag == OX_DATA)                  if (tag == OX_DATA)
                         receive_cmo(fd);                          receive_cmo(fd);
                   else
                           receive_int32(fd);
         }          }
         DPRINTF(("-- end.\n"));          DPRINTF((" <== end.\n"));
   
           longjmp(G_jmpbuf, sig);
 }  }
   
   /*****************************************************************************
    * execute sm command
    *
    * PARAM : NONE
    * RETURN: NONE
    *****************************************************************************/
 static int  static int
 oxserv_receive_and_execute_sm_command(OXFILE *fd)  oxserv_execute_sm_command(OXFILE *fd, int code)
 {  {
         int code = receive_int32(fd);  
   
           DPRINTF(("[SM:%d=0x%x]", code, code));
   
         switch (code) {          switch (code) {
         case SM_popCMO:          case SM_popCMO: /* 262 */
                 oxserv_sm_popCMO(fd);                  oxserv_sm_popCMO(fd);
                 break;                  break;
         case SM_executeStringByLocalParser:          case SM_executeStringByLocalParser: /* 268 */
                 if (G_userExecuteStringParser)                  if (G_userExecuteStringParser)
                         oxserv_sm_executeStringByLocalParser();                          oxserv_sm_executeStringByLocalParser();
                 break;                  break;
         case SM_executeStringByLocalParserInBatchMode:          case SM_executeStringByLocalParserInBatchMode: /* 274 */
                 if (G_userExecuteStringParser)                  if (G_userExecuteStringParser)
                         oxserv_sm_executeStringByLocalParserInBatchMode();                          oxserv_sm_executeStringByLocalParserInBatchMode();
                 break;                  break;
         case SM_pops:          case SM_pops: /* 265 */
                 oxserv_sm_pops();                  oxserv_sm_pops();
                 break;                  break;
         case SM_popString:          case SM_popString: /* 263 */
                 oxserv_sm_popString(fd);                  oxserv_sm_popString(fd);
                 break;                  break;
         case SM_getsp:          case SM_getsp: /* 275 */
                 oxserv_sm_getsp();                  oxserv_sm_getsp();
                 break;                  break;
         case SM_mathcap:          case SM_mathcap: /* 264 */
                 oxserv_sm_mathcap();                  oxserv_sm_mathcap();
                 break;                  break;
         case SM_setMathCap:          case SM_setMathCap: /* 273 */
                 /* dont support */                  /* dont support */
                 oxstack_pop();                  oxstack_pop();
                 break;                  break;
         case SM_executeFunction:          case SM_executeFunction: /* 269 */
                 if (G_userExecuteFunction)                  if (G_userExecuteFunction)
                         oxserv_sm_executeFunction();                          oxserv_sm_executeFunction();
                 break;                  break;
         case SM_pushCMOtag:          case SM_pushCMOtag: /* 277 */
                 oxserv_sm_pushCMOtag();                  oxserv_sm_pushCMOtag();
                 break;                  break;
         case SM_dupErrors:          case SM_dupErrors: /* 276 */
                 oxserv_sm_dupErrors();                  oxserv_sm_dupErrors();
                 break;                  break;
           case SM_popSerializedLocalObject:
           case SM_setName:
           case SM_evalName:
           case SM_beginBlock:
           case SM_endBlock:
           case SM_shutdown:
           case SM_executeFunctionAndPopCMO:
           case SM_executeFunctionAndPopSerializedLocalObject:
         case SM_control_reset_connection:          case SM_control_reset_connection:
         case SM_control_reset_connection_server:          case SM_control_reset_connection_server:
         default:          default:
Line 456  oxserv_receive_and_execute_sm_command(OXFILE *fd)
Line 579  oxserv_receive_and_execute_sm_command(OXFILE *fd)
  * PARAM : fd : OXFILE   * PARAM : fd : OXFILE
  * RETURN: NONE   * RETURN: NONE
  *****************************************************************************/   *****************************************************************************/
 int  static int
 oxserv_receive(OXFILE *fd)  oxserv_ox_receive(OXFILE *fd)
 {  {
         int tag;          int tag;
         cmo *c;          cmo *c;
         int ret = OXSERV_SUCCESS;          int ret = OXSERV_SUCCESS;
           int code;
   
         tag = receive_ox_tag(fd);          tag = receive_ox_tag(fd);
   
         switch (tag) {          switch (tag) {
         case OX_DATA:          case OX_DATA:
                 c = receive_cmo(fd);                  c = receive_cmo(fd);
                 DPRINTF(("[CMO:%d]", c->tag));                  DPRINTF(("[CMO:%d=0x%x]", c->tag, c->tag));
                 oxstack_push(c);                  oxstack_push(c);
                 break;                  break;
   
         case OX_COMMAND:          case OX_COMMAND:
                 DPRINTF(("[SM:%d=0x%x]", tag, tag));                  code = receive_int32(fd);
                 ret = oxserv_receive_and_execute_sm_command(fd);                  ret = oxserv_execute_sm_command(fd, code);
                 break;                  break;
   
         default:          default:
Line 485  oxserv_receive(OXFILE *fd)
Line 609  oxserv_receive(OXFILE *fd)
         return (ret);          return (ret);
 }  }
   
   int
   oxserv_receive(OXFILE *fd)
   {
           int i = 0;
           int ret;
   
           ret = setjmp(G_jmpbuf);
           if (ret == 0) {
                   DPRINTF(("setjmp first time -- %d\n", ret));
           } else {
                   DPRINTF(("setjmp return from longjmp() -- %d -- \n", ret));
           }
   
           for (;; i++) {
                   ret = oxserv_ox_receive(fd);
                   if (ret != OXSERV_SUCCESS)
                           break;
           }
           return (ret);
   }
   
   
 /*****************************************************************************  /*****************************************************************************
  * initialize oxserver   * initialize oxserver
  *   *
Line 500  oxserv_init(OXFILE *oxfp, int ver, char *vstr, char *s
Line 645  oxserv_init(OXFILE *oxfp, int ver, char *vstr, char *s
 {  {
         int ret;          int ret;
   
           DPRINTF(("init start\n"));
   
         ret = oxstack_init_stack();          ret = oxstack_init_stack();
         if (ret != OXSERV_SUCCESS)          if (ret != OXSERV_SUCCESS)
                 return (ret);                  return (ret);
Line 508  oxserv_init(OXFILE *oxfp, int ver, char *vstr, char *s
Line 655  oxserv_init(OXFILE *oxfp, int ver, char *vstr, char *s
   
         oxserv_mathcap_init(ver, vstr, sysname, cmos, sms);          oxserv_mathcap_init(ver, vstr, sysname, cmos, sms);
   
           /* signal */
           sigemptyset(&G_oxserv_sigusr1);
           sigaddset(&G_oxserv_sigusr1, SIGUSR1);
         signal(SIGUSR1, oxserv_sm_control_reset_connection);          signal(SIGUSR1, oxserv_sm_control_reset_connection);
   
           /* initialize GMP memory functions. */
           mp_set_memory_functions(oxserv_malloc, oxserv_realloc, oxserv_free);
   
           /* session start */
         oxf_determine_byteorder_server(oxfp);          oxf_determine_byteorder_server(oxfp);
   
         return (OXSERV_SUCCESS);          return (OXSERV_SUCCESS);
Line 517  oxserv_init(OXFILE *oxfp, int ver, char *vstr, char *s
Line 671  oxserv_init(OXFILE *oxfp, int ver, char *vstr, char *s
   
   
 /*****************************************************************************  /*****************************************************************************
  * set oxserver   * set oxserver behavior
  *   *
  * PARAM : mode : mode   * PARAM : mode : mode
  *              :   *              :
Legend:
Removed from v.1.2  
changed lines
  Added in v.1.3
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>