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 2034 of file ssiLink.cc.

2035 {
2036  pid_t kidpid;
2037  int status;
2038 
2039  loop
2040  {
2041  kidpid = si_waitpid(-1, &status, WNOHANG);
2042  if (kidpid==-1)
2043  {
2044  /* continue on interruption (EINTR): */
2045  if (errno == EINTR) continue;
2046  /* break on anything else (EINVAL or ECHILD according to manpage): */
2047  break;
2048  }
2049  else if (kidpid==0) break; /* no more children to process, so break */
2050 
2051  //printf("Child %ld terminated\n", kidpid);
2053  while((hh!=NULL)&&(ssiToBeClosed_inactive))
2054  {
2055  if((hh->l!=NULL) && (hh->l->m->Open==ssiOpen))
2056  {
2057  ssiInfo *d = (ssiInfo *)hh->l->data;
2058  if(d->pid==kidpid)
2059  {
2061  {
2063  slClose(hh->l);
2065  break;
2066  }
2067  else break;
2068  }
2069  else hh=(link_list)hh->next;
2070  }
2071  else hh=(link_list)hh->next;
2072  }
2073  }
2074 }
Definition: s_buff.h:20
#define FALSE
Definition: auxiliary.h:96
#define TRUE
Definition: auxiliary.h:100
pid_t pid
Definition: s_buff.h:25
#define loop
Definition: structs.h:80
#define NULL
Definition: omList.c:12
int * status
Definition: si_signals.h:51

◆ slInitSsiExtension()

si_link_extension slInitSsiExtension ( si_link_extension  s)

Definition at line 1647 of file ssiLink.cc.

