Data Structures | Functions
ssiLink.h File Reference
#include "Singular/links/silink.h"

Go to the source code of this file.

Data Structures

struct  ssiInfo
 

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...
 

Data Structure Documentation

◆ ssiInfo

struct ssiInfo

Definition at line 13 of file ssiLink.h.

Data Fields
s_buff f_read
FILE * f_write
int fd_read
int fd_write
char level
pid_t pid
char quit_sent
ring r
char send_quit_at_exit

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

1952 {
1953  pid_t kidpid;
1954  int status;
1955 
1956  loop
1957  {
1958  kidpid = si_waitpid(-1, &status, WNOHANG);
1959  if (kidpid==-1)
1960  {
1961  /* continue on interruption (EINTR): */
1962  if (errno == EINTR) continue;
1963  /* break on anything else (EINVAL or ECHILD according to manpage): */
1964  break;
1965  }
1966  else if (kidpid==0) break; /* no more children to process, so break */
1967 
1968  //printf("Child %ld terminated\n", kidpid);
1970  while((hh!=NULL)&&(ssiToBeClosed_inactive))
1971  {
1972  if((hh->l!=NULL) && (hh->l->m->Open==ssiOpen))
1973  {
1974  ssiInfo *d = (ssiInfo *)hh->l->data;
1975  if(d->pid==kidpid)
1976  {
1978  {
1980  slClose(hh->l);
1982  break;
1983  }
1984  else break;
1985  }
1986  else hh=(link_list)hh->next;
1987  }
1988  else hh=(link_list)hh->next;
1989  }
1990  }
1991 }
#define FALSE
Definition: auxiliary.h:94
#define TRUE
Definition: auxiliary.h:98
#define loop
Definition: structs.h:78
#define NULL
Definition: omList.c:10
int * status
Definition: si_signals.h:51

◆ slInitSsiExtension()

si_link_extension slInitSsiExtension ( si_link_extension  s)

Definition at line 1564 of file ssiLink.cc.

