[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.39 and 1.44

version 1.39, 2015/10/08 11:49:37 version 1.44, 2020/10/06 11:33:47
Line 1 
Line 1 
 /* $OpenXM: OpenXM/src/kan96xx/Kan/stackmachine.c,v 1.38 2015/09/29 01:52:14 takayama Exp $ */  /* $OpenXM: OpenXM/src/kan96xx/Kan/stackmachine.c,v 1.43 2018/09/07 00:15:44 takayama Exp $ */
 /*   stackmachin.c */  /*   stackmachin.c */
   
 #include <stdio.h>  #include <stdio.h>
Line 11 
Line 11 
 #include "kclass.h"  #include "kclass.h"
 #include <signal.h>  #include <signal.h>
 #include <sys/types.h>  #include <sys/types.h>
   #include <unistd.h>
   #include "mysig.h"
   
 /* The msys2 seems to make a buffer overflow of  EnvOfStackmachine[].  /* The msys2 seems to make a buffer overflow of  EnvOfStackmachine[].
 The code  The code
Line 80  int GotoP = 0;
Line 82  int GotoP = 0;
 static char *SMacros =  static char *SMacros =
 #include "smacro.h"  #include "smacro.h"
   
 static isInteger(char *);  static int isInteger(char *);
 static strToInteger(char *);  static int strToInteger(char *);
 static power(int s,int i);  static int 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);  static int isThereExecutableArrayOnStack(int n);
   
   
 extern int SerialCurrent;  extern int SerialCurrent;
 extern int QuoteMode;  extern int QuoteMode;
   
Line 132  struct object newObjectArray(size) 
Line 135  struct object newObjectArray(size) 
   return(rob);    return(rob);
 }  }
   
 isNullObject(obj)  int isNullObject(obj)
      struct object obj;       struct object obj;
 {  {
   if (obj.tag == 0) return(1);    if (obj.tag == 0) return(1);
Line 400  void hashInitialize(struct dictionary *dic)
Line 403  void hashInitialize(struct dictionary *dic)
   }    }
 }  }
   
 static isInteger(str)  static int isInteger(str)
      char *str;       char *str;
 {  {
   int i;    int i;
Line 421  static isInteger(str)
Line 424  static isInteger(str)
   return(1);    return(1);
 }  }
   
 static strToInteger(str)  static int strToInteger(str)
      char *str;       char *str;
 {  {
   int i;    int i;
Line 442  static strToInteger(str)
Line 445  static strToInteger(str)
   return(r);    return(r);
 }  }
   
 static power(s,i)  static int power(s,i)
      int s;       int s;
      int i;       int i;
 {  {
Line 671  void printOperandStack() {
Line 674  void printOperandStack() {
   
   
   
 static initSystemDictionary()  static int initSystemDictionary()
 {  {
   StandardStack.ostack = StandardStackA;    StandardStack.ostack = StandardStackA;
   StandardStack.sp = StandardStackP;    StandardStack.sp = StandardStackP;
Line 809  void scanner() {
Line 812  void scanner() {
     fprintf(stderr,"An error or interrupt in reading macros, files and command strings.\n");      fprintf(stderr,"An error or interrupt in reading macros, files and command strings.\n");
     exit(10);      exit(10);
   } else {  }    } else {  }
   if (signal(SIGINT,SIG_IGN) != SIG_IGN) {    if (mysignal(SIGINT,SIG_IGN) != SIG_IGN) {
     signal(SIGINT,ctrlC);      mysignal(SIGINT,ctrlC);
   }    }
   
   /* setup quiet mode or not */    /* setup quiet mode or not */
Line 915  void ctrlC(sig)
Line 918  void ctrlC(sig)
   extern int OXlock;    extern int OXlock;
   extern int RestrictedMode, RestrictedMode_saved;    extern int RestrictedMode, RestrictedMode_saved;
   
   signal(sig,SIG_IGN);    mysignal(sig,SIG_IGN);
   /* see 133p */    /* see 133p */
   RestrictedMode = RestrictedMode_saved;    RestrictedMode = RestrictedMode_saved;
   cancelAlarm();    cancelAlarm();
Line 926  void ctrlC(sig)
Line 929  void ctrlC(sig)
   if (SGClock) {    if (SGClock) {
     UserCtrlC = 1;      UserCtrlC = 1;
     fprintf(stderr,"ctrl-c is locked because of gc.\n");      fprintf(stderr,"ctrl-c is locked because of gc.\n");
     signal(sig,ctrlC);  if (sig == SIGALRM) alarm((unsigned int)10);      mysignal(sig,ctrlC);  if (sig == SIGALRM) alarm((unsigned int)10);
     return;      return;
   }    }
   if (OXlock) {    if (OXlock) {
Line 935  void ctrlC(sig)
Line 938  void ctrlC(sig)
     if (UserCtrlC > 3) {      if (UserCtrlC > 3) {
       fprintf(stderr,"OK. You are eager to cancel the computation.\n");        fprintf(stderr,"OK. You are eager to cancel the computation.\n");
       fprintf(stderr,"You should close the ox communication cannel.\n");        fprintf(stderr,"You should close the ox communication cannel.\n");
       signal(SIGINT,ctrlC);        mysignal(SIGINT,ctrlC);
       unlockCtrlCForOx();        unlockCtrlCForOx();
     }      }
     fprintf(stderr,"ctrl-c is locked because of ox lock %d.\n",UserCtrlC);      fprintf(stderr,"ctrl-c is locked because of ox lock %d.\n",UserCtrlC);
     signal(sig,ctrlC);  if (sig == SIGALRM) alarm((unsigned int)10);      mysignal(sig,ctrlC);  if (sig == SIGALRM) alarm((unsigned int)10);
     return;      return;
   }    }
   if (ErrorMessageMode != 1) {    if (ErrorMessageMode != 1) {
Line 961  void ctrlC(sig)
Line 964  void ctrlC(sig)
     It SOMETIMES makes core dump.      It SOMETIMES makes core dump.
   */    */
   getokenSM(INIT); /* It might fix the bug above. 1992/11/14 */    getokenSM(INIT); /* It might fix the bug above. 1992/11/14 */
   signal(SIGINT,ctrlC);    mysignal(SIGINT,ctrlC);
 #if defined(__CYGWIN__)  #if defined(__CYGWIN__)
   MYSIGLONGJMP(EnvOfStackMachine,2);    MYSIGLONGJMP(EnvOfStackMachine,2);
 #else  #else
Line 1116  int executeToken(token)
Line 1119  int executeToken(token)
   
   
   
 errorStackmachine(str)  void errorStackmachine(char *str)
      char *str;  
 {  {
   int i,j,k;    int i,j,k;
   static char *u="Usage:";    static char *u="Usage:";
Line 1159  errorStackmachine(str)
Line 1161  errorStackmachine(str)
       }        }
     }else {      }else {
       fprintf(stderr,"ERROR(sm): ");        fprintf(stderr,"ERROR(sm): ");
       fprintf(stderr,str);        fprintf(stderr,"%s",str);
     }      }
     fprintf(stderr,"\n");      fprintf(stderr,"\n");
         MsgStackTraceInArrayp = traceNameStackToArrayp();          MsgStackTraceInArrayp = traceNameStackToArrayp();
Line 1177  errorStackmachine(str)
Line 1179  errorStackmachine(str)
   MYLONGJMP(EnvOfStackMachine,1);    MYLONGJMP(EnvOfStackMachine,1);
 }  }
   
 warningStackmachine(str)  int warningStackmachine(char *str)
      char *str;  
 {  {
   extern int WarningMessageMode;    extern int WarningMessageMode;
   extern int Strict;    extern int Strict;
Line 1186  warningStackmachine(str)
Line 1187  warningStackmachine(str)
     pushErrorStack(KnewErrorPacket(SerialCurrent,-1,str));      pushErrorStack(KnewErrorPacket(SerialCurrent,-1,str));
   }    }
   if (WarningMessageMode != 1) {    if (WarningMessageMode != 1) {
     fprintf(stderr,"WARNING(sm): ");      fprintf(stderr,"%s","WARNING(sm): ");
     fprintf(stderr,str);      fprintf(stderr,"%s",str);
   }    }
   if (Strict) errorStackmachine(" ");    if (Strict) errorStackmachine(" ");
   return(0);    return(0);
