source: git/Singular/misc_ip.cc

spielwiese
Last change on this file was 29b5575, checked in by Hans Schoenemann <hannes@…>, 6 months ago
report sdb witrh "-v" if defined
  • Property mode set to 100644
File size: 36.9 KB
Line 
1/*****************************************************************************\
2 * Computer Algebra System SINGULAR
3\*****************************************************************************/
4/** @file misc_ip.cc
5 *
6 * This file provides miscellaneous functionality.
7 *
8 * For more general information, see the documentation in misc_ip.h.
9 *
10 **/
11/*****************************************************************************/
12
13// include header files
14#define PLURAL_INTERNAL_DECLARATIONS 1
15
16#include "kernel/mod2.h"
17#include "misc/sirandom.h"
18#include "omalloc/omalloc.h"
19#include "misc/mylimits.h"
20#include "reporter/si_signals.h"
21#include "factory/factory.h"
22#include "coeffs/si_gmp.h"
23#include "coeffs/coeffs.h"
24#include "coeffs/flintcf_Q.h"
25#include "coeffs/flintcf_Qrat.h"
26#include "coeffs/flintcf_Zn.h"
27#include "coeffs/rmodulon.h"
28#include "polys/ext_fields/algext.h"
29#include "polys/ext_fields/transext.h"
30#include "polys/nc/gb_hack.h"
31
32#ifdef HAVE_SIMPLEIPC
33#include "Singular/links/simpleipc.h"
34#endif
35
36#include "misc_ip.h"
37#include "ipid.h"
38#include "feOpt.h"
39#include "links/silink.h"
40#include "mod_lib.h"
41#include "misc/distrib.h"
42
43#include "misc/options.h"
44#include "misc/intvec.h"
45
46#include "polys/monomials/ring.h"
47#include "polys/templates/p_Procs.h"
48
49#include "kernel/GBEngine/kstd1.h"
50#include "kernel/oswrapper/timer.h"
51#include "resources/feResource.h"
52#include "kernel/oswrapper/feread.h"
53
54#include "subexpr.h"
55#include "cntrlc.h"
56#include "ipshell.h"
57
58#include "fehelp.h"
59
60#ifdef HAVE_READLINE
61  #ifdef READLINE_READLINE_H_OK
62    #include <readline/readline.h>
63  #endif
64  #ifndef RL_VERSION_MAJOR
65    #define RL_VERSION_MAJOR 0
66  #endif
67#endif
68
69#ifdef HAVE_NTL
70#include <NTL/version.h>
71#endif
72
73
74void setListEntry(lists L, int index, mpz_t n)
75{ /* assumes n > 0 */
76  /* try to fit nn into an int: */
77  if (mpz_size1(n)<=1)
78  {
79    int ui=(int)mpz_get_si(n);
80    if ((((ui<<3)>>3)==ui)
81    && (mpz_cmp_si(n,(long)ui)==0))
82    {
83      L->m[index].rtyp = INT_CMD; L->m[index].data = (void*)(long)ui;
84      return;
85    }
86  }
87  number nn = mpz2number(n, coeffs_BIGINT);
88  L->m[index].rtyp = BIGINT_CMD; L->m[index].data = (void*)nn;
89}
90
91void setListEntry_ui(lists L, int index, unsigned long ui)
92{ /* assumes n > 0 */
93  /* try to fit nn into an int: */
94  int i=(int)ui;
95  if ((((unsigned long)i)==ui) && (((i<<3)>>3)==i))
96  {
97    L->m[index].rtyp = INT_CMD; L->m[index].data = (void*)(long)i;
98  }
99  else
100  {
101    number nn = n_Init(ui, coeffs_BIGINT);
102    L->m[index].rtyp = BIGINT_CMD; L->m[index].data = (void*)nn;
103  }
104}
105
106/* Factoring with Pollard's rho method. stolen from GMP/demos */
107STATIC_VAR unsigned add[] = {4, 2, 4, 2, 4, 6, 2, 6};
108
109static int factor_using_division (mpz_t t, unsigned int limit,lists primes, int *multiplicities,int &index, unsigned long bound)
110{
111  mpz_t q, r;
112  unsigned long int f;
113  int ai;
114  unsigned *addv = add;
115  unsigned int failures;
116  int bound_not_reached=1;
117
118  mpz_init (q);
119  mpz_init (r);
120
121  f = mpz_scan1 (t, 0);
122  mpz_div_2exp (t, t, f);
123  if (f>0)
124  {
125    setListEntry_ui(primes, index, 2);
126    multiplicities[index++] = f;
127  }
128
129  f=0;
130  loop
131  {
132    mpz_tdiv_qr_ui (q, r, t, 3);
133    if (mpz_sgn1 (r) != 0)
134        break;
135    mpz_set (t, q);
136    f++;
137  }
138  if (f>0)
139  {
140    setListEntry_ui(primes, index, 3);
141    multiplicities[index++] = f;
142  }
143  f=0;
144  loop
145  {
146    mpz_tdiv_qr_ui (q, r, t, 5);
147    if (mpz_sgn1 (r) != 0)
148        break;
149    mpz_set (t, q);
150    f++;
151  }
152  if (f>0)
153  {
154    setListEntry_ui(primes, index, 5);
155    multiplicities[index++] = f;
156  }
157
158  failures = 0;
159  f = 7;
160  ai = 0;
161  unsigned long last_f=0;
162  while (mpz_cmp_ui (t, 1) != 0)
163  {
164    mpz_tdiv_qr_ui (q, r, t, f);
165    if (mpz_sgn1 (r) != 0)
166    {
167      f += addv[ai];
168      if (mpz_cmp_ui (t, f) < 0)
169        break;
170      ai = (ai + 1) & 7;
171      failures++;
172      if (failures > limit)
173        break;
174      if ((bound!=0) && (f>bound))
175      {
176        bound_not_reached=0;
177        break;
178      }
179    }
180    else
181    {
182      mpz_swap (t, q);
183      if (f!=last_f)
184      {
185        setListEntry_ui(primes, index, f);
186        multiplicities[index]++;
187        index++;
188      }
189      else
190      {
191        multiplicities[index-1]++;
192      }
193      last_f=f;
194      failures = 0;
195    }
196  }
197
198  mpz_clear (q);
199  mpz_clear (r);
200  //printf("bound=%d,f=%d,failures=%d, reached=%d\n",bound,f,failures,bound_not_reached);
201  return bound_not_reached;
202}
203
204static void factor_using_pollard_rho (mpz_t n, unsigned long a, lists primes, int * multiplicities,int &index)
205{
206  mpz_t x, x1, y, P;
207  mpz_t t1, t2;
208  mpz_t last_f;
209  unsigned long long k, l, i;
210
211  mpz_init (t1);
212  mpz_init (t2);
213  mpz_init_set_ui (last_f, 0);
214  mpz_init_set_ui (y, 2);
215  mpz_init_set_ui (x, 2);
216  mpz_init_set_ui (x1, 2);
217  mpz_init_set_ui (P, 1);
218  k = 1;
219  l = 1;
220
221  while (mpz_cmp_ui (n, 1) != 0)
222  {
223    loop
224    {
225      do
226      {
227        mpz_mul (t1, x, x);
228        mpz_mod (x, t1, n);
229        mpz_add_ui (x, x, a);
230        mpz_sub (t1, x1, x);
231        mpz_mul (t2, P, t1);
232        mpz_mod (P, t2, n);
233
234        if (k % 32 == 1)
235        {
236          mpz_gcd (t1, P, n);
237          if (mpz_cmp_ui (t1, 1) != 0)
238            goto factor_found;
239          mpz_set (y, x);
240        }
241      }
242      while (--k != 0);
243
244      mpz_gcd (t1, P, n);
245      if (mpz_cmp_ui (t1, 1) != 0)
246        goto factor_found;
247
248      mpz_set (x1, x);
249      k = l;
250      l = 2 * l;
251      for (i = 0; i < k; i++)
252      {
253        mpz_mul (t1, x, x);
254        mpz_mod (x, t1, n);
255        mpz_add_ui (x, x, a);
256      }
257      mpz_set (y, x);
258    }
259
260  factor_found:
261    do
262    {
263      mpz_mul (t1, y, y);
264      mpz_mod (y, t1, n);
265      mpz_add_ui (y, y, a);
266      mpz_sub (t1, x1, y);
267      mpz_gcd (t1, t1, n);
268    }
269    while (mpz_cmp_ui (t1, 1) == 0);
270
271    mpz_divexact (n, n, t1);        /* divide by t1, before t1 is overwritten */
272
273    if (!mpz_probab_prime_p (t1, 10))
274    {
275      do
276      {
277        mp_limb_t a_limb;
278        mpn_random (&a_limb, (mp_size_t) 1);
279        a = a_limb;
280      }
281      while (a == 0);
282
283      factor_using_pollard_rho (t1, a, primes,multiplicities,index);
284    }
285    else
286    {
287      if (mpz_cmp(t1,last_f)==0)
288      {
289        multiplicities[index-1]++;
290      }
291      else
292      {
293        mpz_set(last_f,t1);
294        setListEntry(primes, index, t1);
295        multiplicities[index++] = 1;
296      }
297    }
298    mpz_mod (x, x, n);
299    mpz_mod (x1, x1, n);
300    mpz_mod (y, y, n);
301    if (mpz_probab_prime_p (n, 10))
302    {
303      if (mpz_cmp(n,last_f)==0)
304      {
305        multiplicities[index-1]++;
306      }
307      else
308      {
309        mpz_set(last_f,n);
310        setListEntry(primes, index, n);
311        multiplicities[index++] = 1;
312      }
313      mpz_set_ui(n,1);
314      break;
315    }
316  }
317
318  mpz_clear (P);
319  mpz_clear (t2);
320  mpz_clear (t1);
321  mpz_clear (x1);
322  mpz_clear (x);
323  mpz_clear (y);
324  mpz_clear (last_f);
325}
326
327static void factor_gmp (mpz_t t,lists primes,int *multiplicities,int &index,unsigned long bound)
328{
329  unsigned int division_limit;
330
331  if (mpz_sgn (t) == 0)
332    return;
333
334  /* Set the trial division limit according the size of t.  */
335  division_limit = mpz_sizeinbase (t, 2);
336  if (division_limit > 1000)
337    division_limit = 1000 * 1000;
338  else
339    division_limit = division_limit * division_limit;
340
341  if (factor_using_division (t, division_limit,primes,multiplicities,index,bound))
342  {
343    if (mpz_cmp_ui (t, 1) != 0)
344    {
345      if (mpz_probab_prime_p (t, 10))
346      {
347        setListEntry(primes, index, t);
348        multiplicities[index++] = 1;
349        mpz_set_ui(t,1);
350      }
351      else
352        factor_using_pollard_rho (t, 1L, primes,multiplicities,index);
353    }
354  }
355}
356/* n and pBound are assumed to be bigint numbers */
357lists primeFactorisation(const number n, const int pBound)
358{
359  int i;
360  int index=0;
361  mpz_t nn; number2mpz(n, coeffs_BIGINT, nn);
362  lists primes = (lists)omAllocBin(slists_bin); primes->Init(1000);
363  int* multiplicities = (int*)omAlloc0(1000*sizeof(int));
364  int positive=1;
365
366  if (!n_IsZero(n, coeffs_BIGINT))
367  {
368    if (!n_GreaterZero(n, coeffs_BIGINT))
369    {
370      positive=-1;
371      mpz_neg(nn,nn);
372    }
373    factor_gmp(nn,primes,multiplicities,index,pBound);
374  }
375
376  lists primesL = (lists)omAllocBin(slists_bin);
377  primesL->Init(index);
378  for (i = 0; i < index; i++)
379  {
380    primesL->m[i].rtyp = primes->m[i].rtyp;
381    primesL->m[i].data = primes->m[i].data;
382    primes->m[i].rtyp=0;
383    primes->m[i].data=NULL;
384  }
385  primes->Clean(NULL);
386
387  lists multiplicitiesL = (lists)omAllocBin(slists_bin);
388  multiplicitiesL->Init(index);
389  for (i = 0; i < index; i++)
390  {
391    multiplicitiesL->m[i].rtyp = INT_CMD;
392    multiplicitiesL->m[i].data = (void*)(long)multiplicities[i];
393  }
394  omFree(multiplicities);
395
396  lists L=(lists)omAllocBin(slists_bin);
397  L->Init(3);
398  if (positive==-1) mpz_neg(nn,nn);
399  L->m[0].rtyp = LIST_CMD; L->m[0].data = (void*)primesL;
400  L->m[1].rtyp = LIST_CMD; L->m[1].data = (void*)multiplicitiesL;
401  setListEntry(L, 2, nn);
402
403  mpz_clear(nn);
404
405  return L;
406}
407
408//#ifdef HAVE_LIBPARSER
409//#  include "libparse.h"
410//#endif /* HAVE_LIBPARSER */
411
412
413/*2
414* the renice routine for very large jobs
415* works only on unix machines,
416* testet on : linux, HP 9.0
417*
418*#include <sys/times.h>
419*#include <sys/resource.h>
420*extern "C" int setpriority(int,int,int);
421*void very_nice()
422*{
423*#ifndef NO_SETPRIORITY
424*  setpriority(PRIO_PROCESS,0,19);
425*#endif
426*  sleep(10);
427*}
428*/
429
430void singular_example(char *str)
431{
432  assume(str!=NULL);
433  char *s=str;
434  while (*s==' ') s++;
435  char *ss=s;
436  while (*ss!='\0') ss++;
437  while (*ss<=' ')
438  {
439    *ss='\0';
440    ss--;
441  }
442  idhdl h=IDROOT->get_level(s,0);
443  if ((h!=NULL) && (IDTYP(h)==PROC_CMD))
444  {
445    char *lib=iiGetLibName(IDPROC(h));
446    if((lib!=NULL)&&(*lib!='\0'))
447    {
448      Print("// proc %s from lib %s\n",s,lib);
449      s=iiGetLibProcBuffer(IDPROC(h), 2);
450      if (s!=NULL)
451      {
452        if (strlen(s)>5)
453        {
454          iiEStart(s,IDPROC(h));
455          omFree((ADDRESS)s);
456          return;
457        }
458        else omFree((ADDRESS)s);
459      }
460    }
461  }
462  else
463  {
464    char sing_file[MAXPATHLEN];
465    FILE *fd=NULL;
466    char *res_m=feResource('m', 0);
467    if (res_m!=NULL)
468    {
469      snprintf(sing_file,MAXPATHLEN, "%s/%s.sing", res_m, s);
470      fd = feFopen(sing_file, "r");
471    }
472    if (fd != NULL)
473    {
474
475      int old_echo = si_echo;
476      int length, got;
477      char* s;
478
479      fseek(fd, 0, SEEK_END);
480      length = ftell(fd);
481      fseek(fd, 0, SEEK_SET);
482      s = (char*) omAlloc((length+20)*sizeof(char));
483      got = fread(s, sizeof(char), length, fd);
484      fclose(fd);
485      if (got != length)
486      {
487        Werror("Error while reading file %s", sing_file);
488      }
489      else
490      {
491        s[length] = '\0';
492        strcat(s, "\n;return();\n\n");
493        si_echo = 2;
494        iiEStart(s, NULL);
495        si_echo = old_echo;
496      }
497      omFree(s);
498    }
499    else
500    {
501      Werror("no example for %s", str);
502    }
503  }
504}
505
506
507const struct soptionStruct optionStruct[]=
508{
509  {"prot",         Sy_bit(OPT_PROT),           ~Sy_bit(OPT_PROT)   },
510  {"redSB",        Sy_bit(OPT_REDSB),          ~Sy_bit(OPT_REDSB)   },
511  {"notBuckets",   Sy_bit(OPT_NOT_BUCKETS),    ~Sy_bit(OPT_NOT_BUCKETS)   },
512  {"notSugar",     Sy_bit(OPT_NOT_SUGAR),      ~Sy_bit(OPT_NOT_SUGAR)   },
513  {"interrupt",    Sy_bit(OPT_INTERRUPT),      ~Sy_bit(OPT_INTERRUPT)   },
514  {"sugarCrit",    Sy_bit(OPT_SUGARCRIT),      ~Sy_bit(OPT_SUGARCRIT)   },
515  {"teach",        Sy_bit(OPT_DEBUG),          ~Sy_bit(OPT_DEBUG)  },
516  {"notSyzMinim",  Sy_bit(OPT_NO_SYZ_MINIM),   ~Sy_bit(OPT_NO_SYZ_MINIM)  },
517  /* 9 return SB in syz, quotient, intersect, modulo */
518  {"returnSB",     Sy_bit(OPT_RETURN_SB),      ~Sy_bit(OPT_RETURN_SB)  },
519  {"fastHC",       Sy_bit(OPT_FASTHC),         ~Sy_bit(OPT_FASTHC)  },
520  /* 11-19 sort in L/T */
521  {"staircaseBound",Sy_bit(OPT_STAIRCASEBOUND),~Sy_bit(OPT_STAIRCASEBOUND)  },
522  {"multBound",    Sy_bit(OPT_MULTBOUND),      ~Sy_bit(OPT_MULTBOUND)  },
523  {"degBound",     Sy_bit(OPT_DEGBOUND),       ~Sy_bit(OPT_DEGBOUND)  },
524  {"redTailSyz",   Sy_bit(OPT_REDTAIL_SYZ),    ~Sy_bit(OPT_REDTAIL_SYZ) },
525  /* 25 no redTail(p)/redTail(s) */
526  {"redTail",      Sy_bit(OPT_REDTAIL),        ~Sy_bit(OPT_REDTAIL)  },
527  {"redThrough",   Sy_bit(OPT_REDTHROUGH),     ~Sy_bit(OPT_REDTHROUGH)  },
528  {"lazy",         Sy_bit(OPT_OLDSTD),         ~Sy_bit(OPT_OLDSTD)  },
529  {"intStrategy",  Sy_bit(OPT_INTSTRATEGY),    ~Sy_bit(OPT_INTSTRATEGY)  },
530  {"infRedTail",   Sy_bit(OPT_INFREDTAIL),     ~Sy_bit(OPT_INFREDTAIL)  },
531  /* 30: use not regularity for syz */
532  {"notRegularity",Sy_bit(OPT_NOTREGULARITY),  ~Sy_bit(OPT_NOTREGULARITY)  },
533  {"weightM",      Sy_bit(OPT_WEIGHTM),        ~Sy_bit(OPT_WEIGHTM)  },
534/*special for "none" and also end marker for showOption:*/
535  {"ne",           0,                          0 }
536};
537
538const struct soptionStruct verboseStruct[]=
539{
540  {"assign_none",Sy_bit(V_ASSIGN_NONE),~Sy_bit(V_ASSIGN_NONE)},
541  {"mem",      Sy_bit(V_SHOW_MEM),  ~Sy_bit(V_SHOW_MEM)   },
542  {"yacc",     Sy_bit(V_YACC),      ~Sy_bit(V_YACC)       },
543  {"redefine", Sy_bit(V_REDEFINE),  ~Sy_bit(V_REDEFINE)   },
544  {"reading",  Sy_bit(V_READING),   ~Sy_bit(V_READING)    },
545  {"loadLib",  Sy_bit(V_LOAD_LIB),  ~Sy_bit(V_LOAD_LIB)   },
546  {"debugLib", Sy_bit(V_DEBUG_LIB), ~Sy_bit(V_DEBUG_LIB)  },
547  {"loadProc", Sy_bit(V_LOAD_PROC), ~Sy_bit(V_LOAD_PROC)  },
548  {"defRes",   Sy_bit(V_DEF_RES),   ~Sy_bit(V_DEF_RES)    },
549  {"usage",    Sy_bit(V_SHOW_USE),  ~Sy_bit(V_SHOW_USE)   },
550  {"Imap",     Sy_bit(V_IMAP),      ~Sy_bit(V_IMAP)       },
551  {"prompt",   Sy_bit(V_PROMPT),    ~Sy_bit(V_PROMPT)     },
552  {"length",   Sy_bit(V_LENGTH),    ~Sy_bit(V_LENGTH)     },
553  {"notWarnSB",Sy_bit(V_NSB),       ~Sy_bit(V_NSB)        },
554  {"contentSB",Sy_bit(V_CONTENTSB), ~Sy_bit(V_CONTENTSB)  },
555  {"cancelunit",Sy_bit(V_CANCELUNIT),~Sy_bit(V_CANCELUNIT)},
556  {"modpsolve",Sy_bit(V_MODPSOLVSB),~Sy_bit(V_MODPSOLVSB)},
557  {"geometricSB",Sy_bit(V_UPTORADICAL),~Sy_bit(V_UPTORADICAL)},
558  {"findMonomials",Sy_bit(V_FINDMONOM),~Sy_bit(V_FINDMONOM)},
559  {"coefStrat",Sy_bit(V_COEFSTRAT), ~Sy_bit(V_COEFSTRAT)},
560  {"qringNF",  Sy_bit(V_QRING),     ~Sy_bit(V_QRING)},
561  {"warn",     Sy_bit(V_ALLWARN),   ~Sy_bit(V_ALLWARN)},
562  {"intersectSyz",Sy_bit(V_INTERSECT_SYZ), ~Sy_bit(V_INTERSECT_SYZ)},
563  {"intersectElim",Sy_bit(V_INTERSECT_ELIM), ~Sy_bit(V_INTERSECT_ELIM)},
564/*special for "none" and also end marker for showOption:*/
565  {"ne",         0,          0 }
566};
567
568BOOLEAN setOption(leftv res, leftv v)
569{
570  const char *n;
571  do
572  {
573    if (v->Typ()==STRING_CMD)
574    {
575      n=(const char *)v->CopyD(STRING_CMD);
576    }
577    else
578    {
579      if (v->name==NULL)
580        return TRUE;
581      if (v->rtyp==0)
582      {
583        n=v->name;
584        v->name=NULL;
585      }
586      else
587      {
588        n=omStrDup(v->name);
589      }
590    }
591
592    int i;
593
594    if(strcmp(n,"get")==0)
595    {
596      intvec *w=new intvec(2);
597      (*w)[0]=si_opt_1;
598      (*w)[1]=si_opt_2;
599      res->rtyp=INTVEC_CMD;
600      res->data=(void *)w;
601      goto okay;
602    }
603    if(strcmp(n,"set")==0)
604    {
605      if((v->next!=NULL)
606      &&(v->next->Typ()==INTVEC_CMD))
607      {
608        v=v->next;
609        intvec *w=(intvec*)v->Data();
610        si_opt_1=(*w)[0];
611        si_opt_2=(*w)[1];
612#if 0
613        if (TEST_OPT_INTSTRATEGY && (currRing!=NULL)
614        && rField_has_simple_inverse()
615        && !rField_is_Ring(currRing)
616        ) {
617          si_opt_1 &=~Sy_bit(OPT_INTSTRATEGY);
618        }
619#endif
620        goto okay;
621      }
622    }
623    if(strcmp(n,"none")==0)
624    {
625      si_opt_1=0;
626      si_opt_2=0;
627      goto okay;
628    }
629    for (i=0; (i==0) || (optionStruct[i-1].setval!=0); i++)
630    {
631      if (strcmp(n,optionStruct[i].name)==0)
632      {
633        if (optionStruct[i].setval & validOpts)
634        {
635          si_opt_1 |= optionStruct[i].setval;
636          // optOldStd disables redthrough
637          if (optionStruct[i].setval == Sy_bit(OPT_OLDSTD))
638            si_opt_1 &= ~Sy_bit(OPT_REDTHROUGH);
639        }
640        else
641          WarnS("cannot set option");
642#if 0
643        if (TEST_OPT_INTSTRATEGY && (currRing!=NULL)
644        && rField_has_simple_inverse()
645        && !rField_is_Ring(currRing)
646        ) {
647          test &=~Sy_bit(OPT_INTSTRATEGY);
648        }
649#endif
650        goto okay;
651      }
652      else if ((strncmp(n,"no",2)==0)
653      && (strcmp(n+2,optionStruct[i].name)==0))
654      {
655        if (optionStruct[i].setval & validOpts)
656        {
657          si_opt_1 &= optionStruct[i].resetval;
658        }
659        else
660          WarnS("cannot clear option");
661        goto okay;
662      }
663    }
664    for (i=0; (i==0) || (verboseStruct[i-1].setval!=0); i++)
665    {
666      if (strcmp(n,verboseStruct[i].name)==0)
667      {
668        si_opt_2 |= verboseStruct[i].setval;
669        #ifdef YYDEBUG
670        #if YYDEBUG
671        /*debugging the bison grammar --> grammar.cc*/
672        EXTERN_VAR int    yydebug;
673        if (BVERBOSE(V_YACC)) yydebug=1;
674        else                  yydebug=0;
675        #endif
676        #endif
677        goto okay;
678      }
679      else if ((strncmp(n,"no",2)==0)
680      && (strcmp(n+2,verboseStruct[i].name)==0))
681      {
682        si_opt_2 &= verboseStruct[i].resetval;
683        #ifdef YYDEBUG
684        #if YYDEBUG
685        /*debugging the bison grammar --> grammar.cc*/
686        EXTERN_VAR int    yydebug;
687        if (BVERBOSE(V_YACC)) yydebug=1;
688        else                  yydebug=0;
689        #endif
690        #endif
691        goto okay;
692      }
693    }
694    Werror("unknown option `%s`",n);
695  okay:
696    if (currRing != NULL)
697      currRing->options = si_opt_1 & TEST_RINGDEP_OPTS;
698    omFreeBinAddr((ADDRESS)n);
699    v=v->next;
700  } while (v!=NULL);
701
702   // set global variable to show memory usage
703  if (BVERBOSE(V_SHOW_MEM)) om_sing_opt_show_mem = 1;
704  else om_sing_opt_show_mem = 0;
705
706  return FALSE;
707}
708
709char * showOption()
710{
711  int i;
712  BITSET tmp;
713
714  StringSetS("//options:");
715  if ((si_opt_1!=0)||(si_opt_2!=0))
716  {
717    tmp=si_opt_1;
718    if(tmp)
719    {
720      for (i=0; optionStruct[i].setval!=0; i++)
721      {
722        if (optionStruct[i].setval & tmp)
723        {
724          StringAppend(" %s",optionStruct[i].name);
725          tmp &=optionStruct[i].resetval;
726        }
727      }
728      for (i=0; i<32; i++)
729      {
730        if (tmp & Sy_bit(i)) StringAppend(" %d",i);
731      }
732    }
733    tmp=si_opt_2;
734    if (tmp)
735    {
736      for (i=0; verboseStruct[i].setval!=0; i++)
737      {
738        if (verboseStruct[i].setval & tmp)
739        {
740          StringAppend(" %s",verboseStruct[i].name);
741          tmp &=verboseStruct[i].resetval;
742        }
743      }
744      for (i=1; i<32; i++)
745      {
746        if (tmp & Sy_bit(i)) StringAppend(" %d",i+32);
747      }
748    }
749    return StringEndS();
750  }
751  StringAppendS(" none");
752  return StringEndS();
753}
754
755/* version strings */
756#ifdef HAVE_FLINT
757extern "C"
758{
759#ifndef __GMP_BITS_PER_MP_LIMB
760#define __GMP_BITS_PER_MP_LIMB GMP_LIMB_BITS
761#endif
762#include <flint/flint.h>
763}
764#endif
765
766#ifndef MAKE_DISTRIBUTION
767const char *singular_date = __DATE__ " " __TIME__;
768#endif
769
770char * versionString(/*const bool bShowDetails = false*/ )
771{
772  StringSetS("");
773  StringAppend("Singular for %s version %s (%d, %d bit) %s",
774               S_UNAME, VERSION, // SINGULAR_VERSION,
775               SINGULAR_VERSION, sizeof(void*)*8,
776#ifdef MAKE_DISTRIBUTION
777               VERSION_DATE);
778#else
779               singular_date);
780#endif
781  StringAppendS("\nwith\n\t");
782
783#if defined(mpir_version)
784              StringAppend("MPIR(%s)~GMP(%s),", mpir_version, gmp_version);
785#elif defined(gmp_version)
786              // #if defined (__GNU_MP_VERSION) && defined (__GNU_MP_VERSION_MINOR)
787              //              StringAppend("GMP(%d.%d),",__GNU_MP_VERSION,__GNU_MP_VERSION_MINOR);
788              StringAppend("GMP(%s),", gmp_version);
789#endif
790#ifdef HAVE_NTL
791              StringAppend("NTL(%s),",NTL_VERSION);
792#endif
793
794#ifdef HAVE_FLINT
795              StringAppend("FLINT(%s),",FLINT_VERSION);
796#endif
797//              StringAppendS("factory(" FACTORYVERSION "),");
798              StringAppendS("\n\t");
799#ifndef HAVE_OMALLOC
800              StringAppendS("xalloc,");
801#else
802              StringAppendS("omalloc,");
803#endif
804#if defined(HAVE_DYN_RL)
805              if (fe_fgets_stdin==fe_fgets_dummy)
806                StringAppendS("no input,");
807              else if (fe_fgets_stdin==fe_fgets)
808                StringAppendS("fgets,");
809              if (fe_fgets_stdin==fe_fgets_stdin_drl)
810                StringAppend("dynamic readline%d),",RL_VERSION_MAJOR);
811              #ifdef HAVE_FEREAD
812              else if (fe_fgets_stdin==fe_fgets_stdin_emu)
813                StringAppendS("emulated readline,");
814              #endif
815              else
816                StringAppendS("unknown fgets method,");
817#else
818  #if defined(HAVE_READLINE) && !defined(FEREAD)
819              StringAppend("static readline(%d),",RL_VERSION_MAJOR);
820  #else
821    #ifdef HAVE_FEREAD
822              StringAppendS("emulated readline,");
823    #else
824              StringAppendS("fgets,");
825    #endif
826  #endif
827#endif
828#ifdef HAVE_PLURAL
829              StringAppendS("Plural,");
830#endif
831#ifdef HAVE_VSPACE
832  #if defined(__GNUC__) && (__GNUC__<9) &&!defined(__clang__)
833              StringAppendS("vspace(1),");
834  #else
835              StringAppendS("vspace(2),");
836  #endif
837#endif
838#ifdef HAVE_DBM
839              StringAppendS("DBM,\n\t");
840#else
841              StringAppendS("\n\t");
842#endif
843#ifdef HAVE_DYNAMIC_LOADING
844              StringAppendS("dynamic modules,");
845#endif
846#ifdef HAVE_DYNANIC_PPROCS
847              StringAppendS("dynamic p_Procs,");
848#endif
849#if YYDEBUG
850              StringAppendS("YYDEBUG=1,");
851#endif
852#ifdef MDEBUG
853              StringAppend("MDEBUG=%d,",MDEBUG);
854#endif
855#ifdef OM_CHECK
856              StringAppend("OM_CHECK=%d,",OM_CHECK);
857#endif
858#ifdef OM_TRACK
859              StringAppend("OM_TRACK=%d,",OM_TRACK);
860#endif
861#ifdef OM_NDEBUG
862              StringAppendS("OM_NDEBUG,");
863#endif
864#ifdef SING_NDEBUG
865              StringAppendS("SING_NDEBUG,");
866#endif
867#ifdef PDEBUG
868              StringAppendS("PDEBUG,");
869#endif
870#ifdef KDEBUG
871              StringAppendS("KDEBUG,");
872#endif
873#ifdef HAVE_SDB
874              StringAppendS("sdb,");
875#endif
876              StringAppendS("\n\t");
877#ifdef __OPTIMIZE__
878              StringAppendS("CC:OPTIMIZE,");
879#endif
880#ifdef __OPTIMIZE_SIZE__
881              StringAppendS("CC:OPTIMIZE_SIZE,");
882#endif
883#ifdef __NO_INLINE__
884              StringAppendS("CC:NO_INLINE,");
885#endif
886#ifdef HAVE_NTL
887  #ifdef NTL_AVOID_BRANCHING
888  #undef HAVE_GENERIC_ADD
889  #endif
890#endif
891#ifdef HAVE_GENERIC_ADD
892              StringAppendS("GenericAdd,");
893#else
894              StringAppendS("AvoidBranching,");
895#endif
896#ifdef HAVE_GENERIC_MULT
897              StringAppendS("GenericMult,");
898#else
899              StringAppendS("TableMult,");
900#endif
901#ifdef HAVE_INVTABLE
902              StringAppendS("invTable,");
903#else
904              StringAppendS("no invTable,");
905#endif
906              StringAppendS("\n\t");
907#ifdef HAVE_EIGENVAL
908              StringAppendS("eigenvalues,");
909#endif
910#ifdef HAVE_GMS
911              StringAppendS("Gauss-Manin system,");
912#endif
913#ifdef HAVE_RATGRING
914              StringAppendS("ratGB,");
915#endif
916              StringAppend("random=%d\n",siRandomStart);
917
918#define SI_SHOW_BUILTIN_MODULE(name) StringAppend(" %s", #name);
919              StringAppendS("built-in modules: {");
920              SI_FOREACH_BUILTIN(SI_SHOW_BUILTIN_MODULE)
921              StringAppendS("}\n");
922#undef SI_SHOW_BUILTIN_MODULE
923
924              StringAppend("AC_CONFIGURE_ARGS = %s,\n"
925                           "CC = %s,FLAGS : %s,\n"
926                           "CXX = %s,FLAGS : %s,\n"
927                           "DEFS : %s,CPPFLAGS : %s,\n"
928                           "LDFLAGS : %s,LIBS : %s "
929#ifdef __GNUC__
930              "(ver: " __VERSION__ ")"
931#endif
932              "\n",AC_CONFIGURE_ARGS, CC,CFLAGS " " PTHREAD_CFLAGS,
933              CXX,CXXFLAGS " " PTHREAD_CFLAGS,  DEFS,CPPFLAGS,  LDFLAGS,
934              LIBS " " PTHREAD_LIBS);
935              feStringAppendResources(0);
936              feStringAppendBrowsers(0);
937              StringAppendS("\n");
938              return StringEndS();
939}
940
941#ifdef PDEBUG
942#if (OM_TRACK > 2) && defined(OM_TRACK_CUSTOM)
943void p_SetRingOfLeftv(leftv l, ring r)
944{
945  switch(l->rtyp)
946  {
947    case INT_CMD:
948    case BIGINT_CMD:
949    case IDHDL:
950    case DEF_CMD:
951      break;
952    case POLY_CMD:
953    case VECTOR_CMD:
954    {
955      poly p=(poly)l->data;
956      while(p!=NULL) { p_SetRingOfLm(p,r); pIter(p); }
957      break;
958    }
959    case IDEAL_CMD:
960    case MODUL_CMD:
961    case MATRIX_CMD:
962    {
963      ideal I=(ideal)l->data;
964      int i;
965      for(i=IDELEMS(I)-1;i>=0;i--)
966      {
967        poly p=I->m[i];
968        while(p!=NULL) { p_SetRingOfLm(p,r); pIter(p); }
969      }
970      break;
971    }
972    case COMMAND:
973    {
974      command d=(command)l->data;
975      p_SetRingOfLeftv(&d->arg1, r);
976      if (d->argc>1) p_SetRingOfLeftv(&d->arg2, r);
977      if (d->argc>2) p_SetRingOfLeftv(&d->arg3, r);
978      break;
979    }
980    default:
981     printf("type %d not yet implementd in p_SetRingOfLeftv\n",l->rtyp);
982     break;
983  }
984}
985#endif
986#endif
987
988#if 0 /* debug only */
989void listall(int showproc)
990{
991      idhdl hh=basePack->idroot;
992      PrintS("====== Top ==============\n");
993      while (hh!=NULL)
994      {
995        if (showproc || (IDTYP(hh)!=PROC_CMD))
996        {
997          if (IDDATA(hh)==(void *)currRing) PrintS("(R)");
998          else if (IDDATA(hh)==(void *)currPack) PrintS("(P)");
999          else PrintS("   ");
1000          Print("::%s, typ %s level %d data %lx",
1001                 IDID(hh),Tok2Cmdname(IDTYP(hh)),IDLEV(hh),(long)IDDATA(hh));
1002          if (IDTYP(hh)==RING_CMD)
1003            Print(" ref: %d\n",IDRING(hh)->ref);
1004          else
1005            PrintLn();
1006        }
1007        hh=IDNEXT(hh);
1008      }
1009      hh=basePack->idroot;
1010      while (hh!=NULL)
1011      {
1012        if (IDDATA(hh)==(void *)basePack)
1013          Print("(T)::%s, typ %s level %d data %lx\n",
1014          IDID(hh),Tok2Cmdname(IDTYP(hh)),IDLEV(hh),(long)IDDATA(hh));
1015        else
1016        if ((IDTYP(hh)==RING_CMD)
1017        || (IDTYP(hh)==PACKAGE_CMD))
1018        {
1019          Print("====== %s ==============\n",IDID(hh));
1020          idhdl h2=IDRING(hh)->idroot;
1021          while (h2!=NULL)
1022          {
1023            if (showproc || (IDTYP(h2)!=PROC_CMD))
1024            {
1025              if ((IDDATA(h2)==(void *)currRing)
1026              && (IDTYP(h2)==RING_CMD))
1027                PrintS("(R)");
1028              else if (IDDATA(h2)==(void *)currPack) PrintS("(P)");
1029              else PrintS("   ");
1030              Print("%s::%s, typ %s level %d data %lx\n",
1031              IDID(hh),IDID(h2),Tok2Cmdname(IDTYP(h2)),IDLEV(h2),(long)IDDATA(h2));
1032            }
1033            h2=IDNEXT(h2);
1034          }
1035        }
1036        hh=IDNEXT(hh);
1037      }
1038      Print("currRing:%lx, currPack:%lx,basePack:%lx\n",(long)currRing,(long)currPack,(long)basePack);
1039      iiCheckPack(currPack);
1040}
1041#endif
1042
1043#ifndef SING_NDEBUG
1044void checkall()
1045{
1046      idhdl hh=basePack->idroot;
1047      while (hh!=NULL)
1048      {
1049        omCheckAddr(hh);
1050        omCheckAddr((ADDRESS)IDID(hh));
1051        if (RingDependend(IDTYP(hh)))
1052        {
1053          Print("%s typ %d in Top (should be in ring)\n",IDID(hh),IDTYP(hh));
1054        }
1055        hh=IDNEXT(hh);
1056      }
1057      hh=basePack->idroot;
1058      while (hh!=NULL)
1059      {
1060        if (IDTYP(hh)==PACKAGE_CMD)
1061        {
1062          idhdl h2=NULL;
1063          if (IDPACKAGE(hh)!=NULL)
1064            h2=IDPACKAGE(hh)->idroot;
1065          if (IDPACKAGE(hh)!=basePack)
1066          {
1067            while (h2!=NULL)
1068            {
1069              omCheckAddr(h2);
1070              omCheckAddr((ADDRESS)IDID(h2));
1071              if (RingDependend(IDTYP(h2)))
1072              {
1073                Print("%s typ %d in %s (should be in ring)\n",IDID(h2),IDTYP(h2),IDID(hh));
1074              }
1075              h2=IDNEXT(h2);
1076            }
1077          }
1078        }
1079        hh=IDNEXT(hh);
1080      }
1081}
1082#endif
1083
1084extern "C"
1085int singular_fstat(int fd, struct stat *buf)
1086{
1087  return si_fstat(fd,buf);
1088}
1089
1090/*2
1091* the global exit routine of Singular
1092*/
1093extern "C" {
1094/* Note: We cannot use a mutex here because mutexes are not async-safe, but
1095 * m2_end is called by sig_term_hdl(). Anyway, the race condition in the first
1096 * few lines of m2_end() should not matter.
1097 */
1098volatile BOOLEAN m2_end_called = FALSE;
1099
1100void m2_end(int i)
1101{
1102  if (!m2_end_called)
1103  {
1104    EXTERN_VAR FILE* File_Profiling;
1105    EXTERN_VAR FILE* File_Log;
1106    EXTERN_VAR BOOLEAN File_Log_written;
1107    if (File_Profiling!=NULL) { fclose(File_Profiling); File_Profiling=NULL; }
1108    if (File_Log!=NULL)
1109    {
1110      fclose(File_Log);
1111      File_Log=NULL;
1112      if (File_Log_written==FALSE) // remove empty logs
1113      {
1114        int pid=getpid();
1115        char buf[20];
1116        snprintf(buf,20,"/tmp/sing_log.%d",pid);
1117        remove(buf);
1118      }
1119    }
1120    m2_end_called = TRUE;
1121#ifdef HAVE_SIMPLEIPC
1122    for (int j = SIPC_MAX_SEMAPHORES-1; j >= 0; j--)
1123    {
1124      if (semaphore[j] != NULL)
1125      {
1126        while (sem_acquired[j] > 0)
1127        {
1128#if PORTABLE_SEMAPHORES
1129          sem_post(semaphore[j]->sig);
1130#else
1131          sem_post(semaphore[j]);
1132#endif
1133          sem_acquired[j]--;
1134        }
1135      }
1136    }
1137#endif   // HAVE_SIMPLEIPC
1138    monitor(NULL,0);
1139#ifdef PAGE_TEST
1140    mmEndStat();
1141#endif
1142    fe_reset_input_mode();
1143    if (ssiToBeClosed_inactive)
1144    {
1145      link_list hh=ssiToBeClosed;
1146      while(hh!=NULL)
1147      {
1148        //Print("close %s\n",hh->l->name);
1149        slPrepClose(hh->l);
1150        hh=(link_list)hh->next;
1151      }
1152      ssiToBeClosed_inactive=FALSE;
1153
1154      idhdl h = currPack->idroot;
1155      while(h != NULL)
1156      {
1157        if(IDTYP(h) == LINK_CMD)
1158        {
1159          idhdl hh=h->next;
1160          //Print("kill %s\n",IDID(h));
1161          killhdl(h, currPack);
1162          h = hh;
1163        }
1164        else
1165        {
1166          h = h->next;
1167        }
1168      }
1169      hh=ssiToBeClosed;
1170      while(hh!=NULL)
1171      {
1172        //Print("close %s\n",hh->l->name);
1173        slClose(hh->l);
1174        hh=ssiToBeClosed;
1175      }
1176    }
1177    if (!singular_in_batchmode)
1178    {
1179      if (i<=0)
1180      {
1181        //extern long all_farey;
1182        //extern long farey_cnt;
1183        //if (all_farey!=0L) printf("farey:%ld, cnt=%ld\n",all_farey,farey_cnt);
1184        if (TEST_V_QUIET)
1185        {
1186          if (i==0)
1187            printf("Auf Wiedersehen.\n");
1188          else
1189            printf("\n$Bye.\n");
1190        }
1191        //#ifdef sun
1192        //  #ifndef __svr4__
1193        //    _cleanup();
1194        //    _exit(0);
1195        //  #endif
1196        //#endif
1197        i=0;
1198      }
1199      else
1200      {
1201        printf("\nhalt %d\n",i);
1202      }
1203    }
1204    exit(i);
1205  }
1206}
1207}
1208
1209extern "C"
1210{
1211  void omSingOutOfMemoryFunc()
1212  {
1213    fprintf(stderr, "\nSingular error: no more memory\n");
1214    omPrintStats(stderr);
1215    m2_end(14);
1216    /* should never get here */
1217    exit(1);
1218  }
1219}
1220
1221#ifdef HAVE_FLINT
1222STATIC_VAR n_coeffType n_FlintZn=n_unknown;
1223STATIC_VAR n_coeffType n_FlintQ=n_unknown;
1224//STATIC_VAR n_coeffType n_FlintQrat=n_unknown;
1225static BOOLEAN ii_FlintZn_init(leftv res,leftv a)
1226{
1227  const short t[]={2,INT_CMD,STRING_CMD};
1228  if (iiCheckTypes(a,t,1))
1229  {
1230    flintZn_struct p;
1231    p.ch=(int)(long)a->Data();
1232    p.name=(char*)a->next->Data();
1233    res->rtyp=CRING_CMD;
1234    res->data=(void*)nInitChar(n_FlintZn,(void*)&p);
1235    return FALSE;
1236  }
1237  return TRUE;
1238}
1239static BOOLEAN ii_FlintQ_init(leftv res,leftv a)
1240{
1241  const short t[]={1,STRING_CMD};
1242  if (iiCheckTypes(a,t,1))
1243  {
1244    char* p;
1245    p=(char*)a->Data();
1246    res->rtyp=CRING_CMD;
1247    res->data=(void*)nInitChar(n_FlintQ,(void*)p);
1248    return FALSE;
1249  }
1250  return TRUE;
1251}
1252#if __FLINT_RELEASE >= 20503
1253static BOOLEAN ii_FlintQrat_init(leftv res,leftv a)
1254{
1255  if (a==NULL)
1256  {
1257    WerrorS("at least one name required");
1258    return TRUE;
1259  }
1260  QaInfo par;
1261  #ifdef QA_DEBUG
1262  par.C=r->cf;
1263  a=a->next;
1264  #endif
1265  par.N=a->listLength();
1266  par.names=(char**)omAlloc(par.N*sizeof(char*));
1267  int i=0;
1268  while(a!=NULL)
1269  {
1270    par.names[i]=omStrDup(a->Name());
1271    i++;
1272    a=a->next;
1273  }
1274  res->rtyp=CRING_CMD;
1275  res->data=(void*)nInitChar(n_FlintQrat,&par);
1276  for(i=par.N-1;i>=0;i--)
1277  {
1278    omFree(par.names[i]);
1279  }
1280  omFreeSize(par.names,par.N*sizeof(char*));
1281  return FALSE;
1282}
1283#endif
1284extern "C" int flint_mod_init(SModulFunctions* psModulFunctions)
1285{
1286    package save=currPack;
1287    currPack=basePack;
1288    n_FlintQ=nRegister(n_unknown,flintQ_InitChar);
1289    if (n_FlintQ!=n_unknown)
1290    {
1291      iiAddCproc("kernel","flintQp",FALSE,ii_FlintQ_init);
1292      nRegisterCfByName(flintQInitCfByName,n_FlintQ);
1293    }
1294#if __FLINT_RELEASE >= 20503
1295    iiAddCproc("kernel","flintQ",FALSE,ii_FlintQrat_init);
1296    nRegisterCfByName(flintQInitCfByName,n_FlintQ);
1297#endif
1298    n_FlintZn=nRegister(n_unknown,flintZn_InitChar);
1299    if (n_FlintZn!=n_unknown)
1300    {
1301      iiAddCproc("kernel","flintZn",FALSE,ii_FlintZn_init);
1302      nRegisterCfByName(flintZnInitCfByName,n_FlintZn);
1303    }
1304    currPack=save;
1305    return MAX_TOK;
1306}
1307#endif
1308
1309static BOOLEAN iiFloat(leftv res, leftv pnn)
1310{
1311  short float_len=3;
1312  short float_len2=SHORT_REAL_LENGTH;
1313  coeffs cf=NULL;
1314  if ((pnn!=NULL) && (pnn->Typ()==INT_CMD))
1315  {
1316    float_len=(int)(long)pnn->Data();
1317    float_len2=float_len;
1318    pnn=pnn->next;
1319    if ((pnn!=NULL) && (pnn->Typ()==INT_CMD))
1320    {
1321      float_len2=(int)(long)pnn->Data();
1322      pnn=pnn->next;
1323    }
1324  }
1325  if (float_len2 <= (short)SHORT_REAL_LENGTH)
1326       cf=nInitChar(n_R, NULL);
1327  else // longR or longC?
1328  {
1329    LongComplexInfo param;
1330    param.float_len = si_min (float_len, 32767);
1331    param.float_len2 = si_min (float_len2, 32767);
1332    cf = nInitChar(n_long_R, (void*)&param);
1333  }
1334  res->rtyp=CRING_CMD;
1335  res->data=cf;
1336  return cf==NULL;
1337}
1338static BOOLEAN iiCrossProd(leftv res, leftv args)
1339{
1340  leftv h=args;
1341  coeffs *c=NULL;
1342  coeffs cf=NULL;
1343  int i=0;
1344  if (h==NULL) goto crossprod_error;
1345  while (h!=NULL)
1346  {
1347    if (h->Typ()!=CRING_CMD) goto crossprod_error;
1348    i++;
1349    h=h->next;
1350  }
1351  c=(coeffs*)omAlloc0((i+1)*sizeof(coeffs));
1352  h=args;
1353  i=0;
1354  while (h!=NULL)
1355  {
1356    c[i]=(coeffs)h->CopyD();
1357    i++;
1358    h=h->next;
1359  }
1360  cf=nInitChar(n_nTupel,c);
1361  res->data=cf;
1362  res->rtyp=CRING_CMD;
1363  return FALSE;
1364
1365  crossprod_error:
1366    WerrorS("expected `crossprod(coeffs, ...)`");
1367    return TRUE;
1368}
1369/*2
1370* initialize components of Singular
1371*/
1372static void callWerrorS(const char *s) { WerrorS(s); }
1373void siInit(char *name)
1374{
1375// memory initialization: -----------------------------------------------
1376    om_Opts.OutOfMemoryFunc = omSingOutOfMemoryFunc;
1377#ifndef OM_NDEBUG
1378#ifndef __OPTIMIZE__
1379    om_Opts.ErrorHook = dErrorBreak;
1380#else
1381    om_Opts.Keep = 0; /* !OM_NDEBUG, __OPTIMIZE__*/
1382#endif
1383#else
1384    om_Opts.Keep = 0; /* OM_NDEBUG */
1385#endif
1386    omInitInfo();
1387// factory
1388#ifndef HAVE_NTL
1389  extern void initPT();
1390  initPT();
1391#endif
1392// options ---------------------------------------------------------------
1393  si_opt_1=0;
1394// interpreter tables etc.: -----------------------------------------------
1395  memset(&sLastPrinted,0,sizeof(sleftv));
1396  sLastPrinted.rtyp=NONE;
1397
1398  extern int iiInitArithmetic(); iiInitArithmetic(); // iparith.cc
1399
1400  basePack=(package)omAlloc0(sizeof(*basePack));
1401  currPack=basePack;
1402  idhdl h;
1403  h=enterid("Top", 0, PACKAGE_CMD, &IDROOT, FALSE);
1404  IDPACKAGE(h)=basePack;
1405  IDPACKAGE(h)->language = LANG_TOP;
1406  currPackHdl=h;
1407  basePackHdl=h;
1408
1409  coeffs_BIGINT = nInitChar(n_Q,(void*)1);
1410
1411#if 1
1412   // def HAVE_POLYEXTENSIONS
1413  if(TRUE)
1414  {
1415    n_coeffType type;
1416    #ifdef SINGULAR_4_2
1417    type = nRegister(n_polyExt, n2pInitChar);
1418    assume(type == n_polyExt);
1419    #endif
1420
1421    type = nRegister(n_algExt, naInitChar);
1422    assume(type == n_algExt);
1423
1424    type = nRegister(n_transExt, ntInitChar);
1425    assume(type == n_transExt);
1426
1427    (void)type;
1428  }
1429#endif
1430
1431// random generator: -----------------------------------------------
1432  int t=initTimer();
1433  if (t==0) t=1;
1434  initRTimer();
1435  siSeed=t;
1436  factoryseed(t);
1437  siRandomStart=t;
1438  feOptSpec[FE_OPT_RANDOM].value = (void*) ((long)siRandomStart);
1439
1440// ressource table: ----------------------------------------------------
1441  // Don't worry: ifdef OM_NDEBUG, then all these calls are undef'ed
1442  // hack such that all shared' libs in the bindir are loaded correctly
1443  feInitResources(name);
1444
1445// singular links: --------------------------------------------------
1446  slStandardInit();
1447  myynest=0;
1448// how many processes ? -----------------------------------------------------
1449  int cpus=2;
1450  int cpu_n;
1451  #ifdef _SC_NPROCESSORS_ONLN
1452  if ((cpu_n=sysconf(_SC_NPROCESSORS_ONLN))>cpus) cpus=cpu_n;
1453  #elif defined(_SC_NPROCESSORS_CONF)
1454  if ((cpu_n=sysconf(_SC_NPROCESSORS_CONF))>cpus) cpus=cpu_n;
1455  #endif
1456  feSetOptValue(FE_OPT_CPUS, cpus);
1457// how many threads ? -----------------------------------------------------
1458  feSetOptValue(FE_OPT_THREADS, cpus);
1459
1460// default coeffs
1461  {
1462    idhdl h;
1463    h=enterid("QQ",0/*level*/, CRING_CMD,&(basePack->idroot),FALSE /*init*/,FALSE /*search*/);
1464    IDDATA(h)=(char*)nInitChar(n_Q,NULL);
1465    h=enterid("ZZ",0/*level*/, CRING_CMD,&(basePack->idroot),FALSE /*init*/,FALSE /*search*/);
1466    IDDATA(h)=(char*)nInitChar(n_Z,NULL);
1467    nRegisterCfByName(nrnInitCfByName,n_Zn); // and n_Znm
1468    iiAddCproc("kernel","crossprod",FALSE,iiCrossProd);
1469    iiAddCproc("kernel","Float",FALSE,iiFloat);
1470    //h=enterid("RR",0/*level*/, CRING_CMD,&(basePack->idroot),FALSE /*init*/,FALSE /*search*/);
1471    //IDDATA(h)=(char*)nInitChar(n_R,NULL);
1472    //h=enterid("CC",0/*level*/, CRING_CMD,&(basePack->idroot),FALSE /*init*/,FALSE /*search*/);
1473    //IDDATA(h)=(char*)nInitChar(n_long_C,NULL);
1474  }
1475// setting routines for PLURAL QRINGS:
1476// allowing to use libpolys without libSingular(kStd)
1477#ifdef HAVE_PLURAL
1478  nc_NF=k_NF;
1479  gnc_gr_bba=k_gnc_gr_bba;
1480  gnc_gr_mora=k_gnc_gr_mora;
1481  sca_bba=k_sca_bba;
1482  sca_mora=k_sca_mora;
1483  sca_gr_bba=k_sca_gr_bba;
1484#endif
1485// loading standard.lib -----------------------------------------------
1486  if (! feOptValue(FE_OPT_NO_STDLIB))
1487  {
1488    BITSET save1,save2;
1489    SI_SAVE_OPT(save1,save2);
1490    si_opt_2 &= ~Sy_bit(V_LOAD_LIB);
1491    iiLibCmd("standard.lib", TRUE,TRUE,TRUE);
1492    SI_RESTORE_OPT(save1,save2);
1493  }
1494  // interpreter error handling
1495  #ifndef __CYGWIN__
1496  factoryError=callWerrorS; // to honour later changes of variable WerrorS
1497  #endif
1498  errorreported = 0;
1499}
Note: See TracBrowser for help on using the repository browser.