My Project
Macros | Functions | Variables
ssiLink.cc File Reference
#include "kernel/mod2.h"
#include "misc/intvec.h"
#include "misc/options.h"
#include "reporter/si_signals.h"
#include "reporter/s_buff.h"
#include "coeffs/bigintmat.h"
#include "coeffs/longrat.h"
#include "polys/monomials/ring.h"
#include "polys/monomials/p_polys.h"
#include "polys/ext_fields/transext.h"
#include "polys/simpleideals.h"
#include "polys/matpol.h"
#include "kernel/oswrapper/timer.h"
#include "kernel/oswrapper/feread.h"
#include "kernel/oswrapper/rlimit.h"
#include "Singular/tok.h"
#include "Singular/ipid.h"
#include "Singular/ipshell.h"
#include "Singular/subexpr.h"
#include "Singular/links/silink.h"
#include "Singular/cntrlc.h"
#include "Singular/feOpt.h"
#include "Singular/lists.h"
#include "Singular/blackbox.h"
#include "Singular/links/ssiLink.h"
#include "Singular/links/simpleipc.h"
#include <errno.h>
#include <sys/types.h>
#include <ctype.h>
#include <netdb.h>
#include <netinet/in.h>

Go to the source code of this file.

Macros

#define TRANSEXT_PRIVATES   1 /* allow access to transext internals */
 
#define SSI_VERSION   13
 

Functions

void ssiWritePoly_R (const ssiInfo *d, int typ, poly p, const ring r)
 
void ssiWriteIdeal_R (const ssiInfo *d, int typ, const ideal I, const ring r)
 
poly ssiReadPoly_R (const ssiInfo *D, const ring r)
 
ideal ssiReadIdeal_R (const ssiInfo *d, const ring r)
 
BOOLEAN ssiSetCurrRing (const ring r)
 
void ssiCheckCurrRing (const ring r)
 
void ssiWriteInt (const ssiInfo *d, const int i)
 
void ssiWriteString (const ssiInfo *d, const char *s)
 
void ssiWriteBigInt (const ssiInfo *d, const number n)
 
void ssiWriteNumber_CF (const ssiInfo *d, const number n, const coeffs cf)
 
void ssiWriteNumber (const ssiInfo *d, const number n)
 
void ssiWriteRing_R (ssiInfo *d, const ring r)
 
void ssiWriteRing (ssiInfo *d, const ring r)
 
void ssiWritePoly (const ssiInfo *d, int typ, poly p)
 
void ssiWriteIdeal (const ssiInfo *d, int typ, const ideal I)
 
void ssiWriteCommand (si_link l, command D)
 
void ssiWriteProc (const ssiInfo *d, procinfov p)
 
void ssiWriteList (si_link l, lists dd)
 
void ssiWriteIntvec (const ssiInfo *d, intvec *v)
 
void ssiWriteIntmat (const ssiInfo *d, intvec *v)
 
void ssiWriteBigintmat (const ssiInfo *d, bigintmat *v)
 
char * ssiReadString (const ssiInfo *d)
 
int ssiReadInt (s_buff fich)
 
number ssiReadNumber_CF (const ssiInfo *d, const coeffs cf)
 
number ssiReadBigInt (const ssiInfo *d)
 
number ssiReadNumber (ssiInfo *d)
 
ring ssiReadRing (const ssiInfo *d)
 
poly ssiReadPoly (ssiInfo *d)
 
ideal ssiReadIdeal (ssiInfo *d)
 
matrix ssiReadMatrix (ssiInfo *d)
 
command ssiReadCommand (si_link l)
 
procinfov ssiReadProc (const ssiInfo *d)
 
lists ssiReadList (si_link l)
 
intvecssiReadIntvec (const ssiInfo *d)
 
intvecssiReadIntmat (const ssiInfo *d)
 
bigintmatssiReadBigintmat (const ssiInfo *d)
 
void ssiReadBlackbox (leftv res, si_link l)
 
void ssiReadAttrib (leftv res, si_link l)
 
void ssiReadRingProperties (si_link l)
 
BOOLEAN ssiOpen (si_link l, short flag, leftv u)
 
BOOLEAN ssiPrepClose (si_link l)
 
BOOLEAN ssiClose (si_link l)
 
leftv ssiRead1 (si_link l)
 
BOOLEAN ssiSetRing (si_link l, ring r, BOOLEAN send)
 
BOOLEAN ssiWrite (si_link l, leftv data)
 
BOOLEAN ssiGetDump (si_link l)
 
BOOLEAN ssiDump (si_link l)
 
si_link_extension slInitSsiExtension (si_link_extension s)
 
const char * slStatusSsi (si_link l, const char *request)
 
int slStatusSsiL (lists L, int timeout)
 
int ssiBatch (const char *host, const char *port)
 
int ssiReservePort (int clients)
 
si_link ssiCommandLink ()
 
void sig_chld_hdl (int)
 additional default signal handler More...
 
static BOOLEAN DumpSsiIdhdl (si_link l, idhdl h)
 
static BOOLEAN ssiDumpIter (si_link l, idhdl h)
 

Variables

VAR link_list ssiToBeClosed =NULL
 
VAR volatile BOOLEAN ssiToBeClosed_inactive =TRUE
 
STATIC_VAR int ssiReserved_P =0
 
STATIC_VAR int ssiReserved_sockfd
 
STATIC_VAR struct sockaddr_in ssiResverd_serv_addr
 
STATIC_VAR int ssiReserved_Clients
 
EXTERN_VAR si_link_extension si_link_root
 

Macro Definition Documentation

◆ SSI_VERSION

#define SSI_VERSION   13

Definition at line 52 of file ssiLink.cc.

◆ TRANSEXT_PRIVATES

#define TRANSEXT_PRIVATES   1 /* allow access to transext internals */

Definition at line 8 of file ssiLink.cc.

Function Documentation

◆ DumpSsiIdhdl()

static BOOLEAN DumpSsiIdhdl ( si_link  l,
idhdl  h 
)
static

Definition at line 2182 of file ssiLink.cc.

2183 {
2184  int type_id = IDTYP(h);
2185 
2186  // C-proc not to be dumped, also LIB-proc not
2187  if (type_id == PROC_CMD)
2188  {
2189  if (IDPROC(h)->language == LANG_C) return FALSE;
2190  if (IDPROC(h)->libname != NULL) return FALSE;
2191  }
2192  // do not dump links
2193  if (type_id == LINK_CMD) return FALSE;
2194 
2195  // do not dump ssi internal rings: ssiRing*
2196  if ((type_id == RING_CMD) && (strncmp(IDID(h),"ssiRing",7)==0))
2197  return FALSE;
2198 
2199  // do not dump default cring:
2200  if (type_id == CRING_CMD)
2201  {
2202  if (strcmp(IDID(h),"ZZ")==0) return FALSE;
2203  if (strcmp(IDID(h),"QQ")==0) return FALSE;
2204  #ifdef SINGULAR_4_2
2205  if (strcmp(IDID(h),"AE")==0) return FALSE;
2206  if (strcmp(IDID(h),"QAE")==0) return FALSE;
2207  #endif
2208  }
2209 
2210  command D=(command)omAlloc0(sizeof(*D));
2211  sleftv tmp;
2212  memset(&tmp,0,sizeof(tmp));
2213  tmp.rtyp=COMMAND;
2214  tmp.data=D;
2215 
2216  if (type_id == PACKAGE_CMD)
2217  {
2218  // do not dump Top, Standard
2219  if ((strcmp(IDID(h), "Top") == 0)
2220  || (strcmp(IDID(h), "Standard") == 0))
2221  {
2222  omFreeSize(D,sizeof(*D));
2223  return FALSE;
2224  }
2225  package p=(package)IDDATA(h);
2226  // dump Singular-packages as LIB("...");
2227  if (p->language==LANG_SINGULAR)
2228  {
2229  D->op=LOAD_CMD;
2230  D->argc=2;
2231  D->arg1.rtyp=STRING_CMD;
2232  D->arg1.data=p->libname;
2233  D->arg2.rtyp=STRING_CMD;
2234  D->arg2.data=(char*)"with";
2235  ssiWrite(l,&tmp);
2236  omFreeSize(D,sizeof(*D));
2237  return FALSE;
2238  }
2239  // dump Singular-packages as load("...");
2240  else if (p->language==LANG_C)
2241  {
2242  D->op=LOAD_CMD;
2243  D->argc=1;
2244  D->arg1.rtyp=STRING_CMD;
2245  D->arg1.data=p->libname;
2246  ssiWrite(l,&tmp);
2247  omFreeSize(D,sizeof(*D));
2248  return FALSE;
2249  }
2250  }
2251 
2252  // put type and name
2253  //Print("generic dump:%s,%s\n",IDID(h),Tok2Cmdname(IDTYP(h)));
2254  D->op='=';
2255  D->argc=2;
2256  D->arg1.rtyp=DEF_CMD;
2257  D->arg1.name=IDID(h);
2258  D->arg2.rtyp=IDTYP(h);
2259  D->arg2.data=IDDATA(h);
2260  ssiWrite(l,&tmp);
2261  omFreeSize(D,sizeof(*D));
2262  return FALSE;
2263 }
#define FALSE
Definition: auxiliary.h:96
int l
Definition: cfEzgcd.cc:100
int p
Definition: cfModGcd.cc:4080
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
int rtyp
Definition: subexpr.h:91
void * data
Definition: subexpr.h:88
#define D(A)
Definition: gentable.cc:131
@ PROC_CMD
Definition: grammar.cc:280
@ RING_CMD
Definition: grammar.cc:281
ip_command * command
Definition: ipid.h:23
#define IDDATA(a)
Definition: ipid.h:126
#define IDPROC(a)
Definition: ipid.h:140
#define IDID(a)
Definition: ipid.h:122
#define IDTYP(a)
Definition: ipid.h:119
STATIC_VAR Poly * h
Definition: janet.cc:971
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
#define omAlloc0(size)
Definition: omAllocDecl.h:211
#define NULL
Definition: omList.c:12
@ LANG_SINGULAR
Definition: subexpr.h:22
@ LANG_C
Definition: subexpr.h:22
@ CRING_CMD
Definition: tok.h:56
@ PACKAGE_CMD
Definition: tok.h:149
@ DEF_CMD
Definition: tok.h:58
@ LINK_CMD
Definition: tok.h:117
@ STRING_CMD
Definition: tok.h:185
@ LOAD_CMD
Definition: tok.h:119
#define COMMAND
Definition: tok.h:29

◆ sig_chld_hdl()

void sig_chld_hdl ( int  sig)

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

2141 {
2142  pid_t kidpid;
2143  int status;
2144 
2145  loop
2146  {
2147  kidpid = si_waitpid(-1, &status, WNOHANG);
2148  if (kidpid==-1)
2149  {
2150  /* continue on interruption (EINTR): */
2151  if (errno == EINTR) continue;
2152  /* break on anything else (EINVAL or ECHILD according to manpage): */
2153  break;
2154  }
2155  else if (kidpid==0) break; /* no more children to process, so break */
2156 
2157  //printf("Child %ld terminated\n", kidpid);
2159  while((hh!=NULL)&&(ssiToBeClosed_inactive))
2160  {
2161  if((hh->l!=NULL) && (hh->l->m->Open==ssiOpen))
2162  {
2163  ssiInfo *d = (ssiInfo *)hh->l->data;
2164  if(d->pid==kidpid)
2165  {
2167  {
2169  slClose(hh->l);
2171  break;
2172  }
2173  else break;
2174  }
2175  else hh=(link_list)hh->next;
2176  }
2177  else hh=(link_list)hh->next;
2178  }
2179  }
2180 }
#define TRUE
Definition: auxiliary.h:100
pid_t pid
Definition: s_buff.h:25
Definition: s_buff.h:21
int * status
Definition: si_signals.h:51
#define loop
Definition: structs.h:80

◆ slInitSsiExtension()

si_link_extension slInitSsiExtension ( si_link_extension  s)

Definition at line 1753 of file ssiLink.cc.

1754 {
1755  s->Open=ssiOpen;
1756  s->Close=ssiClose;
1757  s->Kill=ssiClose;
1758  s->Read=ssiRead1;
1759  s->Read2=(slRead2Proc)NULL;
1760  s->Write=ssiWrite;
1761  s->Dump=ssiDump;
1762  s->GetDump=ssiGetDump;
1763 
1764  s->Status=slStatusSsi;
1765  s->SetRing=ssiSetRing;
1766  s->type="ssi";
1767  return s;
1768 }
const CanonicalForm int s
Definition: facAbsFact.cc:51

◆ slStatusSsi()

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

Definition at line 1770 of file ssiLink.cc.

