=================================================================== RCS file: /home/cvs/OpenXM/src/ox_math/Attic/serv2.c,v retrieving revision 1.10 retrieving revision 1.18 diff -u -p -r1.10 -r1.18 --- OpenXM/src/ox_math/Attic/serv2.c 1999/11/29 12:09:58 1.10 +++ OpenXM/src/ox_math/Attic/serv2.c 2000/12/03 15:19:23 1.18 @@ -1,88 +1,111 @@ /* -*- mode: C; coding: euc-japan -*- */ -/* $OpenXM: OpenXM/src/ox_math/serv2.c,v 1.9 1999/11/19 20:51:36 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. + 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 "parse.h" +#include #include "serv2.h" extern int flag_mlo_symbol; -/* MathLink 非依存部分 */ +/* MathLink independent */ +static cmo **stack = NULL; +static int stack_size = 0; +static int stack_ptr = 0; +OXFILE *stack_oxfp = NULL; -#define SIZE_OPERAND_STACK 2048 +#define DIFFERENCE_OF_STACK 1024 -static cmo* Operand_Stack[SIZE_OPERAND_STACK]; -static int Stack_Pointer = 0; - -int initialize_stack() +static void stack_extend() { - Stack_Pointer = 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); + } + stack_size = newsize; + stack = newstack; } int push(cmo* m) { #if DEBUG - symbol *symp; + symbol_t symp; if (m->tag == CMO_STRING) { 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", symp->key); + 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"); - Stack_Pointer--; + if (stack_ptr >= stack_size) { + stack_extend(); } + stack[stack_ptr] = m; + stack_ptr++; } -/* スタックが空のときは, (CMO_NULL) をかえす. */ +/* 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 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; } } -/* sm_XXX 関数群は、エラーのときは 0 以外の値を返し、呼び出し元で - エラーオブジェクトをセットする */ -int sm_popCMO(int fd_write) +void push_error(int errcode, cmo* pushback) { + return push((cmo *)make_error_object(errcode, pushback)); +} + +/* + 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 *symp = lookup_by_tag(m->tag); - fprintf(stderr, "ox_math:: opecode = SM_popCMO. (%s)\n", symp->key); + symbol_t symp = lookup_by_tag(m->tag); + fprintf(stderr, "ox_math:: opecode = SM_popCMO. (%s)\n", symbol_get_key(symp)); #endif 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) { @@ -92,8 +115,8 @@ int sm_pops(int fd_write) return ERROR_ID_UNKNOWN_SM; } -/* MathLink 依存部分 */ -int sm_popString(int fd_write) +/* MathLink dependent */ +int sm_popString(OXFILE* oxfp) { char *s; cmo *err; @@ -105,12 +128,12 @@ int sm_popString(int fd_write) m = pop(); if (m->tag == CMO_STRING) { - send_ox_cmo(fd_write, m); - }else if ((s = convert_cmo_to_string(m)) != NULL) { - send_ox_cmo(fd_write, (cmo *)new_cmo_string(s)); + 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(fd_write, err); + send_ox_cmo(oxfp, err); } return 0; } @@ -131,10 +154,10 @@ int local_execute(char *s) return 0; } -/* この関数はサーバに依存する. */ -int sm_executeStringByLocalParser(int fd_write) +/* The following function is depend on an implementation of a server. */ +int sm_executeStringByLocalParser(OXFILE* oxfp) { - symbol *symp; + symbol_t symp; cmo* m = pop(); char *s = NULL; #ifdef DEBUG @@ -147,20 +170,21 @@ int sm_executeStringByLocalParser(int fd_write) local_execute(++s); }else { /* for mathematica */ - /* mathematica に文字列を送って評価させる */ + /* Sending the string `s' to mathematica for its evaluation. */ ml_evaluateStringByLocalParser(s); - push(ml_get_object()); + ml_select(); + push(receive_mlo()); } return 0; } #ifdef DEBUG symp = lookup_by_tag(m->tag); - fprintf(stderr, "ox_math:: error. the top of stack is %s.\n", symp->key); + 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; @@ -182,58 +206,66 @@ int sm_executeFunction(int fd_write) argv[i] = pop(); } ml_executeFunction(func, argc, argv); - push(ml_get_object()); + ml_select(); + push(receive_mlo()); return 0; } -/* 平成11年10月13日 */ -#define VERSION 0x11102700 -#define ID_STRING "ox_math server 1999/10/28 17:29:25" - -int sm_mathcap(int fd_write) +int sm_mathcap(OXFILE* oxfp) { - push(make_mathcap_object(VERSION, ID_STRING)); + push((cmo *)oxf_cmo_mathcap(oxfp)); return 0; } -int receive_sm_command(int fd_read) +void sm_set_mathcap(OXFILE *oxfp) { - return receive_int32(fd_read); + 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 */ + } } -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 *sp = lookup_by_tag(code); - fprintf(stderr, "ox_math:: %s received.\n", sp->key); + 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: case SM_executeStringByLocalParserInBatchMode: - err = sm_executeStringByLocalParser(fd_write); + err = sm_executeStringByLocalParser(oxfp); break; case SM_executeFunction: - err = sm_executeFunction(fd_write); + err = sm_executeFunction(oxfp); break; case SM_shutdown: shutdown(); break; case SM_setMathCap: - pop(); /* 無視する */ + pop(); /* ignore */ break; default: fprintf(stderr, "unknown command: %d.\n", code);