=================================================================== RCS file: /home/cvs/OpenXM/src/ox_math/Attic/serv2.c,v retrieving revision 1.1.1.1 retrieving revision 1.18 diff -u -p -r1.1.1.1 -r1.18 --- OpenXM/src/ox_math/Attic/serv2.c 1999/10/29 08:06:41 1.1.1.1 +++ OpenXM/src/ox_math/Attic/serv2.c 2000/12/03 15:19:23 1.18 @@ -1,283 +1,190 @@ /* -*- mode: C; coding: euc-japan -*- */ -/* $OpenXM$ */ -/* $Id: serv2.c,v 1.1.1.1 1999/10/29 08:06:41 ohara Exp $ */ +/* $OpenXM: OpenXM/src/ox_math/serv2.c,v 1.17 2000/11/28 20:16:03 ohara Exp $ */ -/* Open Mathematica サーバ */ -/* ファイルディスクリプタ 3, 4 は open されていると仮定して動作する. */ +/* + Copyright (C) Katsuyoshi OHARA, 2000. + Portions copyright 1999 Wolfram Research, Inc. -/* MathLink との通信部分 */ + You must see OpenXM/Copyright/Copyright.generic. + The MathLink Library is licensed from Wolfram Research Inc.. + See OpenXM/Copyright/Copyright.mathlink for detail. +*/ +/* + Remarks: + file descripter 3 and 4 are already opened by the parent process. +*/ + #include #include #include #include #include -#include "ox.h" +#include #include "serv2.h" -#define UNKNOWN_SM_COMMAND 50000 -#define MATH_ERROR 50001 +extern int flag_mlo_symbol; +/* MathLink independent */ +static cmo **stack = NULL; +static int stack_size = 0; +static int stack_ptr = 0; +OXFILE *stack_oxfp = NULL; -/* MLINK はポインタ型. */ -MLINK lp = NULL; +#define DIFFERENCE_OF_STACK 1024 -/* Mathematica を起動する. */ -int MATH_init() +static void stack_extend() { - int argc = 2; - char *argv[] = {"-linkname", "math -mathlink"}; - - if(MLInitialize(NULL) != NULL) { - lp = MLOpen(argc, argv); - if(lp != NULL) { - return 0; - } + int newsize = stack_size + DIFFERENCE_OF_STACK; + cmo **newstack = (cmo **)malloc(sizeof(cmo *)*newsize); + if (stack != NULL) { + memcpy(newstack, stack, sizeof(cmo *)*stack_size); + free(stack); } - exit(1); + stack_size = newsize; + stack = newstack; } -int MATH_exit() -{ - /* quit Mathematica then close the link */ - MLPutFunction(lp, "Exit", 0); - MLClose(lp); -} - -char *MATH_getObject() -{ - char *s; - - /* skip any packets before the first ReturnPacket */ - while (MLNextPacket(lp) != RETURNPKT) { - usleep(10); - MLNewPacket(lp); - } - /* いまはタイプにかかわらず文字列を取得する. */ - switch(MLGetNext(lp)) { - case MLTKINT: - fprintf(stderr, "type is INTEGER.\n"); - MLGetString(lp, &s); - break; - case MLTKSTR: - fprintf(stderr, "type is STRING.\n"); - MLGetString(lp, &s); - break; - default: - MLGetString(lp, &s); - } - return s; -} - -cmo *MATH_getObject2() -{ - char *s; - cmo *m; - char **sp; - int i,n; - - /* skip any packets before the first ReturnPacket */ - while (MLNextPacket(lp) != RETURNPKT) { - usleep(10); - MLNewPacket(lp); - } - /* いまはタイプにかかわらず文字列を取得する. */ - switch(MLGetNext(lp)) { - case MLTKINT: - fprintf(stderr, "type is INTEGER.\n"); - MLGetString(lp, &s); - m = (cmo *)new_cmo_zz_set_string(s); - break; - case MLTKSTR: - fprintf(stderr, "type is STRING.\n"); - MLGetString(lp, &s); - m = (cmo *)new_cmo_string(s); - break; - case MLTKERR: - fprintf(stderr, "type is ERROR.\n"); - m = gen_error_object(MATH_ERROR); - break; - case MLTKSYM: - fprintf(stderr, "MLTKSYM.\n"); - MLGetString(lp, s); - m = (cmo *)new_cmo_string(s); - break; - case MLTKFUNC: - fprintf(stderr, "MLTKFUNC.\n"); -#if DEBUG - MLGetString(lp, s); - m = (cmo *)new_cmo_string(s); - break; -#endif - MLGetFunction(lp, sp, &n); - fprintf(stderr, "n = %d\n", n); - for (i=0; i<=n; i++) { - fprintf(stderr, "%s "); - } - fprintf(stderr, "\n"); - m = (cmo *)new_cmo_string(s[0]); - break; - case MLTKREAL: - fprintf(stderr, "MLTKREAL is not supported: we use MLTKSTR.\n"); - MLGetString(lp, &s); - m = (cmo *)new_cmo_string(s); - break; - default: - fprintf(stderr, "unknown type: we use STRING.\n"); - MLGetString(lp, &s); - m = (cmo *)new_cmo_string(s); - } - return m; -} - -int MATH_sendObject(cmo *m) -{ - char *s; - switch(m->tag) { - case CMO_INT32: - MLPutInteger(lp, ((cmo_int32 *)m)->i); - break; - case CMO_STRING: - s = ((cmo_string *)m)->s; - MLPutString(lp, s); - fprintf(stderr, "put %s.", s); - break; - default: - MLPutFunction(lp, "ToExpression", 1); - s = CONVERT_CMO_TO_CSTRING(m); - MLPutString(lp, s); - fprintf(stderr, "put %s.", s); - break; - } -} - -int MATH_evaluateStringByLocalParser(char *str) -{ - MLPutFunction(lp, "ToExpression", 1); - MLPutString(lp, str); - MLEndPacket(lp); -} - -int MATH_executeFunction(char *function, int argc, cmo *argv[]) -{ - int i; - MLPutFunction(lp, function, argc); - for (i=0; itag); + symbol_t symp; + if (m->tag == CMO_STRING) { - fprintf(stderr, "server:: %s\n", ((cmo_string *)m)->s); + fprintf(stderr, "ox_math:: a CMO_STRING(%s) was pushed.\n", ((cmo_string *)m)->s); + }else { + symp = lookup_by_tag(m->tag); + fprintf(stderr, "ox_math:: a %s was pushed.\n", symbol_get_key(symp)); } #endif - Operand_Stack[Stack_Pointer] = m; - Stack_Pointer++; - if (Stack_Pointer >= SIZE_OPERAND_STACK) { - fprintf(stderr, "stack over flow.\n"); - exit(1); + if (stack_ptr >= stack_size) { + stack_extend(); } + stack[stack_ptr] = m; + stack_ptr++; } -/* エラーのときは NULL を返す */ -/* gen_error_object(SM_popCMO); */ -/* CMO_ERROR2 */ - +/* if the stack is empty, then pop() returns (CMO_NULL). */ cmo* pop() { - if (Stack_Pointer > 0) { - Stack_Pointer--; - return Operand_Stack[Stack_Pointer]; + if (stack_ptr > 0) { + return stack[--stack_ptr]; } - return NULL; + return new_cmo_null(); } void pops(int n) { - Stack_Pointer -= n; - if (Stack_Pointer < 0) { - Stack_Pointer = 0; + stack_ptr -= n; + if (stack_ptr < 0) { + stack_ptr = 0; } } +void push_error(int errcode, cmo* pushback) +{ + return push((cmo *)make_error_object(errcode, pushback)); +} -/* sm_XXX 関数群は、エラーのときは 0 以外の値を返し、呼び出し元で - エラーオブジェクトをセットする */ -int sm_popCMO(int fd_write) +/* + if error occurs, then a sm_*() function returns non-zero and + an error obect is set by a function which calls sm_*(). +*/ +int sm_popCMO(OXFILE* oxfp) { cmo* m = pop(); +#ifdef DEBUG + symbol_t symp = lookup_by_tag(m->tag); + fprintf(stderr, "ox_math:: opecode = SM_popCMO. (%s)\n", symbol_get_key(symp)); +#endif - fprintf(stderr, "code: SM_popCMO.\n"); if (m != NULL) { - send_ox_cmo(fd_write, m); + send_ox_cmo(oxfp, m); return 0; } return SM_popCMO; } -int sm_pops(int fd_write) +int sm_pops(OXFILE* oxfp) { cmo* m = pop(); if (m != NULL && m->tag == CMO_INT32) { pops(((cmo_int32 *)m)->i); return 0; } - return UNKNOWN_SM_COMMAND; + return ERROR_ID_UNKNOWN_SM; } -/* MathLink 依存部分 */ -int sm_popString(int fd_write) +/* MathLink dependent */ +int sm_popString(OXFILE* oxfp) { - char* s; - cmo* m; + char *s; + cmo *err; + cmo *m; #ifdef DEBUG - fprintf(stderr, "code: SM_popString.\n"); + fprintf(stderr, "ox_math:: opecode = SM_popString.\n"); #endif - if ((m = pop()) != NULL && (s = CONVERT_CMO_TO_CSTRING(m)) != NULL) { - send_ox_cmo(fd_write, new_cmo_string(s)); - return 0; + m = pop(); + if (m->tag == CMO_STRING) { + send_ox_cmo(oxfp, m); + }else if ((s = new_string_set_cmo(m)) != NULL) { + send_ox_cmo(oxfp, (cmo *)new_cmo_string(s)); + }else { + err = make_error_object(SM_popString, m); + send_ox_cmo(oxfp, err); } - return SM_popString; + return 0; } -/* この関数はサーバに依存する. */ -int sm_executeStringByLocalParser(int fd_write) +int local_execute(char *s) { - cmo* m = NULL; + if(*s == 'i') { + switch(s[1]) { + case '+': + flag_mlo_symbol = FLAG_MLTKSYM_IS_STRING; + break; + case '-': + case '=': + default: + flag_mlo_symbol = FLAG_MLTKSYM_IS_INDETERMINATE; + } + } + return 0; +} + +/* The following function is depend on an implementation of a server. */ +int sm_executeStringByLocalParser(OXFILE* oxfp) +{ + symbol_t symp; + cmo* m = pop(); + char *s = NULL; #ifdef DEBUG - fprintf(stderr, "code: SM_executeStringByLocalParser.\n"); + fprintf(stderr, "ox_math:: opecode = SM_executeStringByLocalParser.\n"); #endif - if ((m = pop()) != NULL && m->tag == CMO_STRING) { - /* for mathematica */ - /* mathematica に文字列を送って評価させる */ - MATH_evaluateStringByLocalParser(((cmo_string *)m)->s); - push(MATH_getObject2()); + + if (m->tag == CMO_STRING + && strlen(s = ((cmo_string *)m)->s) != 0) { + if (s[0] == ':') { + local_execute(++s); + }else { + /* for mathematica */ + /* Sending the string `s' to mathematica for its evaluation. */ + ml_evaluateStringByLocalParser(s); + ml_select(); + push(receive_mlo()); + } return 0; } - fprintf(stderr, "cannot execute: top of stack is not string!(%p, %d)\n", m, m->tag); +#ifdef DEBUG + symp = lookup_by_tag(m->tag); + fprintf(stderr, "ox_math:: error. the top of stack is %s.\n", symbol_get_key(symp)); +#endif return SM_executeStringByLocalParser; } -int sm_executeFunction(int fd_write) +int sm_executeFunction(OXFILE* oxfp) { int i, argc; cmo **argv; @@ -292,66 +199,80 @@ int sm_executeFunction(int fd_write) if ((m = pop()) == NULL || m->tag != CMO_INT32) { return SM_executeFunction; } + argc = ((cmo_int32 *)m)->i; - argv = malloc(sizeof(cmo *)*argc); + argv = malloc(argc*sizeof(cmo *)); for (i=0; itag == CMO_MATHCAP) { + oxf_mathcap_update(oxfp, m); + }else { + push_error(-1, m); + /* an error object must be pushed */ + } } -int execute_sm_command(int fd_write, int code) +int receive_sm_command(OXFILE* oxfp) { + return receive_int32(oxfp); +} + +int execute_sm_command(OXFILE* oxfp, int code) +{ int err = 0; +#ifdef DEBUG + symbol_t sp = lookup_by_tag(code); + fprintf(stderr, "ox_math:: %s received.\n", symbol_get_key(sp)); +#endif switch(code) { case SM_popCMO: - err = sm_popCMO(fd_write); + err = sm_popCMO(oxfp); break; case SM_popString: - err = sm_popString(fd_write); + err = sm_popString(oxfp); break; case SM_mathcap: - err = sm_mathcap(fd_write); + err = sm_mathcap(oxfp); break; case SM_pops: - err = sm_pops(fd_write); + err = sm_pops(oxfp); break; case SM_executeStringByLocalParser: - err = sm_executeStringByLocalParser(fd_write); + case SM_executeStringByLocalParserInBatchMode: + err = sm_executeStringByLocalParser(oxfp); break; case SM_executeFunction: - err = sm_executeFunction(fd_write); + err = sm_executeFunction(oxfp); break; - case SM_setMathcap: - pop(); /* 無視する */ + case SM_shutdown: + shutdown(); break; + case SM_setMathCap: + pop(); /* ignore */ + break; default: fprintf(stderr, "unknown command: %d.\n", code); - err = UNKNOWN_SM_COMMAND; + err = ERROR_ID_UNKNOWN_SM; } if (err != 0) { - push(gen_error_object(err)); + push((cmo *)make_error_object(err, new_cmo_null())); } }