1771 {
1772  ssiInfo *d=(ssiInfo*)l->data;
1773  if (d==NULL) return "not open";
1774  if (((strcmp(l->mode,"fork")==0)
1775  ||(strcmp(l->mode,"tcp")==0)
1776  ||(strcmp(l->mode,"connect")==0))
1777  && (strcmp(request, "read") == 0))
1778  {
1779  fd_set mask;
1780  struct timeval wt;
1781  if (s_isready(d->f_read)) return "ready";
1782  loop
1783  {
1784  /* Don't block. Return socket status immediately. */
1785  wt.tv_sec = 0;
1786  wt.tv_usec = 0;
1787 
1788  FD_ZERO(&mask);
1789  FD_SET(d->fd_read, &mask);
1790  //Print("test fd %d\n",d->fd_read);
1791  /* check with select: chars waiting: no -> not ready */
1792  switch (si_select(d->fd_read+1, &mask, NULL, NULL, &wt))
1793  {
1794  case 0: /* not ready */ return "not ready";
1795  case -1: /*error*/ return "error";
1796  case 1: /*ready ? */ break;
1797  }
1798  /* yes: read 1 char*/
1799  /* if \n, check again with select else ungetc(c), ready*/
1800  int c=s_getc(d->f_read);
1801  //Print("try c=%d\n",c);
1802  if (c== -1) return "eof"; /* eof or error */
1803  else if (isdigit(c))
1804  { s_ungetc(c,d->f_read); return "ready"; }
1805  else if (c>' ')
1806  {
1807  Werror("unknown char in ssiLink(%d)",c);
1808  return "error";
1809  }
1810  /* else: next char */
1811  }
1812  }
1813  else if (strcmp(request, "read") == 0)
1814  {
1815  if (SI_LINK_R_OPEN_P(l) && (!s_iseof(d->f_read)) && (s_isready(d->f_read))) return "ready";
1816  else return "not ready";
1817  }
1818  else if (strcmp(request, "write") == 0)
1819  {
1820  if (SI_LINK_W_OPEN_P(l)) return "ready";
1821  else return "not ready";
1822  }
1823  else return "unknown status request";
1824 }
if(yy_init)
Definition: libparse.cc:1420
void Werror(const char *fmt,...)
Definition: reporter.cc:189
int s_getc(s_buff F)
Definition: s_buff.cc:58
int s_isready(s_buff F)
Definition: s_buff.cc:85
int s_iseof(s_buff F)
Definition: s_buff.cc:252
void s_ungetc(int c, s_buff F)
Definition: s_buff.cc:99
s_buff f_read
Definition: s_buff.h:22
int fd_read
Definition: s_buff.h:26

◆ slStatusSsiL()

int slStatusSsiL ( lists  L,
int  timeout 
)

Definition at line 1826 of file ssiLink.cc.

1827 {
1828 // input: L: a list with links of type
1829 // ssi-connect, ssi-fork, ssi-tcp, MPtcp-fork or MPtcp-launch.
1830 // Note: Not every entry in L must be set.
1831 // timeout: timeout for select in micro-seconds
1832 // or -1 for infinity
1833 // or 0 for polling
1834 // returns: ERROR (via Werror): L has wrong elements or link not open
1835 // -2: select returns an error
1836 // -1: the read state of all links is eof
1837 // 0: timeout (or polling): none ready,
1838 // i>0: (at least) L[i] is ready
1839  si_link l;
1840  ssiInfo *d;
1841  int d_fd;
1842  fd_set mask, fdmask;
1843  FD_ZERO(&fdmask);
1844  FD_ZERO(&mask);
1845  int max_fd=0; /* 1 + max fd in fd_set */
1846 
1847  /* timeout */
1848  struct timeval wt;
1849  struct timeval *wt_ptr=&wt;
1850  int startingtime = getRTimer()/TIMER_RESOLUTION; // in seconds
1851  if (timeout== -1)
1852  {
1853  wt_ptr=NULL;
1854  }
1855  else
1856  {
1857  wt.tv_sec = timeout / 1000000;
1858  wt.tv_usec = timeout % 1000000;
1859  }
1860 
1861  /* auxiliary variables */
1862  int i;
1863  int j;
1864  int k;
1865  int s;
1866  char fdmaskempty;
1867 
1868  /* check the links and fill in fdmask */
1869  /* check ssi links for ungetc_buf */
1870  for(i=L->nr; i>=0; i--)
1871  {
1872  if (L->m[i].Typ()!=DEF_CMD)
1873  {
1874  if (L->m[i].Typ()!=LINK_CMD)
1875  { WerrorS("all elements must be of type link"); return -2;}
1876  l=(si_link)L->m[i].Data();
1877  if(SI_LINK_OPEN_P(l)==0)
1878  { WerrorS("all links must be open"); return -2;}
1879  if (((strcmp(l->m->type,"ssi")!=0) && (strcmp(l->m->type,"MPtcp")!=0))
1880  || ((strcmp(l->mode,"fork")!=0) && (strcmp(l->mode,"tcp")!=0)
1881  && (strcmp(l->mode,"launch")!=0) && (strcmp(l->mode,"connect")!=0)))
1882  {
1883  WerrorS("all links must be of type ssi:fork, ssi:tcp, ssi:connect");
1884  return -2;
1885  }
1886  if (strcmp(l->m->type,"ssi")==0)
1887  {
1888  d=(ssiInfo*)l->data;
1889  d_fd=d->fd_read;
1890  if (!s_isready(d->f_read))
1891  {
1892  FD_SET(d_fd, &fdmask);
1893  if (d_fd > max_fd) max_fd=d_fd;
1894  }
1895  else
1896  return i+1;
1897  }
1898  else
1899  {
1900  Werror("wrong link type >>%s<<",l->m->type);
1901  return -2;
1902  }
1903  }
1904  }
1905  max_fd++;
1906 
1907 do_select:
1908  /* copy fdmask to mask */
1909  FD_ZERO(&mask);
1910  for(k = 0; k < max_fd; k++)
1911  {
1912  if(FD_ISSET(k, &fdmask))
1913  {
1914  FD_SET(k, &mask);
1915  }
1916  }
1917 
1918  /* check with select: chars waiting: no -> not ready */
1919  s = si_select(max_fd, &mask, NULL, NULL, wt_ptr);
1920  if (s==-1)
1921  {
1922  WerrorS("error in select call");
1923  return -2; /*error*/
1924  }
1925  if (s==0)
1926  {
1927  return 0; /*poll: not ready */
1928  }
1929  else /* s>0, at least one ready (the number of fd which are ready is s)*/
1930  {
1931  j=0;
1932  while (j<=max_fd) { if (FD_ISSET(j,&mask)) break; j++; }
1933  for(i=L->nr; i>=0; i--)
1934  {
1935  if (L->m[i].rtyp==LINK_CMD)
1936  {
1937  l=(si_link)L->m[i].Data();
1938  if (strcmp(l->m->type,"ssi")==0)
1939  {
1940  d=(ssiInfo*)l->data;
1941  d_fd=d->fd_read;
1942  if(j==d_fd) break;
1943  }
1944  else
1945  {
1946  Werror("wrong link type >>%s<<",l->m->type);
1947  return -2;
1948  }
1949  }
1950  }
1951  // only ssi links:
1952  loop
1953  {
1954  /* yes: read 1 char*/
1955  /* if \n, check again with select else ungetc(c), ready*/
1956  /* setting: d: current ssiInfo, j current fd, i current entry in L*/
1957  int c=s_getc(d->f_read);
1958  //Print("try c=%d\n",c);
1959  if (c== -1) /* eof */
1960  {
1961  FD_CLR(j,&fdmask);
1962  fdmaskempty = 1;
1963  for(k = 0; k < max_fd; k++)
1964  {
1965  if(FD_ISSET(k, &fdmask))
1966  {
1967  fdmaskempty = 0;
1968  break;
1969  }
1970  }
1971  if(fdmaskempty)
1972  {
1973  return -1;
1974  }
1975  if(timeout != -1)
1976  {
1977  timeout = si_max(0,
1978  timeout - 1000000*(getRTimer()/TIMER_RESOLUTION - startingtime));
1979  wt.tv_sec = timeout / 1000000;
1980  wt.tv_usec = (timeout % 1000000);
1981  }
1982  goto do_select;
1983  }
1984 
1985  else if (isdigit(c))
1986  { s_ungetc(c,d->f_read); return i+1; }
1987  else if (c>' ')
1988  {
1989  Werror("unknown char in ssiLink(%d)",c);
1990  return -2;
1991  }
1992  /* else: next char */
1993  goto do_select;
1994  }
1995  }
1996 }
static int si_max(const int a, const int b)
Definition: auxiliary.h:124
int i
Definition: cfEzgcd.cc:132
int k
Definition: cfEzgcd.cc:99
int Typ()
Definition: subexpr.cc:1011
void * Data()
Definition: subexpr.cc:1154
sleftv * m
Definition: lists.h:46
int nr
Definition: lists.h:44
int j
Definition: facHensel.cc:110
void WerrorS(const char *s)
Definition: feFopen.cc:24
#define TIMER_RESOLUTION
Definition: mod2.h:34
int getRTimer()
Definition: timer.cc:170

◆ ssiBatch()

int ssiBatch ( const char *  host,
const char *  port 
)

Definition at line 1998 of file ssiLink.cc.

2000 {
2002  char *buf=(char*)omAlloc(256);
2003  sprintf(buf,"ssi:connect %s:%s",host,port);
2004  slInit(l, buf);
2005  omFreeSize(buf,256);
2006  if (slOpen(l,SI_LINK_OPEN,NULL)) return 1;
2008 
2009  idhdl id = enterid("link_ll", 0, LINK_CMD, &IDROOT, FALSE);
2010  IDLINK(id) = l;
2011 
2012  loop
2013  {
2014  leftv h=ssiRead1(l); /*contains an exit.... */
2015  if (feErrors != NULL && *feErrors != '\0')
2016  {
2017  // handle errors:
2018  PrintS(feErrors); /* currently quite simple */
2019  *feErrors = '\0';
2020  }
2021  ssiWrite(l,h);
2022  h->CleanUp();
2024  }
2025  /* never reached*/
2026  exit(0);
2027 }
Definition: idrec.h:35
idhdl enterid(const char *s, int lev, int t, idhdl *root, BOOLEAN init, BOOLEAN search)
Definition: ipid.cc:278
EXTERN_VAR omBin sleftv_bin
Definition: ipid.h:145
#define IDLINK(a)
Definition: ipid.h:138
#define IDROOT
Definition: ipid.h:19
#define omAlloc(size)
Definition: omAllocDecl.h:210
#define omAlloc0Bin(bin)
Definition: omAllocDecl.h:206
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
void PrintS(const char *s)
Definition: reporter.cc:284
VAR char * feErrors
Definition: reporter.cc:47
int status int void * buf
Definition: si_signals.h:59

◆ ssiCheckCurrRing()

void ssiCheckCurrRing ( const ring  r)

Definition at line 117 of file ssiLink.cc.

118 {
119  if ((r!=currRing)
120  ||(currRingHdl==NULL)
121  ||(IDRING(currRingHdl)!=r))
122  {
123  char name[20];
124  int nr=0;
125  idhdl h=NULL;
126  loop
127  {
128  sprintf(name,"ssiRing%d",nr); nr++;
129  h=IDROOT->get(name, 0);
130  if (h==NULL)
131  {
133  IDRING(h)=rIncRefCnt(r);
134  r->ref=2;/*ref==2: d->r and h */
135  break;
136  }
137  else if ((IDTYP(h)==RING_CMD)
138  && (rEqual(r,IDRING(h),1)))
139  {
140  break;
141  }
142  }
143  rSetHdl(h);
144  }
145  assume((currRing==r) || rEqual(r,currRing));
146 }
char name(const Variable &v)
Definition: factory.h:196
VAR idhdl currRingHdl
Definition: ipid.cc:59
#define IDRING(a)
Definition: ipid.h:127
void rSetHdl(idhdl h)
Definition: ipshell.cc:5135
#define assume(x)
Definition: mod2.h:387
VAR ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:13
BOOLEAN rEqual(ring r1, ring r2, BOOLEAN qr)
returns TRUE, if r1 equals r2 FALSE, otherwise Equality is determined componentwise,...
Definition: ring.cc:1663
static ring rIncRefCnt(ring r)
Definition: ring.h:847

◆ ssiClose()

BOOLEAN ssiClose ( si_link  l)

Definition at line 1330 of file ssiLink.cc.

