[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.36 and 1.43

version 1.36, 2006/02/02 05:55:33 version 1.43, 2018/09/07 00:15:44
Line 1 
Line 1 
 /* $OpenXM: OpenXM/src/kan96xx/Kan/stackmachine.c,v 1.35 2006/02/02 04:16:49 takayama Exp $ */  /* $OpenXM: OpenXM/src/kan96xx/Kan/stackmachine.c,v 1.42 2016/03/31 06:34:29 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 "mysig.h"
   
   /* The msys2 seems to make a buffer overflow of  EnvOfStackmachine[].
   The code
   [(x) ring_of_differential_operators 11] define_ring
   ( Dx*(x+Dx) ) /ff set
   causes the segfault because Mp_zero is borken. Is it a bug of msys2?
   Anyway, the following definition seems to be a workaround. 2015.09
   Singnals do not work properly on msys2. (gcc -dM -E ... to see macros defs)
   See stackm.h
   */
   
 /* #define OPERAND_STACK_SIZE  2000 */  /* #define OPERAND_STACK_SIZE  2000 */
 #define OPERAND_STACK_SIZE 30000  #define OPERAND_STACK_SIZE 30000
Line 792  void scanner() {
Line 802  void scanner() {
   initSystemDictionary();    initSystemDictionary();
   
 #if defined(__CYGWIN__)  #if defined(__CYGWIN__)
   if (sigsetjmp(EnvOfStackMachine,1)) {    if (MYSIGSETJMP(EnvOfStackMachine,1)) {
 #else  #else
   if (setjmp(EnvOfStackMachine)) {    if (MYSETJMP(EnvOfStackMachine)) {
 #endif  #endif
     /* do nothing in the case of error */      /* do nothing in the case of error */
     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 856  void scanner() {
Line 866  void scanner() {
   
   for (;;) {    for (;;) {
 #if defined(__CYGWIN__)  #if defined(__CYGWIN__)
     if (jval=sigsetjmp(EnvOfStackMachine,1)) {      if (jval=MYSIGSETJMP(EnvOfStackMachine,1)) {
 #else  #else
     if (jval=setjmp(EnvOfStackMachine)) {      if (jval=MYSETJMP(EnvOfStackMachine)) {
 #endif  #endif
       /* ***  The following does not work properly.  ****        /* ***  The following does not work properly.  ****
          if (jval == 2) {           if (jval == 2) {
Line 906  void ctrlC(sig)
Line 916  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 917  void ctrlC(sig)
Line 927  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 926  void ctrlC(sig)
Line 936  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 952  void ctrlC(sig)
Line 962  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__)
   siglongjmp(EnvOfStackMachine,2);    MYSIGLONGJMP(EnvOfStackMachine,2);
 #else  #else
   longjmp(EnvOfStackMachine,2); /* returns 2 for ctrl-C */    MYLONGJMP(EnvOfStackMachine,2); /* returns 2 for ctrl-C */
 #endif  #endif
 }  }
   
Line 1165  errorStackmachine(str)
Line 1175  errorStackmachine(str)
   stdOperandStack(); contextControl(CCRESTORE);    stdOperandStack(); contextControl(CCRESTORE);
   getokenSM(INIT); /* It might fix the bug. 1996/3/10 */    getokenSM(INIT); /* It might fix the bug. 1996/3/10 */
   /* fprintf(stderr,"Now, Long jump!\n"); */    /* fprintf(stderr,"Now, Long jump!\n"); */
   longjmp(EnvOfStackMachine,1);    MYLONGJMP(EnvOfStackMachine,1);
 }  }
   
 warningStackmachine(str)  warningStackmachine(str)
Line 1210  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) {
     *saved_EnvOfStackMachine = *EnvOfStackMachine;      *saved_EnvOfStackMachine = *EnvOfStackMachine;
 #if defined(__CYGWIN__)  #if defined(__CYGWIN__)
     if (jval = sigsetjmp(EnvOfStackMachine,1)) {      if (jval = MYSIGSETJMP(EnvOfStackMachine,1)) {
 #else  #else
     if (jval = setjmp(EnvOfStackMachine)) {      if (jval = MYSETJMP(EnvOfStackMachine)) {
 #endif  #endif
       *EnvOfStackMachine = *saved_EnvOfStackMachine;        *EnvOfStackMachine = *saved_EnvOfStackMachine;
       if (jval == 2) {        if (jval == 2) {
Line 1228  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 1236  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{
     if (recursive == 0) {      if (recursive == 0) {
 #if defined(__CYGWIN__)  #if defined(__CYGWIN__)
       if (jval=sigsetjmp(EnvOfStackMachine,1)) {        if (jval=MYSIGSETJMP(EnvOfStackMachine,1)) {
 #else  #else
       if (jval=setjmp(EnvOfStackMachine)) {        if (jval=MYSETJMP(EnvOfStackMachine)) {
 #endif  #endif
         if (jval == 2) {          if (jval == 2) {
           if (ErrorMessageMode == 1 || ErrorMessageMode == 2) {            if (ErrorMessageMode == 1 || ErrorMessageMode == 2) {
Line 1251  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 1260  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 1278  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);
 }  }
   
Line 1303  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 1315  void KSstart() {
Line 1332  void KSstart() {
   /* The following line may cause a core dump, if you do not setjmp properly    /* The following line may cause a core dump, if you do not setjmp properly
      after calling KSstart().*/       after calling KSstart().*/
   /*    /*
     if (setjmp(EnvOfStackMachine)) {      if (MYSETJMP(EnvOfStackMachine)) {
     fprintf(stderr,"KSstart(): An error or interrupt in reading macros, files and command strings.\n");      fprintf(stderr,"KSstart(): An error or interrupt in reading macros, files and command strings.\n");
     exit(10);      exit(10);
     } else {  }  */      } else {  }  */
Line 1613  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.36  
changed lines
  Added in v.1.43
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>