[BACK]Return to stackmachine.c CVS log [TXT][DIR] Up to [local] / OpenXM / src / kan96xx / Kan

Diff for /OpenXM/src/kan96xx/Kan/stackmachine.c between version 1.23 and 1.29

version 1.23, 2004/09/12 01:53:11 version 1.29, 2004/09/19 00:47:47
Line 1 
Line 1 
 /* $OpenXM: OpenXM/src/kan96xx/Kan/stackmachine.c,v 1.22 2004/09/12 01:32:08 takayama Exp $ */  /* $OpenXM: OpenXM/src/kan96xx/Kan/stackmachine.c,v 1.28 2004/09/17 02:42:57 takayama Exp $ */
 /*   stackmachin.c */  /*   stackmachin.c */
   
 #include <stdio.h>  #include <stdio.h>
Line 74  static strToInteger(char *);
Line 74  static strToInteger(char *);
 static power(int s,int i);  static power(int s,int i);
 static void pstack(void);  static void pstack(void);
 static struct object executableStringToExecutableArray(char *str);  static struct object executableStringToExecutableArray(char *str);
   static int isThereExecutableArrayOnStack(int n);
   
 extern int SerialCurrent;  extern int SerialCurrent;
 extern int QuoteMode;  extern int QuoteMode;
