Return to sm1stackmachine.c CVS log

Up to [local] / OpenXM / src / kxx

Annotation of OpenXM/src/kxx/sm1stackmachine.c, Revision 1.1.1.1

1.1       maekawa     1: #include <stdio.h>
                      2: #include <setjmp.h>
                      3: #include "ox_kan.h"
                      4: #include "serversm.h"
                      5: extern int OXprintMessage;
                      6:
                      7: /*  server stack machine */
                      8:
                      9: int Sm1_start(int argc, char *fnames[],char *myname) {
                     10:   int i;
                     11:   char cmd[4092];
                     12:   extern int ErrorMessageMode;
                     13:   extern char *VersionString;
                     14:   extern int CmoClientMode;
                     15:   CmoClientMode = 0;
                     16:   KSstart();
                     17:   fprintf(stderr,"sm1 version : %s\n",VersionString);
                     18:   fprintf(stderr,"sm1 url : http://www.math.kobe-u.ac.jp/KAN\n");
                     19:   fprintf(stderr,"name = %s\n",myname);
                     20:
                     21:   /* Initialize for ox_sm1 */
                     22:   ErrorMessageMode = 2;
                     23:   KSexecuteString(" [ [(Strict) 1] system_variable ] pop ");
                     24:
                     25:   /* Write a system start-up script here. */
                     26:   KSexecuteString(" [(cmoLispLike) 1] extension pop  ");
                     27:
                     28:   /* if argc > 0, execute the system startup files fnames and
                     29:      set oxSystemName to myname. */
                     30:   if (argc > 0) {
                     31:     for (i=0; i<argc; i++) {
                     32:       /* load files from the search path */
                     33:       if (strlen(fnames[i]) > 1024) {
                     34:        fprintf(stderr,"Too long name for sm1 library file to load.\n");
                     35:        exit(10);
                     36:       }
                     37:       sprintf(cmd," [(parse) (%s) pushfile ] extension pop ",fnames[i]);
                     38:       KSexecuteString(cmd);
                     39:     }
                     40:     sprintf(cmd," [(cmoOxSystem) (ox_sm1_%s) ] extension pop ",myname);
                     41:     KSexecuteString(cmd);
                     42:   }
                     43:   KSexecuteString(" (---------------------------------------------------) message ");
                     44:   KSexecuteString(" [(flush)] extension pop ");
                     45:
                     46:   return(0);
                     47: }
                     48:
                     49: void *Sm1_mathcap() {
                     50:   int n,i;
                     51:   struct mathCap *mathcap;
                     52:   mathcap = KSmathCapByStruct();
                     53:   return((void *)mathcap);
                     54: }
                     55:
                     56: int Sm1_setMathCap(ox_stream os) {
                     57:   /* Set the mathcap data of the client in the server. */
                     58:   /*  sm1 <====== ox_sm1  mathcap is set in ox_stream = FILE2 * */
                     59:   /* The mathcap data is on the stack. */
                     60:   struct object ob;
                     61:   struct object ob2;
                     62:   int n,i;
                     63:   ob = KSpop();
                     64:   KSpush(ob);  KSexecuteString(" (mathcap data is ) message message ");
                     65:   Kan_setMathCapToStream(os,ob);
                     66:   /* set the math cap data associated to the ox_stream. */
                     67: }
                     68: void Sm1_pops(void) {
                     69:   char data[100];
                     70:   sprintf(data," 1 1 3 -1 roll { pop pop } for ");
                     71:   KSexecuteString(data);
                     72: }
                     73: int Sm1_executeStringByLocalParser(void) {
                     74:   int i;
                     75:   char *s;
                     76:   s = Sm1_popString();
                     77:   if (s == NULL) {
                     78:     printf("NULL argument for executeString.\n");
                     79:     return(-1);
                     80:   }else{
                     81:     if (OXprintMessage) fprintf(stderr,"KSexecuteString(%s)\n",s);
                     82:     i = KSexecuteString(s);
                     83:     return(i);
                     84:   }
                     85: }
                     86: char *Sm1_popString(void) {
                     87:   char *KSpopString();
                     88:   KSexecuteString(" toString ");
                     89:   return(KSpopString());
                     90: }
                     91:
                     92:
                     93: int Sm1_setName(void)
                     94: {
                     95:   char *s;
                     96:   struct object ob;
                     97:   s = Sm1_popString();
                     98:   if (s == NULL) {
                     99:     printf("NULL argument for setName.\n");
                    100:     return(-1);
                    101:   }else{
                    102:     ob = KSpop();
                    103:     printf("/%s tag=%d def\n",s,ob.tag);
                    104:     KputUserDictionary(s,ob);
                    105:     return(0);
                    106:   }
                    107: }
                    108:
                    109: int Sm1_evalName(void)
                    110: {
                    111:   char *s;
                    112:   struct object ob;
                    113:   s = Sm1_popString();
                    114:   if (s == NULL) {
                    115:     printf("NULL argument for evalName.\n");
                    116:     return(-1);
                    117:   }else{
                    118:     ob = KfindUserDictionary(s);
                    119:     if (ob.tag == -1) {
                    120:       printf("findUserDictionary(%s)--> tag=%d Not found.\n",s,ob.tag);
                    121:       return(-1);
                    122:     }
                    123:     printf("findUserDictionary(%s)--> tag=%d\n",s,ob.tag);
                    124:     KSpush(ob);
                    125:     return(0);
                    126:   }
                    127: }
                    128:
                    129: int Sm1_pushCMO(ox_stream fp)
                    130: {
                    131:   return(Kan_pushCMOFromStream(fp));
                    132: }
                    133: int Sm1_popCMO(ox_stream fp,int serial)
                    134: {
                    135:   return(Kan_popCMOToStream(fp,serial));
                    136: }
                    137:
                    138: int Sm1_pushError2(int serial, int no, char *s)
                    139: {
                    140:   struct object ob;
                    141:   ob = KnewErrorPacket(serial,no,s);
                    142:   KSpush(ob);
                    143: }
                    144:
                    145: char *Sm1_popErrorMessage(char *s) {
                    146:   char *e;
                    147:   char *a;
                    148:   extern int ErrorMessageMode;
                    149:   /* Set ErrorMessageMode = 2 to use this function. */
                    150:   if (ErrorMessageMode != 2) return(s);
                    151:   e = popErrorStackByString();
                    152:   if (e == NULL ) {
                    153:     a = (char *) sGC_malloc(sizeof(char)*(strlen(s)+80));
                    154:     if (a == NULL) {
                    155:       fprintf(stderr,"No more memory in Sm1_popErrorMessage.\n");
                    156:       exit(10);
                    157:     }
                    158:     strcpy(a,s); strcat(a,"No error message on the error stack.");
                    159:     return(a);
                    160:   }else{
                    161:     a = (char *) sGC_malloc(sizeof(char)*(strlen(s)+strlen(e)+2));
                    162:     if (a == NULL) {
                    163:       fprintf(stderr,"No more memory in Sm1_popErrorMessage.\n");
                    164:       exit(10);
                    165:     }
                    166:     strcpy(a,s); strcat(a,e);
                    167:     return(a);
                    168:   }
                    169: }
                    170:
                    171: void Sm1_getsp(void) {
                    172:   KSpush(KpoInteger(KSstackPointer()));
                    173: }
                    174:
                    175: void Sm1_dupErrors(void) {
                    176:   KSpush(KSdupErrors());
                    177: }
                    178:
                    179:
                    180: