Changeset df326b in git


Ignore:
Timestamp:
Feb 19, 2013, 9:43:53 PM (11 years ago)
Author:
Oleksandr Motsak <motsak@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', '4188d308699580d975efd0f6cca8dcb41c396f70')
Children:
20fee797b7a66e0f0dd4d487a5647e70eeee2f8e
Parents:
44ca2ffccdd8d9f8f06ceab239425b54669e3200
git-author:
Oleksandr Motsak <motsak@mathematik.uni-kl.de>2013-02-19 21:43:53+01:00
git-committer:
Oleksandr Motsak <motsak@mathematik.uni-kl.de>2013-02-20 14:50:04+01:00
Message:
Updates due to master (links) + SW adaptation/separation
Location:
Singular/links
Files:
1 added
10 edited

Legend:

Unmodified
Added
Removed
  • Singular/links/ndbm.cc

    r44ca2f rdf326b  
    291291#endif
    292292    }
    293     short tmp;
    294     memcpy(&tmp, db->dbm_pagbuf, sizeof(short));
    295     if (tmp != 0)
     293    if (((short *)db->dbm_pagbuf)[0] != 0)
    296294    {
    297295      item = makdatum(db->dbm_pagbuf, db->dbm_keyptr);
     
    430428        29, 25, 21, 17, 13,  9,  5,  1,
    431429};
    432 static unsigned long hltab[64]
     430static long hltab[64]
    433431 = {
    434432        06100151277L,06106161736L,06452611562L,05001724107L,
     
    454452  register int s, c, j;
    455453  register char *cp;
    456   register unsigned long hashl;
    457   register unsigned int hashi;
     454  register long hashl;
     455  register int hashi;
    458456
    459457  hashl = 0;
     
    469467    }
    470468  }
    471   return (long)(hashl);
     469  return (hashl);
    472470}
    473471
  • Singular/links/s_buff.cc

    r44ca2f rdf326b  
    11#include <unistd.h>
     2#include <stdio.h>
    23#include <ctype.h>
    34#include <sys/types.h>
     
    2122//typedef struct s_buff_s * s_buff;
    2223
    23 #define S_BUFF_LEN 8192
     24#define S_BUFF_LEN 4096
    2425
    2526sigset_t ssi_sigmask; // set in ssiLink.cc
     
    5253  {
    5354    SSI_BLOCK_CHLD;
    54       #ifdef TEST_SBUFF
    55       printf("%d bytes read, %d read op.\n",F->len[10],F->len[0]);
    56       if (F->len[1]>0) printf("%d read op with <16 bytes\n",F->len[1]);
    57       if (F->len[2]>0) printf("%d read op with <32 bytes\n",F->len[2]);
    58       if (F->len[3]>0) printf("%d read op with <54 bytes\n",F->len[3]);
    59       if (F->len[4]>0) printf("%d read op with <128 bytes\n",F->len[4]);
    60       if (F->len[5]>0) printf("%d read op with <256 bytes\n",F->len[5]);
    61       if (F->len[6]>0) printf("%d read op with <512 bytes\n",F->len[6]);
    62       if (F->len[7]>0) printf("%d read op with <1024 bytes\n",F->len[7]);
    63       if (F->len[8]>0) printf("%d read op with <2048 bytes\n",F->len[8]);
    64       if (F->len[9]>0) printf("%d read op with >=2048 bytes\n",F->len[9]);
    65       #endif
    6655    omFreeSize(F->buff,S_BUFF_LEN);
    6756    int r=close(F->fd);
     
    9685      F->end=r-1;
    9786      F->bp=0;
    98       #ifdef TEST_SBUFF
    99       F->len[0]++;
    100       if (r<16) F->len[1]++;
    101       else if (r<32) F->len[2]++;
    102       else if (r<64) F->len[3]++;
    103       else if (r<128) F->len[4]++;
    104       else if (r<256) F->len[5]++;
    105       else if (r<512) F->len[6]++;
    106       else if (r<1024) F->len[7]++;
    107       else if (r<2048) F->len[8]++;
    108       else  F->len[9]++;
    109       F->len[10]+=r;
    110       #endif
    11187      return F->buff[0];
    11288    }
     
    135111  {
    136112    printf("link closed");
    137     return;
    138   }
    139   if (F->bp>=0)
     113  }
     114  else if (F->bp>=0)
    140115  {
    141116    F->buff[F->bp]=c;
     
    172147}
    173148
     149long s_readlong(s_buff F)
     150{
     151  if (F==NULL)
     152  {
     153    printf("link closed");
     154    return 0;
     155  }
     156  char c;
     157  long neg=1;
     158  long r=0;
     159  //int digit=0;
     160  do
     161  {
     162    c=s_getc(F);
     163  } while((!F->is_eof) && (c<=' '));
     164  if (c=='-') { neg=-1; c=s_getc(F); }
     165  while(isdigit(c))
     166  {
     167    //digit++;
     168    r=r*10+(c-'0');
     169    c=s_getc(F);
     170  }
     171  s_ungetc(c,F);
     172  //if (digit==0) { printf("unknown char %c(%d)\n",c,c); /*debug*/
     173  //                printf("buffer:%s\np=%d,e=%d\n",F->buff,F->bp,F->end);fflush(stdout); } /*debug*/
     174  return r*neg;
     175}
     176
    174177int s_readbytes(char *buff,int len, s_buff F)
    175178{
     
    254257  if (neg==-1) mpz_neg(a,a);
    255258}
    256 
    257259int s_iseof(s_buff F)
    258260{
  • Singular/links/s_buff.h

    r44ca2f rdf326b  
    33
    44#include<signal.h>
    5 
    6 //#define TEST_SBUFF
    75
    86struct s_buff_s
     
    1311    int end;     // last position in buff
    1412    int is_eof;
    15     #ifdef TEST_SBUFF
    16     int len[11];
    17     #endif
    1813};
    1914
     
    2823
    2924int s_readint(s_buff F);
     25long s_readlong(s_buff F);
    3026int s_readbytes(char *buff,int len, s_buff F);
    3127void s_readmpz(s_buff F, mpz_ptr a);
  • Singular/links/semaphore.c

    r44ca2f rdf326b  
    55#include <stdio.h>
    66#include <stdlib.h>
    7 #include <Singular/mod2.h>
     7
     8#include <kernel/mod2.h>
    89
    910#ifdef HAVE_SIMPLEIPC
  • Singular/links/silink.cc

    r44ca2f rdf326b  
    220220}
    221221
     222BOOLEAN slPrepClose(si_link l)
     223{
     224
     225  if(! SI_LINK_OPEN_P(l))
     226    return FALSE;
     227
     228  BOOLEAN res = TRUE;
     229  if (l->m->PrepClose != NULL)
     230  {
     231    res = l->m->PrepClose(l);
     232    if (res)
     233      Werror("close: Error for link of type: %s, mode: %s, name: %s",
     234           l->m->type, l->mode, l->name);
     235  }
     236  return res;
     237}
     238
    222239BOOLEAN slClose(si_link l)
    223240{
     
    339356      Werror("dump: Error for link of type %s, mode: %s, name: %s",
    340357             l->m->type, l->mode, l->name);
    341 
    342358    if (!SI_LINK_R_OPEN_P(l)) slClose(l); // do not close r/w links
    343359    return res;
     
    383399
    384400/* =============== ASCII ============================================= */
    385 BOOLEAN slOpenAscii(si_link l, short flag, leftv)
     401BOOLEAN slOpenAscii(si_link l, short flag, leftv h)
    386402{
    387403  const char *mode;
     
    841857  si_link_extension ns = (si_link_extension)omAlloc0Bin(s_si_link_extension_bin);
    842858
    843   if (0) 0;
     859  if (0) 0; // dummy
    844860#ifdef HAVE_DBM
    845861  else if (strcmp(type, "DBM") == 0)
     
    877893  si_link_root->Open=slOpenAscii;
    878894  si_link_root->Close=slCloseAscii;
    879   si_link_root->Kill=slCloseAscii;
     895  si_link_root->Kill=NULL;
    880896  si_link_root->Read=slReadAscii;
    881897  si_link_root->Read2=slReadAscii2;
  • Singular/links/silink.h

    r44ca2f rdf326b  
    2323typedef BOOLEAN    (*slWriteProc)(si_link l, leftv lv);
    2424typedef BOOLEAN    (*slCloseProc)(si_link l);
     25typedef BOOLEAN    (*slPrepCloseProc)(si_link l);
    2526typedef BOOLEAN    (*slKillProc)(si_link l);
    2627typedef leftv      (*slReadProc)(si_link l);
     
    3536  slOpenProc       Open;
    3637  slCloseProc      Close;
     38  slPrepCloseProc  PrepClose;
    3739  slKillProc       Kill;
    3840  slReadProc       Read;
     
    7678BOOLEAN slOpen(si_link l, short flag, leftv h);
    7779BOOLEAN slClose(si_link l);
     80BOOLEAN slPrepClose(si_link l);
    7881leftv   slRead(si_link l,leftv a=NULL);
    7982BOOLEAN slWrite(si_link l, leftv v);
     
    9396
    9497#include <omalloc/omalloc.h>
    95 
    9698inline char* slString(si_link l)
    9799{
     
    122124
    123125extern link_list ssiToBeClosed;
     126extern BOOLEAN ssiToBeClosed_inactive;
    124127#endif // SILINK_H
  • Singular/links/sing_dbm.cc

    r44ca2f rdf326b  
    33****************************************/
    44
    5 //**************************************************************************/
    6 //
    7 //
    85//**************************************************************************/
    96//  'sing_dbm.cc' containes command to handle dbm-files under
  • Singular/links/slInit_Dynamic.cc

    r44ca2f rdf326b  
    3737  s->Open=(slOpenProc)dynl_sym_warn(handle, "dbOpen");
    3838  s->Close=(slCloseProc)dynl_sym_warn(handle, "dbClose");
    39   s->Kill=(slKillProc)dynl_sym_warn(handle, "dbClose");
     39  s->Kill=NULL;
    4040  s->Read=(slReadProc)dynl_sym_warn(handle, "dbRead1");
    4141  s->Read2=(slRead2Proc)dynl_sym_warn(handle, "dbRead2");
    4242  s->Write=(slWriteProc)dynl_sym_warn(handle, "dbWrite");
    4343
    44   if (s->Open == NULL || s->Close == NULL || s->Kill == NULL ||
     44  if (s->Open == NULL || s->Close == NULL ||
    4545      s->Read == NULL || s->Read2 == NULL)
    4646    return NULL;
  • Singular/links/ssiLink.cc

    r44ca2f rdf326b  
    2626#include <kernel/mod2.h>
    2727
    28 #include <Singular/tok.h>
    29 #include <Singular/ipshell.h>
    30 #include <Singular/ipid.h>
    3128#include <omalloc/omalloc.h>
     29
     30#include <misc/intvec.h>
     31#include <misc/options.h>
     32
    3233#include <polys/monomials/ring.h>
    3334#include <polys/matpol.h>
     35
     36#include <coeffs/bigintmat.h>
     37
    3438#include <kernel/ideals.h>
    3539#include <kernel/polys.h>
    3640#include <kernel/longrat.h>
    3741#include <kernel/ideals.h>
    38 #include <misc/intvec.h>
    39 #include <misc/options.h>
    4042#include <kernel/timer.h>
     43
     44#include <Singular/tok.h>
     45#include <Singular/ipshell.h>
     46#include <Singular/ipid.h>
     47
    4148#include <Singular/subexpr.h>
    42 #include <Singular/links/silink.h>
    4349#include <Singular/cntrlc.h>
    4450#include <Singular/lists.h>
    4551#include <Singular/blackbox.h>
     52
     53#include <Singular/links/silink.h>
    4654#include <Singular/links/s_buff.h>
    4755#include <Singular/links/ssiLink.h>
     56
     57// TODO: use number n_InitMPZ(mpz_t n, coeffs_BIGINT) instead!?
    4858
    4959struct snumber_dummy
     
    5868typedef struct snumber_dummy  *number_dummy;
    5969
     70#ifdef HAVE_SIMPLEIPC
     71#include <Singular/simpleipc.h>
     72#endif
    6073//#if (_POSIX_C_SOURCE >= 200112L) || (_XOPEN_SOURCE >= 600)
    6174//#define HAVE_PSELECT
    6275//#endif
    6376
    64 #define SSI_VERSION 4
    65 
     77#define SSI_VERSION 5
     78
     79// 64 bit version:
     80//#if SIZEOF_LONG == 8
     81#if 0
     82#define MAX_NUM_SIZE 60
     83#define POW_2_28 (1L<<60)
     84#define LONG long
     85#else
     86// 32 bit version:
     87#define MAX_NUM_SIZE 28
     88#define POW_2_28 (1L<<28)
     89#define LONG int
     90#endif
    6691typedef struct
    6792{
     
    7398  char level;
    7499  char send_quit_at_exit;
     100  char quit_sent;
    75101
    76102} ssiInfo;
    77 
    78103
    79104link_list ssiToBeClosed=NULL;
     
    126151  //        or     3 3 <mpz_t nominator>
    127152  SSI_BLOCK_CHLD;
    128   if((long)(n) & SR_INT)
     153  if(SR_HDL(n) & SR_INT)
    129154  {
    130155    fprintf(d->f_write,"4 %ld ",SR_TO_INT(n));
     
    164189    if(SR_HDL(n) & SR_INT)
    165190    {
    166       fprintf(d->f_write,"4 %ld ",SR_TO_INT(n));
     191      #if SIZEOF_LONG == 4
     192      fprintf(d->f_write,"4 %d ",((LONG)SR_TO_INT(n)));
     193      #else
     194      long nn=SR_TO_INT(n);
     195      if ((nn<POW_2_28)||(nn>= -POW_2_28))
     196        fprintf(d->f_write,"4 %d ",((LONG)nn)); // NOTE: use %ld once LONG can be long !!!
     197      else
     198      {
     199        mpz_t tmp;
     200        mpz_init_set_si(tmp,nn);
     201        fputs("8 ",d->f_write);
     202        mpz_out_str (d->f_write,32, tmp);
     203        fputc(' ',d->f_write);
     204        mpz_clear(tmp);
     205      }
     206      #endif
    167207      //if (d->f_debug!=NULL) fprintf(d->f_debug,"number: short \"%ld\" ",SR_TO_INT(n));
    168208    }
     
    229269      }
    230270      break;
     271
    231272      case ringorder_a64:
    232273      case ringorder_M:
     
    243284}
    244285
    245 void ssiWritePoly(ssiInfo *d, poly p)
     286void ssiWritePoly(ssiInfo *d, int typ, poly p)
    246287{
    247288  SSI_BLOCK_CHLD;
    248289  fprintf(d->f_write,"%d ",pLength(p));//number of terms
    249290  SSI_UNBLOCK_CHLD;
     291  int i;
    250292
    251293  while(p!=NULL)
     
    267309void ssiWriteIdeal(ssiInfo *d, int typ,ideal I)
    268310{
    269    // syntax ideal/module: 7 # of elements <poly 1> <poly2>.....
    270    // syntax matrix: 8 <rows> <cols> <poly 1> <poly2>.....
     311   // syntax: 7 # of elements <poly 1> <poly2>.....
     312   // syntax: 8 <rows> <cols> <poly 1> <poly2>.....
    271313   matrix M=(matrix)I;
     314   int mn;
    272315   SSI_BLOCK_CHLD;
    273316   if (typ==MATRIX_CMD)
    274         fprintf(d->f_write,"%d %d ", MATROWS(M),MATCOLS(M));
     317   {
     318     mn=MATROWS(M)*MATCOLS(M);
     319     fprintf(d->f_write,"%d %d ", MATROWS(M),MATCOLS(M));
     320   }
    275321   else
     322   {
     323     mn=IDELEMS(I);
    276324     fprintf(d->f_write,"%d ",IDELEMS(I));
     325   }
    277326    SSI_UNBLOCK_CHLD;
    278327
    279328   int i;
    280 
    281    for(i=0;i<IDELEMS(I);i++)
     329   int tt;
     330   if (typ==MODUL_CMD) tt=VECTOR_CMD;
     331   else                tt=POLY_CMD;
     332
     333   for(i=0;i<mn;i++)
    282334   {
    283      ssiWritePoly(d,I->m[i]);
     335     ssiWritePoly(d,tt,I->m[i]);
    284336   }
    285337}
     338
    286339void ssiWriteCommand(si_link l, command D)
    287340{
     
    312365{
    313366  ssiInfo *d=(ssiInfo*)l->data;
     367  int Ll=lSize(dd);
    314368  SSI_BLOCK_CHLD;
    315   fprintf(d->f_write,"%d ",dd->nr+1);
     369  fprintf(d->f_write,"%d ",Ll+1);
    316370  SSI_UNBLOCK_CHLD;
    317371  int i;
    318   for(i=0;i<=dd->nr;i++)
     372  for(i=0;i<=Ll;i++)
    319373  {
    320374    ssiWrite(l,&(dd->m[i]));
     
    340394  {
    341395    fprintf(d->f_write,"%d ",(*v)[i]);
     396  }
     397  SSI_UNBLOCK_CHLD;
     398}
     399
     400void ssiWriteBigintmat(ssiInfo *d,bigintmat * v)
     401{
     402  SSI_BLOCK_CHLD;
     403  fprintf(d->f_write,"%d %d ",v->rows(),v->cols());
     404  int i;
     405  for(i=0;i<v->length();i++)
     406  {
     407    ssiWriteBigInt(d,(*v)[i]);
    342408  }
    343409  SSI_UNBLOCK_CHLD;
     
    387453}
    388454
    389 number ssiReadNumber(ssiInfo *d)
    390 {
    391   if (rField_is_Q(d->r))
    392   {
    393      int sub_type=s_readint(d->f_read);
    394      switch(sub_type)
    395      {
     455static number ssiReadQNumber(ssiInfo *d)
     456{
     457  int sub_type=-1;
     458  sub_type=s_readint(d->f_read);
     459  switch(sub_type)
     460  {
    396461     case 0:
    397462     case 1:
     
    417482       {
    418483         int dd=s_readint(d->f_read);
    419          return n_Init(dd,d->r->cf);
     484         return n_Init(dd,coeffs_BIGINT);
    420485       }
    421486     case 5:
     
    441506     default: Werror("error in reading number: invalid subtype %d",sub_type);
    442507              return NULL;
    443      }
     508  }
     509  return NULL;
     510}
     511number ssiReadNumber(ssiInfo *d)
     512{
     513  if (rField_is_Q(d->r))
     514  {
     515     return ssiReadQNumber(d);
    444516  }
    445517  else if (rField_is_Zp(d->r))
     
    456528{
    457529/* syntax is <ch> <N> <l1> <v1> ...<lN> <vN> <number of orderings> <ord1> <block0_1> <block1_1> .... */
    458   int ch, N,i;
     530  int ch, N,i,l;
    459531  char **names;
    460532  ch=s_readint(d->f_read);
     
    513585  //Print("poly: terms:%d\n",n);
    514586  poly p;
     587  int j;
     588  j=0;
    515589  poly ret=NULL;
    516590  poly prev=NULL;
     
    658732  return v;
    659733}
     734bigintmat* ssiReadBigintmat(ssiInfo *d)
     735{
     736  int r,c;
     737  r=s_readint(d->f_read);
     738  c=s_readint(d->f_read);
     739  bigintmat *v=new bigintmat(r,c,coeffs_BIGINT);
     740  for(int i=0;i<r*c;i++)
     741  {
     742    (*v)[i]=ssiReadBigInt(d);
     743  }
     744  return v;
     745}
    660746
    661747void ssiReadBlackbox(leftv res, si_link l)
     
    720806        int pc[2];
    721807        int cp[2];
    722         SSI_BLOCK_CHLD;
     808        SSI_BLOCK_CHLD;
    723809        pipe(pc);
    724810        pipe(cp);
    725811        pid_t pid=fork();
    726         SSI_UNBLOCK_CHLD;
     812        SSI_UNBLOCK_CHLD;
    727813        if (pid==0) /*fork: child*/
    728814        {
     
    731817          while(hh!=NULL)
    732818          {
    733             SI_LINK_SET_CLOSE_P(hh->l);
     819            SI_LINK_SET_CLOSE_P(hh->l);
    734820            ssiInfo *dd=(ssiInfo*)hh->l->data;
    735             SSI_BLOCK_CHLD;
     821            SSI_BLOCK_CHLD;
    736822            s_close(dd->f_read);
    737823            fclose(dd->f_write);
    738             SSI_UNBLOCK_CHLD;
     824            SSI_UNBLOCK_CHLD;
    739825            if (dd->r!=NULL) rKill(dd->r);
    740826            omFreeSize((ADDRESS)dd,(sizeof *dd));
     
    745831          }
    746832          ssiToBeClosed->next=NULL;
    747           SSI_BLOCK_CHLD;
     833          SSI_BLOCK_CHLD;
    748834          close(pc[1]); close(cp[0]);
    749835          d->f_write=fdopen(cp[1],"w");
    750           SSI_UNBLOCK_CHLD;
    751           d->f_read=s_open(pc[0]);
    752           d->fd_read=pc[0];
     836          SSI_UNBLOCK_CHLD;
     837          d->f_read=s_open(pc[0]);
     838          d->fd_read=pc[0];
    753839          d->fd_write=cp[1];
    754840          l->data=d;
     
    759845          //myynest=0;
    760846          fe_fgets_stdin=fe_fgets_dummy;
    761           WerrorS_callback=WerrorS_batch;
    762847          if ((u!=NULL)&&(u->rtyp==IDHDL))
    763848          {
     
    783868        {
    784869          d->pid=pid;
    785           SSI_BLOCK_CHLD;
     870          SSI_BLOCK_CHLD;
    786871          close(pc[0]); close(cp[1]);
    787872          d->f_write=fdopen(pc[1],"w");
    788           SSI_UNBLOCK_CHLD;
    789           d->f_read=s_open(cp[0]);
    790           d->fd_read=cp[0];
     873          SSI_UNBLOCK_CHLD;
     874          d->f_read=s_open(cp[0]);
     875          d->fd_read=cp[0];
    791876          d->fd_write=pc[1];
    792877          SI_LINK_SET_RW_OPEN_P(l);
     
    806891        int sockfd, newsockfd, portno, clilen;
    807892        struct sockaddr_in serv_addr, cli_addr;
     893        int n;
    808894        sockfd = socket(AF_INET, SOCK_STREAM, 0);
    809895        if(sockfd < 0)
     
    832918        while(bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0);
    833919        Print("waiting on port %d\n", portno);mflush();
    834         listen(sockfd,5);
     920        listen(sockfd,1);
    835921        newsockfd = accept(sockfd, (struct sockaddr *) &cli_addr, (socklen_t *)&clilen);
    836922        if(newsockfd < 0)
     
    866952        int sockfd, newsockfd, portno, clilen;
    867953        struct sockaddr_in serv_addr, cli_addr;
     954        int n;
    868955        sockfd = socket(AF_INET, SOCK_STREAM, 0);
    869956        if(sockfd < 0)
     
    891978        while(bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0);
    892979        //Print("waiting on port %d\n", portno);mflush();
    893         listen(sockfd,5);
     980        listen(sockfd,1);
    894981        char* cli_host = (char*)omAlloc(256);
    895982        char* path = (char*)omAlloc(1024);
     
    9331020        d->fd_write = newsockfd;
    9341021        d->f_read = s_open(newsockfd);
    935         SSI_BLOCK_CHLD;
     1022        SSI_BLOCK_CHLD;
    9361023        d->f_write = fdopen(newsockfd, "w");
    9371024        close(sockfd);
    938         SSI_UNBLOCK_CHLD;
     1025        SSI_UNBLOCK_CHLD;
    9391026        SI_LINK_SET_RW_OPEN_P(l);
    9401027        d->send_quit_at_exit=1;
     1028        SSI_BLOCK_CHLD;
    9411029        fprintf(d->f_write,"98 %d %d %u %u\n",SSI_VERSION,MAX_TOK,si_opt_1,si_opt_2);
     1030        SSI_UNBLOCK_CHLD;
    9421031      }
    9431032      // ----------------------------------------------------------------------
     
    9451034      {
    9461035        char* host = (char*)omAlloc(256);
    947         int sockfd, portno;
     1036        int sockfd, portno, n;
    9481037        struct sockaddr_in serv_addr;
    9491038        struct hostent *server;
     
    10011090          }
    10021091        }
    1003         SSI_BLOCK_CHLD;
     1092        SSI_BLOCK_CHLD;
    10041093        outfile=myfopen(filename,mode);
    1005         SSI_UNBLOCK_CHLD;
     1094        SSI_UNBLOCK_CHLD;
    10061095        if (outfile!=NULL)
    10071096        {
     
    10151104          else
    10161105          {
     1106            SSI_BLOCK_CHLD;
    10171107            d->f_write = outfile;
    10181108            fprintf(d->f_write,"98 %d %d %u %u\n",SSI_VERSION,MAX_TOK,si_opt_1,si_opt_2);
     1109            SSI_UNBLOCK_CHLD;
    10191110          }
    10201111        }
     
    10331124
    10341125//**************************************************************************/
     1126BOOLEAN ssiPrepClose(si_link l)
     1127{
     1128  if (l!=NULL)
     1129  {
     1130    ssiInfo *d = (ssiInfo *)l->data;
     1131    if (d!=NULL)
     1132    {
     1133      if (d->send_quit_at_exit)
     1134      {
     1135        SSI_BLOCK_CHLD;
     1136        fputs("99\n",d->f_write);
     1137        fflush(d->f_write);
     1138        SSI_UNBLOCK_CHLD;
     1139      }
     1140      d->quit_sent=1;
     1141    }
     1142  }
     1143  return FALSE;
     1144}
     1145
    10351146BOOLEAN ssiClose(si_link l)
    10361147{
     
    10411152    if (d!=NULL)
    10421153    {
    1043       if (d->send_quit_at_exit)
     1154      if ((d->send_quit_at_exit)
     1155      && (d->quit_sent==0))
    10441156      {
    10451157        SSI_BLOCK_CHLD;
     
    11081220  ssiInfo *d = (ssiInfo *)l->data;
    11091221  leftv res=(leftv)omAlloc0(sizeof(sleftv));
    1110   int t=s_readint(d->f_read);
     1222  int t=0;
     1223  t=s_readint(d->f_read);
    11111224  //Print("got type %d\n",t);
    11121225  switch(t)
     
    11851298             res->data=ssiReadIntmat(d);
    11861299             break;
     1300    case 19: res->rtyp=BIGINTMAT_CMD;
     1301             res->data=ssiReadBigintmat(d);
     1302             break;
    11871303    case 20: ssiReadBlackbox(res,l);
    11881304             break;
     
    12751391                        if(tt==POLY_CMD) fputs("6 ",d->f_write);
    12761392                        else             fputs("9 ",d->f_write);
    1277                         ssiWritePoly(d,(poly)dd);
     1393                        ssiWritePoly(d,tt,(poly)dd);
    12781394                        break;
    12791395          case IDEAL_CMD:
     
    13151431                   ssiWriteIntmat(d,(intvec *)dd);
    13161432                   break;
     1433          case BIGINTMAT_CMD:
     1434                   fputs("19 ",d->f_write);
     1435                   ssiWriteBigintmat(d,(bigintmat *)dd);
     1436                   break;
    13171437          default:
    13181438            if (tt>MAX_TOK)
     
    13651485  && (strcmp(request, "read") == 0))
    13661486  {
    1367     fd_set  mask;
     1487    fd_set  mask, fdmask;
    13681488    struct timeval wt;
    13691489    if (s_isready(d->f_read)) return "ready";
     
    16901810  }
    16911811  int portno;
     1812  int n;
    16921813  ssiReserved_sockfd = socket(AF_INET, SOCK_STREAM, 0);
    16931814  if(ssiReserved_sockfd < 0)
     
    17911912**/
    17921913/*---------------------------------------------------------------------*/
    1793 void sig_chld_hdl(int)
     1914void sig_chld_hdl(int sig)
    17941915{
    17951916  pid_t kidpid;
     
    19192040
    19202041  if (currRingHdl != rh) rSetHdl(rh);
    1921   //fprintf(fd, "option(set, intvec(%d, %d));\n", test, verbose);
     2042  //fprintf(fd, "option(set, intvec(%d, %d));\n", si_opt_1, si_opt_2);
    19222043
    19232044  return status;
     
    19632084// 17 intvec <len> ...
    19642085// 18 intmat
     2086// 19 bigintmat <r> <c> ...
    19652087//
    19662088// 20 blackbox <name> ...
  • Singular/links/ssiLink.h

    r44ca2f rdf326b  
    66 *  Purpose: declaration of sl_link routines for ssi
    77 ***************************************************************/
    8  #ifndef SSILINK_H
    9  #define SSILINK_H
     8#ifndef SSILINK_H
     9#define SSILINK_H
    1010BOOLEAN ssiOpen(si_link l, short flag, leftv u);
    1111BOOLEAN ssiWrite(si_link l, leftv v);
     
    1717int ssiBatch(const char *host, const char * port);
    1818/* return 0 on success, >0 else*/
     19
     20
     21void sig_chld_hdl(int sig);
    1922#endif
    2023
Note: See TracChangeset for help on using the changeset viewer.