My Project  UNKNOWN_GIT_VERSION
Functions
ssiLink.h File Reference
#include "Singular/links/silink.h"

Go to the source code of this file.

Functions

BOOLEAN ssiOpen (si_link l, short flag, leftv u)
 
BOOLEAN ssiWrite (si_link l, leftv v)
 
leftv ssiRead1 (si_link l)
 
leftv ssiRead2 (si_link l, leftv key)
 
BOOLEAN ssiClose (si_link l)
 
const char * slStatusSsi (si_link l, const char *request)
 
si_link_extension slInitSsiExtension (si_link_extension s)
 
si_link ssiCommandLink ()
 
void sig_chld_hdl (int sig)
 additional default signal handler More...
 

Function Documentation

◆ sig_chld_hdl()

void sig_chld_hdl ( int  )

additional default signal handler

some newer Linux version cannot have SIG_IGN for SIGCHLD, so use this nice routine here: SuSe 9.x reports -1 always Redhat 9.x/FC x reports sometimes -1 see also: hpux_system also needed by getrusage (timer etc.)

Parameters
[in]sig

Definition at line 1970 of file ssiLink.cc.

1973 {
1974  pid_t kidpid;
1975  int status;
1976 
1977  loop
1978  {
1979  kidpid = si_waitpid(-1, &status, WNOHANG);
1980  if (kidpid==-1)
1981  {
1982  /* continue on interruption (EINTR): */
1983  if (errno == EINTR) continue;
1984  /* break on anything else (EINVAL or ECHILD according to manpage): */
1985  break;
1986  }
1987  else if (kidpid==0) break; /* no more children to process, so break */
1988 
1989  //printf("Child %ld terminated\n", kidpid);
1991  while((hh!=NULL)&&(ssiToBeClosed_inactive))
1992  {
1993  if((hh->l!=NULL) && (hh->l->m->Open==ssiOpen))
1994  {
1995  ssiInfo *d = (ssiInfo *)hh->l->data;
1996  if(d->pid==kidpid)
1997  {
1999  {
2001  slClose(hh->l);
2003  break;
2004  }
2005  else break;
2006  }
2007  else hh=(link_list)hh->next;
2008  }
2009  else hh=(link_list)hh->next;
2010  }

◆ slInitSsiExtension()

si_link_extension slInitSsiExtension ( si_link_extension  s)

Definition at line 1583 of file ssiLink.cc.

1586 {
1587  s->Open=ssiOpen;
1588  s->Close=ssiClose;
1589  s->Kill=ssiClose;
1590  s->Read=ssiRead1;
1591  s->Read2=(slRead2Proc)NULL;
1592  s->Write=ssiWrite;
1593  s->Dump=ssiDump;
1594  s->GetDump=ssiGetDump;
1595 
1596  s->Status=slStatusSsi;
1597  s->SetRing=ssiSetRing;
1598  s->type="ssi";

◆ slStatusSsi()

const char* slStatusSsi ( si_link  l,
const char *  request 
)

Definition at line 1600 of file ssiLink.cc.

1603 {
1604  ssiInfo *d=(ssiInfo*)l->data;
1605  if (d==NULL) return "not open";
1606  if (((strcmp(l->mode,"fork")==0)
1607  ||(strcmp(l->mode,"tcp")==0)
1608  ||(strcmp(l->mode,"connect")==0))
1609  && (strcmp(request, "read") == 0))
1610  {
1611  fd_set mask;
1612  struct timeval wt;
1613  if (s_isready(d->f_read)) return "ready";
1614  loop
1615  {
1616  /* Don't block. Return socket status immediately. */
1617  wt.tv_sec = 0;
1618  wt.tv_usec = 0;
1619 
1620  FD_ZERO(&mask);
1621  FD_SET(d->fd_read, &mask);
1622  //Print("test fd %d\n",d->fd_read);
1623  /* check with select: chars waiting: no -> not ready */
1624  switch (si_select(d->fd_read+1, &mask, NULL, NULL, &wt))
1625  {
1626  case 0: /* not ready */ return "not ready";
1627  case -1: /*error*/ return "error";
1628  case 1: /*ready ? */ break;
1629  }
1630  /* yes: read 1 char*/
1631  /* if \n, check again with select else ungetc(c), ready*/
1632  int c=s_getc(d->f_read);
1633  //Print("try c=%d\n",c);
1634  if (c== -1) return "eof"; /* eof or error */
1635  else if (isdigit(c))
1636  { s_ungetc(c,d->f_read); return "ready"; }
1637  else if (c>' ')
1638  {
1639  Werror("unknown char in ssiLink(%d)",c);
1640  return "error";
1641  }
1642  /* else: next char */
1643  }
1644  }
1645  else if (strcmp(request, "read") == 0)
1646  {
1647  if (SI_LINK_R_OPEN_P(l) && (!s_iseof(d->f_read)) && (s_isready(d->f_read))) return "ready";
1648  else return "not ready";
1649  }
1650  else if (strcmp(request, "write") == 0)
1651  {
1652  if (SI_LINK_W_OPEN_P(l)) return "ready";
1653  else return "not ready";
1654  }

◆ ssiClose()

BOOLEAN ssiClose ( si_link  l)

Definition at line 1169 of file ssiLink.cc.

1172 {
1173  if (l!=NULL)
1174  {
1176  ssiInfo *d = (ssiInfo *)l->data;
1177  if (d!=NULL)
1178  {
1179  // send quit signal
1180  if ((d->send_quit_at_exit)
1181  && (d->quit_sent==0))
1182  {
1183  fputs("99\n",d->f_write);
1184  fflush(d->f_write);
1185  }
1186  // clean ring
1187  if (d->r!=NULL) rKill(d->r);
1188  // did the child to stop ?
1189  si_waitpid(d->pid,NULL,WNOHANG);
1190  if ((d->pid!=0)
1191  && (kill(d->pid,0)==0)) // child is still running
1192  {
1193  struct timespec t;
1194  t.tv_sec=0;
1195  t.tv_nsec=100000000; // <=100 ms
1196  struct timespec rem;
1197  int r;
1198  loop
1199  {
1200  // wait till signal or time rem:
1201  r = nanosleep(&t, &rem);
1202  t = rem;
1203  // child finished:
1204  if (si_waitpid(d->pid,NULL,WNOHANG) != 0) break;
1205  // other signal, waited s>= 100 ms:
1206  if ((r==0) || (errno != EINTR)) break;
1207  }
1208  if (kill(d->pid,0) == 0) // pid still exists
1209  {
1210  kill(d->pid,15);
1211  t.tv_sec=5; // <=5s
1212  t.tv_nsec=0;
1213  loop
1214  {
1215  // wait till signal or time rem:
1216  r = nanosleep(&t, &rem);
1217  t = rem;
1218  // child finished:
1219  if (si_waitpid(d->pid,NULL,WNOHANG) != 0) break;
1220  // other signal, waited s>= 5 s:
1221  if ((r==0) || (errno != EINTR)) break;
1222  }
1223  if (kill(d->pid,0) == 0)
1224  {
1225  kill(d->pid,9); // just to be sure
1226  si_waitpid(d->pid,NULL,0);
1227  }
1228  }
1229  }
1230  if (d->f_read!=NULL) { s_close(d->f_read);d->f_read=NULL;}
1231  if (d->f_write!=NULL) { fclose(d->f_write); d->f_write=NULL; }
1232  if ((strcmp(l->mode,"tcp")==0)
1233  || (strcmp(l->mode,"fork")==0))
1234  {
1236  if (hh!=NULL)
1237  {
1238  if (hh->l==l)
1239  {
1241  omFreeSize(hh,sizeof(link_struct));
1242  }
1243  else while(hh->next!=NULL)
1244  {
1245  link_list hhh=(link_list)hh->next;
1246  if (hhh->l==l)
1247  {
1248  hh->next=hhh->next;
1249  omFreeSize(hhh,sizeof(link_struct));
1250  break;
1251  }
1252  else
1253  hh=(link_list)hh->next;
1254  }
1255  }
1256  }
1257  omFreeSize((ADDRESS)d,(sizeof *d));
1258  }
1259  l->data=NULL;
1260  }

◆ ssiCommandLink()

si_link ssiCommandLink ( )

Definition at line 1899 of file ssiLink.cc.

1902 {
1903  if (ssiReserved_P==0)
1904  {
1905  WerrorS("ERROR no reverved port requested");
1906  return NULL;
1907  }
1908  struct sockaddr_in cli_addr;
1909  int clilen = sizeof(cli_addr);
1910  int newsockfd = si_accept(ssiReserved_sockfd, (struct sockaddr *) &cli_addr, (socklen_t *)&clilen);
1911  if(newsockfd < 0)
1912  {
1913  Werror("ERROR on accept (errno=%d)",errno);
1914  return NULL;
1915  }
1917  si_link_extension s = si_link_root;
1918  si_link_extension prev = s;
1919  while (strcmp(s->type, "ssi") != 0)
1920  {
1921  if (s->next == NULL)
1922  {
1923  prev = s;
1924  s = NULL;
1925  break;
1926  }
1927  else
1928  {
1929  s = s->next;
1930  }
1931  }
1932  if (s != NULL)
1933  l->m = s;
1934  else
1935  {
1936  si_link_extension ns = (si_link_extension)omAlloc0Bin(s_si_link_extension_bin);
1937  prev->next=slInitSsiExtension(ns);
1938  l->m = prev->next;
1939  }
1940  l->name=omStrDup("");
1941  l->mode=omStrDup("tcp");
1942  l->ref=1;
1943  ssiInfo *d=(ssiInfo*)omAlloc0(sizeof(ssiInfo));
1944  l->data=d;
1945  d->fd_read = newsockfd;
1946  d->fd_write = newsockfd;
1947  d->f_read = s_open(newsockfd);
1948  d->f_write = fdopen(newsockfd, "w");
1951  if (ssiReserved_Clients<=0)
1952  {
1953  ssiReserved_P=0;
1954  si_close(ssiReserved_sockfd);
1955  }

◆ ssiOpen()

BOOLEAN ssiOpen ( si_link  l,
short  flag,
leftv  u 
)

Definition at line 784 of file ssiLink.cc.

787 {
788  if (l!=NULL)
789  {
790  const char *mode;
791  ssiInfo *d=(ssiInfo*)omAlloc0(sizeof(ssiInfo));
792  if (flag & SI_LINK_OPEN)
793  {
794  if (l->mode[0] != '\0' && (strcmp(l->mode, "r") == 0))
795  flag = SI_LINK_READ;
796  else flag = SI_LINK_WRITE;
797  }
798 
799  if (flag == SI_LINK_READ) mode = "r";
800  else if (strcmp(l->mode, "w") == 0) mode = "w";
801  else if (strcmp(l->mode, "fork") == 0) mode = "fork";
802  else if (strcmp(l->mode, "tcp") == 0) mode = "tcp";
803  else if (strcmp(l->mode, "connect") == 0) mode = "connect";
804  else mode = "a";
805 
806 
807  SI_LINK_SET_OPEN_P(l, flag);
808  if(l->data!=NULL) omFreeSize(l->data,sizeof(ssiInfo));
809  l->data=d;
810  omFree(l->mode);
811  l->mode = omStrDup(mode);
812 
813  if (l->name[0] == '\0')
814  {
815  if (strcmp(mode,"fork")==0)
816  {
818  n->u=u;
819  n->l=l;
820  n->next=(void *)ssiToBeClosed;
821  ssiToBeClosed=n;
822 
823  int pc[2];
824  int cp[2];
825  pipe(pc);
826  pipe(cp);
827  pid_t pid = fork();
828  if (pid == -1 && errno == EAGAIN) // RLIMIT_NPROC too low?
829  {
831  pid = fork();
832  }
833  if (pid == -1)
834  {
835  WerrorS("could not fork");
836  }
837  if (pid==0) /*fork: child*/
838  {
839  /* block SIGINT */
840  sigset_t sigint;
841  sigemptyset(&sigint);
842  sigaddset(&sigint, SIGINT);
843  sigprocmask(SIG_BLOCK, &sigint, NULL);
844 
846  /* we know: l is the first entry in ssiToBeClosed-list */
847  while(hh!=NULL)
848  {
849  SI_LINK_SET_CLOSE_P(hh->l);
850  ssiInfo *dd=(ssiInfo*)hh->l->data;
851  s_close(dd->f_read);
852  fclose(dd->f_write);
853  if (dd->r!=NULL) rKill(dd->r);
854  omFreeSize((ADDRESS)dd,(sizeof *dd));
855  hh->l->data=NULL;
856  link_list nn=(link_list)hh->next;
857  omFree(hh);
858  hh=nn;
859  }
861 #ifdef HAVE_SIMPLEIPC
862  memset(sem_acquired, 0, SIPC_MAX_SEMAPHORES*sizeof(sem_acquired[0]));
863 #endif // HAVE_SIMPLEIPC
864  si_close(pc[1]); si_close(cp[0]);
865  d->f_write=fdopen(cp[1],"w");
866  d->f_read=s_open(pc[0]);
867  d->fd_read=pc[0];
868  d->fd_write=cp[1];
869  //d->r=currRing;
870  //if (d->r!=NULL) d->r->ref++;
871  l->data=d;
872  omFree(l->mode);
873  l->mode = omStrDup(mode);
876  //myynest=0;
878  if ((u!=NULL)&&(u->rtyp==IDHDL))
879  {
880  idhdl h=(idhdl)u->data;
881  h->lev=0;
882  }
883  loop
884  {
885  if (!SI_LINK_OPEN_P(l)) m2_end(0);
886  if(d->f_read->is_eof) m2_end(0);
887  leftv h=ssiRead1(l); /*contains an exit.... */
888  if (feErrors != NULL && *feErrors != '\0')
889  {
890  // handle errors:
891  PrintS(feErrors); /* currently quite simple */
892  *feErrors = '\0';
893  }
894  ssiWrite(l,h);
895  h->CleanUp();
897  }
898  /* never reached*/
899  }
900  else if (pid>0) /*fork: parent*/
901  {
902  d->pid=pid;
903  si_close(pc[0]); si_close(cp[1]);
904  d->f_write=fdopen(pc[1],"w");
905  d->f_read=s_open(cp[0]);
906  d->fd_read=cp[0];
907  d->fd_write=pc[1];
909  d->send_quit_at_exit=1;
910  //d->r=currRing;
911  //if (d->r!=NULL) d->r->ref++;
912  }
913  else
914  {
915  Werror("fork failed (%d)",errno);
916  l->data=NULL;
917  omFree(d);
918  return TRUE;
919  }
920  }
921  // ---------------------------------------------------------------------
922  else if (strcmp(mode,"tcp")==0)
923  {
924  int sockfd, newsockfd, portno, clilen;
925  struct sockaddr_in serv_addr, cli_addr;
926  sockfd = socket(AF_INET, SOCK_STREAM, 0);
927  if(sockfd < 0)
928  {
929  WerrorS("ERROR opening socket");
930  l->data=NULL;
931  omFree(d);
932  return TRUE;
933  }
934  memset((char *) &serv_addr,0, sizeof(serv_addr));
935  portno = 1025;
936  serv_addr.sin_family = AF_INET;
937  serv_addr.sin_addr.s_addr = INADDR_ANY;
938  do
939  {
940  portno++;
941  serv_addr.sin_port = htons(portno);
942  if(portno > 50000)
943  {
944  WerrorS("ERROR on binding (no free port available?)");
945  l->data=NULL;
946  omFree(d);
947  return TRUE;
948  }
949  }
950  while(bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0);
951  Print("waiting on port %d\n", portno);mflush();
952  listen(sockfd,1);
953  newsockfd = si_accept(sockfd, (struct sockaddr *) &cli_addr, (socklen_t *)&clilen);
954  if(newsockfd < 0)
955  {
956  WerrorS("ERROR on accept");
957  l->data=NULL;
958  omFree(d);
959  return TRUE;
960  }
961  PrintS("client accepted\n");
962  d->fd_read = newsockfd;
963  d->fd_write = newsockfd;
964  d->f_read = s_open(newsockfd);
965  d->f_write = fdopen(newsockfd, "w");
967  si_close(sockfd);
968  }
969  // no ssi-Link on stdin or stdout
970  else
971  {
972  Werror("invalid mode >>%s<< for ssi",mode);
973  l->data=NULL;
974  omFree(d);
975  return TRUE;
976  }
977  }
978  // =========================================================================
979  else /*l->name=NULL*/
980  {
981  // tcp mode
982  if(strcmp(mode,"tcp")==0)
983  {
984  int sockfd, newsockfd, portno, clilen;
985  struct sockaddr_in serv_addr, cli_addr;
986  sockfd = socket(AF_INET, SOCK_STREAM, 0);
987  if(sockfd < 0)
988  {
989  WerrorS("ERROR opening socket");
990  l->data=NULL;
991  omFree(d);
992  return TRUE;
993  }
994  memset((char *) &serv_addr,0, sizeof(serv_addr));
995  portno = 1025;
996  serv_addr.sin_family = AF_INET;
997  serv_addr.sin_addr.s_addr = INADDR_ANY;
998  do
999  {
1000  portno++;
1001  serv_addr.sin_port = htons(portno);
1002  if(portno > 50000)
1003  {
1004  WerrorS("ERROR on binding (no free port available?)");
1005  l->data=NULL;
1006  return TRUE;
1007  }
1008  }
1009  while(bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0);
1010  //Print("waiting on port %d\n", portno);mflush();
1011  listen(sockfd,1);
1012  char* cli_host = (char*)omAlloc(256);
1013  char* path = (char*)omAlloc(1024);
1014  int r = si_sscanf(l->name,"%255[^:]:%s",cli_host,path);
1015  if(r == 0)
1016  {
1017  WerrorS("ERROR: no host specified");
1018  l->data=NULL;
1019  omFree(d);
1020  omFree(path);
1021  omFree(cli_host);
1022  return TRUE;
1023  }
1024  else if(r == 1)
1025  {
1026  WarnS("program not specified, using /usr/local/bin/Singular");
1027  Warn("in line >>%s<<",my_yylinebuf);
1028  strcpy(path,"/usr/local/bin/Singular");
1029  }
1030  char* ssh_command = (char*)omAlloc(256);
1031  char* ser_host = (char*)omAlloc(64);
1032  gethostname(ser_host,64);
1033  sprintf(ssh_command,"ssh %s %s -q --batch --link=ssi --MPhost=%s --MPport=%d &",cli_host,path,ser_host,portno);
1034  //Print("client on %s started:%s\n",cli_host,path);
1035  omFree(path);
1036  omFree(cli_host);
1037  if (TEST_OPT_PROT) { Print("running >>%s<<\n",ssh_command); }
1038  system(ssh_command);
1039  omFree(ssh_command);
1040  omFree(ser_host);
1041  clilen = sizeof(cli_addr);
1042  newsockfd = si_accept(sockfd, (struct sockaddr *) &cli_addr, (socklen_t *)&clilen);
1043  if(newsockfd < 0)
1044  {
1045  WerrorS("ERROR on accept");
1046  l->data=NULL;
1047  omFree(d);
1048  return TRUE;
1049  }
1050  //PrintS("client accepted\n");
1051  d->fd_read = newsockfd;
1052  d->fd_write = newsockfd;
1053  d->f_read = s_open(newsockfd);
1054  d->f_write = fdopen(newsockfd, "w");
1055  si_close(sockfd);
1057  d->send_quit_at_exit=1;
1058  link_list newlink=(link_list)omAlloc(sizeof(link_struct));
1059  newlink->u=u;
1060  newlink->l=l;
1061  newlink->next=(void *)ssiToBeClosed;
1062  ssiToBeClosed=newlink;
1063  fprintf(d->f_write,"98 %d %d %u %u\n",SSI_VERSION,MAX_TOK,si_opt_1,si_opt_2);
1064  }
1065  // ----------------------------------------------------------------------
1066  else if(strcmp(mode,"connect")==0)
1067  {
1068  char* host = (char*)omAlloc(256);
1069  int sockfd, portno;
1070  struct sockaddr_in serv_addr;
1071  struct hostent *server;
1072 
1073  si_sscanf(l->name,"%255[^:]:%d",host,&portno);
1074  //Print("connect to host %s, port %d\n",host,portno);mflush();
1075  if (portno!=0)
1076  {
1077  sockfd = socket(AF_INET, SOCK_STREAM, 0);
1078  if (sockfd < 0) { WerrorS("ERROR opening socket"); return TRUE; }
1079  server = gethostbyname(host);
1080  if (server == NULL) { WerrorS("ERROR, no such host"); return TRUE; }
1081  memset((char *) &serv_addr, 0, sizeof(serv_addr));
1082  serv_addr.sin_family = AF_INET;
1083  memcpy((char *)&serv_addr.sin_addr.s_addr,
1084  (char *)server->h_addr,
1085  server->h_length);
1086  serv_addr.sin_port = htons(portno);
1087  if (si_connect(sockfd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0)
1088  { Werror("ERROR connecting(errno=%d)",errno); return TRUE; }
1089  //PrintS("connected\n");mflush();
1090  d->f_read=s_open(sockfd);
1091  d->fd_read=sockfd;
1092  d->f_write=fdopen(sockfd,"w");
1093  d->fd_write=sockfd;
1095  omFree(host);
1096  }
1097  else
1098  {
1099  l->data=NULL;
1100  omFree(d);
1101  return TRUE;
1102  }
1103  }
1104  // ======================================================================
1105  else
1106  {
1107  // normal link to a file
1108  FILE *outfile;
1109  char *filename=l->name;
1110 
1111  if(filename[0]=='>')
1112  {
1113  if (filename[1]=='>')
1114  {
1115  filename+=2;
1116  mode = "a";
1117  }
1118  else
1119  {
1120  filename++;
1121  mode="w";
1122  }
1123  }
1124  outfile=myfopen(filename,mode);
1125  if (outfile!=NULL)
1126  {
1127  if (strcmp(l->mode,"r")==0)
1128  {
1129  fclose(outfile);
1130  d->f_read=s_open_by_name(filename);
1131  }
1132  else
1133  {
1134  d->f_write = outfile;
1135  fprintf(d->f_write,"98 %d %d %u %u\n",SSI_VERSION,MAX_TOK,si_opt_1,si_opt_2);
1136  }
1137  }
1138  else
1139  {
1140  omFree(d);
1141  l->data=NULL;
1142  return TRUE;
1143  }
1144  }
1145  }
1146  }
1147 

◆ ssiRead1()

leftv ssiRead1 ( si_link  l)

Definition at line 1263 of file ssiLink.cc.

1266 {
1267  ssiInfo *d = (ssiInfo *)l->data;
1269  int t=0;
1270  t=s_readint(d->f_read);
1271  //Print("got type %d\n",t);
1272  switch(t)
1273  {
1274  case 1:res->rtyp=INT_CMD;
1275  res->data=(char *)(long)ssiReadInt(d->f_read);
1276  break;
1277  case 2:res->rtyp=STRING_CMD;
1278  res->data=(char *)ssiReadString(d);
1279  break;
1280  case 3:res->rtyp=NUMBER_CMD;
1281  res->data=(char *)ssiReadNumber(d);
1282  break;
1283  case 4:res->rtyp=BIGINT_CMD;
1284  res->data=(char *)ssiReadBigInt(d);
1285  break;
1286  case 15:
1287  case 5:{
1288  d->r=ssiReadRing(d);
1289  if (d->r==NULL) return NULL;
1290  res->data=(char*)d->r;
1291  d->r->ref++;
1292  res->rtyp=RING_CMD;
1293  if (t==15) // setring
1294  {
1295  if(ssiSetCurrRing(d->r)) { d->r=currRing; d->r->ref++; }
1297  return ssiRead1(l);
1298  }
1299  }
1300  break;
1301  case 6:res->rtyp=POLY_CMD;
1302  if (d->r==NULL) goto no_ring;
1303  res->data=(char*)ssiReadPoly(d);
1304  break;
1305  case 7:res->rtyp=IDEAL_CMD;
1306  if (d->r==NULL) goto no_ring;
1307  res->data=(char*)ssiReadIdeal(d);
1308  break;
1309  case 8:res->rtyp=MATRIX_CMD;
1310  if (d->r==NULL) goto no_ring;
1311  res->data=(char*)ssiReadMatrix(d);
1312  break;
1313  case 9:res->rtyp=VECTOR_CMD;
1314  if (d->r==NULL) goto no_ring;
1315  res->data=(char*)ssiReadPoly(d);
1316  break;
1317  case 10:
1318  case 22:if (t==22) res->rtyp=SMATRIX_CMD;
1319  else res->rtyp=MODUL_CMD;
1320  if (d->r==NULL) goto no_ring;
1321  {
1322  int rk=s_readint(d->f_read);
1323  ideal M=ssiReadIdeal(d);
1324  M->rank=rk;
1325  res->data=(char*)M;
1326  }
1327  break;
1328  case 11:
1329  {
1330  res->rtyp=COMMAND;
1331  res->data=ssiReadCommand(l);
1332  int nok=res->Eval();
1333  if (nok) WerrorS("error in eval");
1334  break;
1335  }
1336  case 12: /*DEF_CMD*/
1337  {
1338  res->rtyp=0;
1339  res->name=(char *)ssiReadString(d);
1340  int nok=res->Eval();
1341  if (nok) WerrorS("error in name lookup");
1342  break;
1343  }
1344  case 13: res->rtyp=PROC_CMD;
1345  res->data=ssiReadProc(d);
1346  break;
1347  case 14: res->rtyp=LIST_CMD;
1348  res->data=ssiReadList(l);
1349  break;
1350  case 16: res->rtyp=NONE; res->data=NULL;
1351  break;
1352  case 17: res->rtyp=INTVEC_CMD;
1353  res->data=ssiReadIntvec(d);
1354  break;
1355  case 18: res->rtyp=INTMAT_CMD;
1356  res->data=ssiReadIntmat(d);
1357  break;
1358  case 19: res->rtyp=BIGINTMAT_CMD;
1359  res->data=ssiReadBigintmat(d);
1360  break;
1361  case 20: ssiReadBlackbox(res,l);
1362  break;
1363  case 21: ssiReadAttrib(res,l);
1364  break;
1365  // ------------
1366  case 98: // version
1367  {
1368  int n98_v,n98_m;
1369  BITSET n98_o1,n98_o2;
1370  n98_v=s_readint(d->f_read);
1371  n98_m=s_readint(d->f_read);
1372  n98_o1=s_readint(d->f_read);
1373  n98_o2=s_readint(d->f_read);
1374  if ((n98_v!=SSI_VERSION) ||(n98_m!=MAX_TOK))
1375  {
1376  Print("incompatible versions of ssi: %d/%d vs %d/%d\n",
1377  SSI_VERSION,MAX_TOK,n98_v,n98_m);
1378  }
1379  #ifndef SING_NDEBUG
1380  if (TEST_OPT_DEBUG)
1381  Print("// opening ssi-%d, MAX_TOK=%d\n",n98_v,n98_m);
1382  #endif
1383  si_opt_1=n98_o1;
1384  si_opt_2=n98_o2;
1386  return ssiRead1(l);
1387  }
1388  case 99: omFreeBin(res,sleftv_bin); ssiClose(l); m2_end(0);
1389  case 0: if (s_iseof(d->f_read))
1390  {
1391  ssiClose(l);
1392  }
1393  res->rtyp=DEF_CMD;
1394  break;
1395  default: Werror("not implemented (t:%d)",t);
1397  res=NULL;
1398  break;
1399  }
1400  // if currRing is required for the result, but lost
1401  // define "ssiRing%d" as currRing:
1402  if ((d->r!=NULL)
1403  && (currRing!=d->r)
1404  && (res->RingDependend()))
1405  {
1406  if(ssiSetCurrRing(d->r)) { d->r=currRing; d->r->ref++; }
1407  }
1408  return res;
1409 no_ring: WerrorS("no ring");

◆ ssiRead2()

leftv ssiRead2 ( si_link  l,
leftv  key 
)

◆ ssiWrite()

BOOLEAN ssiWrite ( si_link  l,
leftv  v 
)

Definition at line 1431 of file ssiLink.cc.

1434 {
1435  if(SI_LINK_W_OPEN_P(l)==0)
1436  if (slOpen(l,SI_LINK_OPEN|SI_LINK_WRITE,NULL)) return TRUE;
1437  ssiInfo *d = (ssiInfo *)l->data;
1438  d->level++;
1439  //FILE *fich=d->f;
1440  while (data!=NULL)
1441  {
1442  int tt=data->Typ();
1443  void *dd=data->Data();
1444  attr *aa=data->Attribute();
1445  BOOLEAN with_attr=FALSE;
1446  if ((aa!=NULL) && ((*aa)!=NULL))
1447  {
1448  attr a=*aa;
1449  int n=0;
1450  while(a!=NULL) { n++; a=a->next;}
1451  fprintf(d->f_write,"21 %d %d ",data->flag,n);
1452  }
1453  else if (data->flag!=0)
1454  {
1455  fprintf(d->f_write,"21 %d 0 ",data->flag);
1456  }
1457  if ((dd==NULL) && (data->name!=NULL) && (tt==0)) tt=DEF_CMD;
1458  // return pure undefined names as def
1459 
1460  switch(tt /*data->Typ()*/)
1461  {
1462  case 0: /*error*/
1463  case NONE/* nothing*/:fputs("16 ",d->f_write);
1464  break;
1465  case STRING_CMD: fputs("2 ",d->f_write);
1466  ssiWriteString(d,(char *)dd);
1467  break;
1468  case INT_CMD: fputs("1 ",d->f_write);
1469  ssiWriteInt(d,(int)(long)dd);
1470  break;
1471  case BIGINT_CMD:fputs("4 ",d->f_write);
1472  ssiWriteBigInt(d,(number)dd);
1473  break;
1474  case NUMBER_CMD:
1475  if (d->r!=currRing)
1476  {
1477  fputs("15 ",d->f_write);
1479  if (d->level<=1) fputc('\n',d->f_write);
1480  }
1481  fputs("3 ",d->f_write);
1482  ssiWriteNumber(d,(number)dd);
1483  break;
1484  case RING_CMD:fputs("5 ",d->f_write);
1485  ssiWriteRing(d,(ring)dd);
1486  break;
1487  case BUCKET_CMD:
1488  {
1489  sBucket_pt b=(sBucket_pt)dd;
1490  if (d->r!=sBucketGetRing(b))
1491  {
1492  fputs("15 ",d->f_write);
1494  if (d->level<=1) fputc('\n',d->f_write);
1495  }
1496  fputs("6 ",d->f_write);
1497  ssiWritePoly(d,tt,sBucketPeek(b));
1498  break;
1499  }
1500  case POLY_CMD:
1501  case VECTOR_CMD:
1502  if (d->r!=currRing)
1503  {
1504  fputs("15 ",d->f_write);
1506  if (d->level<=1) fputc('\n',d->f_write);
1507  }
1508  if(tt==POLY_CMD) fputs("6 ",d->f_write);
1509  else fputs("9 ",d->f_write);
1510  ssiWritePoly(d,tt,(poly)dd);
1511  break;
1512  case IDEAL_CMD:
1513  case MODUL_CMD:
1514  case MATRIX_CMD:
1515  case SMATRIX_CMD:
1516  if (d->r!=currRing)
1517  {
1518  fputs("15 ",d->f_write);
1520  if (d->level<=1) fputc('\n',d->f_write);
1521  }
1522  if(tt==IDEAL_CMD) fputs("7 ",d->f_write);
1523  else if(tt==MATRIX_CMD) fputs("8 ",d->f_write);
1524  else if(tt==SMATRIX_CMD) fputs("22 ",d->f_write);
1525  else
1526  {
1527  ideal M=(ideal)dd;
1528  fprintf(d->f_write,"10 %d ",(int)M->rank);
1529  }
1530  ssiWriteIdeal(d,tt,(ideal)dd);
1531  break;
1532  case COMMAND:
1533  fputs("11 ",d->f_write);
1534  ssiWriteCommand(l,(command)dd);
1535  break;
1536  case DEF_CMD: /* not evaluated stuff in quotes */
1537  fputs("12 ",d->f_write);
1538  ssiWriteString(d,data->Name());
1539  break;
1540  case PROC_CMD:
1541  fputs("13 ",d->f_write);
1542  ssiWriteProc(d,(procinfov)dd);
1543  break;
1544  case LIST_CMD:
1545  fputs("14 ",d->f_write);
1546  ssiWriteList(l,(lists)dd);
1547  break;
1548  case INTVEC_CMD:
1549  fputs("17 ",d->f_write);
1550  ssiWriteIntvec(d,(intvec *)dd);
1551  break;
1552  case INTMAT_CMD:
1553  fputs("18 ",d->f_write);
1554  ssiWriteIntmat(d,(intvec *)dd);
1555  break;
1556  case BIGINTMAT_CMD:
1557  fputs("19 ",d->f_write);
1558  ssiWriteBigintmat(d,(bigintmat *)dd);
1559  break;
1560  default:
1561  if (tt>MAX_TOK)
1562  {
1563  blackbox *b=getBlackboxStuff(tt);
1564  fputs("20 ",d->f_write);
1565  b->blackbox_serialize(b,dd,l);
1566  }
1567  else
1568  {
1569  Werror("not implemented (t:%d, rtyp:%d)",tt, data->rtyp);
1570  d->level=0;
1571  return TRUE;
1572  }
1573  break;
1574  }
1575  if (d->level<=1) { fputc('\n',d->f_write); fflush(d->f_write); }
1576  data=data->next;
1577  }
1578  d->level--;
FALSE
#define FALSE
Definition: auxiliary.h:94
fe_fgets_dummy
char * fe_fgets_dummy(const char *, char *, int)
Definition: feread.cc:451
s_iseof
int s_iseof(s_buff F)
Definition: s_buff.cc:250
status
int * status
Definition: si_signals.h:50
omFree
#define omFree(addr)
Definition: omAllocDecl.h:259
ssiInfo
Definition: s_buff.h:20
TEST_OPT_PROT
#define TEST_OPT_PROT
Definition: options.h:101
raise_rlimit_nproc
int raise_rlimit_nproc()
Definition: rlimit.c:18
NUMBER_CMD
Definition: grammar.cc:288
bigintmat
Definition: bigintmat.h:50
s_readint
int s_readint(s_buff F)
Definition: s_buff.cc:110
ssiInfo::pid
pid_t pid
Definition: s_buff.h:25
BIGINT_CMD
Definition: tok.h:37
LIST_CMD
Definition: tok.h:117
ADDRESS
void * ADDRESS
Definition: auxiliary.h:133
MODUL_CMD
Definition: grammar.cc:287
STRING_CMD
Definition: tok.h:182
ssiInfo::send_quit_at_exit
char send_quit_at_exit
Definition: s_buff.h:28
BITSET
#define BITSET
Definition: structs.h:17
NONE
#define NONE
Definition: tok.h:218
MAX_TOK
Definition: tok.h:215
rKill
void rKill(ring r)
Definition: ipshell.cc:6118
procinfo
Definition: subexpr.h:52
sattr
Definition: attrib.h:16
omStrDup
#define omStrDup(s)
Definition: omAllocDecl.h:261
ssiInfo::fd_write
int fd_write
Definition: s_buff.h:26
DEF_CMD
Definition: tok.h:57
TEST_OPT_DEBUG
#define TEST_OPT_DEBUG
Definition: options.h:106
BIGINTMAT_CMD
Definition: grammar.cc:278
omAlloc0Bin
#define omAlloc0Bin(bin)
Definition: omAllocDecl.h:204
fe_fgets_stdin
char *(* fe_fgets_stdin)(const char *pr, char *s, int size)
Definition: feread.cc:34
ssiInfo::level
char level
Definition: s_buff.h:27
loop
#define loop
Definition: structs.h:77
sBucketGetRing
ring sBucketGetRing(const sBucket_pt bucket)
Returns bucket ring.
Definition: sbuckets.cc:46
sleftv
Class used for (list of) interpreter objects.
Definition: subexpr.h:81
ssiInfo::f_read
s_buff f_read
Definition: s_buff.h:22
idhdl
idrec * idhdl
Definition: ring.h:21
RING_CMD
Definition: grammar.cc:281
b
CanonicalForm b
Definition: cfModGcd.cc:4044
m2_end
void m2_end(int i)
Definition: misc_ip.cc:1101
MATRIX_CMD
Definition: grammar.cc:286
singular_in_batchmode
BOOLEAN singular_in_batchmode
Definition: cntrlc.cc:67
currRing
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
TRUE
#define TRUE
Definition: auxiliary.h:98
res
CanonicalForm res
Definition: facAbsFact.cc:64
INT_CMD
Definition: tok.h:95
COMMAND
#define COMMAND
Definition: tok.h:28
sBucketPeek
poly sBucketPeek(sBucket_pt b)
Definition: sbuckets.cc:453
M
#define M
Definition: sirandom.c:24
PrintS
void PrintS(const char *s)
Definition: reporter.cc:283
s_close
int s_close(s_buff &F)
Definition: s_buff.cc:43
omFreeSize
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:258
BOOLEAN
int BOOLEAN
Definition: auxiliary.h:85
PROC_CMD
Definition: grammar.cc:280
ssiInfo::r
ring r
Definition: s_buff.h:24
s_open_by_name
s_buff s_open_by_name(const char *n)
Definition: s_buff.cc:37
IDEAL_CMD
Definition: grammar.cc:284
s_ungetc
void s_ungetc(int c, s_buff F)
Definition: s_buff.cc:97
h
static Poly * h
Definition: janet.cc:972
sBucket_pt
sBucket * sBucket_pt
Definition: sbuckets.h:14
intvec
Definition: intvec.h:16
sleftv::data
void * data
Definition: subexpr.h:87
omAlloc
#define omAlloc(size)
Definition: omAllocDecl.h:208
s_open
s_buff s_open(int fd)
Definition: s_buff.cc:29
VECTOR_CMD
Definition: grammar.cc:292
ssiInfo::f_write
FILE * f_write
Definition: s_buff.h:23
my_yylinebuf
char my_yylinebuf[80]
Definition: febase.cc:42
sBucket
Definition: sbuckets.cc:29
slists
Definition: lists.h:21
INTVEC_CMD
Definition: tok.h:100
INTMAT_CMD
Definition: grammar.cc:279
s_isready
int s_isready(s_buff F)
Definition: s_buff.cc:83
idrec
Definition: idrec.h:33
system
void system(sys)
BUCKET_CMD
Definition: grammar.cc:283
myfopen
FILE * myfopen(const char *path, const char *mode)
Definition: feFopen.cc:166
feErrors
char * feErrors
Definition: reporter.cc:46
Print
#define Print
Definition: emacs.cc:79
sattr::next
attr next
Definition: attrib.h:25
Werror
void Werror(const char *fmt,...)
Definition: reporter.cc:188
while
while(1)
Definition: libparse.cc:1441
SIPC_MAX_SEMAPHORES
#define SIPC_MAX_SEMAPHORES
Definition: simpleipc.h:10
command
ip_command * command
Definition: ipid.h:21
IDHDL
#define IDHDL
Definition: tok.h:30
WerrorS
void WerrorS(const char *s)
Definition: feFopen.cc:24
WarnS
#define WarnS
Definition: emacs.cc:77
sleftv::rtyp
int rtyp
Definition: subexpr.h:90
NULL
#define NULL
Definition: omList.c:9
mflush
#define mflush()
Definition: reporter.h:56
l
int l
Definition: cfEzgcd.cc:93
Warn
#define Warn
Definition: emacs.cc:76
sleftv_bin
omBin sleftv_bin
Definition: subexpr.cc:46
ssiInfo::quit_sent
char quit_sent
Definition: s_buff.h:29
s
const CanonicalForm int s
Definition: facAbsFact.cc:55
ssiInfo::fd_read
int fd_read
Definition: s_buff.h:26
POLY_CMD
Definition: grammar.cc:289
s_getc
int s_getc(s_buff F)
Definition: s_buff.cc:56
omFreeBin
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:257
getBlackboxStuff
blackbox * getBlackboxStuff(const int t)
return the structure to the type given by t
Definition: blackbox.cc:16
omAlloc0
#define omAlloc0(size)
Definition: omAllocDecl.h:209
rem
void rem(unsigned long *a, unsigned long *q, unsigned long p, int &dega, int degq)
Definition: minpoly.cc:572
if
if(yy_init)
Definition: libparse.cc:1417
sem_acquired
int sem_acquired[SIPC_MAX_SEMAPHORES]
Definition: semaphore.c:25
si_opt_2
unsigned si_opt_2
Definition: options.c:6
SMATRIX_CMD
Definition: grammar.cc:291
si_opt_1
unsigned si_opt_1
Definition: options.c:5