1648 {
1649  s->Open=ssiOpen;
1650  s->Close=ssiClose;
1651  s->Kill=ssiClose;
1652  s->Read=ssiRead1;
1653  s->Read2=(slRead2Proc)NULL;
1654  s->Write=ssiWrite;
1655  s->Dump=ssiDump;
1656  s->GetDump=ssiGetDump;
1657 
1658  s->Status=slStatusSsi;
1659  s->SetRing=ssiSetRing;
1660  s->type="ssi";
1661  return s;
1662 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
#define NULL
Definition: omList.c:12

◆ slStatusSsi()

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

Definition at line 1664 of file ssiLink.cc.

1665 {
1666  ssiInfo *d=(ssiInfo*)l->data;
1667  if (d==NULL) return "not open";
1668  if (((strcmp(l->mode,"fork")==0)
1669  ||(strcmp(l->mode,"tcp")==0)
1670  ||(strcmp(l->mode,"connect")==0))
1671  && (strcmp(request, "read") == 0))
1672  {
1673  fd_set mask;
1674  struct timeval wt;
1675  if (s_isready(d->f_read)) return "ready";
1676  loop
1677  {
1678  /* Don't block. Return socket status immediately. */
1679  wt.tv_sec = 0;
1680  wt.tv_usec = 0;
1681 
1682  FD_ZERO(&mask);
1683  FD_SET(d->fd_read, &mask);
1684  //Print("test fd %d\n",d->fd_read);
1685  /* check with select: chars waiting: no -> not ready */
1686  switch (si_select(d->fd_read+1, &mask, NULL, NULL, &wt))
1687  {
1688  case 0: /* not ready */ return "not ready";
1689  case -1: /*error*/ return "error";
1690  case 1: /*ready ? */ break;
1691  }
1692  /* yes: read 1 char*/
1693  /* if \n, check again with select else ungetc(c), ready*/
1694  int c=s_getc(d->f_read);
1695  //Print("try c=%d\n",c);
1696  if (c== -1) return "eof"; /* eof or error */
1697  else if (isdigit(c))
1698  { s_ungetc(c,d->f_read); return "ready"; }
1699  else if (c>' ')
1700  {
1701  Werror("unknown char in ssiLink(%d)",c);
1702  return "error";
1703  }
1704  /* else: next char */
1705  }
1706  }
1707  else if (strcmp(request, "read") == 0)
1708  {
1709  if (SI_LINK_R_OPEN_P(l) && (!s_iseof(d->f_read)) && (s_isready(d->f_read))) return "ready";
1710  else return "not ready";
1711  }
1712  else if (strcmp(request, "write") == 0)
1713  {
1714  if (SI_LINK_W_OPEN_P(l)) return "ready";
1715  else return "not ready";
1716  }
1717  else return "unknown status request";
1718 }
Definition: s_buff.h:20
#define loop
Definition: structs.h:80
int s_getc(s_buff F)
Definition: s_buff.cc:58
s_buff f_read
Definition: s_buff.h:22
if(yy_init)
Definition: libparse.cc:1420
void s_ungetc(int c, s_buff F)
Definition: s_buff.cc:99
int s_iseof(s_buff F)
Definition: s_buff.cc:252
#define NULL
Definition: omList.c:12
int fd_read
Definition: s_buff.h:26
int s_isready(s_buff F)
Definition: s_buff.cc:85
void Werror(const char *fmt,...)
Definition: reporter.cc:189
int l
Definition: cfEzgcd.cc:93

◆ ssiClose()

BOOLEAN ssiClose ( si_link  l)

Definition at line 1230 of file ssiLink.cc.

1231 {
1232  if (l!=NULL)
1233  {
1235  ssiInfo *d = (ssiInfo *)l->data;
1236  if (d!=NULL)
1237  {
1238  // send quit signal
1239  if ((d->send_quit_at_exit)
1240  && (d->quit_sent==0))
1241  {
1242  fputs("99\n",d->f_write);
1243  fflush(d->f_write);
1244  }
1245  // clean ring
1246  if (d->r!=NULL) rKill(d->r);
1247  // did the child to stop ?
1248  si_waitpid(d->pid,NULL,WNOHANG);
1249  if ((d->pid!=0)
1250  && (kill(d->pid,0)==0)) // child is still running
1251  {
1252  struct timespec t;
1253  t.tv_sec=0;
1254  t.tv_nsec=100000000; // <=100 ms
1255  struct timespec rem;
1256  int r;
1257  loop
1258  {
1259  // wait till signal or time rem:
1260  r = nanosleep(&t, &rem);
1261  t = rem;
1262  // child finished:
1263  if (si_waitpid(d->pid,NULL,WNOHANG) != 0) break;
1264  // other signal, waited s>= 100 ms:
1265  if ((r==0) || (errno != EINTR)) break;
1266  }
1267  if (kill(d->pid,0) == 0) // pid still exists
1268  {
1269  kill(d->pid,15);
1270  t.tv_sec=5; // <=5s
1271  t.tv_nsec=0;
1272  loop
1273  {
1274  // wait till signal or time rem:
1275  r = nanosleep(&t, &rem);
1276  t = rem;
1277  // child finished:
1278  if (si_waitpid(d->pid,NULL,WNOHANG) != 0) break;
1279  // other signal, waited s>= 5 s:
1280  if ((r==0) || (errno != EINTR)) break;
1281  }
1282  if (kill(d->pid,0) == 0)
1283  {
1284  kill(d->pid,9); // just to be sure
1285  si_waitpid(d->pid,NULL,0);
1286  }
1287  }
1288  }
1289  if (d->f_read!=NULL) { s_close(d->f_read);d->f_read=NULL;}
1290  if (d->f_write!=NULL) { fclose(d->f_write); d->f_write=NULL; }
1291  if ((strcmp(l->mode,"tcp")==0)
1292  || (strcmp(l->mode,"fork")==0))
1293  {
1295  if (hh!=NULL)
1296  {
1297  if (hh->l==l)
1298  {
1300  omFreeSize(hh,sizeof(link_struct));
1301  }
1302  else while(hh->next!=NULL)
1303  {
1304  link_list hhh=(link_list)hh->next;
1305  if (hhh->l==l)
1306  {
1307  hh->next=hhh->next;
1308  omFreeSize(hhh,sizeof(link_struct));
1309  break;
1310  }
1311  else
1312  hh=(link_list)hh->next;
1313  }
1314  }
1315  }
1316  omFreeSize((ADDRESS)d,(sizeof *d));
1317  }
1318  l->data=NULL;
1319  }
1320  return FALSE;
1321 }
Definition: s_buff.h:20
void rem(unsigned long *a, unsigned long *q, unsigned long p, int &dega, int degq)
Definition: minpoly.cc:572
char send_quit_at_exit
Definition: s_buff.h:28
#define FALSE
Definition: auxiliary.h:96
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
pid_t pid
Definition: s_buff.h:25
void * ADDRESS
Definition: auxiliary.h:135
#define loop
Definition: structs.h:80
ring r
Definition: s_buff.h:24
int s_close(s_buff &F)
Definition: s_buff.cc:45
s_buff f_read
Definition: s_buff.h:22
if(yy_init)
Definition: libparse.cc:1420
void rKill(ring r)
Definition: ipshell.cc:6124
#define NULL
Definition: omList.c:12
FILE * f_write
Definition: s_buff.h:23
int l
Definition: cfEzgcd.cc:93
char quit_sent
Definition: s_buff.h:29

◆ ssiCommandLink()

si_link ssiCommandLink ( )

Definition at line 1963 of file ssiLink.cc.

1964 {
1965  if (ssiReserved_P==0)
1966  {
1967  WerrorS("ERROR no reverved port requested");
1968  return NULL;
1969  }
1970  struct sockaddr_in cli_addr;
1971  int clilen = sizeof(cli_addr);
1972  int newsockfd = si_accept(ssiReserved_sockfd, (struct sockaddr *) &cli_addr, (socklen_t *)&clilen);
1973  if(newsockfd < 0)
1974  {
1975  Werror("ERROR on accept (errno=%d)",errno);
1976  return NULL;
1977  }
1979  si_link_extension s = si_link_root;
1980  si_link_extension prev = s;
1981  while (strcmp(s->type, "ssi") != 0)
1982  {
1983  if (s->next == NULL)
1984  {
1985  prev = s;
1986  s = NULL;
1987  break;
1988  }
1989  else
1990  {
1991  s = s->next;
1992  }
1993  }
1994  if (s != NULL)
1995  l->m = s;
1996  else
1997  {
1998  si_link_extension ns = (si_link_extension)omAlloc0Bin(s_si_link_extension_bin);
1999  prev->next=slInitSsiExtension(ns);
2000  l->m = prev->next;
2001  }
2002  l->name=omStrDup("");
2003  l->mode=omStrDup("tcp");
2004  l->ref=1;
2005  ssiInfo *d=(ssiInfo*)omAlloc0(sizeof(ssiInfo));
2006  l->data=d;
2007  d->fd_read = newsockfd;
2008  d->fd_write = newsockfd;
2009  d->f_read = s_open(newsockfd);
2010  d->f_write = fdopen(newsockfd, "w");
2013  if (ssiReserved_Clients<=0)
2014  {
2015  ssiReserved_P=0;
2016  si_close(ssiReserved_sockfd);
2017  }
2018  return l;
2019 }
Definition: s_buff.h:20
const CanonicalForm int s
Definition: facAbsFact.cc:55
int fd_write
Definition: s_buff.h:26
void WerrorS(const char *s)
Definition: feFopen.cc:24
s_buff f_read
Definition: s_buff.h:22
#define omAlloc0Bin(bin)
Definition: omAllocDecl.h:206
#define NULL
Definition: omList.c:12
FILE * f_write
Definition: s_buff.h:23
int fd_read
Definition: s_buff.h:26
void Werror(const char *fmt,...)
Definition: reporter.cc:189
#define omAlloc0(size)
Definition: omAllocDecl.h:211
int l
Definition: cfEzgcd.cc:93
s_buff s_open(int fd)
Definition: s_buff.cc:31
#define omStrDup(s)
Definition: omAllocDecl.h:263

◆ ssiOpen()

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

Definition at line 845 of file ssiLink.cc.

846 {
847  if (l!=NULL)
848  {
849  const char *mode;
850  ssiInfo *d=(ssiInfo*)omAlloc0(sizeof(ssiInfo));
851  if (flag & SI_LINK_OPEN)
852  {
853  if (l->mode[0] != '\0' && (strcmp(l->mode, "r") == 0))
854  flag = SI_LINK_READ;
855  else flag = SI_LINK_WRITE;
856  }
857 
858  if (flag == SI_LINK_READ) mode = "r";
859  else if (strcmp(l->mode, "w") == 0) mode = "w";
860  else if (strcmp(l->mode, "fork") == 0) mode = "fork";
861  else if (strcmp(l->mode, "tcp") == 0) mode = "tcp";
862  else if (strcmp(l->mode, "connect") == 0) mode = "connect";
863  else mode = "a";
864 
865 
866  SI_LINK_SET_OPEN_P(l, flag);
867  if(l->data!=NULL) omFreeSize(l->data,sizeof(ssiInfo));
868  l->data=d;
869  omFree(l->mode);
870  l->mode = omStrDup(mode);
871 
872  if (l->name[0] == '\0')
873  {
874  if (strcmp(mode,"fork")==0)
875  {
877  n->u=u;
878  n->l=l;
879  n->next=(void *)ssiToBeClosed;
880  ssiToBeClosed=n;
881 
882  int pc[2];
883  int cp[2];
884  pipe(pc);
885  pipe(cp);
886  pid_t pid = fork();
887  if (pid == -1 && errno == EAGAIN) // RLIMIT_NPROC too low?
888  {
890  pid = fork();
891  }
892  if (pid == -1)
893  {
894  WerrorS("could not fork");
895  }
896  if (pid==0) /*fork: child*/
897  {
898  /* block SIGINT */
899  sigset_t sigint;
900  sigemptyset(&sigint);
901  sigaddset(&sigint, SIGINT);
902  sigprocmask(SIG_BLOCK, &sigint, NULL);
903 
905  /* we know: l is the first entry in ssiToBeClosed-list */
906  while(hh!=NULL)
907  {
908  SI_LINK_SET_CLOSE_P(hh->l);
909  ssiInfo *dd=(ssiInfo*)hh->l->data;
910  s_close(dd->f_read);
911  fclose(dd->f_write);
912  if (dd->r!=NULL) rKill(dd->r);
913  omFreeSize((ADDRESS)dd,(sizeof *dd));
914  hh->l->data=NULL;
915  link_list nn=(link_list)hh->next;
916  omFree(hh);
917  hh=nn;
918  }
920 #ifdef HAVE_SIMPLEIPC
921  memset(sem_acquired, 0, SIPC_MAX_SEMAPHORES*sizeof(sem_acquired[0]));
922 #endif // HAVE_SIMPLEIPC
923  si_close(pc[1]); si_close(cp[0]);
924  d->f_write=fdopen(cp[1],"w");
925  d->f_read=s_open(pc[0]);
926  d->fd_read=pc[0];
927  d->fd_write=cp[1];
928  //d->r=currRing;
929  //if (d->r!=NULL) d->r->ref++;
930  l->data=d;
931  omFree(l->mode);
932  l->mode = omStrDup(mode);
935  //myynest=0;
937  if ((u!=NULL)&&(u->rtyp==IDHDL))
938  {
939  idhdl h=(idhdl)u->data;
940  h->lev=0;
941  }
942  loop
943  {
944  if (!SI_LINK_OPEN_P(l)) m2_end(0);
945  if(d->f_read->is_eof) m2_end(0);
946  leftv h=ssiRead1(l); /*contains an exit.... */
947  if (feErrors != NULL && *feErrors != '\0')
948  {
949  // handle errors:
950  PrintS(feErrors); /* currently quite simple */
951  *feErrors = '\0';
952  }
953  ssiWrite(l,h);
954  h->CleanUp();
955  omFreeBin(h, sleftv_bin);
956  }
957  /* never reached*/
958  }
959  else if (pid>0) /*fork: parent*/
960  {
961  d->pid=pid;
962  si_close(pc[0]); si_close(cp[1]);
963  d->f_write=fdopen(pc[1],"w");
964  d->f_read=s_open(cp[0]);
965  d->fd_read=cp[0];
966  d->fd_write=pc[1];
968  d->send_quit_at_exit=1;
969  //d->r=currRing;
970  //if (d->r!=NULL) d->r->ref++;
971  }
972  else
973  {
974  Werror("fork failed (%d)",errno);
975  l->data=NULL;
976  omFree(d);
977  return TRUE;
978  }
979  }
980  // ---------------------------------------------------------------------
981  else if (strcmp(mode,"tcp")==0)
982  {
983  int sockfd, newsockfd, portno, clilen;
984  struct sockaddr_in serv_addr, cli_addr;
985  sockfd = socket(AF_INET, SOCK_STREAM, 0);
986  if(sockfd < 0)
987  {
988  WerrorS("ERROR opening socket");
989  l->data=NULL;
990  omFree(d);
991  return TRUE;
992  }
993  memset((char *) &serv_addr,0, sizeof(serv_addr));
994  portno = 1025;
995  serv_addr.sin_family = AF_INET;
996  serv_addr.sin_addr.s_addr = INADDR_ANY;
997  do
998  {
999  portno++;
1000  serv_addr.sin_port = htons(portno);
1001  if(portno > 50000)
1002  {
1003  WerrorS("ERROR on binding (no free port available?)");
1004  l->data=NULL;
1005  omFree(d);
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  newsockfd = si_accept(sockfd, (struct sockaddr *) &cli_addr, (socklen_t *)&clilen);
1013  if(newsockfd < 0)
1014  {
1015  WerrorS("ERROR on accept");
1016  l->data=NULL;
1017  omFree(d);
1018  return TRUE;
1019  }
1020  PrintS("client accepted\n");
1021  d->fd_read = newsockfd;
1022  d->fd_write = newsockfd;
1023  d->f_read = s_open(newsockfd);
1024  d->f_write = fdopen(newsockfd, "w");
1026  si_close(sockfd);
1027  }
1028  // no ssi-Link on stdin or stdout
1029  else
1030  {
1031  Werror("invalid mode >>%s<< for ssi",mode);
1032  l->data=NULL;
1033  omFree(d);
1034  return TRUE;
1035  }
1036  }
1037  // =========================================================================
1038  else /*l->name=NULL*/
1039  {
1040  // tcp mode
1041  if(strcmp(mode,"tcp")==0)
1042  {
1043  int sockfd, newsockfd, portno, clilen;
1044  struct sockaddr_in serv_addr, cli_addr;
1045  sockfd = socket(AF_INET, SOCK_STREAM, 0);
1046  if(sockfd < 0)
1047  {
1048  WerrorS("ERROR opening socket");
1049  l->data=NULL;
1050  omFree(d);
1051  return TRUE;
1052  }
1053  memset((char *) &serv_addr,0, sizeof(serv_addr));
1054  portno = 1025;
1055  serv_addr.sin_family = AF_INET;
1056  serv_addr.sin_addr.s_addr = INADDR_ANY;
1057  do
1058  {
1059  portno++;
1060  serv_addr.sin_port = htons(portno);
1061  if(portno > 50000)
1062  {
1063  WerrorS("ERROR on binding (no free port available?)");
1064  l->data=NULL;
1065  return TRUE;
1066  }
1067  }
1068  while(bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0);
1069  //Print("waiting on port %d\n", portno);mflush();
1070  listen(sockfd,1);
1071  char* cli_host = (char*)omAlloc(256);
1072  char* path = (char*)omAlloc(1024);
1073  int r = si_sscanf(l->name,"%255[^:]:%s",cli_host,path);
1074  if(r == 0)
1075  {
1076  WerrorS("ERROR: no host specified");
1077  l->data=NULL;
1078  omFree(d);
1079  omFree(path);
1080  omFree(cli_host);
1081  return TRUE;
1082  }
1083  else if(r == 1)
1084  {
1085  WarnS("program not specified, using /usr/local/bin/Singular");
1086  Warn("in line >>%s<<",my_yylinebuf);
1087  strcpy(path,"/usr/local/bin/Singular");
1088  }
1089  char* ssh_command = (char*)omAlloc(256);
1090  char* ser_host = (char*)omAlloc(64);
1091  gethostname(ser_host,64);
1092  sprintf(ssh_command,"ssh %s %s -q --batch --link=ssi --MPhost=%s --MPport=%d &",cli_host,path,ser_host,portno);
1093  //Print("client on %s started:%s\n",cli_host,path);
1094  omFree(path);
1095  omFree(cli_host);
1096  if (TEST_OPT_PROT) { Print("running >>%s<<\n",ssh_command); }
1097  system(ssh_command);
1098  omFree(ssh_command);
1099  omFree(ser_host);
1100  clilen = sizeof(cli_addr);
1101  newsockfd = si_accept(sockfd, (struct sockaddr *) &cli_addr, (socklen_t *)&clilen);
1102  if(newsockfd < 0)
1103  {
1104  WerrorS("ERROR on accept");
1105  l->data=NULL;
1106  omFree(d);
1107  return TRUE;
1108  }
1109  //PrintS("client accepted\n");
1110  d->fd_read = newsockfd;
1111  d->fd_write = newsockfd;
1112  d->f_read = s_open(newsockfd);
1113  d->f_write = fdopen(newsockfd, "w");
1114  si_close(sockfd);
1116  d->send_quit_at_exit=1;
1117  link_list newlink=(link_list)omAlloc(sizeof(link_struct));
1118  newlink->u=u;
1119  newlink->l=l;
1120  newlink->next=(void *)ssiToBeClosed;
1121  ssiToBeClosed=newlink;
1122  fprintf(d->f_write,"98 %d %d %u %u\n",SSI_VERSION,MAX_TOK,si_opt_1,si_opt_2);
1123  }
1124  // ----------------------------------------------------------------------
1125  else if(strcmp(mode,"connect")==0)
1126  {
1127  char* host = (char*)omAlloc(256);
1128  int sockfd, portno;
1129  struct sockaddr_in serv_addr;
1130  struct hostent *server;
1131 
1132  si_sscanf(l->name,"%255[^:]:%d",host,&portno);
1133  //Print("connect to host %s, port %d\n",host,portno);mflush();
1134  if (portno!=0)
1135  {
1136  sockfd = socket(AF_INET, SOCK_STREAM, 0);
1137  if (sockfd < 0) { WerrorS("ERROR opening socket"); return TRUE; }
1138  server = gethostbyname(host);
1139  if (server == NULL) { WerrorS("ERROR, no such host"); return TRUE; }
1140  memset((char *) &serv_addr, 0, sizeof(serv_addr));
1141  serv_addr.sin_family = AF_INET;
1142  memcpy((char *)&serv_addr.sin_addr.s_addr,
1143  (char *)server->h_addr,
1144  server->h_length);
1145  serv_addr.sin_port = htons(portno);
1146  if (si_connect(sockfd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0)
1147  { Werror("ERROR connecting(errno=%d)",errno); return TRUE; }
1148  //PrintS("connected\n");mflush();
1149  d->f_read=s_open(sockfd);
1150  d->fd_read=sockfd;
1151  d->f_write=fdopen(sockfd,"w");
1152  d->fd_write=sockfd;
1154  omFree(host);
1155  }
1156  else
1157  {
1158  l->data=NULL;
1159  omFree(d);
1160  return TRUE;
1161  }
1162  }
1163  // ======================================================================
1164  else
1165  {
1166  // normal link to a file
1167  FILE *outfile;
1168  char *filename=l->name;
1169 
1170  if(filename[0]=='>')
1171  {
1172  if (filename[1]=='>')
1173  {
1174  filename+=2;
1175  mode = "a";
1176  }
1177  else
1178  {
1179  filename++;
1180  mode="w";
1181  }
1182  }
1183  outfile=myfopen(filename,mode);
1184  if (outfile!=NULL)
1185  {
1186  if (strcmp(l->mode,"r")==0)
1187  {
1188  fclose(outfile);
1189  d->f_read=s_open_by_name(filename);
1190  }
1191  else
1192  {
1193  d->f_write = outfile;
1194  fprintf(d->f_write,"98 %d %d %u %u\n",SSI_VERSION,MAX_TOK,si_opt_1,si_opt_2);
1195  }
1196  }
1197  else
1198  {
1199  omFree(d);
1200  l->data=NULL;
1201  return TRUE;
1202  }
1203  }
1204  }
1205  }
1206 
1207  return FALSE;
1208 }
Definition: s_buff.h:20
VAR unsigned si_opt_2
Definition: options.c:6
char *(* fe_fgets_stdin)(const char *pr, char *s, int size)
Definition: feread.cc:34
Class used for (list of) interpreter objects.
Definition: subexpr.h:82
#define Print
Definition: emacs.cc:80
int fd_write
Definition: s_buff.h:26
VAR char * feErrors
Definition: reporter.cc:47
EXTERN_VAR omBin sleftv_bin
Definition: ipid.h:140
VAR unsigned si_opt_1
Definition: options.c:5
#define TEST_OPT_PROT
Definition: options.h:101
char send_quit_at_exit
Definition: s_buff.h:28
#define FALSE
Definition: auxiliary.h:96
Definition: tok.h:217
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
char * fe_fgets_dummy(const char *, char *, int)
Definition: feread.cc:451
#define TRUE
Definition: auxiliary.h:100
pid_t pid
Definition: s_buff.h:25
void * ADDRESS
Definition: auxiliary.h:135
void WerrorS(const char *s)
Definition: feFopen.cc:24
#define loop
Definition: structs.h:80
ring r
Definition: s_buff.h:24
int s_close(s_buff &F)
Definition: s_buff.cc:45
#define WarnS
Definition: emacs.cc:78
#define omAlloc(size)
Definition: omAllocDecl.h:210
Definition: idrec.h:34
#define IDHDL
Definition: tok.h:31
void * data
Definition: subexpr.h:88
#define mflush()
Definition: reporter.h:57
s_buff f_read
Definition: s_buff.h:22
void rKill(ring r)
Definition: ipshell.cc:6124
#define omFree(addr)
Definition: omAllocDecl.h:261
FILE * myfopen(const char *path, const char *mode)
Definition: feFopen.cc:167
void system(sys)
int raise_rlimit_nproc()
Definition: rlimit.c:18
idrec * idhdl
Definition: ring.h:21
void PrintS(const char *s)
Definition: reporter.cc:284
void m2_end(int i)
Definition: misc_ip.cc:1096
STATIC_VAR Poly * h
Definition: janet.cc:971
#define NULL
Definition: omList.c:12
FILE * f_write
Definition: s_buff.h:23
short lev
Definition: idrec.h:45
VAR int sem_acquired[SIPC_MAX_SEMAPHORES]
Definition: semaphore.c:25
int rtyp
Definition: subexpr.h:91
#define SIPC_MAX_SEMAPHORES
Definition: simpleipc.h:10
void CleanUp(ring r=currRing)
Definition: subexpr.cc:348
int fd_read
Definition: s_buff.h:26
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
s_buff s_open_by_name(const char *n)
Definition: s_buff.cc:39
void Werror(const char *fmt,...)
Definition: reporter.cc:189
VAR char my_yylinebuf[80]
Definition: febase.cc:43
#define omAlloc0(size)
Definition: omAllocDecl.h:211
int l
Definition: cfEzgcd.cc:93
s_buff s_open(int fd)
Definition: s_buff.cc:31
#define Warn
Definition: emacs.cc:77
#define omStrDup(s)
Definition: omAllocDecl.h:263
VAR BOOLEAN singular_in_batchmode
Definition: cntrlc.cc:65

◆ ssiRead1()

leftv ssiRead1 ( si_link  l)

Definition at line 1324 of file ssiLink.cc.

1325 {
1326  ssiInfo *d = (ssiInfo *)l->data;
1328  int t=0;
1329  t=s_readint(d->f_read);
1330  //Print("got type %d\n",t);
1331  switch(t)
1332  {
1333  case 1:res->rtyp=INT_CMD;
1334  res->data=(char *)(long)ssiReadInt(d->f_read);
1335  break;
1336  case 2:res->rtyp=STRING_CMD;
1337  res->data=(char *)ssiReadString(d);
1338  break;
1339  case 3:res->rtyp=NUMBER_CMD;
1340  res->data=(char *)ssiReadNumber(d);
1341  break;
1342  case 4:res->rtyp=BIGINT_CMD;
1343  res->data=(char *)ssiReadBigInt(d);
1344  break;
1345  case 15:
1346  case 5:{
1347  d->r=ssiReadRing(d);
1348  if (d->r==NULL) return NULL;
1349  res->data=(char*)d->r;
1350  d->r->ref++;
1351  res->rtyp=RING_CMD;
1352  if (t==15) // setring
1353  {
1354  if(ssiSetCurrRing(d->r)) { d->r=currRing; d->r->ref++; }
1356  return ssiRead1(l);
1357  }
1358  }
1359  break;
1360  case 6:res->rtyp=POLY_CMD;
1361  if (d->r==NULL) goto no_ring;
1362  res->data=(char*)ssiReadPoly(d);
1363  break;
1364  case 7:res->rtyp=IDEAL_CMD;
1365  if (d->r==NULL) goto no_ring;
1366  res->data=(char*)ssiReadIdeal(d);
1367  break;
1368  case 8:res->rtyp=MATRIX_CMD;
1369  if (d->r==NULL) goto no_ring;
1370  res->data=(char*)ssiReadMatrix(d);
1371  break;
1372  case 9:res->rtyp=VECTOR_CMD;
1373  if (d->r==NULL) goto no_ring;
1374  res->data=(char*)ssiReadPoly(d);
1375  break;
1376  case 10:
1377  case 22:if (t==22) res->rtyp=SMATRIX_CMD;
1378  else res->rtyp=MODUL_CMD;
1379  if (d->r==NULL) goto no_ring;
1380  {
1381  int rk=s_readint(d->f_read);
1382  ideal M=ssiReadIdeal(d);
1383  M->rank=rk;
1384  res->data=(char*)M;
1385  }
1386  break;
1387  case 11:
1388  {
1389  res->rtyp=COMMAND;
1390  res->data=ssiReadCommand(l);
1391  int nok=res->Eval();
1392  if (nok) WerrorS("error in eval");
1393  break;
1394  }
1395  case 12: /*DEF_CMD*/
1396  {
1397  res->rtyp=0;
1398  res->name=(char *)ssiReadString(d);
1399  int nok=res->Eval();
1400  if (nok) WerrorS("error in name lookup");
1401  break;
1402  }
1403  case 13: res->rtyp=PROC_CMD;
1404  res->data=ssiReadProc(d);
1405  break;
1406  case 14: res->rtyp=LIST_CMD;
1407  res->data=ssiReadList(l);
1408  break;
1409  case 16: res->rtyp=NONE; res->data=NULL;
1410  break;
1411  case 17: res->rtyp=INTVEC_CMD;
1412  res->data=ssiReadIntvec(d);
1413  break;
1414  case 18: res->rtyp=INTMAT_CMD;
1415  res->data=ssiReadIntmat(d);
1416  break;
1417  case 19: res->rtyp=BIGINTMAT_CMD;
1418  res->data=ssiReadBigintmat(d);
1419  break;
1420  case 20: ssiReadBlackbox(res,l);
1421  break;
1422  case 21: ssiReadAttrib(res,l);
1423  break;
1424  case 23: ssiReadRingProperties(l);
1425  return ssiRead1(l);
1426  break;
1427  // ------------
1428  case 98: // version
1429  {
1430  int n98_v,n98_m;
1431  BITSET n98_o1,n98_o2;
1432  n98_v=s_readint(d->f_read);
1433  n98_m=s_readint(d->f_read);
1434  n98_o1=s_readint(d->f_read);
1435  n98_o2=s_readint(d->f_read);
1436  if ((n98_v!=SSI_VERSION) ||(n98_m!=MAX_TOK))
1437  {
1438  Print("incompatible versions of ssi: %d/%d vs %d/%d\n",
1439  SSI_VERSION,MAX_TOK,n98_v,n98_m);
1440  }
1441  #ifndef SING_NDEBUG
1442  if (TEST_OPT_DEBUG)
1443  Print("// opening ssi-%d, MAX_TOK=%d\n",n98_v,n98_m);
1444  #endif
1445  si_opt_1=n98_o1;
1446  si_opt_2=n98_o2;
1448  return ssiRead1(l);
1449  }
1450  case 99: omFreeBin(res,sleftv_bin); ssiClose(l); m2_end(0);
1451  case 0: if (s_iseof(d->f_read))
1452  {
1453  ssiClose(l);
1454  }
1455  res->rtyp=DEF_CMD;
1456  break;
1457  default: Werror("not implemented (t:%d)",t);
1459  res=NULL;
1460  break;
1461  }
1462  // if currRing is required for the result, but lost
1463  // define "ssiRing%d" as currRing:
1464  if ((d->r!=NULL)
1465  && (currRing!=d->r)
1466  && (res->RingDependend()))
1467  {
1468  if(ssiSetCurrRing(d->r)) { d->r=currRing; }
1469  }
1470  return res;
1471 no_ring: WerrorS("no ring");
1473  return NULL;
1474 }
Definition: s_buff.h:20
VAR unsigned si_opt_2
Definition: options.c:6
Class used for (list of) interpreter objects.
Definition: subexpr.h:82
#define Print
Definition: emacs.cc:80
Definition: tok.h:96
EXTERN_VAR omBin sleftv_bin
Definition: ipid.h:140
VAR unsigned si_opt_1
Definition: options.c:5
Definition: tok.h:38
Definition: tok.h:217
void WerrorS(const char *s)
Definition: feFopen.cc:24
#define TEST_OPT_DEBUG
Definition: options.h:106
ring r
Definition: s_buff.h:24
#define BITSET
Definition: structs.h:20
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
#define M
Definition: sirandom.c:25
s_buff f_read
Definition: s_buff.h:22
if(yy_init)
Definition: libparse.cc:1420
CanonicalForm res
Definition: facAbsFact.cc:64
int s_readint(s_buff F)
Definition: s_buff.cc:112
Definition: tok.h:58
int s_iseof(s_buff F)
Definition: s_buff.cc:252
#define omAlloc0Bin(bin)
Definition: omAllocDecl.h:206
void m2_end(int i)
Definition: misc_ip.cc:1096
#define NULL
Definition: omList.c:12
Definition: tok.h:118
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
#define NONE
Definition: tok.h:220
void Werror(const char *fmt,...)
Definition: reporter.cc:189
int l
Definition: cfEzgcd.cc:93
#define COMMAND
Definition: tok.h:29

◆ ssiRead2()

leftv ssiRead2 ( si_link  l,
leftv  key 
)

◆ ssiWrite()

BOOLEAN ssiWrite ( si_link  l,
leftv  v 
)

Definition at line 1495 of file ssiLink.cc.

1496 {
1497  if(SI_LINK_W_OPEN_P(l)==0)
1498  if (slOpen(l,SI_LINK_OPEN|SI_LINK_WRITE,NULL)) return TRUE;
1499  ssiInfo *d = (ssiInfo *)l->data;
1500  d->level++;
1501  //FILE *fich=d->f;
1502  while (data!=NULL)
1503  {
1504  int tt=data->Typ();
1505  void *dd=data->Data();
1506  attr *aa=data->Attribute();
1507  BOOLEAN with_attr=FALSE;
1508  if ((aa!=NULL) && ((*aa)!=NULL))
1509  {
1510  attr a=*aa;
1511  int n=0;
1512  while(a!=NULL) { n++; a=a->next;}
1513  fprintf(d->f_write,"21 %d %d ",data->flag,n);
1514  }
1515  else if (data->flag!=0)
1516  {
1517  fprintf(d->f_write,"21 %d 0 ",data->flag);
1518  }
1519  if ((dd==NULL) && (data->name!=NULL) && (tt==0)) tt=DEF_CMD;
1520  // return pure undefined names as def
1521 
1522  switch(tt /*data->Typ()*/)
1523  {
1524  case 0: /*error*/
1525  case NONE/* nothing*/:fputs("16 ",d->f_write);
1526  break;
1527  case STRING_CMD: fputs("2 ",d->f_write);
1528  ssiWriteString(d,(char *)dd);
1529  break;
1530  case INT_CMD: fputs("1 ",d->f_write);
1531  ssiWriteInt(d,(int)(long)dd);
1532  break;
1533  case BIGINT_CMD:fputs("4 ",d->f_write);
1534  ssiWriteBigInt(d,(number)dd);
1535  break;
1536  case NUMBER_CMD:
1537  if (d->r!=currRing)
1538  {
1539  fputs("15 ",d->f_write);
1541  if (d->level<=1) fputc('\n',d->f_write);
1542  }
1543  fputs("3 ",d->f_write);
1544  ssiWriteNumber(d,(number)dd);
1545  break;
1546  case RING_CMD:fputs("5 ",d->f_write);
1547  ssiWriteRing(d,(ring)dd);
1548  break;
1549  case BUCKET_CMD:
1550  {
1551  sBucket_pt b=(sBucket_pt)dd;
1552  if (d->r!=sBucketGetRing(b))
1553  {
1554  fputs("15 ",d->f_write);
1556  if (d->level<=1) fputc('\n',d->f_write);
1557  }
1558  fputs("6 ",d->f_write);
1559  ssiWritePoly(d,tt,sBucketPeek(b));
1560  break;
1561  }
1562  case POLY_CMD:
1563  case VECTOR_CMD:
1564  if (d->r!=currRing)
1565  {
1566  fputs("15 ",d->f_write);
1568  if (d->level<=1) fputc('\n',d->f_write);
1569  }
1570  if(tt==POLY_CMD) fputs("6 ",d->f_write);
1571  else fputs("9 ",d->f_write);
1572  ssiWritePoly(d,tt,(poly)dd);
1573  break;
1574  case IDEAL_CMD:
1575  case MODUL_CMD:
1576  case MATRIX_CMD:
1577  case SMATRIX_CMD:
1578  if (d->r!=currRing)
1579  {
1580  fputs("15 ",d->f_write);
1582  if (d->level<=1) fputc('\n',d->f_write);
1583  }
1584  if(tt==IDEAL_CMD) fputs("7 ",d->f_write);
1585  else if(tt==MATRIX_CMD) fputs("8 ",d->f_write);
1586  else if(tt==SMATRIX_CMD) fputs("22 ",d->f_write);
1587  else /* tt==MODUL_CMD*/
1588  {
1589  ideal M=(ideal)dd;
1590  fprintf(d->f_write,"10 %d ",(int)M->rank);
1591  }
1592  ssiWriteIdeal(d,tt,(ideal)dd);
1593  break;
1594  case COMMAND:
1595  fputs("11 ",d->f_write);
1596  ssiWriteCommand(l,(command)dd);
1597  break;
1598  case DEF_CMD: /* not evaluated stuff in quotes */
1599  fputs("12 ",d->f_write);
1600  ssiWriteString(d,data->Name());
1601  break;
1602  case PROC_CMD:
1603  fputs("13 ",d->f_write);
1604  ssiWriteProc(d,(procinfov)dd);
1605  break;
1606  case LIST_CMD:
1607  fputs("14 ",d->f_write);
1608  ssiWriteList(l,(lists)dd);
1609  break;
1610  case INTVEC_CMD:
1611  fputs("17 ",d->f_write);
1612  ssiWriteIntvec(d,(intvec *)dd);
1613  break;
1614  case INTMAT_CMD:
1615  fputs("18 ",d->f_write);
1616  ssiWriteIntmat(d,(intvec *)dd);
1617  break;
1618  case BIGINTMAT_CMD:
1619  fputs("19 ",d->f_write);
1620  ssiWriteBigintmat(d,(bigintmat *)dd);
1621  break;
1622  default:
1623  if (tt>MAX_TOK)
1624  {
1625  blackbox *b=getBlackboxStuff(tt);
1626  fputs("20 ",d->f_write);
1627  b->blackbox_serialize(b,dd,l);
1628  }
1629  else
1630  {
1631  Werror("not implemented (t:%d, rtyp:%d)",tt, data->rtyp);
1632  d->level=0;
1633  return TRUE;
1634  }
1635  break;
1636  }
1637  if (d->level<=1) { fputc('\n',d->f_write); fflush(d->f_write); }
1638  data=data->next;
1639  }
1640  d->level--;
1641  return FALSE;
1642 }
Definition: s_buff.h:20
ip_command * command
Definition: ipid.h:22
Definition: tok.h:96
Definition: attrib.h:17
Definition: lists.h:23
#define FALSE
Definition: auxiliary.h:96
Definition: tok.h:38
Matrices of numbers.
Definition: bigintmat.h:50
Definition: tok.h:217
char level
Definition: s_buff.h:27
#define TRUE
Definition: auxiliary.h:100
ring r
Definition: s_buff.h:24
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
#define M
Definition: sirandom.c:25
CanonicalForm b
Definition: cfModGcd.cc:4044
Definition: intvec.h:19
Definition: tok.h:58
sBucket * sBucket_pt
Definition: sbuckets.h:16
while(1)
Definition: libparse.cc:1444
ring sBucketGetRing(const sBucket_pt bucket)
Returns bucket ring.
Definition: sbuckets.cc:46
#define NULL
Definition: omList.c:12
FILE * f_write
Definition: s_buff.h:23
attr next
Definition: attrib.h:26
poly sBucketPeek(sBucket_pt b)
Definition: sbuckets.cc:455
Definition: tok.h:118
int BOOLEAN
Definition: auxiliary.h:87
#define NONE
Definition: tok.h:220
void Werror(const char *fmt,...)
Definition: reporter.cc:189
int l
Definition: cfEzgcd.cc:93
#define COMMAND
Definition: tok.h:29
blackbox * getBlackboxStuff(const int t)
return the structure to the type given by t
Definition: blackbox.cc:16