1331 {
1332  if (l!=NULL)
1333  {
1335  ssiInfo *d = (ssiInfo *)l->data;
1336  if (d!=NULL)
1337  {
1338  // send quit signal
1339  if ((d->send_quit_at_exit)
1340  && (d->quit_sent==0))
1341  {
1342  fputs("99\n",d->f_write);
1343  fflush(d->f_write);
1344  }
1345  // clean ring
1346  if (d->r!=NULL) rKill(d->r);
1347  // did the child to stop ?
1348  si_waitpid(d->pid,NULL,WNOHANG);
1349  if ((d->pid!=0)
1350  && (kill(d->pid,0)==0)) // child is still running
1351  {
1352  struct timespec t;
1353  t.tv_sec=0;
1354  t.tv_nsec=100000000; // <=100 ms
1355  struct timespec rem;
1356  int r;
1357  loop
1358  {
1359  // wait till signal or time rem:
1360  r = nanosleep(&t, &rem);
1361  t = rem;
1362  // child finished:
1363  if (si_waitpid(d->pid,NULL,WNOHANG) != 0) break;
1364  // other signal, waited s>= 100 ms:
1365  if ((r==0) || (errno != EINTR)) break;
1366  }
1367  if (kill(d->pid,0) == 0) // pid still exists
1368  {
1369  kill(d->pid,15);
1370  t.tv_sec=5; // <=5s
1371  t.tv_nsec=0;
1372  loop
1373  {
1374  // wait till signal or time rem:
1375  r = nanosleep(&t, &rem);
1376  t = rem;
1377  // child finished:
1378  if (si_waitpid(d->pid,NULL,WNOHANG) != 0) break;
1379  // other signal, waited s>= 5 s:
1380  if ((r==0) || (errno != EINTR)) break;
1381  }
1382  if (kill(d->pid,0) == 0)
1383  {
1384  kill(d->pid,9); // just to be sure
1385  si_waitpid(d->pid,NULL,0);
1386  }
1387  }
1388  }
1389  if (d->f_read!=NULL) { s_close(d->f_read);d->f_read=NULL;}
1390  if (d->f_write!=NULL) { fclose(d->f_write); d->f_write=NULL; }
1391  if ((strcmp(l->mode,"tcp")==0)
1392  || (strcmp(l->mode,"fork")==0))
1393  {
1395  if (hh!=NULL)
1396  {
1397  if (hh->l==l)
1398  {
1400  omFreeSize(hh,sizeof(link_struct));
1401  }
1402  else while(hh->next!=NULL)
1403  {
1404  link_list hhh=(link_list)hh->next;
1405  if (hhh->l==l)
1406  {
1407  hh->next=hhh->next;
1408  omFreeSize(hhh,sizeof(link_struct));
1409  break;
1410  }
1411  else
1412  hh=(link_list)hh->next;
1413  }
1414  }
1415  }
1416  omFreeSize((ADDRESS)d,(sizeof *d));
1417  }
1418  l->data=NULL;
1419  }
1420  return FALSE;
1421 }
void * ADDRESS
Definition: auxiliary.h:119
void rKill(ring r)
Definition: ipshell.cc:6179
void rem(unsigned long *a, unsigned long *q, unsigned long p, int &dega, int degq)
Definition: minpoly.cc:572
int s_close(s_buff &F)
Definition: s_buff.cc:45
char send_quit_at_exit
Definition: s_buff.h:28
char quit_sent
Definition: s_buff.h:29
FILE * f_write
Definition: s_buff.h:23
ring r
Definition: s_buff.h:24

◆ ssiCommandLink()

si_link ssiCommandLink ( )

Definition at line 2069 of file ssiLink.cc.

2070 {
2071  if (ssiReserved_P==0)
2072  {
2073  WerrorS("ERROR no reverved port requested");
2074  return NULL;
2075  }
2076  struct sockaddr_in cli_addr;
2077  int clilen = sizeof(cli_addr);
2078  int newsockfd = si_accept(ssiReserved_sockfd, (struct sockaddr *) &cli_addr, (socklen_t *)&clilen);
2079  if(newsockfd < 0)
2080  {
2081  Werror("ERROR on accept (errno=%d)",errno);
2082  return NULL;
2083  }
2085  si_link_extension s = si_link_root;
2086  si_link_extension prev = s;
2087  while (strcmp(s->type, "ssi") != 0)
2088  {
2089  if (s->next == NULL)
2090  {
2091  prev = s;
2092  s = NULL;
2093  break;
2094  }
2095  else
2096  {
2097  s = s->next;
2098  }
2099  }
2100  if (s != NULL)
2101  l->m = s;
2102  else
2103  {
2104  si_link_extension ns = (si_link_extension)omAlloc0Bin(s_si_link_extension_bin);
2105  prev->next=slInitSsiExtension(ns);
2106  l->m = prev->next;
2107  }
2108  l->name=omStrDup("");
2109  l->mode=omStrDup("tcp");
2110  l->ref=1;
2111  ssiInfo *d=(ssiInfo*)omAlloc0(sizeof(ssiInfo));
2112  l->data=d;
2113  d->fd_read = newsockfd;
2114  d->fd_write = newsockfd;
2115  d->f_read = s_open(newsockfd);
2116  d->f_write = fdopen(newsockfd, "w");
2119  if (ssiReserved_Clients<=0)
2120  {
2121  ssiReserved_P=0;
2122  si_close(ssiReserved_sockfd);
2123  }
2124  return l;
2125 }
#define omStrDup(s)
Definition: omAllocDecl.h:263
s_buff s_open(int fd)
Definition: s_buff.cc:31
int fd_write
Definition: s_buff.h:26

◆ ssiDump()

BOOLEAN ssiDump ( si_link  l)

Definition at line 2285 of file ssiLink.cc.

2286 {
2287  idhdl h = IDROOT, rh = currRingHdl;
2289 
2290  //if (! status ) status = DumpAsciiMaps(fd, h, NULL);
2291 
2292  if (currRingHdl != rh) rSetHdl(rh);
2293  //fprintf(fd, "option(set, intvec(%d, %d));\n", si_opt_1, si_opt_2);
2294 
2295  return status;
2296 }
int BOOLEAN
Definition: auxiliary.h:87

◆ ssiDumpIter()

static BOOLEAN ssiDumpIter ( si_link  l,
idhdl  h 
)
static

Definition at line 2264 of file ssiLink.cc.

2265 {
2266  if (h == NULL) return FALSE;
2267 
2268  if (ssiDumpIter(l, IDNEXT(h))) return TRUE;
2269 
2270  // need to set the ring before writing it, otherwise we get in
2271  // trouble with minpoly
2272  if (IDTYP(h) == RING_CMD)
2273  rSetHdl(h);
2274 
2275  if (DumpSsiIdhdl(l, h)) return TRUE;
2276 
2277  // do not dump ssi internal rings: ssiRing*
2278  // but dump objects of all other rings
2279  if ((IDTYP(h) == RING_CMD)
2280  && (strncmp(IDID(h),"ssiRing",7)!=0))
2281  return ssiDumpIter(l, IDRING(h)->idroot);
2282  else
2283  return FALSE;
2284 }
#define IDNEXT(a)
Definition: ipid.h:118

◆ ssiGetDump()

BOOLEAN ssiGetDump ( si_link  l)

Definition at line 2297 of file ssiLink.cc.

2298 {
2299  ssiInfo *d=(ssiInfo*)l->data;
2300  loop
2301  {
2302  if (!SI_LINK_OPEN_P(l)) break;
2303  if (s_iseof(d->f_read)) break;
2304  leftv h=ssiRead1(l); /*contains an exit.... */
2305  if (feErrors != NULL && *feErrors != '\0')
2306  {
2307  // handle errors:
2308  PrintS(feErrors); /* currently quite simple */
2309  return TRUE;
2310  *feErrors = '\0';
2311  }
2312  h->CleanUp();
2314  }
2315  return FALSE;
2316 }

◆ ssiOpen()

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

Definition at line 916 of file ssiLink.cc.

