Changeset 00e336 in git


Ignore:
Timestamp:
Aug 22, 2012, 2:17:06 PM (10 years ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'ad2543eab51733612ba7d118afc77edca719600e')
Children:
dec6c88a5a04cf848c091da42041c23143413b8d
Parents:
47367fd534cd6fb5e9d3a999aa476df1d6ee78c9
Message:
fix: include path for tests
add: s_buff.*
Location:
Singular
Files:
2 added
4 edited

Legend:

Unmodified
Added
Removed
  • Singular/Makefile.am

    r47367fd r00e336  
    7474   scanner.cc\
    7575   sdb.cc\
     76   links/s_buff.cc\
    7677   links/silink.cc\
    7778   links/sing_dbm.cc\
     
    131132   sdb.h \
    132133   silink.h \
     134   links/s_buff.h \
    133135   links/sing_dbm.h \
    134136   sing_win.h \
  • Singular/cntrlc.cc

    r47367fd r00e336  
    231231}
    232232
    233 /*---------------------------------------------------------------------*/
    234 /**
    235  * @brief additional default signal handler
    236 
    237   // some newer Linux version cannot have SIG_IGN for SIGCHLD,
    238   // so use this nice routine here:
    239   //  SuSe 9.x reports -1 always
    240   //  Redhat 9.x/FC x reports sometimes -1
    241   // see also: hpux_system
    242   // also needed by getrusage (timer etc.)
    243 
    244  @param[in] sig
    245 **/
    246 /*---------------------------------------------------------------------*/
    247 void sig_chld_hdl(int sig)
    248 {
    249   waitpid(-1,NULL,WNOHANG);
    250 }
    251 
    252233/*2
    253234* init signal handlers, linux/i386 version
  • Singular/links/ssiLink.cc

    r47367fd r00e336  
    1919#include <netdb.h>
    2020#include <sys/wait.h>
     21#include <time.h>
    2122
    2223
     
    4344#include <Singular/lists.h>
    4445#include <Singular/blackbox.h>
     46#include <Singular/links/s_buff.h>
    4547#include <Singular/links/ssiLink.h>
    4648
     
    6062//#endif
    6163
    62 #define SSI_VERSION 3
     64#define SSI_VERSION 4
    6365
    6466typedef struct
    6567{
    66   FILE *f_read;
     68  s_buff f_read;
    6769  FILE *f_write;
    6870  ring r;
     
    7072  int fd_read,fd_write; /* only valid for fork/tcp mode*/
    7173  char level;
    72   char ungetc_buf; /* status sets to !=0, if ungetc was used, ssiRead* set to 0*/
    7374  char send_quit_at_exit;
    7475
     
    7778
    7879link_list ssiToBeClosed=NULL;
    79 sigset_t ssi_sigmask;
    80 sigset_t ssi_oldmask;
     80BOOLEAN ssiToBeClosed_inactive=TRUE;
    8181#define SSI_BLOCK_CHLD sigprocmask(SIG_SETMASK, &ssi_sigmask, &ssi_oldmask)
    8282#define SSI_UNBLOCK_CHLD sigprocmask(SIG_SETMASK, &ssi_oldmask, NULL)
     
    114114{
    115115  SSI_BLOCK_CHLD;
    116   fprintf(d->f_write,"%d %s ",strlen(s),s);
     116  fprintf(d->f_write,"%d %s ",(int)strlen(s),s);
    117117  SSI_UNBLOCK_CHLD;
    118118  //if (d->f_debug!=NULL) fprintf(d->f_debug,"stringi: %d \"%s\" ",strlen(s),s);
     
    204204  for(i=0;i<r->N;i++)
    205205  {
    206     fprintf(d->f_write,"%d %s ",strlen(r->names[i]),r->names[i]);
     206    fprintf(d->f_write,"%d %s ",(int)strlen(r->names[i]),r->names[i]);
    207207  }
    208208  /* number of orderings:*/
     
    248248  fprintf(d->f_write,"%d ",pLength(p));//number of terms
    249249  SSI_UNBLOCK_CHLD;
    250   int i;
    251250
    252251  while(p!=NULL)
     
    305304void ssiWriteProc(ssiInfo *d,procinfov p)
    306305{
    307   ssiWriteString(d,p->data.s.body);
     306  if (p->data.s.body==NULL)
     307    iiGetLibProcBuffer(p);
     308  if (p->data.s.body!=NULL)
     309    ssiWriteString(d,p->data.s.body);
     310  else
     311    ssiWriteString(d,"");
    308312}
    309313
     
    331335  SSI_UNBLOCK_CHLD;
    332336}
     337void ssiWriteIntmat(ssiInfo *d,intvec * v)
     338{
     339  SSI_BLOCK_CHLD;
     340  fprintf(d->f_write,"%d %d ",v->rows(),v->cols());
     341  int i;
     342  for(i=0;i<v->length();i++)
     343  {
     344    fprintf(d->f_write,"%d ",(*v)[i]);
     345  }
     346  SSI_UNBLOCK_CHLD;
     347}
    333348
    334349char *ssiReadString(ssiInfo *d)
     
    336351  char *buf;
    337352  int l;
    338   SSI_BLOCK_CHLD;
    339   fscanf(d->f_read,"%d ",&l);
    340   SSI_UNBLOCK_CHLD;
    341   buf=(char*)omAlloc(l+1);
    342   SSI_BLOCK_CHLD;
    343   fread(buf,1,l,d->f_read);
    344   SSI_UNBLOCK_CHLD;
     353  l=s_readint(d->f_read);
     354  buf=(char*)omAlloc0(l+1);
     355  int c =s_getc(d->f_read); /* skip ' '*/
     356  int ll=s_readbytes(buf,l,d->f_read);
     357  //if (ll!=l) printf("want %d, got %d bytes\n",l,ll);
    345358  buf[l]='\0';
    346359  return buf;
    347360}
    348361
    349 int ssiReadInt(FILE *fich)
    350 {
    351   int d;
    352   SSI_BLOCK_CHLD;
    353   fscanf(fich,"%d",&d);
    354   SSI_UNBLOCK_CHLD;
    355   return d;
     362int ssiReadInt(s_buff fich)
     363{
     364  return s_readint(fich);
    356365}
    357366
     
    359368{
    360369  int sub_type=-1;
    361   SSI_BLOCK_CHLD;
    362   fscanf(d->f_read,"%d",&sub_type);
    363   SSI_UNBLOCK_CHLD;
     370  sub_type=s_readint(d->f_read);
    364371  switch(sub_type)
    365372  {
     
    367374     {// read int or mpz_t or mpz_t, mpz_t
    368375       number n=(number)omAlloc0(sizeof(snumber_dummy));
    369        SSI_BLOCK_CHLD;
    370        mpz_inp_str(((number_dummy)n)->z,d->f_read,0);
    371        SSI_UNBLOCK_CHLD;
     376       s_readmpz(d->f_read,((number_dummy)n)->z);
    372377       ((number_dummy)n)->s=sub_type;
    373378       return n;
     
    376381     {
    377382       int dd;
    378        SSI_BLOCK_CHLD;
    379        fscanf(d->f_read,"%d",&dd);
    380        SSI_UNBLOCK_CHLD;
     383       dd=s_readint(d->f_read);
    381384       return n_Init(dd,d->r->cf);
    382385     }
     
    391394  if (rField_is_Q(d->r))
    392395  {
    393      int sub_type=-1;
    394      SSI_BLOCK_CHLD;
    395      fscanf(d->f_read,"%d",&sub_type);
    396      SSI_UNBLOCK_CHLD;
     396     int sub_type=s_readint(d->f_read);
    397397     switch(sub_type)
    398398     {
     
    401401       {// read mpz_t, mpz_t
    402402         number n=(number)omAlloc0(sizeof(snumber_dummy));
     403         mpz_init(((number_dummy)n)->z);
    403404         mpz_init(((number_dummy)n)->n);
    404          SSI_BLOCK_CHLD;
    405          gmp_fscanf(d->f_read,"%Zd %Zd",((number_dummy)n)->z,((number_dummy)n)->n);
    406          SSI_UNBLOCK_CHLD;
     405         s_readmpz(d->f_read,((number_dummy)n)->z);
     406         s_readmpz(d->f_read,((number_dummy)n)->n);
    407407         ((number_dummy)n)->s=sub_type;
    408408         return n;
     
    412412       {// read mpz_t
    413413         number n=(number)omAlloc0(sizeof(snumber_dummy));
    414          SSI_BLOCK_CHLD;
    415          gmp_fscanf(d->f_read,"%Zd",((number_dummy)n)->z);
    416          SSI_UNBLOCK_CHLD;
     414         mpz_init(((number_dummy)n)->z);
     415         s_readmpz(d->f_read,((number_dummy)n)->z);
    417416         ((number_dummy)n)->s=3; /*sub_type*/
    418417         return n;
     
    420419     case 4:
    421420       {
    422          int dd;
    423          SSI_BLOCK_CHLD;
    424          fscanf(d->f_read,"%d",&dd);
    425          SSI_UNBLOCK_CHLD;
     421         int dd=s_readint(d->f_read);
    426422         return n_Init(dd,d->r->cf);
    427423       }
     
    430426       {// read raw mpz_t, mpz_t
    431427         number n=(number)omAlloc0(sizeof(snumber_dummy));
     428         mpz_init(((number_dummy)n)->z);
    432429         mpz_init(((number_dummy)n)->n);
    433          SSI_BLOCK_CHLD;
    434          mpz_inp_str (((number_dummy)n)->z, d->f_read, 32);
    435          mpz_inp_str (((number_dummy)n)->n, d->f_read, 32);
    436          SSI_UNBLOCK_CHLD;
     430         s_readmpz_base (d->f_read,((number_dummy)n)->z, 32);
     431         s_readmpz_base (d->f_read,((number_dummy)n)->n, 32);
    437432         ((number_dummy)n)->s=sub_type-5;
    438433         return n;
     
    441436       {// read raw mpz_t
    442437         number n=(number)omAlloc0(sizeof(snumber_dummy));
    443          SSI_BLOCK_CHLD;
    444          mpz_inp_str (((number_dummy)n)->z, d->f_read, 32);
    445          SSI_UNBLOCK_CHLD;
     438         mpz_init(((number_dummy)n)->z);
     439         s_readmpz_base (d->f_read,((number_dummy)n)->z, 32);
    446440         ((number_dummy)n)->s=sub_type=3; /*subtype-5*/
    447441         return n;
     
    455449  {
    456450    // read int
    457     int dd;
    458     SSI_BLOCK_CHLD;
    459     fscanf(d->f_read,"%d",&dd);
    460     SSI_UNBLOCK_CHLD;
     451    int dd=s_readint(d->f_read);
    461452    return (number)dd;
    462453  }
     
    468459{
    469460/* syntax is <ch> <N> <l1> <v1> ...<lN> <vN> <number of orderings> <ord1> <block0_1> <block1_1> .... */
    470   int ch, N,i,l;
     461  int ch, N,i;
    471462  char **names;
    472   SSI_BLOCK_CHLD;
    473   fscanf(d->f_read,"%d %d ",&ch,&N);
    474   SSI_UNBLOCK_CHLD;
     463  ch=s_readint(d->f_read);
     464  N=s_readint(d->f_read);
    475465  names=(char**)omAlloc(N*sizeof(char*));
    476466  for(i=0;i<N;i++)
     
    480470  // read the orderings:
    481471  int num_ord; // number of orderings
    482   SSI_BLOCK_CHLD;
    483   fscanf(d->f_read,"%d",&num_ord);
    484   SSI_UNBLOCK_CHLD;
     472  num_ord=s_readint(d->f_read);
    485473  int *ord=(int *)omAlloc0((num_ord+1)*sizeof(int));
    486474  int *block0=(int *)omAlloc0((num_ord+1)*sizeof(int));
    487475  int *block1=(int *)omAlloc0((num_ord+1)*sizeof(int));
    488   SSI_BLOCK_CHLD;
    489476  int **wvhdl=(int**)omAlloc0((num_ord+1)*sizeof(int*));
    490477  for(i=0;i<num_ord;i++)
    491478  {
    492     fscanf(d->f_read,"%d %d %d",&ord[i],&block0[i],&block1[i]);
     479    ord[i]=s_readint(d->f_read);
     480    block0[i]=s_readint(d->f_read);
     481    block1[i]=s_readint(d->f_read);
    493482    switch(ord[i])
    494483    {
     
    503492        int ii;
    504493        for(ii=block0[i];ii<=block1[i];ii++)
    505           fscanf(d->f_read,"%d",&(wvhdl[i][ii-block0[i]]));
     494          wvhdl[i][ii-block0[i]]=s_readint(d->f_read);
    506495      }
    507496      break;
     
    517506    }
    518507  }
    519   SSI_UNBLOCK_CHLD;
    520508  return rDefault(ch,N,names,num_ord,ord,block0,block1,wvhdl);
    521509}
     
    537525    p=p_Init(D->r);
    538526    pGetCoeff(p)=ssiReadNumber(D);
    539     int d;
    540     SSI_BLOCK_CHLD;
    541     fscanf(D->f_read,"%d",&d);
    542     SSI_UNBLOCK_CHLD;
     527    int d=s_readint(D->f_read);
    543528    p_SetComp(p,d,D->r);
    544529    for(i=1;i<=rVar(D->r);i++)
    545530    {
    546       SSI_BLOCK_CHLD;
    547       fscanf(D->f_read,"%d",&d);
    548       SSI_UNBLOCK_CHLD;
     531      d=s_readint(D->f_read);
    549532      p_SetExp(p,i,d,D->r);
    550533    }
     
    560543ideal ssiReadIdeal(ssiInfo *d)
    561544{
    562   int n,i;
    563   ideal I;
    564   SSI_BLOCK_CHLD;
    565   fscanf(d->f_read,"%d",&n);
    566   SSI_UNBLOCK_CHLD;
    567   I=idInit(n,1);
     545  int i;
     546  int n=s_readint(d->f_read);
     547  ideal I=idInit(n,1);
    568548  for(i=0;i<IDELEMS(I);i++) // read n terms
    569549  {
     
    575555matrix ssiReadMatrix(ssiInfo *d)
    576556{
    577   int n,m,i,j;
    578   SSI_BLOCK_CHLD;
    579   fscanf(d->f_read,"%d %d",&m,&n);
    580   SSI_UNBLOCK_CHLD;
     557  int m=s_readint(d->f_read);
     558  int n=s_readint(d->f_read);
    581559  matrix M=mpNew(m,n);
    582560  poly p;
     
    596574  command D=(command)omAlloc0(sizeof(*D));
    597575  int argc,op;
    598   SSI_BLOCK_CHLD;
    599   fscanf(d->f_read,"%d %d",&argc,&op);
    600   SSI_UNBLOCK_CHLD;
     576  argc=s_readint(d->f_read);
     577  op=s_readint(d->f_read);
    601578  D->argc=argc; D->op=op;
    602579  leftv v;
     
    650627{
    651628  ssiInfo *d=(ssiInfo*)l->data;
    652   int nr;
    653   SSI_BLOCK_CHLD;
    654   fscanf(d->f_read,"%d",&nr);
    655   SSI_UNBLOCK_CHLD;
     629  int nr=s_readint(d->f_read);
    656630  lists L=(lists)omAlloc(sizeof(*L));
    657631  L->Init(nr);
     
    669643intvec* ssiReadIntvec(ssiInfo *d)
    670644{
    671   int nr;
    672   SSI_BLOCK_CHLD;
    673   fscanf(d->f_read,"%d",&nr);
    674   SSI_UNBLOCK_CHLD;
     645  int nr=s_readint(d->f_read);
    675646  intvec *v=new intvec(nr);
    676   SSI_BLOCK_CHLD;
    677647  for(int i=0;i<nr;i++)
    678648  {
    679     fscanf(d->f_read,"%d",&((*v)[i]));
    680   }
    681   SSI_UNBLOCK_CHLD;
     649    (*v)[i]=s_readint(d->f_read);
     650  }
    682651  return v;
    683652}
     653intvec* ssiReadIntmat(ssiInfo *d)
     654{
     655  int r,c;
     656  r=s_readint(d->f_read);
     657  c=s_readint(d->f_read);
     658  intvec *v=new intvec(r,c,0);
     659  for(int i=0;i<r*c;i++)
     660  {
     661    (*v)[i]=s_readint(d->f_read);
     662  }
     663  return v;
     664}
    684665
    685666void ssiReadBlackbox(leftv res, si_link l)
    686667{
    687668  ssiInfo *d=(ssiInfo*)l->data;
    688   int throwaway;
    689   SSI_BLOCK_CHLD;
    690   fscanf(d->f_read,"%d ",&throwaway);
    691   SSI_UNBLOCK_CHLD;
     669  int throwaway=s_readint(d->f_read);
    692670  char *name=ssiReadString(d);
    693671  int tok;
     
    747725        int pc[2];
    748726        int cp[2];
     727        SSI_BLOCK_CHLD;
    749728        pipe(pc);
    750729        pipe(cp);
    751730        pid_t pid=fork();
     731        SSI_UNBLOCK_CHLD;
    752732        if (pid==0) /*fork: child*/
    753733        {
     
    756736          while(hh!=NULL)
    757737          {
     738            SI_LINK_SET_CLOSE_P(hh->l);
    758739            ssiInfo *dd=(ssiInfo*)hh->l->data;
    759             fclose(dd->f_read);
     740            SSI_BLOCK_CHLD;
     741            s_close(dd->f_read);
    760742            fclose(dd->f_write);
     743            SSI_UNBLOCK_CHLD;
    761744            if (dd->r!=NULL) rKill(dd->r);
    762745            omFreeSize((ADDRESS)dd,(sizeof *dd));
    763746            hh->l->data=NULL;
    764             SI_LINK_SET_CLOSE_P(hh->l);
    765747            link_list nn=(link_list)hh->next;
    766748            omFree(hh);
     
    768750          }
    769751          ssiToBeClosed->next=NULL;
     752          SSI_BLOCK_CHLD;
    770753          close(pc[1]); close(cp[0]);
    771           d->f_read=fdopen(pc[0],"r");
    772           d->fd_read=pc[0];
    773754          d->f_write=fdopen(cp[1],"w");
     755          SSI_UNBLOCK_CHLD;
     756          d->f_read=s_open(pc[0]);
     757          d->fd_read=pc[0];
    774758          d->fd_write=cp[1];
    775759          l->data=d;
     
    804788        {
    805789          d->pid=pid;
     790          SSI_BLOCK_CHLD;
    806791          close(pc[0]); close(cp[1]);
    807           d->f_read=fdopen(cp[0],"r");
    808           d->fd_read=cp[0];
    809792          d->f_write=fdopen(pc[1],"w");
     793          SSI_UNBLOCK_CHLD;
     794          d->f_read=s_open(cp[0]);
     795          d->fd_read=cp[0];
    810796          d->fd_write=pc[1];
    811797          SI_LINK_SET_RW_OPEN_P(l);
     
    825811        int sockfd, newsockfd, portno, clilen;
    826812        struct sockaddr_in serv_addr, cli_addr;
    827         int n;
    828813        sockfd = socket(AF_INET, SOCK_STREAM, 0);
    829814        if(sockfd < 0)
     
    864849        d->fd_read = newsockfd;
    865850        d->fd_write = newsockfd;
    866         d->f_read = fdopen(newsockfd, "r");
     851        d->f_read = s_open(newsockfd);
    867852        d->f_write = fdopen(newsockfd, "w");
    868853        SI_LINK_SET_RW_OPEN_P(l);
     
    886871        int sockfd, newsockfd, portno, clilen;
    887872        struct sockaddr_in serv_addr, cli_addr;
    888         int n;
    889873        sockfd = socket(AF_INET, SOCK_STREAM, 0);
    890874        if(sockfd < 0)
     
    953937        d->fd_read = newsockfd;
    954938        d->fd_write = newsockfd;
    955         d->f_read = fdopen(newsockfd, "r");
     939        d->f_read = s_open(newsockfd);
     940        SSI_BLOCK_CHLD;
    956941        d->f_write = fdopen(newsockfd, "w");
     942        close(sockfd);
     943        SSI_UNBLOCK_CHLD;
    957944        SI_LINK_SET_RW_OPEN_P(l);
    958945        d->send_quit_at_exit=1;
    959         close(sockfd);
    960946        fprintf(d->f_write,"98 %d %d %u %u\n",SSI_VERSION,MAX_TOK,test,verbose);
    961947      }
     
    964950      {
    965951        char* host = (char*)omAlloc(256);
    966         int sockfd, portno, n;
     952        int sockfd, portno;
    967953        struct sockaddr_in serv_addr;
    968954        struct hostent *server;
     
    985971          { Werror("ERROR connecting(errno=%d)",errno); return TRUE; }
    986972          //PrintS("connected\n");mflush();
    987           d->f_read=fdopen(sockfd,"r");
     973          d->f_read=s_open(sockfd);
    988974          d->fd_read=sockfd;
    989975          d->f_write=fdopen(sockfd,"w");
     
    10201006          }
    10211007        }
     1008        SSI_BLOCK_CHLD;
    10221009        outfile=myfopen(filename,mode);
     1010        SSI_UNBLOCK_CHLD;
    10231011        if (outfile!=NULL)
    10241012        {
    1025           if (strcmp(l->mode,"r")==0) d->f_read = outfile;
     1013          if (strcmp(l->mode,"r")==0)
     1014          {
     1015            SSI_BLOCK_CHLD;
     1016            fclose(outfile);
     1017            d->f_read=s_open_by_name(filename);
     1018            SSI_UNBLOCK_CHLD;
     1019          }
    10261020          else
    10271021          {
     
    10481042  if (l!=NULL)
    10491043  {
     1044    SI_LINK_SET_CLOSE_P(l);
    10501045    ssiInfo *d = (ssiInfo *)l->data;
    10511046    if (d!=NULL)
    10521047    {
     1048      if (d->send_quit_at_exit)
     1049      {
     1050        SSI_BLOCK_CHLD;
     1051        fputs("99\n",d->f_write);
     1052        fflush(d->f_write);
     1053        SSI_UNBLOCK_CHLD;
     1054      }
    10531055      if (d->r!=NULL) rKill(d->r);
     1056      if ((d->pid!=0)
     1057      && (waitpid(d->pid,NULL,WNOHANG)==0))
     1058      {
     1059        struct timespec t;
     1060        t.tv_sec=0;
     1061        t.tv_nsec=50000000; // <=50 ms
     1062        int r=nanosleep(&t,NULL);
     1063        if((r==0) && (waitpid(d->pid,NULL,WNOHANG)==0))
     1064        {
     1065          kill(d->pid,15);
     1066          t.tv_sec=0;
     1067          t.tv_nsec=10000000; // <=10 ms
     1068          r=nanosleep(&t,NULL);
     1069          if((r==0)&&(waitpid(d->pid,NULL,WNOHANG)==0))
     1070          {
     1071            kill(d->pid,9); // just to be sure
     1072            waitpid(d->pid,NULL,0);
     1073          }
     1074        }
     1075      }
     1076      if (d->f_read!=NULL) s_close(d->f_read);
     1077      if (d->f_write!=NULL) fclose(d->f_write);
    10541078      if ((strcmp(l->mode,"tcp")==0)
    10551079      || (strcmp(l->mode,"fork")==0))
     
    10631087             omFreeSize(hh,sizeof(link_struct));
    10641088          }
    1065           else while(hh!=NULL)
     1089          else while(hh->next!=NULL)
    10661090          {
    10671091            link_list hhh=(link_list)hh->next;
     
    10721096              break;
    10731097            }
    1074             hh=(link_list)hh->next;
     1098            else
     1099              hh=(link_list)hh->next;
    10751100          }
    10761101        }
    1077         if (d->send_quit_at_exit)
    1078         {
    1079           fputs("99\n",d->f_write);fflush(d->f_write);
    1080         }
    1081       }
    1082       if (d->f_read!=NULL) fclose(d->f_read);
    1083       if (d->f_write!=NULL) fclose(d->f_write);
    1084       if (d->pid!=0)
    1085       {
    1086         kill(d->pid,15);
    1087         waitpid(d->pid,NULL,WNOHANG);
    1088         kill(d->pid,9); // just to be sure
    1089         waitpid(d->pid,NULL,0);
    10901102      }
    10911103      omFreeSize((ADDRESS)d,(sizeof *d));
    10921104    }
    10931105    l->data=NULL;
    1094     SI_LINK_SET_CLOSE_P(l);
    10951106  }
    10961107  return FALSE;
     
    11011112{
    11021113  ssiInfo *d = (ssiInfo *)l->data;
    1103   d->ungetc_buf='\0';
    11041114  leftv res=(leftv)omAlloc0(sizeof(sleftv));
    1105   int t=0;
    1106   SSI_BLOCK_CHLD;
    1107   fscanf(d->f_read,"%d",&t);
    1108   SSI_UNBLOCK_CHLD;
     1115  int t=s_readint(d->f_read);
    11091116  //Print("got type %d\n",t);
    11101117  switch(t)
     
    11801187             res->data=ssiReadIntvec(d);
    11811188             break;
     1189    case 18: res->rtyp=INTMAT_CMD;
     1190             res->data=ssiReadIntmat(d);
     1191             break;
    11821192    case 20: ssiReadBlackbox(res,l);
    11831193             break;
     
    11871197                int n98_v,n98_m;
    11881198                BITSET n98_o1,n98_o2;
    1189                 SSI_BLOCK_CHLD;
    1190                 fscanf(d->f_read,"%d %d %u %u\n",&n98_v,&n98_m,&n98_o1,&n98_o2);
    1191                 SSI_UNBLOCK_CHLD;
     1199                n98_v=s_readint(d->f_read);
     1200                n98_m=s_readint(d->f_read);
     1201                n98_o1=s_readint(d->f_read);
     1202                n98_o2=s_readint(d->f_read);
    11921203                if ((n98_v!=SSI_VERSION) ||(n98_m!=MAX_TOK))
    11931204                {
     
    12041215             }
    12051216    case 99: ssiClose(l); m2_end(0);
    1206     case 0: if (feof(d->f_read))
     1217    case 0: if (s_iseof(d->f_read))
    12071218            {
    12081219              ssiClose(l);
     
    13051316                   ssiWriteIntvec(d,(intvec *)dd);
    13061317                   break;
     1318          case INTMAT_CMD:
     1319                   fputs("18 ",d->f_write);
     1320                   ssiWriteIntmat(d,(intvec *)dd);
     1321                   break;
    13071322          default:
    13081323            if (tt>MAX_TOK)
     
    13271342}
    13281343
     1344BOOLEAN ssiGetDump(si_link l);
     1345BOOLEAN ssiDump(si_link l);
     1346
    13291347si_link_extension slInitSsiExtension(si_link_extension s)
    13301348{
     
    13351353  s->Read2=(slRead2Proc)NULL;
    13361354  s->Write=ssiWrite;
     1355  s->Dump=ssiDump;
     1356  s->GetDump=ssiGetDump;
    13371357
    13381358  s->Status=slStatusSsi;
     
    13451365  ssiInfo *d=(ssiInfo*)l->data;
    13461366  if (d==NULL) return "not open";
    1347   if (((strcmp(l->mode,"fork")==0)||(strcmp(l->mode,"tcp")==0))
     1367  if (((strcmp(l->mode,"fork")==0)
     1368  ||(strcmp(l->mode,"tcp")==0)
     1369  ||(strcmp(l->mode,"connect")==0))
    13481370  && (strcmp(request, "read") == 0))
    13491371  {
    1350     fd_set  mask, fdmask;
     1372    fd_set  mask;
    13511373    struct timeval wt;
    1352     if (d->ungetc_buf) return "ready";
     1374    if (s_isready(d->f_read)) return "ready";
    13531375    loop
    13541376    {
     
    13691391    /* yes: read 1 char*/
    13701392    /* if \n, check again with select else ungetc(c), ready*/
    1371       int c=fgetc(d->f_read);
     1393      int c=s_getc(d->f_read);
    13721394      //Print("try c=%d\n",c);
    13731395      if (c== -1) return "eof"; /* eof or error */
    13741396      else if (isdigit(c))
    1375       { ungetc(c,d->f_read); d->ungetc_buf='\1'; return "ready"; }
     1397      { s_ungetc(c,d->f_read); return "ready"; }
    13761398      else if (c>' ')
    13771399      {
     
    13841406  else if (strcmp(request, "read") == 0)
    13851407  {
    1386     if (SI_LINK_R_OPEN_P(l) && (!feof(d->f_read))) return "ready";
     1408    if (SI_LINK_R_OPEN_P(l) && (!s_iseof(d->f_read)) && (s_isready(d->f_read))) return "ready";
    13871409    else return "not ready";
    13881410  }
     
    14101432  si_link l;
    14111433  ssiInfo *d;
     1434  #ifdef HAVE_MPSR
     1435  MP_Link_pt dd;
     1436  #endif
    14121437  int d_fd;
    14131438  fd_set  mask, fdmask;
     
    14781503        return -2;
    14791504      }
     1505    #ifdef HAVE_MPSR
     1506      if (strcmp(l->m->type,"ssi")==0)
     1507      {
     1508        d=(ssiInfo*)l->data;
     1509        d_fd=d->fd_read;
     1510        if (!s_isready(d->f_read))
     1511        {
     1512          FD_SET(d_fd, &fdmask);
     1513          if (d_fd > max_fd) max_fd=d_fd;
     1514        }
     1515        else
     1516          return i+1;
     1517      }
     1518      else
     1519      {
     1520        dd=(MP_Link_pt)l->data;
     1521        d_fd=((MP_TCP_t *)dd->transp.private1)->sock;
     1522        FD_SET(d_fd, &fdmask);
     1523        if (d_fd > max_fd) max_fd=d_fd;
     1524      }
     1525    #else
    14801526      d=(ssiInfo*)l->data;
    14811527      d_fd=d->fd_read;
    1482       if (d->ungetc_buf=='\0')
     1528      if (!s_isready(d->f_read))
    14831529      {
    14841530        FD_SET(d_fd, &fdmask);
     
    14871533      else
    14881534        return i+1;
     1535    #endif
    14891536    }
    14901537  }
     
    15031550
    15041551  /* check with select: chars waiting: no -> not ready */
     1552  #ifdef HAVE_SIMPLEIPC
     1553  sipc_semaphore_release(0);
     1554  #endif
    15051555  #ifdef HAVE_PSELECT
    15061556  s = pselect(max_fd, &mask, NULL, NULL, wt_ptr, &sigmask);
     
    15101560  SSI_UNBLOCK_CHLD;
    15111561  #endif
     1562  #ifdef HAVE_SIMPLEIPC
     1563  sipc_semaphore_acquire(0);
     1564  #endif
    15121565
    15131566  if (s==-1)
     
    15291582      {
    15301583        l=(si_link)L->m[i].Data();
     1584        #ifdef HAVE_MPSR
     1585        if (strcmp(l->m->type,"ssi")!=0)
     1586        {
     1587          // for MP links, return here:
     1588          dd=(MP_Link_pt)l->data;
     1589          d_fd=((MP_TCP_t *)dd->transp.private1)->sock;
     1590          if(j==d_fd) return i+1;
     1591        }
     1592        else
     1593        {
     1594          d=(ssiInfo*)l->data;
     1595          d_fd=d->fd_read;
     1596          if(j==d_fd) break;
     1597        }
     1598        #else
    15311599        d=(ssiInfo*)l->data;
    15321600        d_fd=d->fd_read;
    15331601        if(j==d_fd) break;
     1602        #endif
    15341603      }
    15351604    }
     
    15401609      /* if \n, check again with select else ungetc(c), ready*/
    15411610      /* setting: d: current ssiInfo, j current fd, i current entry in L*/
    1542       int c=fgetc(d->f_read);
     1611      int c=s_getc(d->f_read);
    15431612      //Print("try c=%d\n",c);
    15441613      if (c== -1) /* eof */
     
    15611630        {
    15621631          timeout = si_max(0,
    1563                timeout - 1000000*(getRTimer()/TIMER_RESOLUTION - startingtime));
     1632             timeout - 1000000*(getRTimer()/TIMER_RESOLUTION - startingtime));
    15641633          wt.tv_sec  = timeout / 1000000;
    15651634          #ifdef HAVE_PSELECT
     
    15731642
    15741643      else if (isdigit(c))
    1575       { ungetc(c,d->f_read); d->ungetc_buf='\1'; return i+1; }
     1644      { s_ungetc(c,d->f_read); return i+1; }
    15761645      else if (c>' ')
    15771646      {
     
    16141683}
    16151684
     1685static int ssiReserved_P=0;
     1686static int ssiReserved_sockfd;
     1687static  struct sockaddr_in ssiResverd_serv_addr;
     1688static int  ssiReserved_Clients;
     1689int ssiReservePort(int clients)
     1690{
     1691  if (ssiReserved_P!=0)
     1692  {
     1693    WerrorS("ERROR already a reverved port requested");
     1694    return 0;
     1695  }
     1696  int portno;
     1697  ssiReserved_sockfd = socket(AF_INET, SOCK_STREAM, 0);
     1698  if(ssiReserved_sockfd < 0)
     1699  {
     1700    WerrorS("ERROR opening socket");
     1701    return 0;
     1702  }
     1703  memset((char *) &ssiResverd_serv_addr,0, sizeof(ssiResverd_serv_addr));
     1704  portno = 1025;
     1705  ssiResverd_serv_addr.sin_family = AF_INET;
     1706  ssiResverd_serv_addr.sin_addr.s_addr = INADDR_ANY;
     1707  do
     1708  {
     1709    portno++;
     1710    ssiResverd_serv_addr.sin_port = htons(portno);
     1711    if(portno > 50000)
     1712    {
     1713      WerrorS("ERROR on binding (no free port available?)");
     1714      return 0;
     1715    }
     1716  }
     1717  while(bind(ssiReserved_sockfd, (struct sockaddr *) &ssiResverd_serv_addr, sizeof(ssiResverd_serv_addr)) < 0);
     1718  ssiReserved_P=portno;
     1719  listen(ssiReserved_sockfd,clients);
     1720  ssiReserved_Clients=clients;
     1721  return portno;
     1722}
     1723
     1724extern si_link_extension si_link_root;
     1725si_link ssiCommandLink()
     1726{
     1727  if (ssiReserved_P==0)
     1728  {
     1729    WerrorS("ERROR no reverved port requested");
     1730    return NULL;
     1731  }
     1732  struct sockaddr_in cli_addr;
     1733  int clilen = sizeof(cli_addr);
     1734  int newsockfd = accept(ssiReserved_sockfd, (struct sockaddr *) &cli_addr, (socklen_t *)&clilen);
     1735  if(newsockfd < 0)
     1736  {
     1737    Werror("ERROR on accept (errno=%d)",errno);
     1738    return NULL;
     1739  }
     1740  si_link l=(si_link) omAlloc0Bin(sip_link_bin);
     1741  si_link_extension s = si_link_root;
     1742  si_link_extension prev = s;
     1743  while (strcmp(s->type, "ssi") != 0)
     1744  {
     1745    if (s->next == NULL)
     1746    {
     1747      prev = s;
     1748      s = NULL;
     1749      break;
     1750    }
     1751    else
     1752    {
     1753      s = s->next;
     1754    }
     1755  }
     1756  if (s != NULL)
     1757    l->m = s;
     1758  else
     1759  {
     1760    si_link_extension ns = (si_link_extension)omAlloc0Bin(s_si_link_extension_bin);
     1761    prev->next=slInitSsiExtension(ns);
     1762    l->m = prev->next;
     1763  }
     1764  l->name=omStrDup("");
     1765  l->mode=omStrDup("tcp");
     1766  l->ref=1;
     1767  ssiInfo *d=(ssiInfo*)omAlloc0(sizeof(ssiInfo));
     1768  sigprocmask(SIG_SETMASK, NULL, &ssi_sigmask);
     1769  sigaddset(&ssi_sigmask, SIGCHLD);
     1770  l->data=d;
     1771  d->fd_read = newsockfd;
     1772  d->fd_write = newsockfd;
     1773  d->f_read = s_open(newsockfd);
     1774  d->f_write = fdopen(newsockfd, "w");
     1775  SI_LINK_SET_RW_OPEN_P(l);
     1776  ssiReserved_Clients--;
     1777  if (ssiReserved_Clients<=0)
     1778  {
     1779    ssiReserved_P=0;
     1780    close(ssiReserved_sockfd);
     1781  }
     1782  return l;
     1783}
     1784/*---------------------------------------------------------------------*/
     1785/**
     1786 * @brief additional default signal handler
     1787
     1788  // some newer Linux version cannot have SIG_IGN for SIGCHLD,
     1789  // so use this nice routine here:
     1790  //  SuSe 9.x reports -1 always
     1791  //  Redhat 9.x/FC x reports sometimes -1
     1792  // see also: hpux_system
     1793  // also needed by getrusage (timer etc.)
     1794
     1795 @param[in] sig
     1796**/
     1797/*---------------------------------------------------------------------*/
     1798void sig_chld_hdl(int sig)
     1799{
     1800  pid_t kidpid;
     1801  int status;
     1802
     1803  loop
     1804  {
     1805    kidpid = waitpid(-1, &status, WNOHANG);
     1806    if (kidpid==-1)
     1807    {
     1808      /* continue on interruption (EINTR): */
     1809      if (errno == EINTR) continue;
     1810      /* break on anything else (EINVAL or ECHILD according to manpage): */
     1811      break;
     1812    }
     1813    else if (kidpid==0) break; /* no more children to process, so break */
     1814
     1815    //printf("Child %ld terminated\n", kidpid);
     1816    link_list hh=ssiToBeClosed;
     1817    while(hh!=NULL)
     1818    {
     1819      if((hh->l!=NULL) && (hh->l->m->Open==ssiOpen))
     1820      {
     1821        ssiInfo *d = (ssiInfo *)hh->l->data;
     1822        if(d->pid==kidpid)
     1823        {
     1824          if(ssiToBeClosed_inactive)
     1825          {
     1826            ssiToBeClosed_inactive=FALSE;
     1827            slClose(hh->l);
     1828            ssiToBeClosed_inactive=TRUE;
     1829            break;
     1830          }
     1831          else break;
     1832        }
     1833        else hh=(link_list)hh->next;
     1834      }
     1835      else hh=(link_list)hh->next;
     1836    }
     1837  }
     1838}
     1839
     1840static BOOLEAN DumpSsiIdhdl(si_link l, idhdl h)
     1841{
     1842  int type_id = IDTYP(h);
     1843
     1844  // C-proc not to be dumped, also LIB-proc not
     1845  if (type_id == PROC_CMD)
     1846  {
     1847    if (IDPROC(h)->language == LANG_C) return FALSE;
     1848    if (IDPROC(h)->libname != NULL) return FALSE;
     1849  }
     1850  // do not dump links
     1851  if (type_id == LINK_CMD) return FALSE;
     1852
     1853  // do not dump ssi internal rings: ssiRing*
     1854  if ((type_id == RING_CMD) && (strncmp(IDID(h),"ssiRing",7)==0))
     1855    return FALSE;
     1856
     1857  command D=(command)omAlloc0(sizeof(*D));
     1858  sleftv tmp;
     1859  memset(&tmp,0,sizeof(tmp));
     1860  tmp.rtyp=COMMAND;
     1861  tmp.data=D;
     1862
     1863  if (type_id == PACKAGE_CMD)
     1864  {
     1865    // do not dump Top
     1866    if (strcmp(IDID(h), "Top") == 0) return FALSE;
     1867    package p=(package)IDDATA(h);
     1868    // dump Singular-packages as load("...");
     1869    if (p->language==LANG_SINGULAR)
     1870    {
     1871      D->op=LOAD_CMD;
     1872      D->argc=1;
     1873      D->arg1.rtyp=STRING_CMD;
     1874      D->arg1.data=p->libname;
     1875      ssiWrite(l,&tmp);
     1876      omFree(D);
     1877      return FALSE;
     1878    }
     1879  }
     1880
     1881  // handle qrings separately
     1882  //if (type_id == QRING_CMD)
     1883  //  return DumpSsiQringQring(l, h);
     1884
     1885  // put type and name
     1886  //Print("generic dump:%s,%s\n",IDID(h),Tok2Cmdname(IDTYP(h)));
     1887  D->op='=';
     1888  D->argc=2;
     1889  D->arg1.rtyp=DEF_CMD;
     1890  D->arg1.name=IDID(h);
     1891  D->arg2.rtyp=IDTYP(h);
     1892  D->arg2.data=IDDATA(h);
     1893  ssiWrite(l,&tmp);
     1894  omFree(D);
     1895  return FALSE;
     1896}
     1897static BOOLEAN ssiDumpIter(si_link l, idhdl h)
     1898{
     1899  if (h == NULL) return FALSE;
     1900
     1901  if (ssiDumpIter(l, IDNEXT(h))) return TRUE;
     1902
     1903  // need to set the ring before writing it, otherwise we get in
     1904  // trouble with minpoly
     1905  if (IDTYP(h) == RING_CMD || IDTYP(h) == QRING_CMD)
     1906    rSetHdl(h);
     1907
     1908  if (DumpSsiIdhdl(l, h)) return TRUE;
     1909
     1910  // do not dump ssi internal rings: ssiRing*
     1911  // but dump objects of all other rings
     1912  if ((IDTYP(h) == RING_CMD || IDTYP(h) == QRING_CMD)
     1913  && (strncmp(IDID(h),"ssiRing",7)!=0))
     1914    return ssiDumpIter(l, IDRING(h)->idroot);
     1915  else
     1916    return FALSE;
     1917}
     1918BOOLEAN ssiDump(si_link l)
     1919{
     1920  idhdl h = IDROOT, rh = currRingHdl;
     1921  BOOLEAN status = ssiDumpIter(l, h);
     1922
     1923  //if (! status ) status = DumpAsciiMaps(fd, h, NULL);
     1924
     1925  if (currRingHdl != rh) rSetHdl(rh);
     1926  //fprintf(fd, "option(set, intvec(%d, %d));\n", test, verbose);
     1927
     1928  return status;
     1929}
     1930BOOLEAN ssiGetDump(si_link l)
     1931{
     1932  ssiInfo *d=(ssiInfo*)l->data;
     1933  loop
     1934  {
     1935    if (!SI_LINK_OPEN_P(l)) break;
     1936    if (s_iseof(d->f_read)) break;
     1937    leftv h=ssiRead1(l); /*contains an exit.... */
     1938    if (feErrors != NULL && *feErrors != '\0')
     1939    {
     1940      // handle errors:
     1941      PrintS(feErrors); /* currently quite simple */
     1942      return TRUE;
     1943      *feErrors = '\0';
     1944    }
     1945    h->CleanUp();
     1946    omFreeBin(h, sleftv_bin);
     1947  }
     1948  return FALSE;
     1949}
    16161950// ----------------------------------------------------------------
    16171951// format
     
    16331967// 16 nothing
    16341968// 17 intvec <len> ...
     1969// 18 intmat
    16351970//
    16361971// 20 blackbox <name> ...
  • Singular/test.cc

    r47367fd r00e336  
    194194#include "CacheImplementation.h"
    195195#include "cntrlc.h"
    196 #include "dbm_sl.h"
     196#include "links/dbm_sl.h"
    197197#include "distrib.h"
    198198#include "eigenval_ip.h"
     
    214214#include "minpoly.h"
    215215#include "misc_ip.h"
    216 #include "ndbm.h"
     216#include "links/ndbm.h"
    217217#include "newstruct.h"
    218218#include "omSingularConfig.h"
    219219#include "pcv.h"
    220 #include "pipeLink.h"
     220#include "links/pipeLink.h"
    221221#include "run.h"
    222222#include "sdb.h"
    223223#include "silink.h"
    224 #include "sing_dbm.h"
     224#include "links/sing_dbm.h"
    225225#include "sing_win.h"
    226226#include "slInit.h"
    227 #include "ssiLink.h"
     227#include "links/ssiLink.h"
    228228#include "static.h"
    229229#include "stype.h"
Note: See TracChangeset for help on using the changeset viewer.