| version 1.11, 2001/10/09 01:36:24 | 
version 1.38, 2015/08/14 13:51:56 | 
 | 
 | 
|   * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE, | 
  * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE, | 
|   * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE. | 
  * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE. | 
|   * | 
  * | 
|   * $OpenXM: OpenXM_contrib2/asir2000/parse/main.c,v 1.10 2001/08/20 09:03:28 noro Exp $ | 
  * $OpenXM: OpenXM_contrib2/asir2000/parse/main.c,v 1.37 2015/08/06 10:01:53 fujimoto Exp $ | 
|  */ | 
 */ | 
|  #include "ca.h" | 
 #include "ca.h" | 
|  #include "parse.h" | 
 #include "parse.h" | 
|   | 
  | 
|  #if PARI | 
 #include <stdlib.h> | 
|  #include "genpari.h" | 
 #if defined(VISUAL) || defined(__MINGW32__) | 
|   | 
 #include <io.h> | 
|  extern jmp_buf environnement; | 
 #define R_OK 4 | 
|   | 
 #else | 
|   | 
 #include <unistd.h> | 
|   | 
 #include <fcntl.h> | 
|  #endif | 
 #endif | 
|   | 
  | 
|  extern jmp_buf main_env; | 
 extern JMP_BUF main_env; | 
|   | 
  | 
|  #if defined(INTERVAL) | 
  | 
|  #ifndef ASIRRCNAME | 
 #ifndef ASIRRCNAME | 
|  #define ASIRRCNAME      "int_asirrc" | 
  | 
|  #endif | 
  | 
|  #else | 
  | 
|  #ifndef ASIRRCNAME | 
  | 
|  #define ASIRRCNAME      "asirrc" | 
 #define ASIRRCNAME      "asirrc" | 
|  #endif | 
 #endif | 
|  #endif | 
  | 
|   | 
  | 
|   | 
  | 
|  double get_current_time(); | 
 double get_current_time(); | 
|  void init_socket(); | 
 void init_socket(); | 
|  void recover(); | 
 void recover(); | 
|   | 
 void set_stacksize(); | 
|   | 
  | 
|  extern int mpi_nprocs,mpi_myid; | 
 extern int mpi_nprocs,mpi_myid; | 
|   | 
  | 
|  #if MPI | 
 char *find_asirrc() | 
|  int *StackBottom; | 
 { | 
|   | 
         static char name[BUFSIZ]; | 
|   | 
         char dir[BUFSIZ]; | 
|   | 
         char *env,*env2; | 
|   | 
  | 
|   | 
 /* if ASIR_CONFIG is set, execute it; else execute .asirrc */ | 
|   | 
         env = getenv("ASIR_CONFIG"); | 
|   | 
         if( env && !access(env, R_OK) ) { | 
|   | 
                 strcpy(name,env); | 
|   | 
                 return name; | 
|   | 
         } | 
|   | 
         env = getenv("HOME"); | 
|   | 
         if ( env ) { | 
|   | 
                 sprintf(name, "%s/.asirrc", env); | 
|   | 
                 if (!access(name, R_OK)) { | 
|   | 
                         return name; | 
|   | 
                 } | 
|   | 
         } | 
|   | 
 #if defined(VISUAL) || defined(__MINGW32__) | 
|   | 
         env  = getenv("HOMEDRIVE"); | 
|   | 
         env2 = getenv("HOMEPATH"); | 
|   | 
         if ( env && env2 ) { | 
|   | 
                 sprintf(name, "%s%s/.asirrc", env, env2); | 
|   | 
                 if (!access(name, R_OK)) { | 
|   | 
                         return name; | 
|   | 
                 } | 
|   | 
         } | 
|   | 
         env  = getenv("APPDATA"); | 
|   | 
         if ( env ) { | 
|   | 
                 sprintf(name, "%s/OpenXM/.asirrc", env); | 
|   | 
                 if (!access(name, R_OK)) { | 
|   | 
                         return name; | 
|   | 
                 } | 
|   | 
         } | 
|   | 
         get_rootdir(dir, BUFSIZ); | 
|   | 
         sprintf(name, "%s/.asirrc", dir); | 
|   | 
         if (!access(name, R_OK)) { | 
|   | 
                 return name; | 
|   | 
         } | 
|  #endif | 
 #endif | 
|   | 
         return NULL; | 
|   | 
 } | 
|   | 
  | 
|  #if defined(VISUAL_LIB) | 
 #if defined(VISUAL_LIB) | 
|  void Main(int argc,char *argv[]) | 
 void Main(int argc,char *argv[]) | 
|  #else | 
 #else | 
|  #if defined(VISUAL) | 
 #if defined(VISUAL) || defined(__MINGW32__) | 