917 {
918  if (l!=NULL)
919  {
920  const char *mode;
921  ssiInfo *d=(ssiInfo*)omAlloc0(sizeof(ssiInfo));
922  if (flag & SI_LINK_OPEN)
923  {
924  if (l->mode[0] != '\0' && (strcmp(l->mode, "r") == 0))
925  flag = SI_LINK_READ;
926  else flag = SI_LINK_WRITE;
927  }
928 
929  if (flag == SI_LINK_READ) mode = "r";
930  else if (strcmp(l->mode, "w") == 0) mode = "w";
931  else if (strcmp(l->mode, "fork") == 0) mode = "fork";
932  else if (strcmp(l->mode, "tcp") == 0) mode = "tcp";
933  else if (strcmp(l->mode, "connect") == 0) mode = "connect";
934  else mode = "a";
935 
936 
937  SI_LINK_SET_OPEN_P(l, flag);
938  if(l->data!=NULL) omFreeSize(l->data,sizeof(ssiInfo));
939  l->data=d;
940  omFree(l->mode);
941  l->mode = omStrDup(mode);
942 
943  if (l->name[0] == '\0')
944  {
945  if (strcmp(mode,"fork")==0)
946  {
948  n->u=u;
949  n->l=l;
950  n->next=(void *)ssiToBeClosed;
951  ssiToBeClosed=n;
952 
953  int pc[2];
954  int cp[2];
955  pipe(pc);
956  pipe(cp);
957  pid_t pid = fork();
958  if (pid == -1 && errno == EAGAIN) // RLIMIT_NPROC too low?
959  {
961  pid = fork();
962  }
963  if (pid == -1)
964  {
965  WerrorS("could not fork");
966  }
967  if (pid==0) /*fork: child*/
968  {
969  /* block SIGINT */
970  sigset_t sigint;
971  sigemptyset(&sigint);
972  sigaddset(&sigint, SIGINT);
973  sigprocmask(SIG_BLOCK, &sigint, NULL);
974  /* set #cpu to 1 for the child:*/
975  feSetOptValue(FE_OPT_CPUS,1);
976 
978  /* we know: l is the first entry in ssiToBeClosed-list */
979  while(hh!=NULL)
980  {
981  SI_LINK_SET_CLOSE_P(hh->l);
982  ssiInfo *dd=(ssiInfo*)hh->l->data;
983  s_close(dd->f_read);
984  fclose(dd->f_write);
985  if (dd->r!=NULL) rKill(dd->r);
986  omFreeSize((ADDRESS)dd,(sizeof *dd));
987  hh->l->data=NULL;
988  link_list nn=(link_list)hh->next;
989  omFree(hh);
990  hh=nn;
991  }
993 #ifdef HAVE_SIMPLEIPC
994  memset(sem_acquired, 0, SIPC_MAX_SEMAPHORES*sizeof(sem_acquired[0]));
995 #endif // HAVE_SIMPLEIPC
996  si_close(pc[1]); si_close(cp[0]);
997  d->f_write=fdopen(cp[1],"w");
998  d->f_read=s_open(pc[0]);
999  d->fd_read=pc[0];
1000  d->fd_write=cp[1];
1001  //d->r=currRing;
1002  //if (d->r!=NULL) d->r->ref++;
1003  l->data=d;
1004  omFree(l->mode);
1005  l->mode = omStrDup(mode);
1008  //myynest=0;
1010  if ((u!=NULL)&&(u->rtyp==IDHDL))
1011  {
1012  idhdl h=(idhdl)u->data;
1013  h->lev=0;
1014  }
1015  loop
1016  {
1017  if (!SI_LINK_OPEN_P(l)) m2_end(0);
1018  if(d->f_read->is_eof) m2_end(0);
1019  leftv h=ssiRead1(l); /*contains an exit.... */
1020  if (feErrors != NULL && *feErrors != '\0')
1021  {
1022  // handle errors:
1023  PrintS(feErrors); /* currently quite simple */
1024  *feErrors = '\0';
1025  }
1026  ssiWrite(l,h);
1027  h->CleanUp();
1029  }
1030  /* never reached*/
1031  }
1032  else if (pid>0) /*fork: parent*/
1033  {
1034  d->pid=pid;
1035  si_close(pc[0]); si_close(cp[1]);
1036  d->f_write=fdopen(pc[1],"w");
1037  d->f_read=s_open(cp[0]);
1038  d->fd_read=cp[0];
1039  d->fd_write=pc[1];
1041  d->send_quit_at_exit=1;
1042  //d->r=currRing;
1043  //if (d->r!=NULL) d->r->ref++;
1044  }
1045  else
1046  {
1047  Werror("fork failed (%d)",errno);
1048  l->data=NULL;
1049  omFree(d);
1050  return TRUE;
1051  }
1052  }
1053  // ---------------------------------------------------------------------
1054  else if (strcmp(mode,"tcp")==0)
1055  {
1056  int sockfd, newsockfd, portno, clilen;
1057  struct sockaddr_in serv_addr, cli_addr;
1058  sockfd = socket(AF_INET, SOCK_STREAM, 0);
1059  if(sockfd < 0)
1060  {
1061  WerrorS("ERROR opening socket");
1062  l->data=NULL;
1063  SI_LINK_CLOSE_P(l);
1064  omFree(d);
1065  return TRUE;
1066  }
1067  memset((char *) &serv_addr,0, sizeof(serv_addr));
1068  portno = 1025;
1069  serv_addr.sin_family = AF_INET;
1070  serv_addr.sin_addr.s_addr = INADDR_ANY;
1071  do
1072  {
1073  portno++;
1074  serv_addr.sin_port = htons(portno);
1075  if(portno > 50000)
1076  {
1077  WerrorS("ERROR on binding (no free port available?)");
1078  l->data=NULL;
1079  SI_LINK_CLOSE_P(l);
1080  omFree(d);
1081  return TRUE;
1082  }
1083  }
1084  while(bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0);
1085  Print("waiting on port %d\n", portno);mflush();
1086  listen(sockfd,1);
1087  newsockfd = si_accept(sockfd, (struct sockaddr *) &cli_addr, (socklen_t *)&clilen);
1088  if(newsockfd < 0)
1089  {
1090  WerrorS("ERROR on accept");
1091  l->data=NULL;
1092  SI_LINK_CLOSE_P(l);
1093  omFree(d);
1094  return TRUE;
1095  }
1096  PrintS("client accepted\n");
1097  d->fd_read = newsockfd;
1098  d->fd_write = newsockfd;
1099  d->f_read = s_open(newsockfd);
1100  d->f_write = fdopen(newsockfd, "w");
1102  si_close(sockfd);
1103  }
1104  // no ssi-Link on stdin or stdout
1105  else
1106  {
1107  Werror("invalid mode >>%s<< for ssi",mode);
1108  l->data=NULL;
1109  SI_LINK_CLOSE_P(l);
1110  omFree(d);
1111  return TRUE;
1112  }
1113  }
1114  // =========================================================================
1115  else /*l->name=NULL*/
1116  {
1117  // tcp mode
1118  if(strcmp(mode,"tcp")==0)
1119  {
1120  int sockfd, newsockfd, portno, clilen;
1121  struct sockaddr_in serv_addr, cli_addr;
1122  sockfd = socket(AF_INET, SOCK_STREAM, 0);
1123  if(sockfd < 0)
1124  {
1125  WerrorS("ERROR opening socket");
1126  l->data=NULL;
1127  SI_LINK_CLOSE_P(l);
1128  omFree(d);
1129  return TRUE;
1130  }
1131  memset((char *) &serv_addr,0, sizeof(serv_addr));
1132  portno = 1025;
1133  serv_addr.sin_family = AF_INET;
1134  serv_addr.sin_addr.s_addr = INADDR_ANY;
1135  do
1136  {
1137  portno++;
1138  serv_addr.sin_port = htons(portno);
1139  if(portno > 50000)
1140  {
1141  WerrorS("ERROR on binding (no free port available?)");
1142  l->data=NULL;
1143  SI_LINK_CLOSE_P(l);
1144  return TRUE;
1145  }
1146  }
1147  while(bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0);
1148  //Print("waiting on port %d\n", portno);mflush();
1149  listen(sockfd,1);
1150  char* cli_host = (char*)omAlloc(256);
1151  char* path = (char*)omAlloc(1024);
1152  int r = si_sscanf(l->name,"%255[^:]:%s",cli_host,path);
1153  if(r == 0)
1154  {
1155  WerrorS("ERROR: no host specified");
1156  l->data=NULL;
1157  SI_LINK_CLOSE_P(l);
1158  omFree(d);
1159  omFree(path);
1160  omFree(cli_host);
1161  return TRUE;
1162  }
1163  else if(r == 1)
1164  {
1165  WarnS("program not specified, using /usr/local/bin/Singular");
1166  Warn("in line >>%s<<",my_yylinebuf);
1167  strcpy(path,"/usr/local/bin/Singular");
1168  }
1169  char* ssh_command = (char*)omAlloc(256);
1170  char* ser_host = (char*)omAlloc(64);
1171  gethostname(ser_host,64);
1172  if (strcmp(cli_host,"localhost")==0) /*avoid "ssh localhost" as key may change*/
1173  sprintf(ssh_command,"%s -q --batch --link=ssi --MPhost=%s --MPport=%d &",path,ser_host,portno);
1174  else
1175  sprintf(ssh_command,"ssh %s %s -q --batch --link=ssi --MPhost=%s --MPport=%d &",cli_host,path,ser_host,portno);
1176  //Print("client on %s started:%s\n",cli_host,path);
1177  omFree(path);
1178  omFree(cli_host);
1179  if (TEST_OPT_PROT) { Print("running >>%s<<\n",ssh_command); }
1180  system(ssh_command);
1181  omFree(ssh_command);
1182  omFree(ser_host);
1183  clilen = sizeof(cli_addr);
1184  newsockfd = si_accept(sockfd, (struct sockaddr *) &cli_addr, (socklen_t *)&clilen);
1185  if(newsockfd < 0)
1186  {
1187  WerrorS("ERROR on accept");
1188  l->data=NULL;
1189  SI_LINK_CLOSE_P(l);
1190  omFree(d);
1191  return TRUE;
1192  }
1193  //PrintS("client accepted\n");
1194  d->fd_read = newsockfd;
1195  d->fd_write = newsockfd;
1196  d->f_read = s_open(newsockfd);
1197  d->f_write = fdopen(newsockfd, "w");
1198  si_close(sockfd);
1200  d->send_quit_at_exit=1;
1201  link_list newlink=(link_list)omAlloc(sizeof(link_struct));
1202  newlink->u=u;
1203  newlink->l=l;
1204  newlink->next=(void *)ssiToBeClosed;
1205  ssiToBeClosed=newlink;
1206  fprintf(d->f_write,"98 %d %d %u %u\n",SSI_VERSION,MAX_TOK,si_opt_1,si_opt_2);
1207  }
1208  // ----------------------------------------------------------------------
1209  else if(strcmp(mode,"connect")==0)
1210  {
1211  char* host = (char*)omAlloc(256);
1212  int sockfd, portno;
1213  struct sockaddr_in serv_addr;
1214  struct hostent *server;
1215 
1216  si_sscanf(l->name,"%255[^:]:%d",host,&portno);
1217  //Print("connect to host %s, port %d\n",host,portno);mflush();
1218  if (portno!=0)
1219  {
1220  sockfd = socket(AF_INET, SOCK_STREAM, 0);
1221  if (sockfd < 0)
1222  {
1223  WerrorS("ERROR opening socket");
1224  SI_LINK_CLOSE_P(l);
1225  return TRUE;
1226  }
1227  server = gethostbyname(host);
1228  if (server == NULL)
1229  {
1230  WerrorS("ERROR, no such host");
1231  SI_LINK_CLOSE_P(l);
1232  return TRUE;
1233  }
1234  memset((char *) &serv_addr, 0, sizeof(serv_addr));
1235  serv_addr.sin_family = AF_INET;
1236  memcpy((char *)&serv_addr.sin_addr.s_addr,
1237  (char *)server->h_addr,
1238  server->h_length);
1239  serv_addr.sin_port = htons(portno);
1240  if (si_connect(sockfd,(sockaddr*)&serv_addr,sizeof(serv_addr)) < 0)
1241  {
1242  Werror("ERROR connecting(errno=%d)",errno);
1243  SI_LINK_CLOSE_P(l);
1244  return TRUE;
1245  }
1246  //PrintS("connected\n");mflush();
1247  d->f_read=s_open(sockfd);
1248  d->fd_read=sockfd;
1249  d->f_write=fdopen(sockfd,"w");
1250  d->fd_write=sockfd;
1252  omFree(host);
1253  }
1254  else
1255  {
1256  l->data=NULL;
1257  SI_LINK_CLOSE_P(l);
1258  omFree(d);
1259  return TRUE;
1260  }
1261  }
1262  // ======================================================================
1263  else
1264  {
1265  // normal link to a file
1266  FILE *outfile;
1267  char *filename=l->name;
1268 
1269  if(filename[0]=='>')
1270  {
1271  if (filename[1]=='>')
1272  {
1273  filename+=2;
1274  mode = "a";
1275  }
1276  else
1277  {
1278  filename++;
1279  mode="w";
1280  }
1281  }
1282  outfile=myfopen(filename,mode);
1283  if (outfile!=NULL)
1284  {
1285  if (strcmp(l->mode,"r")==0)
1286  {
1287  fclose(outfile);
1288  d->f_read=s_open_by_name(filename);
1289  }
1290  else
1291  {
1292  d->f_write = outfile;
1293  fprintf(d->f_write,"98 %d %d %u %u\n",SSI_VERSION,MAX_TOK,si_opt_1,si_opt_2);
1294  }
1295  }
1296  else
1297  {
1298  omFree(d);
1299  l->data=NULL;
1300  SI_LINK_CLOSE_P(l);
1301  return TRUE;
1302  }
1303  }
1304  }
1305  }
1306 
1307  return FALSE;
1308 }
VAR BOOLEAN singular_in_batchmode
Definition: cntrlc.cc:70
#define Print
Definition: emacs.cc:80
#define Warn
Definition: emacs.cc:77
#define WarnS
Definition: emacs.cc:78
FILE * myfopen(const char *path, const char *mode)
Definition: feFopen.cc:167
const char * feSetOptValue(feOptIndex opt, char *optarg)
Definition: feOpt.cc:154
VAR char my_yylinebuf[80]
Definition: febase.cc:44
void system(sys)
char *(* fe_fgets_stdin)(const char *pr, char *s, int size)
Definition: feread.cc:34
char * fe_fgets_dummy(const char *, char *, int)
Definition: feread.cc:451
void m2_end(int i)
Definition: misc_ip.cc:1098
#define omFree(addr)
Definition: omAllocDecl.h:261
VAR unsigned si_opt_2
Definition: options.c:6
VAR unsigned si_opt_1
Definition: options.c:5
#define TEST_OPT_PROT
Definition: options.h:102
#define mflush()
Definition: reporter.h:58
idrec * idhdl
Definition: ring.h:21
int raise_rlimit_nproc()
Definition: rlimit.c:18
s_buff s_open_by_name(const char *n)
Definition: s_buff.cc:39
VAR int sem_acquired[SIPC_MAX_SEMAPHORES]
Definition: semaphore.c:25
#define SIPC_MAX_SEMAPHORES
Definition: simpleipc.h:10
#define IDHDL
Definition: tok.h:31
@ MAX_TOK
Definition: tok.h:218

◆ ssiPrepClose()

BOOLEAN ssiPrepClose ( si_link  l)

Definition at line 1311 of file ssiLink.cc.

1312 {
1313  if (l!=NULL)
1314  {
1316  ssiInfo *d = (ssiInfo *)l->data;
1317  if (d!=NULL)
1318  {
1319  if (d->send_quit_at_exit)
1320  {
1321  fputs("99\n",d->f_write);
1322  fflush(d->f_write);
1323  }
1324  d->quit_sent=1;
1325  }
1326  }
1327  return FALSE;
1328 }

◆ ssiRead1()

leftv ssiRead1 ( si_link  l)

Definition at line 1424 of file ssiLink.cc.