Line 1198  warningStackmachine(str)
Line 1199  warningStackmachine(str)
 /* NOTE:  If you call this function and an error occured,  /* NOTE:  If you call this function and an error occured,
    you have to reset the jump buffer by setjmp(EnvOfStackMachine).     you have to reset the jump buffer by setjmp(EnvOfStackMachine).
    cf. kxx/memo1.txt, kxx/stdserver00.c 1998, 2/6 */     cf. kxx/memo1.txt, kxx/stdserver00.c 1998, 2/6 */
 KSexecuteString(s)  int KSexecuteString(s)
      char *s;       char *s;
 {  {
   struct tokens token;    struct tokens token;
Line 1219  KSexecuteString(s)
Line 1220  KSexecuteString(s)
      we crash. So, we use localCatchCtrlC. */       we crash. So, we use localCatchCtrlC. */
   
   if (localCatchCtrlC) {    if (localCatchCtrlC) {
     sigfunc = signal(SIGINT,SIG_IGN);      sigfunc = mysignal(SIGINT,SIG_IGN);
     signal(SIGINT,ctrlC);      mysignal(SIGINT,ctrlC);
   }    }
   
   if (KSPushEnvMode) {    if (KSPushEnvMode) {
Line 1237  KSexecuteString(s)
Line 1238  KSexecuteString(s)
         }          }
       }        }
       recursive--;        recursive--;
       if (localCatchCtrlC) { signal(SIGINT, sigfunc); }        if (localCatchCtrlC) { mysignal(SIGINT, sigfunc); }
       if (!Calling_ctrlC_hook) {        if (!Calling_ctrlC_hook) {
         Calling_ctrlC_hook = 1; RestrictedMode = 0;          Calling_ctrlC_hook = 1; RestrictedMode = 0;
         KSexecuteString(" ctrlC-hook "); /* Execute User Defined functions. */          KSexecuteString(" ctrlC-hook "); /* Execute User Defined functions. */
Line 1245  KSexecuteString(s)
Line 1246  KSexecuteString(s)
       }        }
       Calling_ctrlC_hook = 0;        Calling_ctrlC_hook = 0;
       KSexecuteString(" (Computation is interrupted.) "); /* move to ctrlC-hook?*/        KSexecuteString(" (Computation is interrupted.) "); /* move to ctrlC-hook?*/
         /* fprintf(stderr,"result code=-1 for %s\n",s); */
       return(-1);        return(-1);
     }else{ }      }else{ }
   }else{    }else{
Line 1260  KSexecuteString(s)
Line 1262  KSexecuteString(s)
           }            }
         }          }
         recursive = 0;          recursive = 0;
         if (localCatchCtrlC) { signal(SIGINT, sigfunc); }          if (localCatchCtrlC) { mysignal(SIGINT, sigfunc); }
         if (!Calling_ctrlC_hook) {          if (!Calling_ctrlC_hook) {
           Calling_ctrlC_hook = 1; RestrictedMode = 0;            Calling_ctrlC_hook = 1; RestrictedMode = 0;
           KSexecuteString(" ctrlC-hook "); /* Execute User Defined functions. */            KSexecuteString(" ctrlC-hook "); /* Execute User Defined functions. */
Line 1269  KSexecuteString(s)
Line 1271  KSexecuteString(s)
         Calling_ctrlC_hook = 0;          Calling_ctrlC_hook = 0;
         Calling_ctrlC_hook = 0;          Calling_ctrlC_hook = 0;
                 KSexecuteString(" (Computation is interrupted.) ");                  KSexecuteString(" (Computation is interrupted.) ");
                   /* fprintf(stderr,"result code=-1 for %s\n",s);*/
         return(-1);          return(-1);
       }else { }        }else { }
     }      }
