My Project
Loading...
Searching...
No Matches
ssiLink.cc
Go to the documentation of this file.
1/****************************************
2 * Computer Algebra System SINGULAR *
3 ****************************************/
4/***************************************************************
5 * File: ssiLink.h
6 * Purpose: declaration of sl_link routines for ssi
7 ***************************************************************/
8#define TRANSEXT_PRIVATES 1 /* allow access to transext internals */
9
10#include "kernel/mod2.h"
11
12#include "misc/intvec.h"
13#include "misc/options.h"
14
15#include "reporter/si_signals.h"
16#include "reporter/s_buff.h"
17#include "reporter/si_signals.h"
18
19#include "coeffs/bigintmat.h"
20#include "coeffs/longrat.h"
21
25#include "polys/simpleideals.h"
26#include "polys/matpol.h"
27
32
33#include "Singular/tok.h"
34#include "Singular/ipid.h"
35#include "Singular/ipshell.h"
36#include "Singular/subexpr.h"
38#include "Singular/cntrlc.h"
39#include "Singular/feOpt.h"
40#include "Singular/lists.h"
41#include "Singular/blackbox.h"
43
44#ifdef HAVE_SIMPLEIPC
46#endif
47
48#include <errno.h>
49#include <sys/types.h> /* for portability */
50#include <ctype.h> /*for isdigit*/
51#include <netdb.h>
52#include <netinet/in.h> /* for htons etc.*/
53
54
55#define SSI_VERSION 15
56// 5->6: changed newstruct representation
57// 6->7: attributes
58// 7->8: qring
59// 8->9: module: added rank
60// 9->10: tokens in grammar.h/tok.h reorganized
61// 10->11: extended ring descr. for named coeffs (not in used until 4.1)
62// 11->12: add rank to ideal/module, add smatrix
63// 12->13: NC rings
64// 13->14: ring references
65// 14->15: bigintvec, prune_map, mres_map
66
70
71// forward declarations:
72static void ssiWriteIdeal(const ssiInfo *d, int typ,const ideal I);
73static void ssiWritePoly_R(const ssiInfo *d, int typ, poly p, const ring r);
74static void ssiWriteIdeal_R(const ssiInfo *d, int typ,const ideal I, const ring r);
75static poly ssiReadPoly_R(const ssiInfo *D, const ring r);
76static ideal ssiReadIdeal_R(const ssiInfo *d,const ring r);
77
78// the helper functions:
79static BOOLEAN ssiSetCurrRing(const ring r) /* returned: not accepted */
80{
81 // if (currRing!=NULL)
82 // Print("need to change the ring, currRing:%s, switch to: ssiRing%d\n",IDID(currRingHdl),nr);
83 // else
84 // Print("no ring, switch to ssiRing%d\n",nr);
85 if (r==currRing)
86 {
87 rIncRefCnt(r);
89 return TRUE;
90 }
91 else if ((currRing==NULL) || (!rEqual(r,currRing,1)))
92 {
93 char name[20];
94 int nr=0;
95 idhdl h=NULL;
96 loop
97 {
98 snprintf(name,20,"ssiRing%d",nr); nr++;
99 h=IDROOT->get(name, 0);
100 if (h==NULL)
101 {
103 IDRING(h)=rIncRefCnt(r);
104 r->ref=2;/*ref==2: d->r and h */
105 break;
106 }
107 else if ((IDTYP(h)==RING_CMD)
108 && (rEqual(r,IDRING(h),1)))
109 {
111 break;
112 }
113 }
114 rSetHdl(h);
115 return FALSE;
116 }
117 else
118 {
119 rKill(r);
121 return TRUE;
122 }
123}
124static void ssiCheckCurrRing(const ring r)
125{
126 if ((r!=currRing)
127 ||(currRingHdl==NULL)
128 ||(IDRING(currRingHdl)!=r))
129 {
130 char name[20];
131 int nr=0;
132 idhdl h=NULL;
133 loop
134 {
135 snprintf(name,20,"ssiRing%d",nr); nr++;
136 h=IDROOT->get(name, 0);
137 if (h==NULL)
138 {
140 IDRING(h)=rIncRefCnt(r);
141 r->ref=2;/*ref==2: d->r and h */
142 break;
143 }
144 else if ((IDTYP(h)==RING_CMD)
145 && (rEqual(r,IDRING(h),1)))
146 {
147 break;
148 }
149 }
150 rSetHdl(h);
151 }
152 assume((currRing==r) || rEqual(r,currRing));
153}
154// the implementation of the functions:
155static void ssiWriteInt(const ssiInfo *d,const int i)
156{
157 fprintf(d->f_write,"%d ",i);
158 //if (d->f_debug!=NULL) fprintf(d->f_debug,"int: %d ",i);
159}
160
161static void ssiWriteString(const ssiInfo *d,const char *s)
162{
163 fprintf(d->f_write,"%d %s ",(int)strlen(s),s);
164 //if (d->f_debug!=NULL) fprintf(d->f_debug,"stringi: %d \"%s\" ",strlen(s),s);
165}
166
167static void ssiWriteBigInt(const ssiInfo *d, const number n)
168{
170}
171
172static void ssiWriteNumber_CF(const ssiInfo *d, const number n, const coeffs cf)
173{
174 // syntax is as follows:
175 // case 1 Z/p: 3 <int>
176 // case 2 Q: 3 4 <int>
177 // or 3 0 <mpz_t nominator> <mpz_t denominator>
178 // or 3 1 dto.
179 // or 3 3 <mpz_t nominator>
180 // or 3 5 <mpz_t raw nom.> <mpz_t raw denom.>
181 // or 3 6 <mpz_t raw nom.> <mpz_t raw denom.>
182 // or 3 8 <mpz_t raw nom.>
184 {
186 ssiWritePoly_R(d,POLY_CMD,NUM(f),cf->extRing);
187 ssiWritePoly_R(d,POLY_CMD,DEN(f),cf->extRing);
188 }
189 else if (getCoeffType(cf)==n_algExt)
190 {
191 ssiWritePoly_R(d,POLY_CMD,(poly)n,cf->extRing);
192 }
193 else if (cf->cfWriteFd!=NULL)
194 {
195 n_WriteFd(n,d,cf);
196 }
197 else WerrorS("coeff field not implemented");
198}
199
200static void ssiWriteNumber(const ssiInfo *d, const number n)
201{
202 ssiWriteNumber_CF(d,n,d->r->cf);
203}
204
205static void ssiWriteRing_R(ssiInfo *d,const ring r)
206{
207 /* 5 <ch> <N> <l1> <v1> ...<lN> <vN> <number of orderings> <ord1> <block0_1> <block1_1> .... <extRing> <Q-ideal> */
208 /* ch=-1: transext, coeff ring follows */
209 /* ch=-2: algext, coeff ring and minpoly follows */
210 /* ch=-3: cf name follows */
211 /* ch=-4: NULL*/
212 /* ch=-5: reference <int> */
213 /* ch=-6: new reference <int> <ring> */
214 if (r!=NULL)
215 {
216 for(int i=0;i<SI_RING_CACHE;i++)
217 {
218 if (d->rings[i]==r)
219 {
220 fprintf(d->f_write,"-5 %d ",i);
221 return;
222 }
223 }
224 for(int i=0;i<SI_RING_CACHE;i++)
225 {
226 if (d->rings[i]==NULL)
227 {
228 d->rings[i]=rIncRefCnt(r);
229 fprintf(d->f_write,"-6 %d ",i);
230 break;
231 }
232 }
233 if (rField_is_Q(r) || rField_is_Zp(r))
234 fprintf(d->f_write,"%d %d ",n_GetChar(r->cf),r->N);
235 else if (rFieldType(r)==n_transExt)
236 fprintf(d->f_write,"-1 %d ",r->N);
237 else if (rFieldType(r)==n_algExt)
238 fprintf(d->f_write,"-2 %d ",r->N);
239 else /*dummy*/
240 {
241 fprintf(d->f_write,"-3 %d ",r->N);
242 ssiWriteString(d,nCoeffName(r->cf));
243 }
244
245 int i;
246 for(i=0;i<r->N;i++)
247 {
248 fprintf(d->f_write,"%d %s ",(int)strlen(r->names[i]),r->names[i]);
249 }
250 /* number of orderings:*/
251 i=0;
252 // remember dummy ring: everything 0:
253 if (r->order!=NULL) while (r->order[i]!=0) i++;
254 fprintf(d->f_write,"%d ",i);
255 /* each ordering block: */
256 i=0;
257 if (r->order!=NULL) while(r->order[i]!=0)
258 {
259 fprintf(d->f_write,"%d %d %d ",r->order[i],r->block0[i], r->block1[i]);
260 switch(r->order[i])
261 {
262 case ringorder_a:
263 case ringorder_wp:
264 case ringorder_Wp:
265 case ringorder_ws:
266 case ringorder_Ws:
267 case ringorder_aa:
268 {
269 int s=r->block1[i]-r->block0[i]+1; // #vars
270 for(int ii=0;ii<s;ii++)
271 fprintf(d->f_write,"%d ",r->wvhdl[i][ii]);
272 }
273 break;
274 case ringorder_M:
275 {
276 int s=r->block1[i]-r->block0[i]+1; // #vars
277 for(int ii=0;ii<s*s;ii++)
278 {
279 fprintf(d->f_write,"%d ",r->wvhdl[i][ii]);
280 }
281 }
282 break;
283
284 case ringorder_a64:
285 case ringorder_L:
286 case ringorder_IS:
287 Werror("ring oder not implemented for ssi:%d",r->order[i]);
288 break;
289
290 default: break;
291 }
292 i++;
293 }
294 if ((rFieldType(r)==n_transExt)
295 || (rFieldType(r)==n_algExt))
296 {
297 ssiWriteRing_R(d,r->cf->extRing); /* includes alg.ext if rFieldType(r)==n_algExt */
298 }
299 /* Q-ideal :*/
300 if (r->qideal!=NULL)
301 {
302 ssiWriteIdeal_R(d,IDEAL_CMD,r->qideal,r);
303 }
304 else
305 {
306 fputs("0 ",d->f_write/*ideal with 0 entries */);
307 }
308 }
309 else /* dummy ring r==NULL*/
310 {
311 fputs("0 0 0 0 "/*,r->ch,r->N, blocks, q-ideal*/,d->f_write);
312 }
313 if (rIsLPRing(r)) // cannot be combined with 23 2
314 {
315 fprintf(d->f_write,"23 1 %d %d ",SI_LOG2(r->bitmask),r->isLPring);
316 }
317 else
318 {
319 unsigned long bm=0;
320 int b=0;
321 bm=rGetExpSize(bm,b,r->N);
322 if (r->bitmask!=bm)
323 {
324 fprintf(d->f_write,"23 0 %d ",SI_LOG2(r->bitmask));
325 }
326 if (rIsPluralRing(r))
327 {
328 fputs("23 2 ",d->f_write);
329 ssiWriteIdeal(d,MATRIX_CMD,(ideal)r->GetNC()->C);
330 ssiWriteIdeal(d,MATRIX_CMD,(ideal)r->GetNC()->D);
331 }
332 }
333}
334
335static void ssiWriteRing(ssiInfo *d,const ring r)
336{
337 /* 5 <ch> <N> <l1> <v1> ...<lN> <vN> <number of orderings> <ord1> <block0_1> <block1_1> .... <extRing> <Q-ideal> */
338 /* ch=-1: transext, coeff ring follows */
339 /* ch=-2: algext, coeff ring and minpoly follows */
340 /* ch=-3: cf name follows */
341 /* ch=-4: NULL */
342 /* ch=-5: reference <int> */
343 /* ch=-6: new reference <int> <ring> */
344 if ((r==NULL)||(r->cf==NULL))
345 {
346 fputs("-4 ",d->f_write);
347 return;
348 }
349 if (r==currRing) // see recursive calls for transExt/algExt
350 {
351 if (d->r!=NULL) rKill(d->r);
352 d->r=r;
353 }
354 if (r!=NULL)
355 {
356 /*d->*/rIncRefCnt(r);
357 }
358 ssiWriteRing_R(d,r);
359}
360static void ssiWritePoly_R(const ssiInfo *d, int /*typ*/, poly p, const ring r)
361{
362 fprintf(d->f_write,"%d ",pLength(p));//number of terms
363
364 while(p!=NULL)
365 {
366 ssiWriteNumber_CF(d,pGetCoeff(p),r->cf);
367 //nWrite(fich,pGetCoeff(p));
368 fprintf(d->f_write,"%ld ",p_GetComp(p,r));//component
369
370 for(int j=1;j<=rVar(r);j++)
371 {
372 fprintf(d->f_write,"%ld ",p_GetExp(p,j,r ));//x^j
373 }
374 pIter(p);
375 }
376}
377
378static void ssiWritePoly(const ssiInfo *d, int typ, poly p)
379{
380 ssiWritePoly_R(d,typ,p,d->r);
381}
382
383static void ssiWriteIdeal_R(const ssiInfo *d, int typ,const ideal I, const ring R)
384{
385 // syntax: 7 # of elements <poly 1> <poly2>.....(ideal,module,smatrix)
386 // syntax: 8 <rows> <cols> <poly 1> <poly2>.....(matrix)
387 // syntax
388 matrix M=(matrix)I;
389 int mn;
390 if (typ==MATRIX_CMD)
391 {
392 mn=MATROWS(M)*MATCOLS(M);
393 fprintf(d->f_write,"%d %d ", MATROWS(M),MATCOLS(M));
394 }
395 else
396 {
397 mn=IDELEMS(I);
398 fprintf(d->f_write,"%d ",IDELEMS(I));
399 }
400
401 int i;
402 int tt;
403 if ((typ==MODUL_CMD)||(typ==SMATRIX_CMD))
405 else
406 tt=POLY_CMD;
407
408 for(i=0;i<mn;i++)
409 {
410 ssiWritePoly_R(d,tt,I->m[i],R);
411 }
412}
413static void ssiWriteIdeal(const ssiInfo *d, int typ,const ideal I)
414{
415 ssiWriteIdeal_R(d,typ,I,d->r);
416}
417
419{
420 ssiInfo *d=(ssiInfo*)l->data;
421 // syntax: <num ops> <operation> <op1> <op2> ....
422 fprintf(d->f_write,"%d %d ",D->argc,D->op);
423 if (D->argc >0) ssiWrite(l, &(D->arg1));
424 if (D->argc < 4)
425 {
426 if (D->argc >1) ssiWrite(l, &(D->arg2));
427 if (D->argc >2) ssiWrite(l, &(D->arg3));
428 }
429}
430
431static void ssiWriteProc(const ssiInfo *d,procinfov p)
432{
433 if (p->data.s.body==NULL)
435 if (p->data.s.body!=NULL)
436 ssiWriteString(d,p->data.s.body);
437 else
438 ssiWriteString(d,"");
439}
440
442{
443 ssiInfo *d=(ssiInfo*)l->data;
444 int Ll=dd->nr;
445 fprintf(d->f_write,"%d ",Ll+1);
446 int i;
447 for(i=0;i<=Ll;i++)
448 {
449 ssiWrite(l,&(dd->m[i]));
450 }
451}
452static void ssiWriteIntvec(const ssiInfo *d,intvec * v)
453{
454 fprintf(d->f_write,"%d ",v->length());
455 int i;
456 for(i=0;i<v->length();i++)
457 {
458 fprintf(d->f_write,"%d ",(*v)[i]);
459 }
460}
461static void ssiWriteIntmat(const ssiInfo *d,intvec * v)
462{
463 fprintf(d->f_write,"%d %d ",v->rows(),v->cols());
464 int i;
465 for(i=0;i<v->length();i++)
466 {
467 fprintf(d->f_write,"%d ",(*v)[i]);
468 }
469}
470
471static void ssiWriteBigintmat(const ssiInfo *d,bigintmat * v)
472{
473 fprintf(d->f_write,"%d %d ",v->rows(),v->cols());
474 int i;
475 for(i=0;i<v->length();i++)
476 {
477 ssiWriteBigInt(d,(*v)[i]);
478 }
479}
480
481static void ssiWriteBigintvec(const ssiInfo *d,bigintmat * v)
482{
483 fprintf(d->f_write,"%d ",v->cols());
484 int i;
485 for(i=0;i<v->length();i++)
486 {
487 ssiWriteBigInt(d,(*v)[i]);
488 }
489}
490
491static char *ssiReadString(const ssiInfo *d)
492{
493 char *buf;
494 int l;
495 l=s_readint(d->f_read);
496 buf=(char*)omAlloc0(l+1);
497 int throwaway =s_getc(d->f_read); /* skip ' '*/
499 //if (throwaway!=l) printf("want %d, got %d bytes\n",l,throwaway);
500 buf[l]='\0';
501 return buf;
502}
503
505{
506 return s_readint(fich);
507}
508
509static number ssiReadNumber_CF(const ssiInfo *d, const coeffs cf)
510{
511 if (cf->cfReadFd!=ndReadFd)
512 {
513 return n_ReadFd(d,cf);
514 }
515 else if (getCoeffType(cf) == n_transExt)
516 {
517 // poly poly
519 p_Delete(&NUM(f),cf->extRing);
520 NUM(f)=ssiReadPoly_R(d,cf->extRing);
521 DEN(f)=ssiReadPoly_R(d,cf->extRing);
522 return (number)f;
523 }
524 else if (getCoeffType(cf) == n_algExt)
525 {
526 // poly
527 return (number)ssiReadPoly_R(d,cf->extRing);
528 }
529 else WerrorS("coeffs not implemented in ssiReadNumber");
530 return NULL;
531}
532
534{
536 if ((SR_HDL(n) & SR_INT)==0)
537 {
538 if (n->s!=3) Werror("invalid sub type in bigint:%d",n->s);
539 }
540 return n;
541}
542
544{
545 return ssiReadNumber_CF(d,d->r->cf);
546}
547
549{
550/* syntax is <ch> <N> <l1> <v1> ...<lN> <vN> <number of orderings> <ord1> <block0_1> <block1_1> .... <Q-ideal> */
551 int ch;
552 int new_ref=-1;
553 ch=s_readint(d->f_read);
554 if (ch==-6)
555 {
557 ch=s_readint(d->f_read);
558 }
559 if (ch==-5)
560 {
561 int index=s_readint(d->f_read);
562 ring r=d->rings[index];
563 rIncRefCnt(r);
564 return r;
565 }
566 if (ch==-4)
567 return NULL;
568 int N=s_readint(d->f_read);
569 char **names;
570 coeffs cf=NULL;
571 if (ch==-3)
572 {
573 char *cf_name=ssiReadString(d);
575 if (cf==NULL)
576 {
577 Werror("cannot find cf:%s",cf_name);
579 return NULL;
580 }
581 }
582 if (N!=0)
583 {
584 names=(char**)omAlloc(N*sizeof(char*));
585 for(int i=0;i<N;i++)
586 {
587 names[i]=ssiReadString(d);
588 }
589 }
590 // read the orderings:
591 int num_ord; // number of orderings
594 int *block0=(int *)omAlloc0((num_ord+1)*sizeof(int));
595 int *block1=(int *)omAlloc0((num_ord+1)*sizeof(int));
596 int **wvhdl=(int**)omAlloc0((num_ord+1)*sizeof(int*));
597 for(int i=0;i<num_ord;i++)
598 {
599 ord[i]=(rRingOrder_t)s_readint(d->f_read);
600 block0[i]=s_readint(d->f_read);
601 block1[i]=s_readint(d->f_read);
602 switch(ord[i])
603 {
604 case ringorder_a:
605 case ringorder_wp:
606 case ringorder_Wp:
607 case ringorder_ws:
608 case ringorder_Ws:
609 case ringorder_aa:
610 {
611 int s=block1[i]-block0[i]+1; // #vars
612 wvhdl[i]=(int*)omAlloc(s*sizeof(int));
613 for(int ii=0;ii<s;ii++)
614 wvhdl[i][ii]=s_readint(d->f_read);
615 }
616 break;
617 case ringorder_M:
618 {
619 int s=block1[i]-block0[i]+1; // #vars
620 wvhdl[i]=(int*)omAlloc(s*s*sizeof(int));
621 for(int ii=0;ii<s*s;ii++)
622 {
623 wvhdl[i][ii]=s_readint(d->f_read);
624 }
625 }
626 break;
627 case ringorder_a64:
628 case ringorder_L:
629 case ringorder_IS:
630 Werror("ring order not implemented for ssi:%d",ord[i]);
631 break;
632
633 default: break;
634 }
635 }
636 if (N==0)
637 {
638 omFree(ord);
639 omFree(block0);
640 omFree(block1);
641 omFree(wvhdl);
642 return NULL;
643 }
644 else
645 {
646 ring r=NULL;
647 if (ch>=0) /* Q, Z/p */
648 r=rDefault(ch,N,names,num_ord,ord,block0,block1,wvhdl);
649 else if (ch==-1) /* trans ext. */
650 {
652 T.r=ssiReadRing(d);
653 if (T.r==NULL) return NULL;
655 r=rDefault(cf,N,names,num_ord,ord,block0,block1,wvhdl);
656 }
657 else if (ch==-2) /* alg ext. */
658 {
660 T.r=ssiReadRing(d); /* includes qideal */
661 if (T.r==NULL) return NULL;
663 r=rDefault(cf,N,names,num_ord,ord,block0,block1,wvhdl);
664 }
665 else if (ch==-3)
666 {
667 r=rDefault(cf,N,names,num_ord,ord,block0,block1,wvhdl);
668 }
669 else
670 {
671 Werror("ssi: read unknown coeffs type (%d)",ch);
672 for(int i=0;i<N;i++)
673 {
674 omFree(names[i]);
675 }
676 omFreeSize(names,N*sizeof(char*));
677 return NULL;
678 }
679 ideal q=ssiReadIdeal_R(d,r);
680 if (IDELEMS(q)==0) omFreeBin(q,sip_sideal_bin);
681 else r->qideal=q;
682 for(int i=0;i<N;i++)
683 {
684 omFree(names[i]);
685 }
686 omFreeSize(names,N*sizeof(char*));
687 rIncRefCnt(r);
688 // check if such ring already exist as ssiRing*
689 char name[20];
690 int nr=0;
691 idhdl h=NULL;
692 loop
693 {
694 snprintf(name,20,"ssiRing%d",nr); nr++;
695 h=IDROOT->get(name, 0);
696 if (h==NULL)
697 {
698 break;
699 }
700 else if ((IDTYP(h)==RING_CMD)
701 && (r!=IDRING(h))
702 && (rEqual(r,IDRING(h),1)))
703 {
704 rDelete(r);
705 r=rIncRefCnt(IDRING(h));
706 break;
707 }
708 }
709 if (new_ref!=-1)
710 {
711 d->rings[new_ref]=r;
712 rIncRefCnt(r);
713 }
714 return r;
715 }
716}
717
718static poly ssiReadPoly_R(const ssiInfo *d, const ring r)
719{
720// < # of terms> < term1> < .....
721 int n,i,l;
722 n=ssiReadInt(d->f_read); // # of terms
723 //Print("poly: terms:%d\n",n);
724 poly p;
725 poly ret=NULL;
726 poly prev=NULL;
727 for(l=0;l<n;l++) // read n terms
728 {
729// coef,comp.exp1,..exp N
730 p=p_Init(r,r->PolyBin);
731 pSetCoeff0(p,ssiReadNumber_CF(d,r->cf));
732 int D;
733 D=s_readint(d->f_read);
734 p_SetComp(p,D,r);
735 for(i=1;i<=rVar(r);i++)
736 {
737 D=s_readint(d->f_read);
738 p_SetExp(p,i,D,r);
739 }
740 p_Setm(p,r);
741 p_Test(p,r);
742 if (ret==NULL) ret=p;
743 else pNext(prev)=p;
744 prev=p;
745 }
746 return ret;
747}
748
749static poly ssiReadPoly(ssiInfo *d)
750{
751 return ssiReadPoly_R(d,d->r);
752}
753
754static ideal ssiReadIdeal_R(const ssiInfo *d,const ring r)
755{
756// < # of terms> < term1> < .....
757 int n,i;
758 ideal I;
759 n=s_readint(d->f_read);
760 I=idInit(n,1); // will be fixed later for module/smatrix
761 for(i=0;i<IDELEMS(I);i++) // read n terms
762 {
763 I->m [i]=ssiReadPoly_R(d,r);
764 }
765 return I;
766}
767
769{
770 return ssiReadIdeal_R(d,d->r);
771}
772
774{
775 int n,m;
776 m=s_readint(d->f_read);
777 n=s_readint(d->f_read);
778 matrix M=mpNew(m,n);
779 poly p;
780 for(int i=1;i<=MATROWS(M);i++)
781 for(int j=1;j<=MATCOLS(M);j++)
782 {
783 p=ssiReadPoly(d);
784 MATELEM(M,i,j)=p;
785 }
786 return M;
787}
788
790{
791 ssiInfo *d=(ssiInfo*)l->data;
792 // syntax: <num ops> <operation> <op1> <op2> ....
793 command D=(command)omAlloc0(sizeof(*D));
794 int argc,op;
795 argc=s_readint(d->f_read);
796 op=s_readint(d->f_read);
797 D->argc=argc; D->op=op;
798 leftv v;
799 if (argc >0)
800 {
801 v=ssiRead1(l);
802 memcpy(&(D->arg1),v,sizeof(*v));
804 }
805 if (argc <4)
806 {
807 if (D->argc >1)
808 {
809 v=ssiRead1(l);
810 memcpy(&(D->arg2),v,sizeof(*v));
812 }
813 if (D->argc >2)
814 {
815 v=ssiRead1(l);
816 memcpy(&(D->arg3),v,sizeof(*v));
818 }
819 }
820 else
821 {
822 leftv prev=&(D->arg1);
823 argc--;
824 while(argc >0)
825 {
826 v=ssiRead1(l);
827 prev->next=v;
828 prev=v;
829 argc--;
830 }
831 }
832 return D;
833}
834
836{
837 char *s=ssiReadString(d);
839 p->language=LANG_SINGULAR;
840 p->libname=omStrDup("");
841 p->procname=omStrDup("");
842 p->data.s.body=s;
843 return p;
844}
846{
847 ssiInfo *d=(ssiInfo*)l->data;
848 int nr;
849 nr=s_readint(d->f_read);
851 L->Init(nr);
852
853 int i;
854 leftv v;
855 for(i=0;i<=L->nr;i++)
856 {
857 v=ssiRead1(l);
858 memcpy(&(L->m[i]),v,sizeof(*v));
860 }
861 return L;
862}
863static intvec* ssiReadIntvec(const ssiInfo *d)
864{
865 int nr;
866 nr=s_readint(d->f_read);
867 intvec *v=new intvec(nr);
868 for(int i=0;i<nr;i++)
869 {
870 (*v)[i]=s_readint(d->f_read);
871 }
872 return v;
873}
874static intvec* ssiReadIntmat(const ssiInfo *d)
875{
876 int r,c;
877 r=s_readint(d->f_read);
878 c=s_readint(d->f_read);
879 intvec *v=new intvec(r,c,0);
880 for(int i=0;i<r*c;i++)
881 {
882 (*v)[i]=s_readint(d->f_read);
883 }
884 return v;
885}
887{
888 int r,c;
889 r=s_readint(d->f_read);
890 c=s_readint(d->f_read);
892 for(int i=0;i<r*c;i++)
893 {
894 (*v)[i]=ssiReadBigInt(d);
895 }
896 return v;
897}
899{
900 int c;
901 c=s_readint(d->f_read);
903 for(int i=0;i<c;i++)
904 {
905 (*v)[i]=ssiReadBigInt(d);
906 }
907 return v;
908}
909
911{
912 ssiInfo *d=(ssiInfo*)l->data;
913 leftv lv=ssiRead1(l);
914 char *name=(char*)lv->data;
916 int tok;
918 if (tok>MAX_TOK)
919 {
923 res->rtyp=tok;
924 b->blackbox_deserialize(&b,&(res->data),l);
925 if (save_ring!=currRing)
926 {
929 else currRingHdl=NULL;
930 }
931 }
932 else
933 {
934 Werror("blackbox %s not found",name);
935 }
936 omFree(name);
937}
938
940{
941 ssiInfo *d=(ssiInfo*)l->data;
944 if (nr_of_attr>0)
945 {
946 for(int i=1;i<nr_of_attr;i++)
947 {
948 }
949 }
951 memcpy(res,tmp,sizeof(sleftv));
952 memset(tmp,0,sizeof(sleftv));
954 if (nr_of_attr>0)
955 {
956 }
957 res->flag=fl;
958}
960{
961 ssiInfo *d=(ssiInfo*)l->data;
962 int what=s_readint(d->f_read);
963 switch(what)
964 {
965 case 0: // bitmask
966 {
967 int lb=s_readint(d->f_read);
968 unsigned long bm=~0L;
969 bm=bm<<lb;
970 bm=~bm;
971 rUnComplete(d->r);
972 d->r->bitmask=bm;
973 rComplete(d->r);
974 break;
975 }
976 case 1: // LPRing
977 {
978 int lb=s_readint(d->f_read);
979 int isLPring=s_readint(d->f_read);
980 unsigned long bm=~0L;
981 bm=bm<<lb;
982 bm=~bm;
983 rUnComplete(d->r);
984 d->r->bitmask=bm;
985 d->r->isLPring=isLPring;
986 rComplete(d->r);
987 break;
988 }
989 case 2: // Plural rings
990 {
993 nc_CallPlural(C,D,NULL,NULL,d->r,true,true,false,d->r,false);
994 break;
995 }
996 }
997}
998//**************************************************************************/
999
1001{
1002 if (l!=NULL)
1003 {
1004 const char *mode;
1005 ssiInfo *d=(ssiInfo*)omAlloc0(sizeof(ssiInfo));
1006 if (flag & SI_LINK_OPEN)
1007 {
1008 if (l->mode[0] != '\0' && (strcmp(l->mode, "r") == 0))
1009 flag = SI_LINK_READ;
1010 else flag = SI_LINK_WRITE;
1011 }
1012
1013 if (flag == SI_LINK_READ) mode = "r";
1014 else if (strcmp(l->mode, "w") == 0) mode = "w";
1015 else if (strcmp(l->mode, "fork") == 0) mode = "fork";
1016 else if (strcmp(l->mode, "tcp") == 0) mode = "tcp";
1017 else if (strcmp(l->mode, "connect") == 0) mode = "connect";
1018 else mode = "a";
1019
1020
1021 SI_LINK_SET_OPEN_P(l, flag);
1022 if(l->data!=NULL) omFreeSize(l->data,sizeof(ssiInfo));
1023 l->data=d;
1024 omFreeBinAddr(l->mode);
1025 l->mode = omStrDup(mode);
1026
1027 if (l->name[0] == '\0')
1028 {
1029 if (strcmp(mode,"fork")==0)
1030 {
1031 int pc[2];
1032 int cp[2];
1033 int err1=pipe(pc);
1034 int err2=pipe(cp);
1035 if (err1 || err2)
1036 {
1037 Werror("pipe failed with %d\n",errno);
1038 return TRUE;
1039 }
1041 n->u=u;
1042 n->l=l;
1043 n->next=(void *)ssiToBeClosed;
1044 ssiToBeClosed=n;
1045
1046 pid_t pid = fork();
1047 if (pid == -1 && errno == EAGAIN) // RLIMIT_NPROC too low?
1048 {
1050 pid = fork();
1051 }
1052 if (pid == -1)
1053 {
1054 WerrorS("could not fork");
1055 }
1056 if (pid==0) /*fork: child*/
1057 {
1058 /* block SIGINT */
1064 /* set #cpu to 1 for the child:*/
1066
1068 /* we know: l is the first entry in ssiToBeClosed-list */
1069 while(hh!=NULL)
1070 {
1072 ssiInfo *dd=(ssiInfo*)hh->l->data;
1073 s_close(dd->f_read);
1074 fclose(dd->f_write);
1075 if (dd->r!=NULL) rKill(dd->r);
1076 omFreeSize((ADDRESS)dd,(sizeof *dd));
1077 hh->l->data=NULL;
1078 link_list nn=(link_list)hh->next;
1079 omFree(hh);
1080 hh=nn;
1081 }
1083#ifdef HAVE_SIMPLEIPC
1085#endif // HAVE_SIMPLEIPC
1086 si_close(pc[1]); si_close(cp[0]);
1087 d->f_write=fdopen(cp[1],"w");
1088 d->f_read=s_open(pc[0]);
1089 d->fd_read=pc[0];
1090 d->fd_write=cp[1];
1091 //d->r=currRing;
1092 //if (d->r!=NULL) d->r->ref++;
1093 l->data=d;
1094 omFreeBinAddr(l->mode);
1095 l->mode = omStrDup(mode);
1098 //myynest=0;
1100 if ((u!=NULL)&&(u->rtyp==IDHDL))
1101 {
1102 idhdl h=(idhdl)u->data;
1103 h->lev=0;
1104 }
1105 loop
1106 {
1107 if (!SI_LINK_OPEN_P(l)) m2_end(0);
1108 if(d->f_read->is_eof) m2_end(0);
1109 leftv h=ssiRead1(l); /*contains an exit.... */
1110 if (feErrors != NULL && *feErrors != '\0')
1111 {
1112 // handle errors:
1113 PrintS(feErrors); /* currently quite simple */
1114 *feErrors = '\0';
1115 }
1116 ssiWrite(l,h);
1117 h->CleanUp();
1119 }
1120 /* never reached*/
1121 }
1122 else if (pid>0) /*fork: parent*/
1123 {
1124 d->pid=pid;
1125 si_close(pc[0]); si_close(cp[1]);
1126 d->f_write=fdopen(pc[1],"w");
1127 d->f_read=s_open(cp[0]);
1128 d->fd_read=cp[0];
1129 d->fd_write=pc[1];
1131 d->send_quit_at_exit=1;
1132 //d->r=currRing;
1133 //if (d->r!=NULL) d->r->ref++;
1134 }
1135 else
1136 {
1137 Werror("fork failed (%d)",errno);
1138 l->data=NULL;
1139 omFree(d);
1140 return TRUE;
1141 }
1142 }
1143 // ---------------------------------------------------------------------
1144 else if (strcmp(mode,"tcp")==0)
1145 {
1149 if(sockfd < 0)
1150 {
1151 WerrorS("ERROR opening socket");
1152 l->data=NULL;
1153 l->flags=0;
1154 omFree(d);
1155 return TRUE;
1156 }
1157 memset((char *) &serv_addr,0, sizeof(serv_addr));
1158 portno = 1025;
1159 serv_addr.sin_family = AF_INET;
1160 serv_addr.sin_addr.s_addr = INADDR_ANY;
1161 do
1162 {
1163 portno++;
1164 serv_addr.sin_port = htons(portno);
1165 if(portno > 50000)
1166 {
1167 WerrorS("ERROR on binding (no free port available?)");
1168 l->data=NULL;
1169 l->flags=0;
1170 omFree(d);
1171 return TRUE;
1172 }
1173 }
1174 while(bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0);
1175 Print("waiting on port %d\n", portno);mflush();
1176 listen(sockfd,1);
1178 if(newsockfd < 0)
1179 {
1180 WerrorS("ERROR on accept");
1181 l->data=NULL;
1182 l->flags=0;
1183 omFree(d);
1184 return TRUE;
1185 }
1186 PrintS("client accepted\n");
1187 d->fd_read = newsockfd;
1188 d->fd_write = newsockfd;
1189 d->f_read = s_open(newsockfd);
1190 d->f_write = fdopen(newsockfd, "w");
1193 }
1194 // no ssi-Link on stdin or stdout
1195 else
1196 {
1197 Werror("invalid mode >>%s<< for ssi",mode);
1198 l->data=NULL;
1199 l->flags=0;
1200 omFree(d);
1201 return TRUE;
1202 }
1203 }
1204 // =========================================================================
1205 else /*now l->name!=NULL*/
1206 {
1207 // tcp mode
1208 if(strcmp(mode,"tcp")==0)
1209 {
1213 if(sockfd < 0)
1214 {
1215 WerrorS("ERROR opening socket");
1216 l->data=NULL;
1217 l->flags=0;
1218 omFree(d);
1219 return TRUE;
1220 }
1221 memset((char *) &serv_addr,0, sizeof(serv_addr));
1222 portno = 1025;
1223 serv_addr.sin_family = AF_INET;
1224 serv_addr.sin_addr.s_addr = INADDR_ANY;
1225 do
1226 {
1227 portno++;
1228 serv_addr.sin_port = htons(portno);
1229 if(portno > 50000)
1230 {
1231 WerrorS("ERROR on binding (no free port available?)");
1232 l->data=NULL;
1233 l->flags=0;
1234 return TRUE;
1235 }
1236 }
1237 while(bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0);
1238 //Print("waiting on port %d\n", portno);mflush();
1239 listen(sockfd,1);
1240 char* cli_host = (char*)omAlloc(256);
1241 char* path = (char*)omAlloc(1024);
1242 int r = si_sscanf(l->name,"%255[^:]:%s",cli_host,path);
1243 if(r == 0)
1244 {
1245 WerrorS("ERROR: no host specified");
1246 l->data=NULL;
1247 l->flags=0;
1248 omFree(d);
1249 omFree(path);
1251 return TRUE;
1252 }
1253 else if(r == 1)
1254 {
1255 WarnS("program not specified, using /usr/local/bin/Singular");
1256 Warn("in line >>%s<<",my_yylinebuf);
1257 strcpy(path,"/usr/local/bin/Singular");
1258 }
1259 char* ssh_command = (char*)omAlloc(256);
1260 char* ser_host = (char*)omAlloc(64);
1261 if(strcmp(cli_host,"localhost")==0)
1262 strcpy(ser_host,"localhost");
1263 else
1265 if (strcmp(cli_host,"localhost")==0) /*avoid "ssh localhost" as key may change*/
1266 snprintf(ssh_command,256,"%s -q --batch --link=ssi --MPhost=%s --MPport=%d &",path,ser_host,portno);
1267 else
1268 snprintf(ssh_command,256,"ssh %s %s -q --batch --link=ssi --MPhost=%s --MPport=%d &",cli_host,path,ser_host,portno);
1269 //Print("client on %s started:%s\n",cli_host,path);
1270 omFree(path);
1272 if (TEST_OPT_PROT) { Print("running >>%s<<\n",ssh_command); }
1273 int re=system(ssh_command);
1274 if (re<0)
1275 {
1276 Werror("ERROR running `%s` (%d)",ssh_command,re);
1277 l->data=NULL;
1278 l->flags=0;
1279 omFree(d);
1280 return TRUE;
1281 }
1284 clilen = sizeof(cli_addr);
1286 if(newsockfd < 0)
1287 {
1288 WerrorS("ERROR on accept");
1289 l->data=NULL;
1290 l->flags=0;
1291 omFree(d);
1292 return TRUE;
1293 }
1294 //PrintS("client accepted\n");
1295 d->fd_read = newsockfd;
1296 d->fd_write = newsockfd;
1297 d->f_read = s_open(newsockfd);
1298 d->f_write = fdopen(newsockfd, "w");
1301 d->send_quit_at_exit=1;
1303 newlink->u=u;
1304 newlink->l=l;
1305 newlink->next=(void *)ssiToBeClosed;
1307 fprintf(d->f_write,"98 %d %d %u %u\n",SSI_VERSION,MAX_TOK,si_opt_1,si_opt_2);
1308 }
1309 // ----------------------------------------------------------------------
1310 else if(strcmp(mode,"connect")==0)
1311 {
1312 char* host = (char*)omAlloc(256);
1313 int sockfd, portno;
1314 struct sockaddr_in serv_addr;
1315 struct hostent *server;
1316
1317 si_sscanf(l->name,"%255[^:]:%d",host,&portno);
1318 //Print("connect to host %s, port %d\n",host,portno);mflush();
1319 if (portno!=0)
1320 {
1322 if (sockfd < 0)
1323 {
1324 WerrorS("ERROR opening socket");
1325 l->flags=0;
1326 return TRUE;
1327 }
1329 if (server == NULL)
1330 {
1331 WerrorS("ERROR, no such host");
1332 l->flags=0;
1333 return TRUE;
1334 }
1335 memset((char *) &serv_addr, 0, sizeof(serv_addr));
1336 serv_addr.sin_family = AF_INET;
1337 memcpy((char *)&serv_addr.sin_addr.s_addr,
1338 (char *)server->h_addr,
1339 server->h_length);
1340 serv_addr.sin_port = htons(portno);
1341 if (si_connect(sockfd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0)
1342 {
1343 Werror("ERROR connecting(errno=%d)",errno);
1344 l->flags=0;
1345 return TRUE;
1346 }
1347 //PrintS("connected\n");mflush();
1348 d->f_read=s_open(sockfd);
1349 d->fd_read=sockfd;
1350 d->f_write=fdopen(sockfd,"w");
1351 d->fd_write=sockfd;
1353 omFree(host);
1354 }
1355 else
1356 {
1357 l->data=NULL;
1358 l->flags=0;
1359 omFree(d);
1360 return TRUE;
1361 }
1362 }
1363 // ======================================================================
1364 else
1365 {
1366 // normal link to a file
1367 if (FE_OPT_NO_SHELL_FLAG) {WerrorS("no links allowed");return TRUE;}
1368 FILE *outfile;
1369 char *filename=l->name;
1370
1371 if(filename[0]=='>')
1372 {
1373 if (filename[1]=='>')
1374 {
1375 filename+=2;
1376 mode = "a";
1377 }
1378 else
1379 {
1380 filename++;
1381 mode="w";
1382 }
1383 }
1384 outfile=myfopen(filename,mode);
1385 if (outfile!=NULL)
1386 {
1387 if (strcmp(l->mode,"r")==0)
1388 {
1389 fclose(outfile);
1390 d->f_read=s_open_by_name(filename);
1391 }
1392 else
1393 {
1394 d->f_write = outfile;
1395 fprintf(d->f_write,"98 %d %d %u %u\n",SSI_VERSION,MAX_TOK,si_opt_1,si_opt_2);
1396 }
1397 }
1398 else
1399 {
1400 omFree(d);
1401 l->data=NULL;
1402 l->flags=0;
1403 return TRUE;
1404 }
1405 }
1406 }
1407 }
1408
1409 return FALSE;
1410}
1411
1412//**************************************************************************/
1414{
1415 if (l!=NULL)
1416 {
1418 ssiInfo *d = (ssiInfo *)l->data;
1419 if (d!=NULL)
1420 {
1421 if (d->send_quit_at_exit)
1422 {
1423 fputs("99\n",d->f_write);
1424 fflush(d->f_write);
1425 }
1426 d->quit_sent=1;
1427 }
1428 }
1429 return FALSE;
1430}
1431
1433{
1434 if (l!=NULL)
1435 {
1437 ssiInfo *d = (ssiInfo *)l->data;
1438 if (d!=NULL)
1439 {
1440 // send quit signal
1441 if ((d->send_quit_at_exit)
1442 && (d->quit_sent==0))
1443 {
1444 fputs("99\n",d->f_write);
1445 fflush(d->f_write);
1446 d->quit_sent=1;
1447 }
1448 // clean ring
1449 if (d->r!=NULL) rKill(d->r);
1450 for(int i=0;i<SI_RING_CACHE;i++)
1451 {
1452 if (d->rings[i]!=NULL) rKill(d->rings[i]);
1453 d->rings[i]=NULL;
1454 }
1455 if (d->f_read!=NULL) { s_close(d->f_read);d->f_read=NULL;}
1456 if (d->f_write!=NULL) { fclose(d->f_write); d->f_write=NULL; }
1457 if (((strcmp(l->mode,"tcp")==0)
1458 || (strcmp(l->mode,"fork")==0))
1459 && (d->pid>1))
1460 {
1461 // did the child stop ?
1462 int pid=si_waitpid(d->pid,NULL,WNOHANG);
1463 if ((pid==0) /* no status change for child*/
1464 && (kill(d->pid,0)==0)) // child is still running
1465 {
1466 struct timespec t;
1467 struct timespec rem;
1468 // wait 60 sec
1469 for(int i=0;i<50;i++)
1470 {
1471 // wait till signal or 100ms:
1472 t.tv_sec=0;
1473 t.tv_nsec=100000000; // <=100 ms
1474 nanosleep(&t, &rem);
1475 // child finished ?
1476 if (si_waitpid(d->pid,NULL,WNOHANG) == d->pid) break;
1477 }
1478 if (kill(d->pid,0)==0) // child still exists
1479 {
1480 kill(d->pid,SIGTERM);
1481 t.tv_sec=1;
1482 t.tv_nsec=0; // <=1000 ms
1483 nanosleep(&t, &rem);
1485 }
1486 }
1487 }
1488 if ((strcmp(l->mode,"tcp")==0)
1489 || (strcmp(l->mode,"fork")==0))
1490 {
1492 if (hh!=NULL)
1493 {
1494 if (hh->l==l)
1495 {
1496 ssiToBeClosed=(link_list)hh->next;
1497 omFreeSize(hh,sizeof(link_struct));
1498 }
1499 else while(hh->next!=NULL)
1500 {
1501 link_list hhh=(link_list)hh->next;
1502 if (hhh->l==l)
1503 {
1504 hh->next=hhh->next;
1505 omFreeSize(hhh,sizeof(link_struct));
1506 break;
1507 }
1508 else
1509 hh=(link_list)hh->next;
1510 }
1511 }
1512 }
1513 omFreeSize((ADDRESS)d,(sizeof *d));
1514 }
1515 l->data=NULL;
1516 }
1517 return FALSE;
1518}
1519
1520//**************************************************************************/
1522{
1523 ssiInfo *d = (ssiInfo *)l->data;
1525 int t=0;
1526 t=s_readint(d->f_read);
1527 //Print("got type %d\n",t);
1528 switch(t)
1529 {
1530 case 1:res->rtyp=INT_CMD;
1531 res->data=(char *)(long)ssiReadInt(d->f_read);
1532 //Print("int: %d\n",(int)(long)res->data);
1533 break;
1534 case 2:res->rtyp=STRING_CMD;
1535 res->data=(char *)ssiReadString(d);
1536 //Print("str: %s\n",(char*)res->data);
1537 break;
1538 case 3:res->rtyp=NUMBER_CMD;
1539 if (d->r==NULL) goto no_ring;
1540 ssiCheckCurrRing(d->r);
1541 res->data=(char *)ssiReadNumber(d);
1542 //Print("number\n");
1543 break;
1544 case 4:res->rtyp=BIGINT_CMD;
1545 res->data=(char *)ssiReadBigInt(d);
1546 //Print("bigint\n");
1547 break;
1548 case 15:
1549 case 5:{
1550 //Print("ring %d\n",t);
1551 d->r=ssiReadRing(d);
1552 if (errorreported) return NULL;
1553 res->data=(char*)d->r;
1554 if (d->r!=NULL) rIncRefCnt(d->r);
1555 res->rtyp=RING_CMD;
1556 if (t==15) // setring
1557 {
1558 if(ssiSetCurrRing(d->r)) { d->r=currRing; }
1560 return ssiRead1(l);
1561 }
1562 }
1563 break;
1564 case 6:res->rtyp=POLY_CMD;
1565 //Print("poly\n");
1566 if (d->r==NULL) goto no_ring;
1567 ssiCheckCurrRing(d->r);
1568 res->data=(char*)ssiReadPoly(d);
1569 break;
1570 case 7:res->rtyp=IDEAL_CMD;
1571 //Print("ideal\n");
1572 if (d->r==NULL) goto no_ring;
1573 ssiCheckCurrRing(d->r);
1574 res->data=(char*)ssiReadIdeal(d);
1575 break;
1576 case 8:res->rtyp=MATRIX_CMD;
1577 //Print("matrix\n");
1578 if (d->r==NULL) goto no_ring;
1579 ssiCheckCurrRing(d->r);
1580 res->data=(char*)ssiReadMatrix(d);
1581 break;
1582 case 9:res->rtyp=VECTOR_CMD;
1583 //Print("vector\n");
1584 if (d->r==NULL) goto no_ring;
1585 ssiCheckCurrRing(d->r);
1586 res->data=(char*)ssiReadPoly(d);
1587 break;
1588 case 10:
1589 case 22:if (t==22) res->rtyp=SMATRIX_CMD;
1590 else res->rtyp=MODUL_CMD;
1591 //Print("module/smatrix %d\n",t);
1592 if (d->r==NULL) goto no_ring;
1593 ssiCheckCurrRing(d->r);
1594 {
1595 int rk=s_readint(d->f_read);
1596 ideal M=ssiReadIdeal(d);
1597 M->rank=rk;
1598 res->data=(char*)M;
1599 }
1600 break;
1601 case 11:
1602 {
1603 //Print("cmd\n",t);
1604 res->rtyp=COMMAND;
1605 res->data=ssiReadCommand(l);
1606 int nok=res->Eval();
1607 if (nok) WerrorS("error in eval");
1608 break;
1609 }
1610 case 12: /*DEF_CMD*/
1611 {
1612 //Print("def\n",t);
1613 res->rtyp=0;
1614 res->name=(char *)ssiReadString(d);
1615 int nok=res->Eval();
1616 if (nok) WerrorS("error in name lookup");
1617 break;
1618 }
1619 case 13: res->rtyp=PROC_CMD;
1620 res->data=ssiReadProc(d);
1621 break;
1622 case 14: res->rtyp=LIST_CMD;
1623 res->data=ssiReadList(l);
1624 break;
1625 case 16: res->rtyp=NONE; res->data=NULL;
1626 break;
1627 case 17: res->rtyp=INTVEC_CMD;
1628 res->data=ssiReadIntvec(d);
1629 break;
1630 case 18: res->rtyp=INTMAT_CMD;
1631 res->data=ssiReadIntmat(d);
1632 break;
1633 case 19: res->rtyp=BIGINTMAT_CMD;
1634 res->data=ssiReadBigintmat(d);
1635 break;
1636 case 20: ssiReadBlackbox(res,l);
1637 break;
1638 case 21: ssiReadAttrib(res,l);
1639 break;
1640 case 23: ssiReadRingProperties(l);
1641 return ssiRead1(l);
1642 break;
1643 case 24: res->rtyp=BIGINTVEC_CMD;
1644 res->data=ssiReadBigintvec(d);
1645 break;
1646 // ------------
1647 case 98: // version
1648 {
1649 int n98_v,n98_m;
1655 if ((n98_v!=SSI_VERSION) ||(n98_m!=MAX_TOK))
1656 {
1657 Print("incompatible versions of ssi: %d/%d vs %d/%d\n",
1659 }
1660 #ifndef SING_NDEBUG
1661 if (TEST_OPT_DEBUG)
1662 Print("// opening ssi-%d, MAX_TOK=%d\n",n98_v,n98_m);
1663 #endif
1667 return ssiRead1(l);
1668 }
1669 case 99: omFreeBin(res,sleftv_bin); ssiClose(l); m2_end(0);
1670 break; /*to make compiler happy*/
1671 case 0: if (s_iseof(d->f_read))
1672 {
1673 ssiClose(l);
1674 }
1675 res->rtyp=DEF_CMD;
1676 break;
1677 default: Werror("not implemented (t:%d)",t);
1679 res=NULL;
1680 break;
1681 }
1682 // if currRing is required for the result, but lost
1683 // define "ssiRing%d" as currRing:
1684 if ((d->r!=NULL)
1685 && (currRing!=d->r)
1686 && (res->RingDependend()))
1687 {
1688 if(ssiSetCurrRing(d->r)) { d->r=currRing; }
1689 }
1690 return res;
1691no_ring: WerrorS("no ring");
1693 return NULL;
1694}
1695//**************************************************************************/
1697{
1698 if(SI_LINK_W_OPEN_P(l)==0)
1700 ssiInfo *d = (ssiInfo *)l->data;
1701 if (d->r!=r)
1702 {
1703 if (send)
1704 {
1705 fputs("15 ",d->f_write);
1706 ssiWriteRing(d,r);
1707 }
1708 d->r=r;
1709 }
1710 if (currRing!=r) rChangeCurrRing(r);
1711 return FALSE;
1712}
1713//**************************************************************************/
1714
1716{
1717 if(SI_LINK_W_OPEN_P(l)==0)
1719 ssiInfo *d = (ssiInfo *)l->data;
1720 d->level++;
1721 //FILE *fich=d->f;
1722 while (data!=NULL)
1723 {
1724 int tt=data->Typ();
1725 void *dd=data->Data();
1726 attr *aa=data->Attribute();
1727 if ((aa!=NULL) && ((*aa)!=NULL)) // n user attributes
1728 {
1729 attr a=*aa;
1730 int n=0;
1731 while(a!=NULL) { n++; a=a->next;}
1732 fprintf(d->f_write,"21 %d %d ",data->flag,n);
1733 }
1734 else if (data->flag!=0) // only "flag" attributes
1735 {
1736 fprintf(d->f_write,"21 %d 0 ",data->flag);
1737 }
1738 if ((dd==NULL) && (data->name!=NULL) && (tt==0)) tt=DEF_CMD;
1739 // return pure undefined names as def
1740
1741 switch(tt /*data->Typ()*/)
1742 {
1743 case 0: /*error*/
1744 case NONE/* nothing*/:fputs("16 ",d->f_write);
1745 break;
1746 case STRING_CMD: fputs("2 ",d->f_write);
1747 ssiWriteString(d,(char *)dd);
1748 break;
1749 case INT_CMD: fputs("1 ",d->f_write);
1750 ssiWriteInt(d,(int)(long)dd);
1751 break;
1752 case BIGINT_CMD:fputs("4 ",d->f_write);
1754 break;
1755 case NUMBER_CMD:
1756 if (d->r!=currRing)
1757 {
1758 fputs("15 ",d->f_write);
1760 if (d->level<=1) fputc('\n',d->f_write);
1761 }
1762 fputs("3 ",d->f_write);
1764 break;
1765 case RING_CMD:fputs("5 ",d->f_write);
1766 ssiWriteRing(d,(ring)dd);
1767 break;
1768 case BUCKET_CMD:
1769 {
1771 if (d->r!=sBucketGetRing(b))
1772 {
1773 fputs("15 ",d->f_write);
1775 if (d->level<=1) fputc('\n',d->f_write);
1776 }
1777 fputs("6 ",d->f_write);
1779 break;
1780 }
1781 case POLY_CMD:
1782 case VECTOR_CMD:
1783 if (d->r!=currRing)
1784 {
1785 fputs("15 ",d->f_write);
1787 if (d->level<=1) fputc('\n',d->f_write);
1788 }
1789 if(tt==POLY_CMD) fputs("6 ",d->f_write);
1790 else fputs("9 ",d->f_write);
1791 ssiWritePoly(d,tt,(poly)dd);
1792 break;
1793 case IDEAL_CMD:
1794 case MODUL_CMD:
1795 case MATRIX_CMD:
1796 case SMATRIX_CMD:
1797 if (d->r!=currRing)
1798 {
1799 fputs("15 ",d->f_write);
1801 if (d->level<=1) fputc('\n',d->f_write);
1802 }
1803 if(tt==IDEAL_CMD) fputs("7 ",d->f_write);
1804 else if(tt==MATRIX_CMD) fputs("8 ",d->f_write);
1805 else /* tt==MODUL_CMD, SMATRIX_CMD*/
1806 {
1807 ideal M=(ideal)dd;
1808 if (tt==MODUL_CMD)
1809 fprintf(d->f_write,"10 %d ",(int)M->rank);
1810 else /*(tt==SMATRIX_CMD)*/
1811 fprintf(d->f_write,"22 %d ",(int)M->rank);
1812 }
1814 break;
1815 case COMMAND:
1816 fputs("11 ",d->f_write);
1818 break;
1819 case DEF_CMD: /* not evaluated stuff in quotes */
1820 fputs("12 ",d->f_write);
1821 ssiWriteString(d,data->Name());
1822 break;
1823 case PROC_CMD:
1824 fputs("13 ",d->f_write);
1826 break;
1827 case LIST_CMD:
1828 fputs("14 ",d->f_write);
1830 break;
1831 case INTVEC_CMD:
1832 fputs("17 ",d->f_write);
1833 ssiWriteIntvec(d,(intvec *)dd);
1834 break;
1835 case INTMAT_CMD:
1836 fputs("18 ",d->f_write);
1837 ssiWriteIntmat(d,(intvec *)dd);
1838 break;
1839 case BIGINTMAT_CMD:
1840 fputs("19 ",d->f_write);
1842 break;
1843 case BIGINTVEC_CMD:
1844 fputs("24 ",d->f_write);
1846 break;
1847 default:
1848 if (tt>MAX_TOK)
1849 {
1851 fputs("20 ",d->f_write);
1852 b->blackbox_serialize(b,dd,l);
1853 }
1854 else
1855 {
1856 Werror("not implemented (t:%d, rtyp:%d)",tt, data->rtyp);
1857 d->level=0;
1858 return TRUE;
1859 }
1860 break;
1861 }
1862 if (d->level<=1) { fputc('\n',d->f_write); fflush(d->f_write); }
1863 data=data->next;
1864 }
1865 d->level--;
1866 return FALSE;
1867}
1868
1871
1873{
1874 s->Open=ssiOpen;
1875 s->Close=ssiClose;
1876 s->Kill=ssiClose;
1877 s->Read=ssiRead1;
1878 s->Read2=(slRead2Proc)NULL;
1879 s->Write=ssiWrite;
1880 s->Dump=ssiDump;
1881 s->GetDump=ssiGetDump;
1882
1883 s->Status=slStatusSsi;
1884 s->SetRing=ssiSetRing;
1885 s->type="ssi";
1886 return s;
1887}
1888
1889const char* slStatusSsi(si_link l, const char* request)
1890{
1891 ssiInfo *d=(ssiInfo*)l->data;
1892 if (d==NULL) return "not open";
1893 if (((strcmp(l->mode,"fork")==0)
1894 ||(strcmp(l->mode,"tcp")==0)
1895 ||(strcmp(l->mode,"connect")==0))
1896 && (strcmp(request, "read") == 0))
1897 {
1898 if (s_isready(d->f_read)) return "ready";
1899#if defined(HAVE_POLL)
1900 pollfd pfd;
1901 loop
1902 {
1903 /* Don't block. Return socket status immediately. */
1904 pfd.fd=d->fd_read;
1905 pfd.events=POLLIN;
1906 //Print("test fd %d\n",d->fd_read);
1907 /* check with select: chars waiting: no -> not ready */
1908 switch (si_poll(&pfd,1,0))
1909 {
1910 case 0: /* not ready */ return "not ready";
1911 case -1: /*error*/ return "error";
1912 case 1: /*ready ? */ break;
1913 }
1914#else
1915 fd_set mask;
1916 struct timeval wt;
1917 if (FD_SETSIZE<=d->fd_read)
1918 {
1919 Werror("file descriptor number too high (%d)",d->fd_read);
1920 return "error";
1921 }
1922
1923 loop
1924 {
1925 /* Don't block. Return socket status immediately. */
1926 wt.tv_sec = 0;
1927 wt.tv_usec = 0;
1928
1929 FD_ZERO(&mask);
1930 FD_SET(d->fd_read, &mask);
1931 //Print("test fd %d\n",d->fd_read);
1932 /* check with select: chars waiting: no -> not ready */
1933 switch (si_select(d->fd_read+1, &mask, NULL, NULL, &wt))
1934 {
1935 case 0: /* not ready */ return "not ready";
1936 case -1: /*error*/ return "error";
1937 case 1: /*ready ? */ break;
1938 }
1939#endif
1940 /* yes: read 1 char*/
1941 /* if \n, check again with select else ungetc(c), ready*/
1942 int c=s_getc(d->f_read);
1943 //Print("try c=%d\n",c);
1944 if (c== -1) return "eof"; /* eof or error */
1945 else if (isdigit(c))
1946 { s_ungetc(c,d->f_read); return "ready"; }
1947 else if (c>' ')
1948 {
1949 Werror("unknown char in ssiLink(%d)",c);
1950 return "error";
1951 }
1952 /* else: next char */
1953 }
1954 }
1955 else if (strcmp(request, "read") == 0)
1956 {
1957 if (SI_LINK_R_OPEN_P(l) && (!s_iseof(d->f_read)) && (s_isready(d->f_read))) return "ready";
1958 else return "not ready";
1959 }
1960 else if (strcmp(request, "write") == 0)
1961 {
1962 if (SI_LINK_W_OPEN_P(l)) return "ready";
1963 else return "not ready";
1964 }
1965 else return "unknown status request";
1966}
1967
1969{
1970// input: L: a list with links of type
1971// ssi-connect, ssi-fork, ssi-tcp, MPtcp-fork or MPtcp-launch.
1972// Note: Not every entry in L must be set.
1973// timeout: timeout for select in milli-seconds
1974// or -1 for infinity
1975// or 0 for polling
1976// returns: ERROR (via Werror): L has wrong elements or link not open
1977// -2: error in L
1978// -1: the read state of all links is eof
1979// 0: timeout (or polling): none ready,
1980// i>0: (at least) L[i] is ready
1981#if defined(HAVE_POLL) && !defined(__APPLE__)
1982// fd is restricted on OsX by ulimit "file descriptors" (256)
1983 si_link l;
1984 ssiInfo *d=NULL;
1985 int d_fd;
1986 int s;
1987 int nfd=L->nr+1;
1988 pollfd *pfd=(pollfd*)omAlloc0(nfd*sizeof(pollfd));
1989 for(int i=L->nr; i>=0; i--)
1990 {
1991 pfd[i].fd=-1;
1992 if (L->m[i].Typ()!=DEF_CMD)
1993 {
1994 if (L->m[i].Typ()!=LINK_CMD)
1995 { WerrorS("all elements must be of type link"); return -2;}
1996 l=(si_link)L->m[i].Data();
1997 if(SI_LINK_OPEN_P(l)==0)
1998 { WerrorS("all links must be open"); return -2;}
1999 if (((strcmp(l->m->type,"ssi")!=0) && (strcmp(l->m->type,"MPtcp")!=0))
2000 || ((strcmp(l->mode,"fork")!=0) && (strcmp(l->mode,"tcp")!=0)
2001 && (strcmp(l->mode,"launch")!=0) && (strcmp(l->mode,"connect")!=0)))
2002 {
2003 WerrorS("all links must be of type ssi:fork, ssi:tcp, ssi:connect");
2004 return -2;
2005 }
2006 if (strcmp(l->m->type,"ssi")==0)
2007 {
2008 d=(ssiInfo*)l->data;
2009 d_fd=d->fd_read;
2010 if (!s_isready(d->f_read))
2011 {
2012 pfd[i].fd=d_fd;
2013 pfd[i].events=POLLIN;
2014 }
2015 else
2016 {
2017 return i+1;
2018 }
2019 }
2020 else
2021 {
2022 Werror("wrong link type >>%s<<",l->m->type);
2023 return -2;
2024 }
2025 }
2026 else if (ignore!=NULL)
2027 {
2028 ignore[i]=TRUE; // not a link
2029 }
2030 }
2032 if (s==-1)
2033 {
2034 Werror("error in poll call (errno:%d)",errno);
2035 return -2; /*error*/
2036 }
2037 if(s==0)
2038 {
2039 return 0; /*timeout*/
2040 }
2041 for(int i=L->nr; i>=0; i--)
2042 {
2043 if ((L->m[i].rtyp==LINK_CMD)
2044 && ((ignore==NULL)||(ignore[i]==FALSE)))
2045 {
2046 // the link type is ssi, that's already tested
2047 l=(si_link)L->m[i].Data();
2048 d=(ssiInfo*)l->data;
2049 d_fd=d->fd_read;
2050 if (pfd[i].fd==d_fd)
2051 {
2052 if (pfd[i].revents &POLLIN)
2053 {
2054 omFree(pfd);
2055 return i+1;
2056 }
2057 }
2058 }
2059 }
2060 // no ready
2061 return 0;
2062#else
2063 // fd is restricted to <=1024
2064 si_link l;
2065 ssiInfo *d=NULL;
2066 int d_fd;
2067 fd_set fdmask;
2068 FD_ZERO(&fdmask);
2069 int max_fd=0; /* 1 + max fd in fd_set */
2070
2071 /* timeout */
2072 struct timeval wt;
2073 struct timeval *wt_ptr=&wt;
2074 int startingtime = getRTimer()/TIMER_RESOLUTION; // in seconds
2075 if (timeout== -1)
2076 {
2077 wt_ptr=NULL;
2078 }
2079 else
2080 {
2081 wt.tv_sec = timeout / 1000;
2082 wt.tv_usec = (timeout % 1000)*1000;
2083 }
2084
2085 /* auxiliary variables */
2086 int i;
2087 int j;
2088 int k;
2089 int s;
2090 char fdmaskempty;
2091
2092 /* check the links and fill in fdmask */
2093 /* check ssi links for ungetc_buf */
2094 for(i=L->nr; i>=0; i--)
2095 {
2096 if (L->m[i].Typ()!=DEF_CMD)
2097 {
2098 if (L->m[i].Typ()!=LINK_CMD)
2099 { WerrorS("all elements must be of type link"); return -2;}
2100 l=(si_link)L->m[i].Data();
2101 if(SI_LINK_OPEN_P(l)==0)
2102 { WerrorS("all links must be open"); return -2;}
2103 if (((strcmp(l->m->type,"ssi")!=0) && (strcmp(l->m->type,"MPtcp")!=0))
2104 || ((strcmp(l->mode,"fork")!=0) && (strcmp(l->mode,"tcp")!=0)
2105 && (strcmp(l->mode,"launch")!=0) && (strcmp(l->mode,"connect")!=0)))
2106 {
2107 WerrorS("all links must be of type ssi:fork, ssi:tcp, ssi:connect");
2108 return -2;
2109 }
2110 if (strcmp(l->m->type,"ssi")==0)
2111 {
2112 d=(ssiInfo*)l->data;
2113 d_fd=d->fd_read;
2114 if (!s_isready(d->f_read))
2115 {
2116 if ((ignore==NULL) || (ignore[i]==FALSE))
2117 {
2118 FD_SET(d_fd, &fdmask);
2119 if (d_fd > max_fd) max_fd=d_fd;
2120 }
2121 }
2122 else
2123 return i+1;
2124 }
2125 else
2126 {
2127 Werror("wrong link type >>%s<<",l->m->type);
2128 return -2;
2129 }
2130 }
2131 }
2132 max_fd++;
2133 if (FD_SETSIZE<=max_fd)
2134 {
2135 Werror("file descriptor number too high (%d)",max_fd);
2136 return -2;
2137 }
2138
2139 /* check with select: chars waiting: no -> not ready */
2141 if (s==-1)
2142 {
2143 Werror("error in select call (errno:%d)",errno);
2144 return -2; /*error*/
2145 }
2146 if (s==0)
2147 {
2148 return 0; /*poll: not ready */
2149 }
2150 else /* s>0, at least one ready (the number of fd which are ready is s)*/
2151 {
2152 j=0;
2153 while (j<=max_fd) { if (FD_ISSET(j,&fdmask)) break; j++; }
2154 for(i=L->nr; i>=0; i--)
2155 {
2156 if (L->m[i].rtyp==LINK_CMD)
2157 {
2158 l=(si_link)L->m[i].Data();
2159 if (strcmp(l->m->type,"ssi")==0)
2160 {
2161 d=(ssiInfo*)l->data;
2162 d_fd=d->fd_read;
2163 if(j==d_fd) return i+1;
2164 }
2165 }
2166 }
2167 }
2168 return 0;
2169#endif
2170}
2171
2172int ssiBatch(const char *host, const char * port)
2173/* return 0 on success, >0 else*/
2174{
2176 char *buf=(char*)omAlloc(256);
2177 snprintf(buf,256,"ssi:connect %s:%s",host,port);
2178 slInit(l, buf);
2179 omFreeSize(buf,256);
2180 if (slOpen(l,SI_LINK_OPEN,NULL)) return 1;
2182
2183 idhdl id = enterid("link_ll", 0, LINK_CMD, &IDROOT, FALSE);
2184 IDLINK(id) = l;
2185
2186 loop
2187 {
2188 leftv h=ssiRead1(l); /*contains an exit.... */
2189 if (feErrors != NULL && *feErrors != '\0')
2190 {
2191 // handle errors:
2192 PrintS(feErrors); /* currently quite simple */
2193 *feErrors = '\0';
2194 }
2195 ssiWrite(l,h);
2196 h->CleanUp();
2198 }
2199 /* never reached*/
2200 _exit(0);
2201}
2202
2208{
2209 if (ssiReserved_P!=0)
2210 {
2211 WerrorS("ERROR already a reserved port requested");
2212 return 0;
2213 }
2214 int portno;
2216 if(ssiReserved_sockfd < 0)
2217 {
2218 WerrorS("ERROR opening socket");
2219 return 0;
2220 }
2221 memset((char *) &ssiResverd_serv_addr,0, sizeof(ssiResverd_serv_addr));
2222 portno = 1025;
2223 ssiResverd_serv_addr.sin_family = AF_INET;
2224 ssiResverd_serv_addr.sin_addr.s_addr = INADDR_ANY;
2225 do
2226 {
2227 portno++;
2228 ssiResverd_serv_addr.sin_port = htons(portno);
2229 if(portno > 50000)
2230 {
2231 WerrorS("ERROR on binding (no free port available?)");
2232 return 0;
2233 }
2234 }
2239 return portno;
2240}
2241
2244{
2245 if (ssiReserved_P==0)
2246 {
2247 WerrorS("ERROR no reserved port requested");
2248 return NULL;
2249 }
2250 struct sockaddr_in cli_addr;
2251 int clilen = sizeof(cli_addr);
2253 if(newsockfd < 0)
2254 {
2255 Werror("ERROR on accept (errno=%d)",errno);
2256 return NULL;
2257 }
2260 si_link_extension prev = s;
2261 while (strcmp(s->type, "ssi") != 0)
2262 {
2263 if (s->next == NULL)
2264 {
2265 prev = s;
2266 s = NULL;
2267 break;
2268 }
2269 else
2270 {
2271 s = s->next;
2272 }
2273 }
2274 if (s != NULL)
2275 l->m = s;
2276 else
2277 {
2279 prev->next=slInitSsiExtension(ns);
2280 l->m = prev->next;
2281 }
2282 l->name=omStrDup("");
2283 l->mode=omStrDup("tcp");
2284 l->ref=1;
2285 ssiInfo *d=(ssiInfo*)omAlloc0(sizeof(ssiInfo));
2286 l->data=d;
2287 d->fd_read = newsockfd;
2288 d->fd_write = newsockfd;
2289 d->f_read = s_open(newsockfd);
2290 d->f_write = fdopen(newsockfd, "w");
2293 if (ssiReserved_Clients<=0)
2294 {
2295 ssiReserved_P=0;
2297 }
2298 return l;
2299}
2300/*---------------------------------------------------------------------*/
2301/**
2302 * @brief additional default signal handler
2303
2304 // some newer Linux version cannot have SIG_IGN for SIGCHLD,
2305 // so use this nice routine here:
2306 // SuSe 9.x reports -1 always
2307 // Redhat 9.x/FC x reports sometimes -1
2308 // see also: hpux_system
2309 // also needed by getrusage (timer etc.)
2310
2311 @param[in] sig
2312**/
2313/*---------------------------------------------------------------------*/
2315{
2316 pid_t kidpid;
2317 int status;
2318
2319#if 0
2320 loop
2321 {
2323 if (kidpid==-1)
2324 {
2325 /* continue on interruption (EINTR): */
2326 if (errno == EINTR) continue;
2327 /* break on anything else (EINVAL or ECHILD according to manpage): */
2328 break;
2329 }
2330 else if (kidpid==0) break; /* no more children to process, so break */
2331
2332 //printf("Child %ld terminated\n", kidpid);
2334 while((hh!=NULL)&&(ssiToBeClosed_inactive))
2335 {
2336 if((hh->l!=NULL) && (hh->l->m->Open==ssiOpen))
2337 {
2338 ssiInfo *d = (ssiInfo *)hh->l->data;
2339 if(d->pid==kidpid)
2340 {
2342 {
2344 slClose(hh->l);
2346 break;
2347 }
2348 else break;
2349 }
2350 else hh=(link_list)hh->next;
2351 }
2352 else hh=(link_list)hh->next;
2353 }
2354 }
2355#endif
2356}
2357
2359{
2360 int type_id = IDTYP(h);
2361
2362 // C-proc not to be dumped, also LIB-proc not
2363 if (type_id == PROC_CMD)
2364 {
2365 if (IDPROC(h)->language == LANG_C) return FALSE;
2366 if (IDPROC(h)->libname != NULL) return FALSE;
2367 }
2368 // do not dump links
2369 if (type_id == LINK_CMD) return FALSE;
2370
2371 // do not dump ssi internal rings: ssiRing*
2372 if ((type_id == RING_CMD) && (strncmp(IDID(h),"ssiRing",7)==0))
2373 return FALSE;
2374
2375 // do not dump default cring:
2376 if (type_id == CRING_CMD)
2377 {
2378 if (strcmp(IDID(h),"ZZ")==0) return FALSE;
2379 if (strcmp(IDID(h),"QQ")==0) return FALSE;
2380 #ifdef SINGULAR_4_2
2381 if (strcmp(IDID(h),"AE")==0) return FALSE;
2382 if (strcmp(IDID(h),"QAE")==0) return FALSE;
2383 #endif
2384 }
2385
2386 command D=(command)omAlloc0(sizeof(*D));
2387 sleftv tmp;
2388 memset(&tmp,0,sizeof(tmp));
2389 tmp.rtyp=COMMAND;
2390 tmp.data=D;
2391
2392 if (type_id == PACKAGE_CMD)
2393 {
2394 // do not dump Top, Standard
2395 if ((strcmp(IDID(h), "Top") == 0)
2396 || (strcmp(IDID(h), "Standard") == 0))
2397 {
2398 omFreeSize(D,sizeof(*D));
2399 return FALSE;
2400 }
2401 package p=(package)IDDATA(h);
2402 // dump Singular-packages as LIB("...");
2403 if (p->language==LANG_SINGULAR)
2404 {
2405 D->op=LOAD_CMD;
2406 D->argc=2;
2407 D->arg1.rtyp=STRING_CMD;
2408 D->arg1.data=p->libname;
2409 D->arg2.rtyp=STRING_CMD;
2410 D->arg2.data=(char*)"with";
2411 ssiWrite(l,&tmp);
2412 omFreeSize(D,sizeof(*D));
2413 return FALSE;
2414 }
2415 // dump Singular-packages as load("...");
2416 else if (p->language==LANG_C)
2417 {
2418 D->op=LOAD_CMD;
2419 D->argc=1;
2420 D->arg1.rtyp=STRING_CMD;
2421 D->arg1.data=p->libname;
2422 ssiWrite(l,&tmp);
2423 omFreeSize(D,sizeof(*D));
2424 return FALSE;
2425 }
2426 }
2427
2428 // put type and name
2429 //Print("generic dump:%s,%s\n",IDID(h),Tok2Cmdname(IDTYP(h)));
2430 D->op='=';
2431 D->argc=2;
2432 D->arg1.rtyp=DEF_CMD;
2433 D->arg1.name=IDID(h);
2434 D->arg2.rtyp=IDTYP(h);
2435 D->arg2.data=IDDATA(h);
2436 ssiWrite(l,&tmp);
2437 omFreeSize(D,sizeof(*D));
2438 return FALSE;
2439}
2441{
2442 if (h == NULL) return FALSE;
2443
2444 if (ssiDumpIter(l, IDNEXT(h))) return TRUE;
2445
2446 // need to set the ring before writing it, otherwise we get in
2447 // trouble with minpoly
2448 if (IDTYP(h) == RING_CMD)
2449 rSetHdl(h);
2450
2451 if (DumpSsiIdhdl(l, h)) return TRUE;
2452
2453 // do not dump ssi internal rings: ssiRing*
2454 // but dump objects of all other rings
2455 if ((IDTYP(h) == RING_CMD)
2456 && (strncmp(IDID(h),"ssiRing",7)!=0))
2457 return ssiDumpIter(l, IDRING(h)->idroot);
2458 else
2459 return FALSE;
2460}
2462{
2465
2466 //if (! status ) status = DumpAsciiMaps(fd, h, NULL);
2467
2468 if (currRingHdl != rh) rSetHdl(rh);
2469 //fprintf(fd, "option(set, intvec(%d, %d));\n", si_opt_1, si_opt_2);
2470
2471 return status;
2472}
2474{
2475 ssiInfo *d=(ssiInfo*)l->data;
2476 loop
2477 {
2478 if (!SI_LINK_OPEN_P(l)) break;
2479 if (s_iseof(d->f_read)) break;
2480 leftv h=ssiRead1(l); /*contains an exit.... */
2481 if (feErrors != NULL && *feErrors != '\0')
2482 {
2483 // handle errors:
2484 PrintS(feErrors); /* currently quite simple */
2485 return TRUE;
2486 *feErrors = '\0';
2487 }
2488 h->CleanUp();
2490 }
2491 return FALSE;
2492}
2493
2495{
2497 while(hh!=NULL)
2498 {
2499 if ((hh->l->m!=NULL)
2500 && (hh->l->m->Open==ssiOpen)
2501 && SI_LINK_OPEN_P(hh->l)
2502 && (strcmp(hh->l->mode, "fork")==0))
2503 {
2505 ssiInfo *d = (ssiInfo *)hh->l->data;
2506 if (d->f_read!=NULL) { s_close(d->f_read);d->f_read=NULL;}
2507 if (d->f_write!=NULL) { fclose(d->f_write); d->f_write=NULL; }
2508 }
2509 hh=(link_list)hh->next;
2510 }
2512}
2513// ----------------------------------------------------------------
2514// format
2515// 1 int %d
2516// 2 string <len> %s
2517// 3 number
2518// 4 bigint 4 %d or 3 <mpz_t>
2519// 5 ring
2520// 6 poly
2521// 7 ideal
2522// 8 matrix
2523// 9 vector
2524// 10 module
2525// 11 command
2526// 12 def <len> %s
2527// 13 proc <len> %s
2528// 14 list %d <elem1> ....
2529// 15 setring .......
2530// 16 nothing
2531// 17 intvec <len> ...
2532// 18 intmat
2533// 19 bigintmat <r> <c> ...
2534// 20 blackbox <name> <len> ...
2535// 21 attrib <bit-attrib> <len> <a-name1> <val1>... <data>
2536// 22 smatrix
2537// 23 0 <log(bitmask)> ring properties: max.exp.
2538// 23 1 <log(bitmask)> <r->IsLPRing> ring properties:LPRing
2539// 23 2 <matrix C> <matrix D> ring properties: PLuralRing
2540// 24 bigintvec <c>
2541//
2542// 98: verify version: <ssi-version> <MAX_TOK> <OPT1> <OPT2>
2543// 99: quit Singular
#define BITSET
Definition auxiliary.h:85
int BOOLEAN
Definition auxiliary.h:88
#define TRUE
Definition auxiliary.h:101
#define FALSE
Definition auxiliary.h:97
blackbox * getBlackboxStuff(const int t)
return the structure to the type given by t
Definition blackbox.cc:17
int blackboxIsCmd(const char *n, int &tok)
used by scanner: returns ROOT_DECL for known types (and the type number in tok)
Definition blackbox.cc:219
const CanonicalForm CFMap CFMap & N
Definition cfEzgcd.cc:56
int l
Definition cfEzgcd.cc:100
int m
Definition cfEzgcd.cc:128
int i
Definition cfEzgcd.cc:132
int k
Definition cfEzgcd.cc:99
int p
Definition cfModGcd.cc:4086
CanonicalForm cf
Definition cfModGcd.cc:4091
CanonicalForm b
Definition cfModGcd.cc:4111
FILE * f
Definition checklibs.c:9
Matrices of numbers.
Definition bigintmat.h:51
Definition idrec.h:35
Definition attrib.h:21
attr next
Definition attrib.h:26
Class used for (list of) interpreter objects.
Definition subexpr.h:83
int Typ()
Definition subexpr.cc:1048
const char * name
Definition subexpr.h:87
int rtyp
Definition subexpr.h:91
void * Data()
Definition subexpr.cc:1192
leftv next
Definition subexpr.h:86
const char * Name()
Definition subexpr.h:120
void * data
Definition subexpr.h:88
attr * Attribute()
Definition subexpr.cc:1505
BITSET flag
Definition subexpr.h:90
Definition lists.h:24
sleftv * m
Definition lists.h:46
INLINE_THIS void Init(int l=0)
int nr
Definition lists.h:44
VAR BOOLEAN singular_in_batchmode
Definition cntrlc.cc:62
si_hdl_typ si_set_signal(int sig, si_hdl_typ signal_handler)
meta function for binding a signal to an handler
Definition cntrlc.cc:121
void sig_term_hdl(int)
Definition cntrlc.cc:77
static FORCE_INLINE number n_ReadFd(const ssiInfo *f, const coeffs r)
io via ssi:
Definition coeffs.h:971
static FORCE_INLINE void n_WriteFd(number a, const ssiInfo *f, const coeffs r)
io via ssi:
Definition coeffs.h:967
@ n_algExt
used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic
Definition coeffs.h:35
@ n_transExt
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
Definition coeffs.h:38
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition numbers.cc:406
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition coeffs.h:429
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition coeffs.h:448
static FORCE_INLINE char * nCoeffName(const coeffs cf)
Definition coeffs.h:960
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition coeffs.h:539
#define Print
Definition emacs.cc:80
#define Warn
Definition emacs.cc:77
#define WarnS
Definition emacs.cc:78
const CanonicalForm int s
Definition facAbsFact.cc:51
CanonicalForm res
Definition facAbsFact.cc:60
const Variable & v
< [in] a sqrfree bivariate poly
Definition facBivar.h:39
int j
Definition facHensel.cc:110
char name(const Variable &v)
Definition factory.h:189
VAR short errorreported
Definition feFopen.cc:23
void WerrorS(const char *s)
Definition feFopen.cc:24
FILE * myfopen(const char *path, const char *mode)
Definition feFopen.cc:167
const char * feSetOptValue(feOptIndex opt, char *optarg)
Definition feOpt.cc:154
VAR char my_yylinebuf[80]
Definition febase.cc:44
char * fe_fgets_dummy(const char *, char *, int)
Definition feread.cc:455
char *(* fe_fgets_stdin)(const char *pr, char *s, int size)
Definition feread.cc:32
#define D(A)
Definition gentable.cc:128
#define STATIC_VAR
Definition globaldefs.h:7
#define EXTERN_VAR
Definition globaldefs.h:6
#define VAR
Definition globaldefs.h:5
@ IDEAL_CMD
Definition grammar.cc:285
@ MATRIX_CMD
Definition grammar.cc:287
@ BUCKET_CMD
Definition grammar.cc:284
@ BIGINTMAT_CMD
Definition grammar.cc:278
@ PROC_CMD
Definition grammar.cc:281
@ INTMAT_CMD
Definition grammar.cc:280
@ MODUL_CMD
Definition grammar.cc:288
@ SMATRIX_CMD
Definition grammar.cc:292
@ VECTOR_CMD
Definition grammar.cc:293
@ BIGINTVEC_CMD
Definition grammar.cc:279
@ NUMBER_CMD
Definition grammar.cc:289
@ POLY_CMD
Definition grammar.cc:290
@ RING_CMD
Definition grammar.cc:282
idhdl enterid(const char *s, int lev, int t, idhdl *root, BOOLEAN init, BOOLEAN search)
Definition ipid.cc:281
VAR idhdl currRingHdl
Definition ipid.cc:59
VAR coeffs coeffs_BIGINT
Definition ipid.cc:50
#define IDNEXT(a)
Definition ipid.h:118
EXTERN_VAR omBin sleftv_bin
Definition ipid.h:145
ip_command * command
Definition ipid.h:23
#define IDDATA(a)
Definition ipid.h:126
#define IDPROC(a)
Definition ipid.h:140
#define IDLINK(a)
Definition ipid.h:138
#define IDID(a)
Definition ipid.h:122
#define IDROOT
Definition ipid.h:19
#define IDRING(a)
Definition ipid.h:127
#define IDTYP(a)
Definition ipid.h:119
char * iiGetLibProcBuffer(procinfo *pi, int part)
Definition iplib.cc:197
void rKill(ring r)
Definition ipshell.cc:6164
idhdl rFindHdl(ring r, idhdl n)
Definition ipshell.cc:1691
void rSetHdl(idhdl h)
Definition ipshell.cc:5112
STATIC_VAR jList * T
Definition janet.cc:30
STATIC_VAR Poly * h
Definition janet.cc:971
BOOLEAN nc_CallPlural(matrix cc, matrix dd, poly cn, poly dn, ring r, bool bSetupQuotient, bool bCopyInput, bool bBeQuiet, ring curr, bool dummy_ring=false)
returns TRUE if there were errors analyze inputs, check them for consistency detects nc_type,...
VAR omBin slists_bin
Definition lists.cc:23
#define SR_INT
Definition longrat.h:67
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition matpol.cc:37
#define MATELEM(mat, i, j)
1-based access to matrix
Definition matpol.h:29
ip_smatrix * matrix
Definition matpol.h:43
#define MATROWS(i)
Definition matpol.h:26
#define MATCOLS(i)
Definition matpol.h:27
void rem(unsigned long *a, unsigned long *q, unsigned long p, int &dega, int degq)
Definition minpoly.cc:572
#define TIMER_RESOLUTION
Definition mod2.h:35
#define assume(x)
Definition mod2.h:389
void m2_end(int i)
Definition misc_ip.cc:1102
#define p_GetComp(p, r)
Definition monomials.h:64
#define pIter(p)
Definition monomials.h:37
#define pNext(p)
Definition monomials.h:36
#define pSetCoeff0(p, n)
Definition monomials.h:59
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
Definition monomials.h:44
slists * lists
The main handler for Singular numbers which are suitable for Singular polynomials.
number ndReadFd(const ssiInfo *, const coeffs r)
Definition numbers.cc:150
coeffs nFindCoeffByName(char *cf_name)
find an existing coeff by its "CoeffName"
Definition numbers.cc:633
#define omStrDup(s)
#define omFreeSize(addr, size)
#define omAlloc(size)
#define omAlloc0Bin(bin)
#define omFree(addr)
#define omAlloc0(size)
#define omFreeBin(addr, bin)
#define omFreeBinAddr(addr)
#define NULL
Definition omList.c:12
VAR unsigned si_opt_2
Definition options.c:6
VAR unsigned si_opt_1
Definition options.c:5
#define TEST_OPT_PROT
Definition options.h:105
#define TEST_OPT_DEBUG
Definition options.h:110
static int index(p_Length length, p_Ord ord)
static int pLength(poly a)
Definition p_polys.h:190
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent @Note: VarOffset encodes the position in p->exp
Definition p_polys.h:489
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition p_polys.h:248
static void p_Setm(poly p, const ring r)
Definition p_polys.h:234
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
Definition p_polys.h:470
static void p_Delete(poly *p, const ring r)
Definition p_polys.h:902
static poly p_Init(const ring r, omBin bin)
Definition p_polys.h:1335
#define p_Test(p, r)
Definition p_polys.h:161
void rChangeCurrRing(ring r)
Definition polys.cc:15
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition polys.cc:13
#define NUM
Definition readcf.cc:180
void PrintS(const char *s)
Definition reporter.cc:284
VAR char * feErrors
Definition reporter.cc:47
void Werror(const char *fmt,...)
Definition reporter.cc:189
#define mflush()
Definition reporter.h:58
BOOLEAN rComplete(ring r, int force)
this needs to be called whenever a new ring is created: new fields in ring are created (like VarOffse...
Definition ring.cc:3481
void rUnComplete(ring r)
Definition ring.cc:4012
static unsigned long rGetExpSize(unsigned long bitmask, int &bits)
Definition ring.cc:2603
void rDelete(ring r)
unconditionally deletes fields in r
Definition ring.cc:452
ring rDefault(const coeffs cf, int N, char **n, int ord_size, rRingOrder_t *ord, int *block0, int *block1, int **wvhdl, unsigned long bitmask)
Definition ring.cc:103
BOOLEAN rEqual(ring r1, ring r2, BOOLEAN qr)
returns TRUE, if r1 equals r2 FALSE, otherwise Equality is determined componentwise,...
Definition ring.cc:1749
static BOOLEAN rField_is_Zp(const ring r)
Definition ring.h:505
static n_coeffType rFieldType(const ring r)
the type of the coefficient filed of r (n_Zp, n_Q, etc)
Definition ring.h:561
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition ring.h:405
static ring rIncRefCnt(ring r)
Definition ring.h:847
static BOOLEAN rIsLPRing(const ring r)
Definition ring.h:416
rRingOrder_t
order stuff
Definition ring.h:68
@ ringorder_a
Definition ring.h:70
@ ringorder_a64
for int64 weights
Definition ring.h:71
@ ringorder_L
Definition ring.h:90
@ ringorder_aa
for idElimination, like a, except pFDeg, pWeigths ignore it
Definition ring.h:92
@ ringorder_Wp
Definition ring.h:82
@ ringorder_ws
Definition ring.h:87
@ ringorder_Ws
Definition ring.h:88
@ ringorder_IS
Induced (Schreyer) ordering.
Definition ring.h:94
@ ringorder_wp
Definition ring.h:81
@ ringorder_M
Definition ring.h:74
static BOOLEAN rField_is_Q(const ring r)
Definition ring.h:511
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition ring.h:597
idrec * idhdl
Definition ring.h:21
int raise_rlimit_nproc()
Definition rlimit.c:18
s_buff s_open(int fd)
Definition s_buff.cc:31
int s_getc(s_buff F)
Definition s_buff.cc:58
int s_isready(s_buff F)
Definition s_buff.cc:85
int s_readint(s_buff F)
Definition s_buff.cc:112
int s_close(s_buff &F)
Definition s_buff.cc:45
s_buff s_open_by_name(const char *n)
Definition s_buff.cc:39
int s_readbytes(char *buff, int len, s_buff F)
Definition s_buff.cc:168
int s_iseof(s_buff F)
Definition s_buff.cc:254
void s_ungetc(int c, s_buff F)
Definition s_buff.cc:99
int fd_write
Definition s_buff.h:26
ring rings[SI_RING_CACHE]
Definition s_buff.h:31
pid_t pid
Definition s_buff.h:25
s_buff f_read
Definition s_buff.h:22
#define SI_RING_CACHE
Definition s_buff.h:30
char send_quit_at_exit
Definition s_buff.h:28
char level
Definition s_buff.h:27
char quit_sent
Definition s_buff.h:29
FILE * f_write
Definition s_buff.h:23
ring r
Definition s_buff.h:24
int fd_read
Definition s_buff.h:26
poly sBucketPeek(sBucket_pt b)
Definition sbuckets.cc:455
ring sBucketGetRing(const sBucket_pt bucket)
Returns bucket ring.
Definition sbuckets.cc:46
sBucket * sBucket_pt
Definition sbuckets.h:16
VAR int sem_acquired[SIPC_MAX_SEMAPHORES]
Definition semaphore.c:25
static int SI_LOG2(int v)
Definition si_log2.h:6
int * status
Definition si_signals.h:61
int status int fd
Definition si_signals.h:69
int status int void * buf
Definition si_signals.h:69
ideal idInit(int idsize, int rank)
initialise an ideal / module
VAR omBin sip_sideal_bin
#define IDELEMS(i)
#define SIPC_MAX_SEMAPHORES
Definition simpleipc.h:10
#define R
Definition sirandom.c:27
#define M
Definition sirandom.c:25
sleftv * leftv
Definition structs.h:53
#define loop
Definition structs.h:71
procinfo * procinfov
Definition structs.h:56
VAR omBin procinfo_bin
Definition subexpr.cc:42
@ LANG_SINGULAR
Definition subexpr.h:22
@ LANG_C
Definition subexpr.h:22
#define SR_HDL(A)
Definition tgb.cc:35
int getRTimer()
Definition timer.cc:150
#define IDHDL
Definition tok.h:31
@ BIGINT_CMD
Definition tok.h:38
@ CRING_CMD
Definition tok.h:56
@ LIST_CMD
Definition tok.h:118
@ INTVEC_CMD
Definition tok.h:101
@ PACKAGE_CMD
Definition tok.h:150
@ DEF_CMD
Definition tok.h:58
@ LINK_CMD
Definition tok.h:117
@ STRING_CMD
Definition tok.h:187
@ LOAD_CMD
Definition tok.h:119
@ INT_CMD
Definition tok.h:96
@ MAX_TOK
Definition tok.h:220
#define NONE
Definition tok.h:223
#define COMMAND
Definition tok.h:29
struct for passing initialization parameters to naInitChar
Definition transext.h:88