1425 {
1426  ssiInfo *d = (ssiInfo *)l->data;
1428  int t=0;
1429  t=s_readint(d->f_read);
1430  //Print("got type %d\n",t);
1431  switch(t)
1432  {
1433  case 1:res->rtyp=INT_CMD;
1434  res->data=(char *)(long)ssiReadInt(d->f_read);
1435  break;
1436  case 2:res->rtyp=STRING_CMD;
1437  res->data=(char *)ssiReadString(d);
1438  break;
1439  case 3:res->rtyp=NUMBER_CMD;
1440  if (d->r==NULL) goto no_ring;
1441  ssiCheckCurrRing(d->r);
1442  res->data=(char *)ssiReadNumber(d);
1443  break;
1444  case 4:res->rtyp=BIGINT_CMD;
1445  res->data=(char *)ssiReadBigInt(d);
1446  break;
1447  case 15:
1448  case 5:{
1449  d->r=ssiReadRing(d);
1450  if (errorreported) return NULL;
1451  res->data=(char*)d->r;
1452  if (d->r!=NULL) rIncRefCnt(d->r);
1453  res->rtyp=RING_CMD;
1454  if (t==15) // setring
1455  {
1456  if(ssiSetCurrRing(d->r)) { d->r=currRing; }
1458  return ssiRead1(l);
1459  }
1460  }
1461  break;
1462  case 6:res->rtyp=POLY_CMD;
1463  if (d->r==NULL) goto no_ring;
1464  ssiCheckCurrRing(d->r);
1465  res->data=(char*)ssiReadPoly(d);
1466  break;
1467  case 7:res->rtyp=IDEAL_CMD;
1468  if (d->r==NULL) goto no_ring;
1469  ssiCheckCurrRing(d->r);
1470  res->data=(char*)ssiReadIdeal(d);
1471  break;
1472  case 8:res->rtyp=MATRIX_CMD;
1473  if (d->r==NULL) goto no_ring;
1474  ssiCheckCurrRing(d->r);
1475  res->data=(char*)ssiReadMatrix(d);
1476  break;
1477  case 9:res->rtyp=VECTOR_CMD;
1478  if (d->r==NULL) goto no_ring;
1479  ssiCheckCurrRing(d->r);
1480  res->data=(char*)ssiReadPoly(d);
1481  break;
1482  case 10:
1483  case 22:if (t==22) res->rtyp=SMATRIX_CMD;
1484  else res->rtyp=MODUL_CMD;
1485  if (d->r==NULL) goto no_ring;
1486  ssiCheckCurrRing(d->r);
1487  {
1488  int rk=s_readint(d->f_read);
1489  ideal M=ssiReadIdeal(d);
1490  M->rank=rk;
1491  res->data=(char*)M;
1492  }
1493  break;
1494  case 11:
1495  {
1496  res->rtyp=COMMAND;
1497  res->data=ssiReadCommand(l);
1498  int nok=res->Eval();
1499  if (nok) WerrorS("error in eval");
1500  break;
1501  }
1502  case 12: /*DEF_CMD*/
1503  {
1504  res->rtyp=0;
1505  res->name=(char *)ssiReadString(d);
1506  int nok=res->Eval();
1507  if (nok) WerrorS("error in name lookup");
1508  break;
1509  }
1510  case 13: res->rtyp=PROC_CMD;
1511  res->data=ssiReadProc(d);
1512  break;
1513  case 14: res->rtyp=LIST_CMD;
1514  res->data=ssiReadList(l);
1515  break;
1516  case 16: res->rtyp=NONE; res->data=NULL;
1517  break;
1518  case 17: res->rtyp=INTVEC_CMD;
1519  res->data=ssiReadIntvec(d);
1520  break;
1521  case 18: res->rtyp=INTMAT_CMD;
1522  res->data=ssiReadIntmat(d);
1523  break;
1524  case 19: res->rtyp=BIGINTMAT_CMD;
1525  res->data=ssiReadBigintmat(d);
1526  break;
1527  case 20: ssiReadBlackbox(res,l);
1528  break;
1529  case 21: ssiReadAttrib(res,l);
1530  break;
1531  case 23: ssiReadRingProperties(l);
1532  return ssiRead1(l);
1533  break;
1534  // ------------
1535  case 98: // version
1536  {
1537  int n98_v,n98_m;
1538  BITSET n98_o1,n98_o2;
1539  n98_v=s_readint(d->f_read);
1540  n98_m=s_readint(d->f_read);
1541  n98_o1=s_readint(d->f_read);
1542  n98_o2=s_readint(d->f_read);
1543  if ((n98_v!=SSI_VERSION) ||(n98_m!=MAX_TOK))
1544  {
1545  Print("incompatible versions of ssi: %d/%d vs %d/%d\n",
1546  SSI_VERSION,MAX_TOK,n98_v,n98_m);
1547  }
1548  #ifndef SING_NDEBUG
1549  if (TEST_OPT_DEBUG)
1550  Print("// opening ssi-%d, MAX_TOK=%d\n",n98_v,n98_m);
1551  #endif
1552  si_opt_1=n98_o1;
1553  si_opt_2=n98_o2;
1555  return ssiRead1(l);
1556  }
1557  case 99: omFreeBin(res,sleftv_bin); ssiClose(l); m2_end(0);
1558  case 0: if (s_iseof(d->f_read))
1559  {
1560  ssiClose(l);
1561  }
1562  res->rtyp=DEF_CMD;
1563  break;
1564  default: Werror("not implemented (t:%d)",t);
1566  res=NULL;
1567  break;
1568  }
1569  // if currRing is required for the result, but lost
1570  // define "ssiRing%d" as currRing:
1571  if ((d->r!=NULL)
1572  && (currRing!=d->r)
1573  && (res->RingDependend()))
1574  {
1575  if(ssiSetCurrRing(d->r)) { d->r=currRing; }
1576  }
1577  return res;
1578 no_ring: WerrorS("no ring");
1580  return NULL;
1581 }
CanonicalForm res
Definition: facAbsFact.cc:60
VAR short errorreported
Definition: feFopen.cc:23
@ IDEAL_CMD
Definition: grammar.cc:284
@ MATRIX_CMD
Definition: grammar.cc:286
@ BIGINTMAT_CMD
Definition: grammar.cc:278
@ INTMAT_CMD
Definition: grammar.cc:279
@ MODUL_CMD
Definition: grammar.cc:287
@ SMATRIX_CMD
Definition: grammar.cc:291
@ VECTOR_CMD
Definition: grammar.cc:292
@ NUMBER_CMD
Definition: grammar.cc:288
@ POLY_CMD
Definition: grammar.cc:289
#define TEST_OPT_DEBUG
Definition: options.h:107
int s_readint(s_buff F)
Definition: s_buff.cc:112
#define M
Definition: sirandom.c:25
#define BITSET
Definition: structs.h:20
@ BIGINT_CMD
Definition: tok.h:38
@ LIST_CMD
Definition: tok.h:118
@ INTVEC_CMD
Definition: tok.h:101
@ INT_CMD
Definition: tok.h:96
#define NONE
Definition: tok.h:221

◆ ssiReadAttrib()

void ssiReadAttrib ( leftv  res,
si_link  l 
)

Definition at line 855 of file ssiLink.cc.

856 {
857  ssiInfo *d=(ssiInfo*)l->data;
858  BITSET fl=(BITSET)s_readint(d->f_read);
859  int nr_of_attr=s_readint(d->f_read);
860  if (nr_of_attr>0)
861  {
862  for(int i=1;i<nr_of_attr;i++)
863  {
864  }
865  }
866  leftv tmp=ssiRead1(l);
867  memcpy(res,tmp,sizeof(sleftv));
868  memset(tmp,0,sizeof(sleftv));
869  omFreeBin(tmp,sleftv_bin);
870  if (nr_of_attr>0)
871  {
872  }
873  res->flag=fl;
874 }

◆ ssiReadBigInt()

number ssiReadBigInt ( const ssiInfo d)

Definition at line 487 of file ssiLink.cc.

488 {
489  number n=ssiReadNumber_CF(d,coeffs_BIGINT);
490  if ((SR_HDL(n) & SR_INT)==0)
491  {
492  if (n->s!=3) Werror("invalid sub type in bigint:%d",n->s);
493  }
494  return n;
495 }
VAR coeffs coeffs_BIGINT
Definition: ipid.cc:50
#define SR_INT
Definition: longrat.h:67
#define SR_HDL(A)
Definition: tgb.cc:35

◆ ssiReadBigintmat()

bigintmat* ssiReadBigintmat ( const ssiInfo d)

Definition at line 814 of file ssiLink.cc.

815 {
816  int r,c;
817  r=s_readint(d->f_read);
818  c=s_readint(d->f_read);
820  for(int i=0;i<r*c;i++)
821  {
822  (*v)[i]=ssiReadBigInt(d);
823  }
824  return v;
825 }
Matrices of numbers.
Definition: bigintmat.h:51
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:39

◆ ssiReadBlackbox()

void ssiReadBlackbox ( leftv  res,
si_link  l 
)

Definition at line 827 of file ssiLink.cc.

828 {
829  ssiInfo *d=(ssiInfo*)l->data;
830  int throwaway=s_readint(d->f_read);
831  char *name=ssiReadString(d);
832  int tok;
833  blackboxIsCmd(name,tok);
834  if (tok>MAX_TOK)
835  {
836  ring save_ring=currRing;
837  idhdl save_hdl=currRingHdl;
838  blackbox *b=getBlackboxStuff(tok);
839  res->rtyp=tok;
840  b->blackbox_deserialize(&b,&(res->data),l);
841  if (save_ring!=currRing)
842  {
843  rChangeCurrRing(save_ring);
844  if (save_hdl!=NULL) rSetHdl(save_hdl);
845  else currRingHdl=NULL;
846  }
847  }
848  else
849  {
850  Werror("blackbox %s not found",name);
851  }
852  omFree(name);
853 }
blackbox * getBlackboxStuff(const int t)
return the structure to the type given by t
Definition: blackbox.cc:17
int blackboxIsCmd(const char *n, int &tok)
used by scanner: returns ROOT_DECL for known types (and the type number in tok)
Definition: blackbox.cc:218
CanonicalForm b
Definition: cfModGcd.cc:4105
void rChangeCurrRing(ring r)
Definition: polys.cc:15

◆ ssiReadCommand()

command ssiReadCommand ( si_link  l)

Definition at line 717 of file ssiLink.cc.

718 {
719  ssiInfo *d=(ssiInfo*)l->data;
720  // syntax: <num ops> <operation> <op1> <op2> ....
721  command D=(command)omAlloc0(sizeof(*D));
722  int argc,op;
723  argc=s_readint(d->f_read);
724  op=s_readint(d->f_read);
725  D->argc=argc; D->op=op;
726  leftv v;
727  if (argc >0)
728  {
729  v=ssiRead1(l);
730  memcpy(&(D->arg1),v,sizeof(*v));
732  }
733  if (argc <4)
734  {
735  if (D->argc >1)
736  {
737  v=ssiRead1(l);
738  memcpy(&(D->arg2),v,sizeof(*v));
740  }
741  if (D->argc >2)
742  {
743  v=ssiRead1(l);
744  memcpy(&(D->arg3),v,sizeof(*v));
746  }
747  }
748  else
749  {
750  leftv prev=&(D->arg1);
751  argc--;
752  while(argc >0)
753  {
754  v=ssiRead1(l);
755  prev->next=v;
756  prev=v;
757  argc--;
758  }
759  }
760  return D;
761 }
leftv next
Definition: subexpr.h:86

◆ ssiReadIdeal()

ideal ssiReadIdeal ( ssiInfo d)

Definition at line 696 of file ssiLink.cc.

697 {
698  return ssiReadIdeal_R(d,d->r);
699 }

◆ ssiReadIdeal_R()

ideal ssiReadIdeal_R ( const ssiInfo d,
const ring  r 
)

Definition at line 682 of file ssiLink.cc.

683 {
684 // < # of terms> < term1> < .....
685  int n,i;
686  ideal I;
687  n=s_readint(d->f_read);
688  I=idInit(n,1); // will be fixed later for module/smatrix
689  for(i=0;i<IDELEMS(I);i++) // read n terms
690  {
691  I->m [i]=ssiReadPoly_R(d,r);
692  }
693  return I;
694 }
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:35
#define IDELEMS(i)
Definition: simpleideals.h:23

◆ ssiReadInt()

int ssiReadInt ( s_buff  fich)

Definition at line 458 of file ssiLink.cc.

459 {
460  return s_readint(fich);
461 }

◆ ssiReadIntmat()

intvec* ssiReadIntmat ( const ssiInfo d)

Definition at line 802 of file ssiLink.cc.

803 {
804  int r,c;
805  r=s_readint(d->f_read);
806  c=s_readint(d->f_read);
807  intvec *v=new intvec(r,c,0);
808  for(int i=0;i<r*c;i++)
809  {
810  (*v)[i]=s_readint(d->f_read);
811  }
812  return v;
813 }
Definition: intvec.h:23

◆ ssiReadIntvec()

intvec* ssiReadIntvec ( const ssiInfo d)

Definition at line 791 of file ssiLink.cc.

792 {
793  int nr;
794  nr=s_readint(d->f_read);
795  intvec *v=new intvec(nr);
796  for(int i=0;i<nr;i++)
797  {
798  (*v)[i]=s_readint(d->f_read);
799  }
800  return v;
801 }

◆ ssiReadList()

lists ssiReadList ( si_link  l)

Definition at line 773 of file ssiLink.cc.

774 {
775  ssiInfo *d=(ssiInfo*)l->data;
776  int nr;
777  nr=s_readint(d->f_read);
779  L->Init(nr);
780 
781  int i;
782  leftv v;
783  for(i=0;i<=L->nr;i++)
784  {
785  v=ssiRead1(l);
786  memcpy(&(L->m[i]),v,sizeof(*v));
788  }
789  return L;
790 }
Definition: lists.h:24
INLINE_THIS void Init(int l=0)
VAR omBin slists_bin
Definition: lists.cc:23
slists * lists
Definition: mpr_numeric.h:146

◆ ssiReadMatrix()

matrix ssiReadMatrix ( ssiInfo d)

Definition at line 701 of file ssiLink.cc.

702 {
703  int n,m;
704  m=s_readint(d->f_read);
705  n=s_readint(d->f_read);
706  matrix M=mpNew(m,n);
707  poly p;
708  for(int i=1;i<=MATROWS(M);i++)
709  for(int j=1;j<=MATCOLS(M);j++)
710  {
711  p=ssiReadPoly(d);
712  MATELEM(M,i,j)=p;
713  }
714  return M;
715 }
int m
Definition: cfEzgcd.cc:128
matrix mpNew(int r, int c)
create a r x c zero-matrix
Definition: matpol.cc:37
#define MATELEM(mat, i, j)
1-based access to matrix
Definition: matpol.h:29
#define MATROWS(i)
Definition: matpol.h:26
#define MATCOLS(i)
Definition: matpol.h:27