Line 1287  KSexecuteString(s)
Line 1290  KSexecuteString(s)
   executePrimitive(ob);    executePrimitive(ob);
   recursive--;    recursive--;
   if (KSPushEnvMode) *EnvOfStackMachine = *saved_EnvOfStackMachine;    if (KSPushEnvMode) *EnvOfStackMachine = *saved_EnvOfStackMachine;
   if (localCatchCtrlC) { signal(SIGINT, sigfunc); }    if (localCatchCtrlC) { mysignal(SIGINT, sigfunc); }
   return(0);    return(0);
 }  }
   
 KSdefineMacros() {  int KSdefineMacros() {
   struct tokens token;    struct tokens token;
   int tmp;    int tmp;
   struct object ob = OINIT;    struct object ob = OINIT;
Line 1312  KSdefineMacros() {
Line 1315  KSdefineMacros() {
   
 }  }
   
   void KSstart_quiet() {
     extern int Quiet;
     Quiet=1;
     KSstart();
   }
 void KSstart() {  void KSstart() {
   struct tokens token;    struct tokens token;
   int tmp;    int tmp;
Line 1363  void KSpush(ob)
Line 1371  void KSpush(ob)
   Kpush(ob);    Kpush(ob);
 }  }
   
 struct object KSpeek(k) {  struct object KSpeek(int k) {
   return(peek(k));    return(peek(k));
 }  }
   
Line 1622  struct object KSdupErrors() {
Line 1630  struct object KSdupErrors() {
   
 void cancelAlarm() {  void cancelAlarm() {
   alarm((unsigned int) 0);    alarm((unsigned int) 0);
   signal(SIGALRM,SIG_DFL);    mysignal(SIGALRM,SIG_DFL);
 }  }
   
 /* back-trace */  /* back-trace */
Legend:
Removed from v.1.39  
changed lines
  Added in v.1.44
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>