Line 295  int putUserDictionary2(str,h0,h1,attr,dic)
Line 296  int putUserDictionary2(str,h0,h1,attr,dic)
     }      }
     return(0);      return(0);
   }    }
     if (OR_ATTR_FOR_ALL_WORDS & attr) {
       for (i=0; i<USER_DICTIONARY_SIZE; i++) {
         if ((dic[i]).key !=EMPTY) (dic[i]).attr |= attr&(~OR_ATTR_FOR_ALL_WORDS);
       }
       return(0);
     }
   x = h0;    x = h0;
   if (str[0] == '\0') {    if (str[0] == '\0') {
     errorKan1("%s\n","putUserDictionary2(): You are defining a value with the null key.");      errorKan1("%s\n","putUserDictionary2(): You are defining a value with the null key.");
Line 458  struct object peek(k)
Line 465  struct object peek(k)
   }    }
 }  }
   
   static int isThereExecutableArray(struct object ob) {
     int n,i;
     struct object otmp;
     if (ob.tag == SexecutableArray) return(1);
     if (ob.tag == Sarray) {
       n = getoaSize(ob);
       for (i=0; i<n; i++) {
         otmp = getoa(ob,i);
         if (isThereExecutableArray(otmp)) return(1);
       }
       return(0);
     }
     /* Class and list is not checked, since there is no parser
        to directory translte these objects. */
     return(0);
   }
   static int isThereExecutableArrayOnStack(int n) {
     int i;
     struct object ob;
     for (i=0; i<n; i++) {
       if (Osp-i-1 < 0) return(0);
       ob = peek(i);
       if (isThereExecutableArray(ob)) return(1);
     }
     return(0);
   }
   
 struct object newOperandStack(int size)  struct object newOperandStack(int size)
 {  {
Line 747  void scanner() {
Line 780  void scanner() {
   extern int InSendmsg2;    extern int InSendmsg2;
   int infixOn = 0;    int infixOn = 0;
   struct tokens infixToken;    struct tokens infixToken;
     extern int RestrictedMode, RestrictedMode_saved;
   getokenSM(INIT);    getokenSM(INIT);
   initSystemDictionary();    initSystemDictionary();
   
Line 830  void scanner() {
Line 864  void scanner() {
         fprintf(Fstack,"\nscanner> ");          fprintf(Fstack,"\nscanner> ");
       }        }
       if (!Calling_ctrlC_hook) { /* to avoid recursive call of ctrlC-hook. */        if (!Calling_ctrlC_hook) { /* to avoid recursive call of ctrlC-hook. */
         Calling_ctrlC_hook = 1;          Calling_ctrlC_hook = 1; RestrictedMode = 0;
         KSexecuteString(" ctrlC-hook "); /* Execute User Defined functions. */          KSexecuteString(" ctrlC-hook "); /* Execute User Defined functions. */
           RestrictedMode = RestrictedMode_saved;
       }        }
       Calling_ctrlC_hook = 0;        Calling_ctrlC_hook = 0;
       KSexecuteString(" (Computation is interrupted.) "); /* move to ctrlC-hook? */        KSexecuteString(" (Computation is interrupted.) "); /* move to ctrlC-hook? */
Line 862  void ctrlC(sig)
Line 897  void ctrlC(sig)
   extern int SGClock;    extern int SGClock;
   extern int UserCtrlC;    extern int UserCtrlC;
   extern int OXlock;    extern int OXlock;
     extern int RestrictedMode, RestrictedMode_saved;
   
   signal(sig,SIG_IGN);    signal(sig,SIG_IGN);
   /* see 133p */    /* see 133p */
     RestrictedMode = RestrictedMode_saved;
   cancelAlarm();    cancelAlarm();
   if (sig == SIGALRM) {    if (sig == SIGALRM) {
     fprintf(stderr,"ctrlC by SIGALRM\n");      fprintf(stderr,"ctrlC by SIGALRM\n");
Line 923  int executeToken(token)
Line 960  int executeToken(token)
   int primitive;    int primitive;
   int size;    int size;
   int status;    int status;
   struct tokens *tokenArray;  
   int i,h0,h1;    int i,h0,h1;
   int infixOn;  
   struct tokens infixToken;  
   extern int WarningMessageMode;    extern int WarningMessageMode;
   extern int Strict;    extern int Strict;
   extern int InSendmsg2;    extern int InSendmsg2;
     extern int RestrictedMode, RestrictedMode_saved;
     int localRestrictedMode_saved;
   
   infixOn = 0;    localRestrictedMode_saved = 0;
   if (GotoP) { /* for goto */    if (GotoP) { /* for goto */
     if (token.kind == ID && isLiteral(token.token)) {      if (token.kind == ID && isLiteral(token.token)) {
       if (strcmp(&((token.token)[1]),GotoLabel) == 0) {        if (strcmp(&((token.token)[1]),GotoLabel) == 0) {
Line 979  int executeToken(token)
Line 1015  int executeToken(token)
       primitive = ((token.object.rc.op)->lc).ival;        primitive = ((token.object.rc.op)->lc).ival;
       if (!(token.tflag & NO_DELAY)) {        if (!(token.tflag & NO_DELAY)) {
         if ((ob.tag >= 0) && (UD_attr & ATTR_INFIX)) {          if ((ob.tag >= 0) && (UD_attr & ATTR_INFIX)) {
           tracePopName(); return STATUS_INFIX;            return STATUS_INFIX;
         }          }
       }        }
       if (ob.tag >= 0) {        if (ob.tag >= 0) {
         /* there is a definition in the user dictionary */          /* there is a definition in the user dictionary */
         if (ob.tag == SexecutableArray) {          if (ob.tag == SexecutableArray) {
           tracePushName(token.token);            if (RestrictedMode) {
           tokenArray = ob.lc.tokenArray;              if (UD_attr & ATTR_EXPORT) {
           size = ob.rc.ival;                localRestrictedMode_saved = RestrictedMode; RestrictedMode = 0;
           for (i=0; i<size; i++) {                if (isThereExecutableArrayOnStack(5)) {
             status = executeToken(tokenArray[i]);                                  int i;
             if ((status & STATUS_BREAK) || (status < 0)) {                  for (i=0; i<5; i++) { (void) Kpop(); }
               tracePopName(); return(status);                  errorStackmachine("Executable array is on the argument stack (restricted mode). They are automatically removed.\n");
                         }                            }
               }else{
             if (status & STATUS_INFIX) {                tracePushName(token.token);
               if (i == size-1) errorStackmachine("Infix operator at the end of an executable array.");                errorStackmachine("You cannot execute this function in restricted mode.\n");
               infixOn = 1; infixToken = tokenArray[i];  
               infixToken.tflag |= NO_DELAY;  
               continue;  
             }else if (infixOn) {  
               infixOn = 0;  
               status = executeToken(infixToken);  
               if ((status & STATUS_BREAK) || (status < 0)) {  
                 tracePopName(); return(status);  
               }  
             }              }
           }            }
           tracePopName();  
             status = executeExecutableArray(ob,token.token,0);
   
             if (localRestrictedMode_saved) RestrictedMode = localRestrictedMode_saved;
             if ((status & STATUS_BREAK) || (status < 0)) return status;
         }else {          }else {
           Kpush(ob);            Kpush(ob);
         }          }
Line 1074  errorStackmachine(str)
Line 1105  errorStackmachine(str)
   char message0[1024];    char message0[1024];
   char *message;    char *message;
   extern int ErrorMessageMode;    extern int ErrorMessageMode;
     extern int RestrictedMode, RestrictedMode_saved;
     RestrictedMode = RestrictedMode_saved;
   cancelAlarm();    cancelAlarm();
   if (ErrorMessageMode == 1 || ErrorMessageMode == 2) {    if (ErrorMessageMode == 1 || ErrorMessageMode == 2) {
     pushErrorStack(KnewErrorPacket(SerialCurrent,-1,str));      pushErrorStack(KnewErrorPacket(SerialCurrent,-1,str));
Line 1156  KSexecuteString(s)
Line 1189  KSexecuteString(s)
   jmp_buf saved_EnvOfStackMachine;    jmp_buf saved_EnvOfStackMachine;
   void (*sigfunc)();    void (*sigfunc)();
   int localCatchCtrlC ;    int localCatchCtrlC ;
     extern int RestrictedMode, RestrictedMode_saved;
   
   localCatchCtrlC = CatchCtrlC;    localCatchCtrlC = CatchCtrlC;
   /* If CatchCtrlC is rewrited in this program,    /* If CatchCtrlC is rewrited in this program,
Line 1182  KSexecuteString(s)
Line 1216  KSexecuteString(s)
       recursive--;        recursive--;
       if (localCatchCtrlC) { signal(SIGINT, sigfunc); }        if (localCatchCtrlC) { signal(SIGINT, sigfunc); }
       if (!Calling_ctrlC_hook) {        if (!Calling_ctrlC_hook) {
         Calling_ctrlC_hook = 1;          Calling_ctrlC_hook = 1; RestrictedMode = 0;
         KSexecuteString(" ctrlC-hook "); /* Execute User Defined functions. */          KSexecuteString(" ctrlC-hook "); /* Execute User Defined functions. */
           RestrictedMode_saved;
       }        }
       Calling_ctrlC_hook = 0;        Calling_ctrlC_hook = 0;
       KSexecuteString(" (Computation is interrupted.) "); /* move to ctrlC-hook?*/        KSexecuteString(" (Computation is interrupted.) "); /* move to ctrlC-hook?*/
Line 1204  KSexecuteString(s)
Line 1239  KSexecuteString(s)
         recursive = 0;          recursive = 0;
         if (localCatchCtrlC) { signal(SIGINT, sigfunc); }          if (localCatchCtrlC) { signal(SIGINT, sigfunc); }
         if (!Calling_ctrlC_hook) {          if (!Calling_ctrlC_hook) {
           Calling_ctrlC_hook = 1;            Calling_ctrlC_hook = 1; RestrictedMode = 0;
           KSexecuteString(" ctrlC-hook "); /* Execute User Defined functions. */            KSexecuteString(" ctrlC-hook "); /* Execute User Defined functions. */
             RestrictedMode = RestrictedMode_saved;
         }          }
         Calling_ctrlC_hook = 0;          Calling_ctrlC_hook = 0;
         Calling_ctrlC_hook = 0;          Calling_ctrlC_hook = 0;
Line 1605  char *traceShowStack(void) {
Line 1641  char *traceShowStack(void) {
     if (t == NULL) {      if (t == NULL) {
       s[p] = ';'; s[p+1] = 0;        s[p] = ';'; s[p+1] = 0;
       break;        break;
     }else if ((strlen(t) + p -10) > TRACE_MSG_SIZE) {      }else if ((strlen(t) + p) > (TRACE_MSG_SIZE-10)) {
           /*      fprintf(stderr,"p=%d, TraceNameStackp=%d, strlen(t)=%d, t=%s\n",p,TraceNameStackp,strlen(t),t); */            /* fprintf(stderr,"p=%d, TraceNameStackp=%d, strlen(t)=%d, t=%s\n",p,TraceNameStackp,strlen(t),t); */
       strcpy(&(s[p])," ...");        strcpy(&(s[p])," ...");
       break;        break;
     }      }
Line 1615  char *traceShowStack(void) {
Line 1651  char *traceShowStack(void) {
   } while (t != (char *)NULL);    } while (t != (char *)NULL);
   fprintf(stderr,"%s\n",s);    fprintf(stderr,"%s\n",s);
   return s;    return s;
   }
   
   /*
     if (fname != NULL) fname is pushed to the trace stack.
    */
   int executeExecutableArray(struct object ob,char *fname,int withGotoP) {
     struct tokens *tokenArray;
     int size,i;
     int status;
     int infixOn;
     struct tokens infixToken;
     extern int GotoP;
   
     infixOn = 0;
     if (ob.tag != SexecutableArray) errorStackmachine("Error (executeTokenArray): the argument is not a token array.");
   
     if (fname != NULL) tracePushName(fname);
     tokenArray = ob.lc.tokenArray;
     size = ob.rc.ival;
     for (i=0; i<size; i++) {
       status = executeToken(tokenArray[i]);
       if ((status & STATUS_BREAK) || (status < 0) || (withGotoP && GotoP)) {
         if (fname != NULL) tracePopName();
         return(status);
       }
   
       if (status & STATUS_INFIX) {
         if (i == size-1) errorStackmachine("Infix operator at the end of an executable array.");
         infixOn = 1; infixToken = tokenArray[i];
         infixToken.tflag |= NO_DELAY;
         continue;
       }else if (infixOn) {
         infixOn = 0;
         status = executeToken(infixToken);
         if ((status & STATUS_BREAK) || (status < 0) || (withGotoP && GotoP)) {
           if (fname != NULL) tracePopName();
           return(status);
         }
       }
     }
     if (fname != NULL) tracePopName();
     return(0); /* normal exit */
 }  }
Legend:
Removed from v.1.23  
changed lines
  Added in v.1.29
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>