◆ ssiReadNumber()

number ssiReadNumber ( ssiInfo d)

Definition at line 497 of file ssiLink.cc.

498 {
499  return ssiReadNumber_CF(d,d->r->cf);
500 }

◆ ssiReadNumber_CF()

number ssiReadNumber_CF ( const ssiInfo d,
const coeffs  cf 
)

Definition at line 463 of file ssiLink.cc.

464 {
465  if (cf->cfReadFd!=NULL)
466  {
467  return n_ReadFd(d,cf);
468  }
469  else if (getCoeffType(cf) == n_transExt)
470  {
471  // poly poly
472  fraction f=(fraction)n_Init(1,cf);
473  p_Delete(&NUM(f),cf->extRing);
474  NUM(f)=ssiReadPoly_R(d,cf->extRing);
475  DEN(f)=ssiReadPoly_R(d,cf->extRing);
476  return (number)f;
477  }
478  else if (getCoeffType(cf) == n_algExt)
479  {
480  // poly
481  return (number)ssiReadPoly_R(d,cf->extRing);
482  }
483  else WerrorS("coeffs not implemented in ssiReadNumber");
484  return NULL;
485 }
CanonicalForm cf
Definition: cfModGcd.cc:4085
FILE * f
Definition: checklibs.c:9
static FORCE_INLINE number n_ReadFd(const ssiInfo *f, const coeffs r)
io via ssi:
Definition: coeffs.h:998
@ n_algExt
used for all algebraic extensions, i.e., the top-most extension in an extension tower is algebraic
Definition: coeffs.h:36
@ n_transExt
used for all transcendental extensions, i.e., the top-most extension in an extension tower is transce...
Definition: coeffs.h:39
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition: coeffs.h:539
static void p_Delete(poly *p, const ring r)
Definition: p_polys.h:861
@ NUM
Definition: readcf.cc:170

◆ ssiReadPoly()

poly ssiReadPoly ( ssiInfo d)

Definition at line 677 of file ssiLink.cc.

678 {
679  return ssiReadPoly_R(d,d->r);
680 }

◆ ssiReadPoly_R()

poly ssiReadPoly_R ( const ssiInfo D,
const ring  r 
)

Definition at line 646 of file ssiLink.cc.

647 {
648 // < # of terms> < term1> < .....
649  int n,i,l;
650  n=ssiReadInt(d->f_read); // # of terms
651  //Print("poly: terms:%d\n",n);
652  poly p;
653  poly ret=NULL;
654  poly prev=NULL;
655  for(l=0;l<n;l++) // read n terms
656  {
657 // coef,comp.exp1,..exp N
658  p=p_Init(r,r->PolyBin);
659  pSetCoeff0(p,ssiReadNumber_CF(d,r->cf));
660  int D;
661  D=s_readint(d->f_read);
662  p_SetComp(p,D,r);
663  for(i=1;i<=rVar(r);i++)
664  {
665  D=s_readint(d->f_read);
666  p_SetExp(p,i,D,r);
667  }
668  p_Setm(p,r);
669  p_Test(p,r);
670  if (ret==NULL) ret=p;
671  else pNext(prev)=p;
672  prev=p;
673  }
674  return ret;
675 }
#define pNext(p)
Definition: monomials.h:36
#define pSetCoeff0(p, n)
Definition: monomials.h:59
static unsigned long p_SetExp(poly p, const unsigned long e, const unsigned long iBitmask, const int VarOffset)
set a single variable exponent @Note: VarOffset encodes the position in p->exp
Definition: p_polys.h:488
static unsigned long p_SetComp(poly p, unsigned long c, ring r)
Definition: p_polys.h:247
static void p_Setm(poly p, const ring r)
Definition: p_polys.h:233
static poly p_Init(const ring r, omBin bin)
Definition: p_polys.h:1280
#define p_Test(p, r)
Definition: p_polys.h:162
static short rVar(const ring r)
#define rVar(r) (r->N)
Definition: ring.h:597

◆ ssiReadProc()

procinfov ssiReadProc ( const ssiInfo d)

Definition at line 763 of file ssiLink.cc.

764 {
765  char *s=ssiReadString(d);
767  p->language=LANG_SINGULAR;
768  p->libname=omStrDup("");
769  p->procname=omStrDup("");
770  p->data.s.body=s;
771  return p;
772 }
procinfo * procinfov
Definition: structs.h:65
VAR omBin procinfo_bin
Definition: subexpr.cc:42

◆ ssiReadRing()

ring ssiReadRing ( const ssiInfo d)

Definition at line 502 of file ssiLink.cc.

503 {
504 /* syntax is <ch> <N> <l1> <v1> ...<lN> <vN> <number of orderings> <ord1> <block0_1> <block1_1> .... <Q-ideal> */
505  int ch;
506  ch=s_readint(d->f_read);
507  if (ch==-4)
508  return NULL;
509  int N=s_readint(d->f_read);
510  char **names;
511  coeffs cf=NULL;
512  if (ch==-3)
513  {
514  char *cf_name=ssiReadString(d);
515  cf=nFindCoeffByName(cf_name);
516  if (cf==NULL)
517  {
518  Werror("cannot find cf:%s",cf_name);
519  omFree(cf_name);
520  return NULL;
521  }
522  }
523  if (N!=0)
524  {
525  names=(char**)omAlloc(N*sizeof(char*));
526  for(int i=0;i<N;i++)
527  {
528  names[i]=ssiReadString(d);
529  }
530  }
531  // read the orderings:
532  int num_ord; // number of orderings
533  num_ord=s_readint(d->f_read);
534  rRingOrder_t *ord=(rRingOrder_t *)omAlloc0((num_ord+1)*sizeof(rRingOrder_t));
535  int *block0=(int *)omAlloc0((num_ord+1)*sizeof(int));
536  int *block1=(int *)omAlloc0((num_ord+1)*sizeof(int));
537  int **wvhdl=(int**)omAlloc0((num_ord+1)*sizeof(int*));
538  for(int i=0;i<num_ord;i++)
539  {
540  ord[i]=(rRingOrder_t)s_readint(d->f_read);
541  block0[i]=s_readint(d->f_read);
542  block1[i]=s_readint(d->f_read);
543  switch(ord[i])
544  {
545  case ringorder_a:
546  case ringorder_wp:
547  case ringorder_Wp:
548  case ringorder_ws:
549  case ringorder_Ws:
550  case ringorder_aa:
551  {
552  wvhdl[i]=(int*)omAlloc((block1[i]-block0[i]+1)*sizeof(int));
553  int ii;
554  for(ii=block0[i];ii<=block1[i];ii++)
555  wvhdl[i][ii-block0[i]]=s_readint(d->f_read);
556  }
557  break;
558 
559  case ringorder_a64:
560  case ringorder_M:
561  case ringorder_L:
562  case ringorder_IS:
563  Werror("ring oder not implemented for ssi:%d",ord[i]);
564  break;
565 
566  default: break;
567  }
568  }
569  if (N==0)
570  {
571  omFree(ord);
572  omFree(block0);
573  omFree(block1);
574  omFree(wvhdl);
575  return NULL;
576  }
577  else
578  {
579  ring r=NULL;
580  if (ch>=0) /* Q, Z/p */
581  r=rDefault(ch,N,names,num_ord,ord,block0,block1,wvhdl);
582  else if (ch==-1) /* trans ext. */
583  {
584  TransExtInfo T;
585  T.r=ssiReadRing(d);
586  if (T.r==NULL) return NULL;
588  r=rDefault(cf,N,names,num_ord,ord,block0,block1,wvhdl);
589  }
590  else if (ch==-2) /* alg ext. */
591  {
592  TransExtInfo T;
593  T.r=ssiReadRing(d); /* includes qideal */
594  if (T.r==NULL) return NULL;
596  r=rDefault(cf,N,names,num_ord,ord,block0,block1,wvhdl);
597  }
598  else if (ch==-3)
599  {
600  r=rDefault(cf,N,names,num_ord,ord,block0,block1,wvhdl);
601  }
602  else
603  {
604  Werror("ssi: read unknown coeffs type (%d)",ch);
605  for(int i=0;i<N;i++)
606  {
607  omFree(names[i]);
608  }
609  omFreeSize(names,N*sizeof(char*));
610  return NULL;
611  }
612  ideal q=ssiReadIdeal_R(d,r);
613  if (IDELEMS(q)==0) omFreeBin(q,sip_sideal_bin);
614  else r->qideal=q;
615  for(int i=0;i<N;i++)
616  {
617  omFree(names[i]);
618  }
619  omFreeSize(names,N*sizeof(char*));
620  rIncRefCnt(r);
621  // check if such ring already exist as ssiRing*
622  char name[20];
623  int nr=0;
624  idhdl h=NULL;
625  loop
626  {
627  sprintf(name,"ssiRing%d",nr); nr++;
628  h=IDROOT->get(name, 0);
629  if (h==NULL)
630  {
631  break;
632  }
633  else if ((IDTYP(h)==RING_CMD)
634  && (r!=IDRING(h))
635  && (rEqual(r,IDRING(h),1)))
636  {
637  rDelete(r);
638  r=rIncRefCnt(IDRING(h));
639  break;
640  }
641  }
642  return r;
643  }
644 }
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:56
coeffs nInitChar(n_coeffType t, void *parameter)
one-time initialisations for new coeffs in case of an error return NULL
Definition: numbers.cc:353
STATIC_VAR jList * T
Definition: janet.cc:30
The main handler for Singular numbers which are suitable for Singular polynomials.
coeffs nFindCoeffByName(char *cf_name)
find an existing coeff by its "CoeffName"
Definition: numbers.cc:591
void rDelete(ring r)
unconditionally deletes fields in r
Definition: ring.cc:449
ring rDefault(const coeffs cf, int N, char **n, int ord_size, rRingOrder_t *ord, int *block0, int *block1, int **wvhdl, unsigned long bitmask)
Definition: ring.cc:102
rRingOrder_t
order stuff
Definition: ring.h:68
@ ringorder_a
Definition: ring.h:70
@ ringorder_a64
for int64 weights
Definition: ring.h:71
@ ringorder_L
Definition: ring.h:89
@ ringorder_aa
for idElimination, like a, except pFDeg, pWeigths ignore it
Definition: ring.h:91
@ ringorder_Wp
Definition: ring.h:82
@ ringorder_ws
Definition: ring.h:86
@ ringorder_Ws
Definition: ring.h:87
@ ringorder_IS
Induced (Schreyer) ordering.
Definition: ring.h:93
@ ringorder_wp
Definition: ring.h:81
@ ringorder_M
Definition: ring.h:74
VAR omBin sip_sideal_bin
Definition: simpleideals.cc:27
struct for passing initialization parameters to naInitChar
Definition: transext.h:88

◆ ssiReadRingProperties()

void ssiReadRingProperties ( si_link  l)

Definition at line 875 of file ssiLink.cc.