|  void | 
 void | 
|  #endif | 
 #endif | 
|  main(int argc,char *argv[]) | 
 main(int argc,char *argv[]) | 
|  #endif | 
 #endif | 
|  { | 
 { | 
|          FILE *ifp; | 
         int tmp; | 
|          char ifname[BUFSIZ]; | 
         char *ifname; | 
|          extern int GC_dont_gc; | 
         extern int GC_dont_gc; | 
|          extern int read_exec_file; | 
  | 
|          extern int do_asirrc; | 
         extern int do_asirrc; | 
|          extern int do_file; | 
         extern int do_file; | 
|   | 
         extern char *do_filename; | 
|   | 
         extern int asir_setenv; | 
|          extern FILE *in_fp; | 
         extern FILE *in_fp; | 
|          char *getenv(); | 
         extern int *StackBottom; | 
|          char *homedir; | 
 #if !defined(VISUAL) && !defined(__MINGW32__) | 
|          char *ptr; | 
         char *slash,*bslash,*binname,*p; | 
|  #if !defined(VISUAL) | 
  | 
|          int tmp; | 
  | 
|          char *slash,*binname; | 
  | 
|  #endif | 
 #endif | 
|   | 
  | 
|  #if MPI | 
         set_stacksize(); | 
|          StackBottom = &tmp; | 
         StackBottom = &tmp; | 
|   | 
         GC_init(); | 
|   | 
 #if defined(MPI) | 
|          mpi_init(); | 
         mpi_init(); | 
|          if ( mpi_myid ) { | 
         if ( mpi_myid ) { | 
|                  int slave_argc; | 
                 int slave_argc; | 
| Line 117  main(int argc,char *argv[]) | 
 
  | 
| Line 155  main(int argc,char *argv[]) | 
 
 
 | 
|                  exit(0); | 
                 exit(0); | 
|          } else | 
         } else | 
|                  ox_mpi_master_init(); | 
                 ox_mpi_master_init(); | 
|  #elif !defined(VISUAL) | 
 #elif !defined(VISUAL) && !defined(__MINGW32__) | 
|          slash = (char *)rindex(argv[0],'/'); | 
         slash = (char *)rindex(argv[0],'/'); | 
|   | 
         bslash = (char *)rindex(argv[0],'\\'); | 
|          if ( slash ) | 
         if ( slash ) | 
|                  binname = slash+1; | 
                 binname = slash+1; | 
|   | 
         else if ( bslash ) | 
|   | 
                 binname = bslash+1; | 
|          else | 
         else | 
|                  binname = argv[0]; | 
                 binname = argv[0]; | 
|          if ( !strcmp(binname,"ox_asir") ) { | 
         for ( p = binname; *p; p++ ) | 
|   | 
                 *p = tolower(*p); | 
|   | 
         if ( !strncmp(binname,"ox_asir",strlen("ox_asir")) ) { | 
|                  /* never return */ | 
                 /* never return */ | 
|                  ox_main(argc,argv); | 
                 ox_main(argc,argv); | 
|                  exit(0); | 
                 exit(0); | 
|  #if DO_PLOT | 
 #if defined(DO_PLOT) | 
|          } else if ( !strcmp(binname,"ox_plot") ) { | 
         } else if ( !strncmp(binname,"ox_plot",strlen("ox_plot")) ) { | 
|                  /* never return */ | 
                 /* never return */ | 
|                  ox_plot_main(argc,argv); | 
                 ox_plot_main(argc,argv); | 
|                  exit(0); | 
                 exit(0); | 
|  #endif | 
 #endif | 
|          } else if ( !strcmp(binname,"ox_launch") ) { | 
         } else if ( !strncmp(binname,"ox_launch",strlen("ox_launch")) ) { | 
|                  /* never return */ | 
                 /* never return */ | 
|                  launch_main(argc,argv); | 
                 launch_main(argc,argv); | 
|                  exit(0); | 
                 exit(0); | 
| Line 146  main(int argc,char *argv[]) | 
 
  | 
| Line 189  main(int argc,char *argv[]) | 
 
 
 | 
|          rtime_init(); | 
         rtime_init(); | 
|          env_init(); | 
         env_init(); | 
|          endian_init(); | 
         endian_init(); | 
|          GC_init(); | 
         cppname_init(); | 
|          process_args(--argc,++argv); | 
         process_args(--argc,++argv); | 
|  #if PARI | 
         if (!do_quiet) { | 
|      risa_pari_init(); | 
                 copyright(); | 
|  #endif | 
         } | 
|          copyright(); | 
  | 
|          output_init(); | 
         output_init(); | 
|          arf_init(); | 
         arf_init(); | 
|          nglob_init(); | 
         nglob_init(); | 
| Line 162  main(int argc,char *argv[]) | 
 
  | 
| Line 204  main(int argc,char *argv[]) | 
 
 
 | 
|          pf_init(); | 
         pf_init(); | 
|          sysf_init(); | 
         sysf_init(); | 
|          parif_init(); | 
         parif_init(); | 
|  #if defined(VISUAL) | 
         order_init(); | 
|   | 
         /* XXX set the default ordering */ | 
|   | 
 #if defined(VISUAL) || defined(__MINGW32__) | 
|          init_socket(); | 
         init_socket(); | 
|  #endif | 
 #endif | 
|  #if defined(UINIT) | 
 #if defined(UINIT) | 
|          reg_sysf(); | 
         reg_sysf(); | 
|  #endif | 
 #endif | 
|   | 
  | 
|  /* if ASIR_CONFIG is set, execute it; else execute .asirrc */ | 
         if ( do_file ) { | 
|          if ( ptr = getenv("ASIR_CONFIG") ) | 
                 asir_infile=NULL; | 
|                  strcpy(ifname,ptr); | 
                 loadasirfile(do_filename); | 
|          else { | 
         } else { | 
|                  homedir = getenv("HOME"); | 
                 /* the bottom of the input stack */ | 
|                  if ( !homedir ) { | 
                 input_init(stdin,"stdin"); | 
|                          char rootname[BUFSIZ]; | 
  | 
|   | 
  | 
|                          get_rootdir(rootname,sizeof(rootname)); | 
  | 
|                          homedir = rootname; | 
  | 
|                  } | 
  | 
|                  sprintf(ifname,"%s/." ASIRRCNAME,homedir); | 
  | 
|          } | 
         } | 
|   | 
  | 
|          if ( do_asirrc && (ifp = fopen(ifname,"r")) ) { | 
         if ( do_asirrc && (ifname = find_asirrc()) ) { | 
|                  input_init(ifp,ifname); | 
                 if ( !SETJMP(main_env) ) | 
|                  if ( !setjmp(main_env) ) { | 
                         execasirfile(ifname); | 
|                          read_exec_file = 1; | 
  | 
|                          read_eval_loop(); | 
  | 
|                          read_exec_file = 0; | 
  | 
|                  } | 
  | 
|                  fclose(ifp); | 
  | 
|          } | 
         } | 
|   | 
  | 
|          if ( do_file ) | 
  | 
|                  input_init(in_fp,"stdin"); | 
  | 
|          else | 
  | 
|                  input_init(stdin,"stdin"); | 
  | 
|          prompt(); | 
         prompt(); | 
|          while ( 1 ) { | 
         while ( 1 ) { | 
|  #if PARI | 
                 if ( SETJMP(main_env) ) | 
|                  recover(0); | 
  | 
|                  if ( setjmp(environnement) ) { | 
  | 
|                          avma = top; recover(1); | 
  | 
|                          resetenv(""); | 
  | 
|                  } | 
  | 
|  #endif | 
  | 
|                  if ( setjmp(main_env) ) | 
  | 
|                          prompt(); | 
                         prompt(); | 
|   | 
                 if ( !do_file ) { | 
|   | 
                         if ( SETJMP(asir_infile->jmpbuf) ) | 
|   | 
                                 prompt(); | 
|   | 
                         else | 
|   | 
                                 asir_infile->ready_for_longjmp = 1; | 
|   | 
                 } | 
|   | 
                 restore_handler(); | 
|                  read_eval_loop(); | 
                 read_eval_loop(); | 
|          } | 
         } | 
|  } | 
 } | 
| Line 218  main(int argc,char *argv[]) | 
 
  | 
| Line 247  main(int argc,char *argv[]) | 
 
 
 | 
|  void set_error(int code,char *reason,char *action) | 
 void set_error(int code,char *reason,char *action) | 
|  {} | 
 {} | 
|  #endif | 
 #endif | 
|   | 
  | 
|   | 
 void set_stacksize() | 
|   | 
 { | 
|   | 
 #if !defined(VISUAL) && !defined(__MINGW32__) | 
|   | 
         struct rlimit rlim; | 
|   | 
         int c,m; | 
|   | 
  | 
|   | 
         getrlimit(RLIMIT_STACK,&rlim); | 
|   | 
         if ( rlim.rlim_cur < (1<<26) ) { | 
|   | 
                 rlim.rlim_cur = MIN(1<<26,rlim.rlim_max); | 
|   | 
                 setrlimit(RLIMIT_STACK,&rlim); | 
|   | 
         } | 
|   | 
 #endif | 
|   | 
 } |