1565 {
1566  s->Open=ssiOpen;
1567  s->Close=ssiClose;
1568  s->Kill=ssiClose;
1569  s->Read=ssiRead1;
1570  s->Read2=(slRead2Proc)NULL;
1571  s->Write=ssiWrite;
1572  s->Dump=ssiDump;
1573  s->GetDump=ssiGetDump;
1574 
1575  s->Status=slStatusSsi;
1576  s->SetRing=ssiSetRing;
1577  s->type="ssi";
1578  return s;
1579 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
#define NULL
Definition: omList.c:10

◆ slStatusSsi()

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

Definition at line 1581 of file ssiLink.cc.

1582 {
1583  ssiInfo *d=(ssiInfo*)l->data;
1584  if (d==NULL) return "not open";
1585  if (((strcmp(l->mode,"fork")==0)
1586  ||(strcmp(l->mode,"tcp")==0)
1587  ||(strcmp(l->mode,"connect")==0))
1588  && (strcmp(request, "read") == 0))
1589  {
1590  fd_set mask;
1591  struct timeval wt;
1592  if (s_isready(d->f_read)) return "ready";
1593  loop
1594  {
1595  /* Don't block. Return socket status immediately. */
1596  wt.tv_sec = 0;
1597  wt.tv_usec = 0;
1598 
1599  FD_ZERO(&mask);
1600  FD_SET(d->fd_read, &mask);
1601  //Print("test fd %d\n",d->fd_read);
1602  /* check with select: chars waiting: no -> not ready */
1603  switch (si_select(d->fd_read+1, &mask, NULL, NULL, &wt))
1604  {
1605  case 0: /* not ready */ return "not ready";
1606  case -1: /*error*/ return "error";
1607  case 1: /*ready ? */ break;
1608  }
1609  /* yes: read 1 char*/
1610  /* if \n, check again with select else ungetc(c), ready*/
1611  int c=s_getc(d->f_read);
1612  //Print("try c=%d\n",c);
1613  if (c== -1) return "eof"; /* eof or error */
1614  else if (isdigit(c))
1615  { s_ungetc(c,d->f_read); return "ready"; }
1616  else if (c>' ')
1617  {
1618  Werror("unknown char in ssiLink(%d)",c);
1619  return "error";
1620  }
1621  /* else: next char */
1622  }
1623  }
1624  else if (strcmp(request, "read") == 0)
1625  {
1626  if (SI_LINK_R_OPEN_P(l) && (!s_iseof(d->f_read)) && (s_isready(d->f_read))) return "ready";
1627  else return "not ready";
1628  }
1629  else if (strcmp(request, "write") == 0)
1630  {
1631  if (SI_LINK_W_OPEN_P(l)) return "ready";
1632  else return "not ready";
1633  }
1634  else return "unknown status request";
1635 }
#define loop
Definition: structs.h:78
int s_getc(s_buff F)
Definition: s_buff.cc:56
if(yy_init)
Definition: libparse.cc:1418
void s_ungetc(int c, s_buff F)
Definition: s_buff.cc:97
int s_iseof(s_buff F)
Definition: s_buff.cc:250
#define NULL
Definition: omList.c:10
int s_isready(s_buff F)
Definition: s_buff.cc:83
void Werror(const char *fmt,...)
Definition: reporter.cc:189
int l
Definition: cfEzgcd.cc:93

◆ ssiClose()

BOOLEAN ssiClose ( si_link  l)

Definition at line 1167 of file ssiLink.cc.

1168 {
1169  if (l!=NULL)
1170  {
1172  ssiInfo *d = (ssiInfo *)l->data;
1173  if (d!=NULL)
1174  {
1175  // send quit signal
1176  if ((d->send_quit_at_exit)
1177  && (d->quit_sent==0))
1178  {
1179  fputs("99\n",d->f_write);
1180  fflush(d->f_write);
1181  }
1182  // clean ring
1183  if (d->r!=NULL) rKill(d->r);
1184  // did the child to stop ?
1185  si_waitpid(d->pid,NULL,WNOHANG);
1186  if ((d->pid!=0)
1187  && (kill(d->pid,0)==0)) // child is still running
1188  {
1189  struct timespec t;
1190  t.tv_sec=0;
1191  t.tv_nsec=100000000; // <=100 ms
1192  struct timespec rem;
1193  int r;
1194  loop
1195  {
1196  // wait till signal or time rem:
1197  r = nanosleep(&t, &rem);
1198  t = rem;
1199  // child finished:
1200  if (si_waitpid(d->pid,NULL,WNOHANG) != 0) break;
1201  // other signal, waited s>= 100 ms:
1202  if ((r==0) || (errno != EINTR)) break;
1203  }
1204  if (kill(d->pid,0) == 0) // pid still exists
1205  {
1206  kill(d->pid,15);
1207  t.tv_sec=5; // <=5s
1208  t.tv_nsec=0;
1209  loop
1210  {
1211  // wait till signal or time rem:
1212  r = nanosleep(&t, &rem);
1213  t = rem;
1214  // child finished:
1215  if (si_waitpid(d->pid,NULL,WNOHANG) != 0) break;
1216  // other signal, waited s>= 5 s:
1217  if ((r==0) || (errno != EINTR)) break;
1218  }
1219  if (kill(d->pid,0) == 0)
1220  {
1221  kill(d->pid,9); // just to be sure
1222  si_waitpid(d->pid,NULL,0);
1223  }
1224  }
1225  }
1226  if (d->f_read!=NULL) { s_close(d->f_read);d->f_read=NULL;}
1227  if (d->f_write!=NULL) { fclose(d->f_write); d->f_write=NULL; }
1228  if ((strcmp(l->mode,"tcp")==0)
1229  || (strcmp(l->mode,"fork")==0))
1230  {
1232  if (hh!=NULL)
1233  {
1234  if (hh->l==l)
1235  {
1237  omFreeSize(hh,sizeof(link_struct));
1238  }
1239  else while(hh->next!=NULL)
1240  {
1241  link_list hhh=(link_list)hh->next;
1242  if (hhh->l==l)
1243  {
1244  hh->next=hhh->next;
1245  omFreeSize(hhh,sizeof(link_struct));
1246  break;
1247  }
1248  else
1249  hh=(link_list)hh->next;
1250  }
1251  }
1252  }
1253  omFreeSize((ADDRESS)d,(sizeof *d));
1254  }
1255  l->data=NULL;
1256  }
1257  return FALSE;
1258 }
void rem(unsigned long *a, unsigned long *q, unsigned long p, int &dega, int degq)
Definition: minpoly.cc:572
#define FALSE
Definition: auxiliary.h:94
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
void * ADDRESS
Definition: auxiliary.h:133
#define loop
Definition: structs.h:78
int s_close(s_buff &F)
Definition: s_buff.cc:43
if(yy_init)
Definition: libparse.cc:1418
void rKill(ring r)
Definition: ipshell.cc:6076
#define NULL
Definition: omList.c:10
int l
Definition: cfEzgcd.cc:93

◆ ssiCommandLink()

si_link ssiCommandLink ( )

Definition at line 1880 of file ssiLink.cc.

1881 {
1882  if (ssiReserved_P==0)
1883  {
1884  WerrorS("ERROR no reverved port requested");
1885  return NULL;
1886  }
1887  struct sockaddr_in cli_addr;
1888  int clilen = sizeof(cli_addr);
1889  int newsockfd = si_accept(ssiReserved_sockfd, (struct sockaddr *) &cli_addr, (socklen_t *)&clilen);
1890  if(newsockfd < 0)
1891  {
1892  Werror("ERROR on accept (errno=%d)",errno);
1893  return NULL;
1894  }
1896  si_link_extension s = si_link_root;
1897  si_link_extension prev = s;
1898  while (strcmp(s->type, "ssi") != 0)
1899  {
1900  if (s->next == NULL)
1901  {
1902  prev = s;
1903  s = NULL;
1904  break;
1905  }
1906  else
1907  {
1908  s = s->next;
1909  }
1910  }
1911  if (s != NULL)
1912  l->m = s;
1913  else
1914  {
1915  si_link_extension ns = (si_link_extension)omAlloc0Bin(s_si_link_extension_bin);
1916  prev->next=slInitSsiExtension(ns);
1917  l->m = prev->next;
1918  }
1919  l->name=omStrDup("");
1920  l->mode=omStrDup("tcp");
1921  l->ref=1;
1922  ssiInfo *d=(ssiInfo*)omAlloc0(sizeof(ssiInfo));
1923  l->data=d;
1924  d->fd_read = newsockfd;
1925  d->fd_write = newsockfd;
1926  d->f_read = s_open(newsockfd);
1927  d->f_write = fdopen(newsockfd, "w");
1930  if (ssiReserved_Clients<=0)
1931  {
1932  ssiReserved_P=0;
1933  si_close(ssiReserved_sockfd);
1934  }
1935  return l;
1936 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
void WerrorS(const char *s)
Definition: feFopen.cc:24
#define omAlloc0Bin(bin)
Definition: omAllocDecl.h:206
#define NULL
Definition: omList.c:10
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:29
#define omStrDup(s)
Definition: omAllocDecl.h:263

◆ ssiOpen()

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

Definition at line 782 of file ssiLink.cc.

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

◆ ssiRead1()

leftv ssiRead1 ( si_link  l)

Definition at line 1261 of file ssiLink.cc.

1262 {
1263  ssiInfo *d = (ssiInfo *)l->data;
1265  int t=0;
1266  t=s_readint(d->f_read);
1267  //Print("got type %d\n",t);
1268  switch(t)
1269  {
1270  case 1:res->rtyp=INT_CMD;
1271  res->data=(char *)(long)ssiReadInt(d->f_read);
1272  break;
1273  case 2:res->rtyp=STRING_CMD;
1274  res->data=(char *)ssiReadString(d);
1275  break;
1276  case 3:res->rtyp=NUMBER_CMD;
1277  res->data=(char *)ssiReadNumber(d);
1278  break;
1279  case 4:res->rtyp=BIGINT_CMD;
1280  res->data=(char *)ssiReadBigInt(d);
1281  break;
1282  case 15:
1283  case 5:{
1284  d->r=ssiReadRing(d);
1285  if (d->r==NULL) return NULL;
1286  res->data=(char*)d->r;
1287  d->r->ref++;
1288  res->rtyp=RING_CMD;
1289  if (t==15) // setring
1290  {
1291  if(ssiSetCurrRing(d->r)) { d->r=currRing; d->r->ref++; }
1293  return ssiRead1(l);
1294  }
1295  }
1296  break;
1297  case 6:res->rtyp=POLY_CMD;
1298  if (d->r==NULL) goto no_ring;
1299  res->data=(char*)ssiReadPoly(d);
1300  break;
1301  case 7:res->rtyp=IDEAL_CMD;
1302  if (d->r==NULL) goto no_ring;
1303  res->data=(char*)ssiReadIdeal(d);
1304  break;
1305  case 8:res->rtyp=MATRIX_CMD;
1306  if (d->r==NULL) goto no_ring;
1307  res->data=(char*)ssiReadMatrix(d);
1308  break;
1309  case 9:res->rtyp=VECTOR_CMD;
1310  if (d->r==NULL) goto no_ring;
1311  res->data=(char*)ssiReadPoly(d);
1312  break;
1313  case 10:res->rtyp=MODUL_CMD;
1314  if (d->r==NULL) goto no_ring;
1315  {
1316  int rk=s_readint(d->f_read);
1317  ideal M=ssiReadIdeal(d);
1318  M->rank=rk;
1319  res->data=(char*)M;
1320  }
1321  break;
1322  case 11:
1323  {
1324  res->rtyp=COMMAND;
1325  res->data=ssiReadCommand(l);
1326  int nok=res->Eval();
1327  if (nok) WerrorS("error in eval");
1328  break;
1329  }
1330  case 12: /*DEF_CMD*/
1331  {
1332  res->rtyp=0;
1333  res->name=(char *)ssiReadString(d);
1334  int nok=res->Eval();
1335  if (nok) WerrorS("error in name lookup");
1336  break;
1337  }
1338  case 13: res->rtyp=PROC_CMD;
1339  res->data=ssiReadProc(d);
1340  break;
1341  case 14: res->rtyp=LIST_CMD;
1342  res->data=ssiReadList(l);
1343  break;
1344  case 16: res->rtyp=NONE; res->data=NULL;
1345  break;
1346  case 17: res->rtyp=INTVEC_CMD;
1347  res->data=ssiReadIntvec(d);
1348  break;
1349  case 18: res->rtyp=INTMAT_CMD;
1350  res->data=ssiReadIntmat(d);
1351  break;
1352  case 19: res->rtyp=BIGINTMAT_CMD;
1353  res->data=ssiReadBigintmat(d);
1354  break;
1355  case 20: ssiReadBlackbox(res,l);
1356  break;
1357  case 21: ssiReadAttrib(res,l);
1358  break;
1359  // ------------
1360  case 98: // version
1361  {
1362  int n98_v,n98_m;
1363  BITSET n98_o1,n98_o2;
1364  n98_v=s_readint(d->f_read);
1365  n98_m=s_readint(d->f_read);
1366  n98_o1=s_readint(d->f_read);
1367  n98_o2=s_readint(d->f_read);
1368  if ((n98_v!=SSI_VERSION) ||(n98_m!=MAX_TOK))
1369  {
1370  Print("incompatible versions of ssi: %d/%d vs %d/%d\n",
1371  SSI_VERSION,MAX_TOK,n98_v,n98_m);
1372  }
1373  #ifndef SING_NDEBUG
1374  if (TEST_OPT_DEBUG)
1375  Print("// opening ssi-%d, MAX_TOK=%d\n",n98_v,n98_m);
1376  #endif
1377  si_opt_1=n98_o1;
1378  si_opt_2=n98_o2;
1380  return ssiRead1(l);
1381  }
1382  case 99: omFreeBin(res,sleftv_bin); ssiClose(l); m2_end(0);
1383  case 0: if (s_iseof(d->f_read))
1384  {
1385  ssiClose(l);
1386  }
1387  res->rtyp=DEF_CMD;
1388  break;
1389  default: Werror("not implemented (t:%d)",t);
1391  res=NULL;
1392  break;
1393  }
1394  // if currRing is required for the result, but lost
1395  // define "ssiRing%d" as currRing:
1396  if ((d->r!=NULL)
1397  && (currRing!=d->r)
1398  && (res->RingDependend()))
1399  {
1400  if(ssiSetCurrRing(d->r)) { d->r=currRing; d->r->ref++; }
1401  }
1402  return res;
1403 no_ring: WerrorS("no ring");
1405  return NULL;
1406 }
unsigned si_opt_1
Definition: options.c:5
Class used for (list of) interpreter objects.
Definition: subexpr.h:82
#define Print
Definition: emacs.cc:80
Definition: tok.h:96
Definition: tok.h:38
Definition: tok.h:215
void WerrorS(const char *s)
Definition: feFopen.cc:24
#define TEST_OPT_DEBUG
Definition: options.h:107
#define BITSET
Definition: structs.h:18
#define M
Definition: sirandom.c:24
if(yy_init)
Definition: libparse.cc:1418
CanonicalForm res
Definition: facAbsFact.cc:64
int s_readint(s_buff F)
Definition: s_buff.cc:110
Definition: tok.h:58
omBin sleftv_bin
Definition: subexpr.cc:46
int s_iseof(s_buff F)
Definition: s_buff.cc:250
#define omAlloc0Bin(bin)
Definition: omAllocDecl.h:206
void m2_end(int i)
Definition: misc_ip.cc:1099
#define NULL
Definition: omList.c:10
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
Definition: tok.h:118
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
unsigned si_opt_2
Definition: options.c:6
#define NONE
Definition: tok.h:218
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 1427 of file ssiLink.cc.

1428 {
1429  if(SI_LINK_W_OPEN_P(l)==0)
1430  if (slOpen(l,SI_LINK_OPEN|SI_LINK_WRITE,NULL)) return TRUE;
1431  ssiInfo *d = (ssiInfo *)l->data;
1432  d->level++;
1433  //FILE *fich=d->f;
1434  while (data!=NULL)
1435  {
1436  int tt=data->Typ();
1437  void *dd=data->Data();
1438  attr *aa=data->Attribute();
1439  BOOLEAN with_attr=FALSE;
1440  if ((aa!=NULL) && ((*aa)!=NULL))
1441  {
1442  attr a=*aa;
1443  int n=0;
1444  while(a!=NULL) { n++; a=a->next;}
1445  fprintf(d->f_write,"21 %d %d ",data->flag,n);
1446  }
1447  else if (data->flag!=0)
1448  {
1449  fprintf(d->f_write,"21 %d 0 ",data->flag);
1450  }
1451  if ((dd==NULL) && (data->name!=NULL) && (tt==0)) tt=DEF_CMD;
1452  // return pure undefined names as def
1453 
1454  switch(tt /*data->Typ()*/)
1455  {
1456  case 0: /*error*/
1457  case NONE/* nothing*/:fputs("16 ",d->f_write);
1458  break;
1459  case STRING_CMD: fputs("2 ",d->f_write);
1460  ssiWriteString(d,(char *)dd);
1461  break;
1462  case INT_CMD: fputs("1 ",d->f_write);
1463  ssiWriteInt(d,(int)(long)dd);
1464  break;
1465  case BIGINT_CMD:fputs("4 ",d->f_write);
1466  ssiWriteBigInt(d,(number)dd);
1467  break;
1468  case NUMBER_CMD:
1469  if (d->r!=currRing)
1470  {
1471  fputs("15 ",d->f_write);
1473  if (d->level<=1) fputc('\n',d->f_write);
1474  }
1475  fputs("3 ",d->f_write);
1476  ssiWriteNumber(d,(number)dd);
1477  break;
1478  case RING_CMD:fputs("5 ",d->f_write);
1479  ssiWriteRing(d,(ring)dd);
1480  break;
1481  case POLY_CMD:
1482  case VECTOR_CMD:
1483  if (d->r!=currRing)
1484  {
1485  fputs("15 ",d->f_write);
1487  if (d->level<=1) fputc('\n',d->f_write);
1488  }
1489  if(tt==POLY_CMD) fputs("6 ",d->f_write);
1490  else fputs("9 ",d->f_write);
1491  ssiWritePoly(d,tt,(poly)dd);
1492  break;
1493  case IDEAL_CMD:
1494  case MODUL_CMD:
1495  case MATRIX_CMD:
1496  if (d->r!=currRing)
1497  {
1498  fputs("15 ",d->f_write);
1500  if (d->level<=1) fputc('\n',d->f_write);
1501  }
1502  if(tt==IDEAL_CMD) fputs("7 ",d->f_write);
1503  else if(tt==MATRIX_CMD) fputs("8 ",d->f_write);
1504  else
1505  {
1506  ideal M=(ideal)dd;
1507  fprintf(d->f_write,"10 %d ",(int)M->rank);
1508  }
1509  ssiWriteIdeal(d,tt,(ideal)dd);
1510  break;
1511  case COMMAND:
1512  fputs("11 ",d->f_write);
1513  ssiWriteCommand(l,(command)dd);
1514  break;
1515  case DEF_CMD: /* not evaluated stuff in quotes */
1516  fputs("12 ",d->f_write);
1517  ssiWriteString(d,data->Name());
1518  break;
1519  case PROC_CMD:
1520  fputs("13 ",d->f_write);
1521  ssiWriteProc(d,(procinfov)dd);
1522  break;
1523  case LIST_CMD:
1524  fputs("14 ",d->f_write);
1525  ssiWriteList(l,(lists)dd);
1526  break;
1527  case INTVEC_CMD:
1528  fputs("17 ",d->f_write);
1529  ssiWriteIntvec(d,(intvec *)dd);
1530  break;
1531  case INTMAT_CMD:
1532  fputs("18 ",d->f_write);
1533  ssiWriteIntmat(d,(intvec *)dd);
1534  break;
1535  case BIGINTMAT_CMD:
1536  fputs("19 ",d->f_write);
1537  ssiWriteBigintmat(d,(bigintmat *)dd);
1538  break;
1539  default:
1540  if (tt>MAX_TOK)
1541  {
1542  blackbox *b=getBlackboxStuff(tt);
1543  fputs("20 ",d->f_write);
1544  b->blackbox_serialize(b,dd,l);
1545  }
1546  else
1547  {
1548  Werror("not implemented (t:%d, rtyp:%d)",tt, data->rtyp);
1549  d->level=0;
1550  return TRUE;
1551  }
1552  break;
1553  }
1554  if (d->level<=1) { fputc('\n',d->f_write); fflush(d->f_write); }
1555  data=data->next;
1556  }
1557  d->level--;
1558  return FALSE;
1559 }
ip_command * command
Definition: ipid.h:22
Definition: tok.h:96
Definition: attrib.h:17
Definition: lists.h:22
#define FALSE
Definition: auxiliary.h:94
Definition: tok.h:38
Matrices of numbers.
Definition: bigintmat.h:51
Definition: tok.h:215
#define TRUE
Definition: auxiliary.h:98
#define M
Definition: sirandom.c:24
CanonicalForm b
Definition: cfModGcd.cc:4044
Definition: intvec.h:17
Definition: tok.h:58
while(1)
Definition: libparse.cc:1442
#define NULL
Definition: omList.c:10
attr next
Definition: attrib.h:26
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
Definition: tok.h:118
int BOOLEAN
Definition: auxiliary.h:85
#define NONE
Definition: tok.h:218
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