876 {
877  ssiInfo *d=(ssiInfo*)l->data;
878  int what=s_readint(d->f_read);
879  switch(what)
880  {
881  case 0: // bitmask
882  {
883  int lb=s_readint(d->f_read);
884  unsigned long bm=~0L;
885  bm=bm<<lb;
886  bm=~bm;
887  rUnComplete(d->r);
888  d->r->bitmask=bm;
889  rComplete(d->r);
890  break;
891  }
892  case 1: // LPRing
893  {
894  int lb=s_readint(d->f_read);
895  int isLPring=s_readint(d->f_read);
896  unsigned long bm=~0L;
897  bm=bm<<lb;
898  bm=~bm;
899  rUnComplete(d->r);
900  d->r->bitmask=bm;
901  d->r->isLPring=isLPring;
902  rComplete(d->r);
903  break;
904  }
905  case 2: // Plural rings
906  {
907  matrix C=ssiReadMatrix(d);
909  nc_CallPlural(C,D,NULL,NULL,d->r,true,true,false,d->r,false);
910  break;
911  }
912  }
913 }
BOOLEAN nc_CallPlural(matrix cc, matrix dd, poly cn, poly dn, ring r, bool bSetupQuotient, bool bCopyInput, bool bBeQuiet, ring curr, bool dummy_ring=false)
returns TRUE if there were errors analyze inputs, check them for consistency detects nc_type,...
Definition: old.gring.cc:2682
BOOLEAN rComplete(ring r, int force)
this needs to be called whenever a new ring is created: new fields in ring are created (like VarOffse...
Definition: ring.cc:3403
void rUnComplete(ring r)
Definition: ring.cc:3918

◆ ssiReadString()

char* ssiReadString ( const ssiInfo d)

Definition at line 445 of file ssiLink.cc.

446 {
447  char *buf;
448  int l;
449  l=s_readint(d->f_read);
450  buf=(char*)omAlloc0(l+1);
451  int throwaway =s_getc(d->f_read); /* skip ' '*/
452  throwaway=s_readbytes(buf,l,d->f_read);
453  //if (throwaway!=l) printf("want %d, got %d bytes\n",l,throwaway);
454  buf[l]='\0';
455  return buf;
456 }
int s_readbytes(char *buff, int len, s_buff F)
Definition: s_buff.cc:168

◆ ssiReservePort()

int ssiReservePort ( int  clients)

Definition at line 2033 of file ssiLink.cc.

2034 {
2035  if (ssiReserved_P!=0)
2036  {
2037  WerrorS("ERROR already a reverved port requested");
2038  return 0;
2039  }
2040  int portno;
2041  ssiReserved_sockfd = socket(AF_INET, SOCK_STREAM, 0);
2042  if(ssiReserved_sockfd < 0)
2043  {
2044  WerrorS("ERROR opening socket");
2045  return 0;
2046  }
2047  memset((char *) &ssiResverd_serv_addr,0, sizeof(ssiResverd_serv_addr));
2048  portno = 1025;
2049  ssiResverd_serv_addr.sin_family = AF_INET;
2050  ssiResverd_serv_addr.sin_addr.s_addr = INADDR_ANY;
2051  do
2052  {
2053  portno++;
2054  ssiResverd_serv_addr.sin_port = htons(portno);
2055  if(portno > 50000)
2056  {
2057  WerrorS("ERROR on binding (no free port available?)");
2058  return 0;
2059  }
2060  }
2061  while(bind(ssiReserved_sockfd, (struct sockaddr *) &ssiResverd_serv_addr, sizeof(ssiResverd_serv_addr)) < 0);
2062  ssiReserved_P=portno;
2063  listen(ssiReserved_sockfd,clients);
2064  ssiReserved_Clients=clients;
2065  return portno;
2066 }

◆ ssiSetCurrRing()

BOOLEAN ssiSetCurrRing ( const ring  r)

Definition at line 72 of file ssiLink.cc.

73 {
74  // if (currRing!=NULL)
75  // Print("need to change the ring, currRing:%s, switch to: ssiRing%d\n",IDID(currRingHdl),nr);
76  // else
77  // Print("no ring, switch to ssiRing%d\n",nr);
78  if (r==currRing)
79  {
80  rIncRefCnt(r);
82  return TRUE;
83  }
84  else if ((currRing==NULL) || (!rEqual(r,currRing,1)))
85  {
86  char name[20];
87  int nr=0;
88  idhdl h=NULL;
89  loop
90  {
91  sprintf(name,"ssiRing%d",nr); nr++;
92  h=IDROOT->get(name, 0);
93  if (h==NULL)
94  {
96  IDRING(h)=rIncRefCnt(r);
97  r->ref=2;/*ref==2: d->r and h */
98  break;
99  }
100  else if ((IDTYP(h)==RING_CMD)
101  && (rEqual(r,IDRING(h),1)))
102  {
103  rIncRefCnt(IDRING(h));
104  break;
105  }
106  }
107  rSetHdl(h);
108  return FALSE;
109  }
110  else
111  {
112  rKill(r);
114  return TRUE;
115  }
116 }
idhdl rFindHdl(ring r, idhdl n)
Definition: ipshell.cc:1632

◆ ssiSetRing()

BOOLEAN ssiSetRing ( si_link  l,
ring  r,
BOOLEAN  send 
)

Definition at line 1583 of file ssiLink.cc.

1584 {
1585  if(SI_LINK_W_OPEN_P(l)==0)
1586  if (slOpen(l,SI_LINK_OPEN|SI_LINK_WRITE,NULL)) return TRUE;
1587  ssiInfo *d = (ssiInfo *)l->data;
1588  if (d->r!=r)
1589  {
1590  if (send)
1591  {
1592  fputs("15 ",d->f_write);
1593  ssiWriteRing(d,r);
1594  }
1595  d->r=r;
1596  }
1597  if (currRing!=r) rChangeCurrRing(r);
1598  return FALSE;
1599 }

◆ ssiWrite()

BOOLEAN ssiWrite ( si_link  l,
leftv  data 
)

Definition at line 1602 of file ssiLink.cc.

1603 {
1604  if(SI_LINK_W_OPEN_P(l)==0)
1605  if (slOpen(l,SI_LINK_OPEN|SI_LINK_WRITE,NULL)) return TRUE;
1606  ssiInfo *d = (ssiInfo *)l->data;
1607  d->level++;
1608  //FILE *fich=d->f;
1609  while (data!=NULL)
1610  {
1611  int tt=data->Typ();
1612  void *dd=data->Data();
1613  attr *aa=data->Attribute();
1614  if ((aa!=NULL) && ((*aa)!=NULL)) // n user attributes
1615  {
1616  attr a=*aa;
1617  int n=0;
1618  while(a!=NULL) { n++; a=a->next;}
1619  fprintf(d->f_write,"21 %d %d ",data->flag,n);
1620  }
1621  else if (data->flag!=0) // only "flag" attributes
1622  {
1623  fprintf(d->f_write,"21 %d 0 ",data->flag);
1624  }
1625  if ((dd==NULL) && (data->name!=NULL) && (tt==0)) tt=DEF_CMD;
1626  // return pure undefined names as def
1627 
1628  switch(tt /*data->Typ()*/)
1629  {
1630  case 0: /*error*/
1631  case NONE/* nothing*/:fputs("16 ",d->f_write);
1632  break;
1633  case STRING_CMD: fputs("2 ",d->f_write);
1634  ssiWriteString(d,(char *)dd);
1635  break;
1636  case INT_CMD: fputs("1 ",d->f_write);
1637  ssiWriteInt(d,(int)(long)dd);
1638  break;
1639  case BIGINT_CMD:fputs("4 ",d->f_write);
1640  ssiWriteBigInt(d,(number)dd);
1641  break;
1642  case NUMBER_CMD:
1643  if (d->r!=currRing)
1644  {
1645  fputs("15 ",d->f_write);
1647  if (d->level<=1) fputc('\n',d->f_write);
1648  }
1649  fputs("3 ",d->f_write);
1650  ssiWriteNumber(d,(number)dd);
1651  break;
1652  case RING_CMD:fputs("5 ",d->f_write);
1653  ssiWriteRing(d,(ring)dd);
1654  break;
1655  case BUCKET_CMD:
1656  {
1657  sBucket_pt b=(sBucket_pt)dd;
1658  if (d->r!=sBucketGetRing(b))
1659  {
1660  fputs("15 ",d->f_write);
1662  if (d->level<=1) fputc('\n',d->f_write);
1663  }
1664  fputs("6 ",d->f_write);
1665  ssiWritePoly(d,tt,sBucketPeek(b));
1666  break;
1667  }
1668  case POLY_CMD:
1669  case VECTOR_CMD:
1670  if (d->r!=currRing)
1671  {
1672  fputs("15 ",d->f_write);
1674  if (d->level<=1) fputc('\n',d->f_write);
1675  }
1676  if(tt==POLY_CMD) fputs("6 ",d->f_write);
1677  else fputs("9 ",d->f_write);
1678  ssiWritePoly(d,tt,(poly)dd);
1679  break;
1680  case IDEAL_CMD:
1681  case MODUL_CMD:
1682  case MATRIX_CMD:
1683  case SMATRIX_CMD:
1684  if (d->r!=currRing)
1685  {
1686  fputs("15 ",d->f_write);
1688  if (d->level<=1) fputc('\n',d->f_write);
1689  }
1690  if(tt==IDEAL_CMD) fputs("7 ",d->f_write);
1691  else if(tt==MATRIX_CMD) fputs("8 ",d->f_write);
1692  else if(tt==SMATRIX_CMD) fputs("22 ",d->f_write);
1693  else /* tt==MODUL_CMD*/
1694  {
1695  ideal M=(ideal)dd;
1696  fprintf(d->f_write,"10 %d ",(int)M->rank);
1697  }
1698  ssiWriteIdeal(d,tt,(ideal)dd);
1699  break;
1700  case COMMAND:
1701  fputs("11 ",d->f_write);
1702  ssiWriteCommand(l,(command)dd);
1703  break;
1704  case DEF_CMD: /* not evaluated stuff in quotes */
1705  fputs("12 ",d->f_write);
1706  ssiWriteString(d,data->Name());
1707  break;
1708  case PROC_CMD:
1709  fputs("13 ",d->f_write);
1710  ssiWriteProc(d,(procinfov)dd);
1711  break;
1712  case LIST_CMD:
1713  fputs("14 ",d->f_write);
1714  ssiWriteList(l,(lists)dd);
1715  break;
1716  case INTVEC_CMD:
1717  fputs("17 ",d->f_write);
1718  ssiWriteIntvec(d,(intvec *)dd);
1719  break;
1720  case INTMAT_CMD:
1721  fputs("18 ",d->f_write);
1722  ssiWriteIntmat(d,(intvec *)dd);
1723  break;
1724  case BIGINTMAT_CMD:
1725  fputs("19 ",d->f_write);
1726  ssiWriteBigintmat(d,(bigintmat *)dd);
1727  break;
1728  default:
1729  if (tt>MAX_TOK)
1730  {
1731  blackbox *b=getBlackboxStuff(tt);
1732  fputs("20 ",d->f_write);
1733  b->blackbox_serialize(b,dd,l);
1734  }
1735  else
1736  {
1737  Werror("not implemented (t:%d, rtyp:%d)",tt, data->rtyp);
1738  d->level=0;
1739  return TRUE;
1740  }
1741  break;
1742  }
1743  if (d->level<=1) { fputc('\n',d->f_write); fflush(d->f_write); }
1744  data=data->next;
1745  }
1746  d->level--;
1747  return FALSE;
1748 }
Definition: attrib.h:21
attr next
Definition: attrib.h:26
const char * name
Definition: subexpr.h:87
attr * Attribute()
Definition: subexpr.cc:1454
BITSET flag
Definition: subexpr.h:90
const char * Name()
Definition: subexpr.h:120
@ BUCKET_CMD
Definition: grammar.cc:283
while(1)
Definition: libparse.cc:1444
char level
Definition: s_buff.h:27
poly sBucketPeek(sBucket_pt b)
Definition: sbuckets.cc:455
ring sBucketGetRing(const sBucket_pt bucket)
Returns bucket ring.
Definition: sbuckets.cc:46
sBucket * sBucket_pt
Definition: sbuckets.h:16

◆ ssiWriteBigInt()

void ssiWriteBigInt ( const ssiInfo d,
const number  n 
)

Definition at line 160 of file ssiLink.cc.

161 {
163 }
static FORCE_INLINE void n_WriteFd(number a, const ssiInfo *f, const coeffs r)
io via ssi:
Definition: coeffs.h:994

◆ ssiWriteBigintmat()

void ssiWriteBigintmat ( const ssiInfo d,
bigintmat v 
)

Definition at line 435 of file ssiLink.cc.

436 {
437  fprintf(d->f_write,"%d %d ",v->rows(),v->cols());
438  int i;
439  for(i=0;i<v->length();i++)
440  {
441  ssiWriteBigInt(d,(*v)[i]);
442  }
443 }

◆ ssiWriteCommand()

void ssiWriteCommand ( si_link  l,
command  D 
)

Definition at line 382 of file ssiLink.cc.

383 {
384  ssiInfo *d=(ssiInfo*)l->data;
385  // syntax: <num ops> <operation> <op1> <op2> ....
386  fprintf(d->f_write,"%d %d ",D->argc,D->op);
387  if (D->argc >0) ssiWrite(l, &(D->arg1));
388  if (D->argc < 4)
389  {
390  if (D->argc >1) ssiWrite(l, &(D->arg2));
391  if (D->argc >2) ssiWrite(l, &(D->arg3));
392  }
393 }

◆ ssiWriteIdeal()

void ssiWriteIdeal ( const ssiInfo d,
int  typ,
const ideal  I 
)

Definition at line 377 of file ssiLink.cc.

378 {
379  ssiWriteIdeal_R(d,typ,I,d->r);
380 }

◆ ssiWriteIdeal_R()

void ssiWriteIdeal_R ( const ssiInfo d,
int  typ,
const ideal  I,
const ring  r 
)

Definition at line 347 of file ssiLink.cc.

348 {
349  // syntax: 7 # of elements <poly 1> <poly2>.....(ideal,module,smatrix)
350  // syntax: 8 <rows> <cols> <poly 1> <poly2>.....(matrix)
351  // syntax
352  matrix M=(matrix)I;
353  int mn;
354  if (typ==MATRIX_CMD)
355  {
356  mn=MATROWS(M)*MATCOLS(M);
357  fprintf(d->f_write,"%d %d ", MATROWS(M),MATCOLS(M));
358  }
359  else
360  {
361  mn=IDELEMS(I);
362  fprintf(d->f_write,"%d ",IDELEMS(I));
363  }
364 
365  int i;
366  int tt;
367  if ((typ==MODUL_CMD)||(typ==SMATRIX_CMD))
368  tt=VECTOR_CMD;
369  else
370  tt=POLY_CMD;
371 
372  for(i=0;i<mn;i++)
373  {
374  ssiWritePoly_R(d,tt,I->m[i],R);
375  }
376 }
ip_smatrix * matrix
Definition: matpol.h:43
#define R
Definition: sirandom.c:27

◆ ssiWriteInt()

void ssiWriteInt ( const ssiInfo d,
const int  i 
)

Definition at line 148 of file ssiLink.cc.

149 {
150  fprintf(d->f_write,"%d ",i);
151  //if (d->f_debug!=NULL) fprintf(d->f_debug,"int: %d ",i);
152 }

◆ ssiWriteIntmat()

void ssiWriteIntmat ( const ssiInfo d,
intvec v 
)

Definition at line 425 of file ssiLink.cc.

426 {
427  fprintf(d->f_write,"%d %d ",v->rows(),v->cols());
428  int i;
429  for(i=0;i<v->length();i++)
430  {
431  fprintf(d->f_write,"%d ",(*v)[i]);
432  }
433 }

◆ ssiWriteIntvec()

void ssiWriteIntvec ( const ssiInfo d,
intvec v 
)

Definition at line 416 of file ssiLink.cc.

417 {
418  fprintf(d->f_write,"%d ",v->length());
419  int i;
420  for(i=0;i<v->length();i++)
421  {
422  fprintf(d->f_write,"%d ",(*v)[i]);
423  }
424 }

◆ ssiWriteList()

void ssiWriteList ( si_link  l,
lists  dd 
)

Definition at line 405 of file ssiLink.cc.

406 {
407  ssiInfo *d=(ssiInfo*)l->data;
408  int Ll=dd->nr;
409  fprintf(d->f_write,"%d ",Ll+1);
410  int i;
411  for(i=0;i<=Ll;i++)
412  {
413  ssiWrite(l,&(dd->m[i]));
414  }
415 }

◆ ssiWriteNumber()

void ssiWriteNumber ( const ssiInfo d,
const number  n 
)

Definition at line 193 of file ssiLink.cc.

194 {
195  ssiWriteNumber_CF(d,n,d->r->cf);
196 }

◆ ssiWriteNumber_CF()

void ssiWriteNumber_CF ( const ssiInfo d,
const number  n,
const coeffs  cf 
)

Definition at line 165 of file ssiLink.cc.

166 {
167  // syntax is as follows:
168  // case 1 Z/p: 3 <int>
169  // case 2 Q: 3 4 <int>
170  // or 3 0 <mpz_t nominator> <mpz_t denominator>
171  // or 3 1 dto.
172  // or 3 3 <mpz_t nominator>
173  // or 3 5 <mpz_t raw nom.> <mpz_t raw denom.>
174  // or 3 6 <mpz_t raw nom.> <mpz_t raw denom.>
175  // or 3 8 <mpz_t raw nom.>
176  if (getCoeffType(cf)==n_transExt)
177  {
178  fraction f=(fraction)n;
179  ssiWritePoly_R(d,POLY_CMD,NUM(f),cf->extRing);
180  ssiWritePoly_R(d,POLY_CMD,DEN(f),cf->extRing);
181  }
182  else if (getCoeffType(cf)==n_algExt)
183  {
184  ssiWritePoly_R(d,POLY_CMD,(poly)n,cf->extRing);
185  }
186  else if (cf->cfWriteFd!=NULL)
187  {
188  n_WriteFd(n,d,cf);
189  }
190  else WerrorS("coeff field not implemented");
191 }

◆ ssiWritePoly()

void ssiWritePoly ( const ssiInfo d,
int  typ,
poly  p 
)

Definition at line 342 of file ssiLink.cc.

343 {
344  ssiWritePoly_R(d,typ,p,d->r);
345 }

◆ ssiWritePoly_R()

void ssiWritePoly_R ( const ssiInfo d,
int  typ,
poly  p,
const ring  r 
)

Definition at line 324 of file ssiLink.cc.

325 {
326  fprintf(d->f_write,"%d ",pLength(p));//number of terms
327 
328  while(p!=NULL)
329  {
330  ssiWriteNumber_CF(d,pGetCoeff(p),r->cf);
331  //nWrite(fich,pGetCoeff(p));
332  fprintf(d->f_write,"%ld ",p_GetComp(p,r));//component
333 
334  for(int j=1;j<=rVar(r);j++)
335  {
336  fprintf(d->f_write,"%ld ",p_GetExp(p,j,r ));//x^j
337  }
338  pIter(p);
339  }
340 }
#define p_GetComp(p, r)
Definition: monomials.h:64
#define pIter(p)
Definition: monomials.h:37
static number & pGetCoeff(poly p)
return an alias to the leading coefficient of p assumes that p != NULL NOTE: not copy
Definition: monomials.h:44
static long p_GetExp(const poly p, const unsigned long iBitmask, const int VarOffset)
get a single variable exponent @Note: the integer VarOffset encodes:
Definition: p_polys.h:469
static unsigned pLength(poly a)
Definition: p_polys.h:191

◆ ssiWriteProc()

void ssiWriteProc ( const ssiInfo d,
procinfov  p 
)

Definition at line 395 of file ssiLink.cc.

396 {
397  if (p->data.s.body==NULL)
399  if (p->data.s.body!=NULL)
400  ssiWriteString(d,p->data.s.body);
401  else
402  ssiWriteString(d,"");
403 }
char * iiGetLibProcBuffer(procinfo *pi, int part)
Definition: iplib.cc:193

◆ ssiWriteRing()

void ssiWriteRing ( ssiInfo d,
const ring  r 
)

Definition at line 301 of file ssiLink.cc.

302 {
303  /* 5 <ch> <N> <l1> <v1> ...<lN> <vN> <number of orderings> <ord1> <block0_1> <block1_1> .... <extRing> <Q-ideal> */
304  /* ch=-1: transext, coeff ring follows */
305  /* ch=-2: algext, coeff ring and minpoly follows */
306  /* ch=-3: cf name follows */
307  /* ch=-4: NULL */
308  if ((r==NULL)||(r->cf==NULL))
309  {
310  fputs("-4 ",d->f_write);
311  return;
312  }
313  if (r==currRing) // see recursive calls for transExt/algExt
314  {
315  if (d->r!=NULL) rKill(d->r);
316  d->r=r;
317  }
318  if (r!=NULL)
319  {
320  /*d->*/rIncRefCnt(r);
321  }
322  ssiWriteRing_R(d,r);
323 }

◆ ssiWriteRing_R()

void ssiWriteRing_R ( ssiInfo d,
const ring  r 
)

Definition at line 198 of file ssiLink.cc.

199 {
200  /* 5 <ch> <N> <l1> <v1> ...<lN> <vN> <number of orderings> <ord1> <block0_1> <block1_1> .... <extRing> <Q-ideal> */
201  /* ch=-1: transext, coeff ring follows */
202  /* ch=-2: algext, coeff ring and minpoly follows */
203  /* ch=-3: cf name follows */
204  if (r!=NULL)
205  {
206  if (rField_is_Q(r) || rField_is_Zp(r))
207  fprintf(d->f_write,"%d %d ",n_GetChar(r->cf),r->N);
208  else if (rFieldType(r)==n_transExt)
209  fprintf(d->f_write,"-1 %d ",r->N);
210  else if (rFieldType(r)==n_algExt)
211  fprintf(d->f_write,"-2 %d ",r->N);
212  else /*dummy*/
213  {
214  fprintf(d->f_write,"-3 %d ",r->N);
215  ssiWriteString(d,nCoeffName(r->cf));
216  }
217 
218  int i;
219  for(i=0;i<r->N;i++)
220  {
221  fprintf(d->f_write,"%d %s ",(int)strlen(r->names[i]),r->names[i]);
222  }
223  /* number of orderings:*/
224  i=0;
225  // remember dummy ring: everything 0:
226  if (r->order!=NULL) while (r->order[i]!=0) i++;
227  fprintf(d->f_write,"%d ",i);
228  /* each ordering block: */
229  i=0;
230  if (r->order!=NULL) while(r->order[i]!=0)
231  {
232  fprintf(d->f_write,"%d %d %d ",r->order[i],r->block0[i], r->block1[i]);
233  switch(r->order[i])
234  {
235  case ringorder_a:
236  case ringorder_wp:
237  case ringorder_Wp:
238  case ringorder_ws:
239  case ringorder_Ws:
240  case ringorder_aa:
241  {
242  int ii;
243  for(ii=r->block0[i];ii<=r->block1[i];ii++)
244  fprintf(d->f_write,"%d ",r->wvhdl[i][ii-r->block0[i]]);
245  }
246  break;
247 
248  case ringorder_a64:
249  case ringorder_M:
250  case ringorder_L:
251  case ringorder_IS:
252  Werror("ring oder not implemented for ssi:%d",r->order[i]);
253  break;
254 
255  default: break;
256  }
257  i++;
258  }
259  if ((rFieldType(r)==n_transExt)
260  || (rFieldType(r)==n_algExt))
261  {
262  ssiWriteRing_R(d,r->cf->extRing); /* includes alg.ext if rFieldType(r)==n_algExt */
263  }
264  /* Q-ideal :*/
265  if (r->qideal!=NULL)
266  {
267  ssiWriteIdeal_R(d,IDEAL_CMD,r->qideal,r);
268  }
269  else
270  {
271  fputs("0 ",d->f_write/*ideal with 0 entries */);
272  }
273  }
274  else /* dummy ring r==NULL*/
275  {
276  fputs("0 0 0 0 "/*,r->ch,r->N, blocks, q-ideal*/,d->f_write);
277  }
278  if (rIsLPRing(r)) // cannot be combined with 23 2
279  {
280  fprintf(d->f_write,"23 1 %d %d ",SI_LOG2(r->bitmask),r->isLPring);
281  }
282  else
283  {
284  unsigned long bm=0;
285  int b=0;
286  bm=rGetExpSize(bm,b,r->N);
287  if (r->bitmask!=bm)
288  {
289  fprintf(d->f_write,"23 0 %d ",SI_LOG2(r->bitmask));
290  }
291  if (rIsPluralRing(r))
292  {
293  fputs("23 2 ",d->f_write);
294  void ssiWriteIdeal(const ssiInfo *d, int typ,const ideal I);
295  ssiWriteIdeal(d,MATRIX_CMD,(ideal)r->GetNC()->C);
296  ssiWriteIdeal(d,MATRIX_CMD,(ideal)r->GetNC()->D);
297  }
298  }
299 }
static FORCE_INLINE char * nCoeffName(const coeffs cf)
Definition: coeffs.h:987
static FORCE_INLINE int n_GetChar(const coeffs r)
Return the characteristic of the coeff. domain.
Definition: coeffs.h:445
static unsigned long rGetExpSize(unsigned long bitmask, int &bits)
Definition: ring.cc:2513
static BOOLEAN rField_is_Zp(const ring r)
Definition: ring.h:505
static n_coeffType rFieldType(const ring r)
the type of the coefficient filed of r (n_Zp, n_Q, etc)
Definition: ring.h:561
static BOOLEAN rIsPluralRing(const ring r)
we must always have this test!
Definition: ring.h:400
static BOOLEAN rIsLPRing(const ring r)
Definition: ring.h:411
static BOOLEAN rField_is_Q(const ring r)
Definition: ring.h:511
static int SI_LOG2(int v)
Definition: si_log2.h:6

◆ ssiWriteString()

void ssiWriteString ( const ssiInfo d,
const char *  s 
)

Definition at line 154 of file ssiLink.cc.

155 {
156  fprintf(d->f_write,"%d %s ",(int)strlen(s),s);
157  //if (d->f_debug!=NULL) fprintf(d->f_debug,"stringi: %d \"%s\" ",strlen(s),s);
158 }

Variable Documentation

◆ si_link_root

EXTERN_VAR si_link_extension si_link_root

Definition at line 2068 of file ssiLink.cc.

◆ ssiReserved_Clients

STATIC_VAR int ssiReserved_Clients

Definition at line 2032 of file ssiLink.cc.

◆ ssiReserved_P

STATIC_VAR int ssiReserved_P =0

Definition at line 2029 of file ssiLink.cc.

◆ ssiReserved_sockfd

STATIC_VAR int ssiReserved_sockfd

Definition at line 2030 of file ssiLink.cc.

◆ ssiResverd_serv_addr

STATIC_VAR struct sockaddr_in ssiResverd_serv_addr

Definition at line 2031 of file ssiLink.cc.

◆ ssiToBeClosed

VAR link_list ssiToBeClosed =NULL

Definition at line 62 of file ssiLink.cc.

◆ ssiToBeClosed_inactive

VAR volatile BOOLEAN ssiToBeClosed_inactive =TRUE

Definition at line 63 of file ssiLink.cc.