Functions
ipprint.cc File Reference
#include <kernel/mod2.h>
#include <omalloc/omalloc.h>
#include <misc/intvec.h>
#include <polys/matpol.h>
#include <kernel/polys.h>
#include <kernel/ideals.h>
#include "tok.h"
#include "ipid.h"
#include "subexpr.h"
#include "ipshell.h"
#include "ipprint.h"
#include "attrib.h"

Go to the source code of this file.

Functions

static BOOLEAN ipPrint_INTVEC (leftv u)
 
static BOOLEAN ipPrint_INTMAT (leftv u)
 
static void ipPrint_MA0 (matrix m, const char *name)
 
static BOOLEAN ipPrint_MA (leftv u)
 
static BOOLEAN ipPrint_RING (leftv u)
 
static BOOLEAN ipPrint_CRING (leftv u)
 
static BOOLEAN ipPrint_V (leftv u)
 
BOOLEAN jjPRINT (leftv res, leftv u)
 
BOOLEAN jjDBPRINT (leftv res, leftv u)
 
static void ipPrintBetti (leftv u)
 
BOOLEAN jjPRINT_FORMAT (leftv res, leftv u, leftv v)
 

Function Documentation

§ ipPrint_CRING()

static BOOLEAN ipPrint_CRING ( leftv  u)
static

Definition at line 215 of file ipprint.cc.

216 {
217  coeffs r=(coeffs)u->Data();
218  if (nCoeff_is_Ring(r))
219  {
220  if (nCoeff_is_Domain(r)) PrintS("domain: ");
221  else PrintS("ring (with zero-divisors): ");
222  }
223  else PrintS("field: ");
224  PrintS(nCoeffName(r));
225  return FALSE;
226 }
#define FALSE
Definition: auxiliary.h:95
static FORCE_INLINE BOOLEAN nCoeff_is_Ring(const coeffs r)
Definition: coeffs.h:762
const ring r
Definition: syzextra.cc:208
The main handler for Singular numbers which are suitable for Singular polynomials.
static FORCE_INLINE char * nCoeffName(const coeffs cf)
Definition: coeffs.h:977
void PrintS(const char *s)
Definition: reporter.cc:284
static FORCE_INLINE BOOLEAN nCoeff_is_Domain(const coeffs r)
returns TRUE, if r is a field or r has no zero divisors (i.e is a domain)
Definition: coeffs.h:773
void * Data()
Definition: subexpr.cc:1146

§ ipPrint_INTMAT()

static BOOLEAN ipPrint_INTMAT ( leftv  u)
static

Definition at line 42 of file ipprint.cc.

43 {
44  intvec *v=(intvec *)u->Data();
45  int i,j;
46  for(i=0;i<v->rows();i++)
47  {
48  for(j=0;j<v->cols();j++)
49  {
50  Print(" %5d",IMATELEM(*v,i+1,j+1));
51  }
52  PrintLn();
53  }
54  return FALSE;
55 }
void PrintLn()
Definition: reporter.cc:310
#define Print
Definition: emacs.cc:83
#define FALSE
Definition: auxiliary.h:95
int rows() const
Definition: intvec.h:88
Definition: intvec.h:14
int j
Definition: myNF.cc:70
int i
Definition: cfEzgcd.cc:123
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
int cols() const
Definition: intvec.h:87
void * Data()
Definition: subexpr.cc:1146
#define IMATELEM(M, I, J)
Definition: intvec.h:77

§ ipPrint_INTVEC()

static BOOLEAN ipPrint_INTVEC ( leftv  u)
static

Definition at line 31 of file ipprint.cc.

32 {
33  intvec *v=(intvec *)u->Data();
34  v->show();
35  PrintLn();
36  return FALSE;
37 }
void PrintLn()
Definition: reporter.cc:310
#define FALSE
Definition: auxiliary.h:95
Definition: intvec.h:14
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:37
void show(int mat=0, int spaces=0) const
Definition: intvec.cc:150
void * Data()
Definition: subexpr.cc:1146

§ ipPrint_MA()

static BOOLEAN ipPrint_MA ( leftv  u)
static

Definition at line 186 of file ipprint.cc.

187 {
188  matrix m=(matrix)u->Data();
189  ipPrint_MA0(m,u->Name());
190  return FALSE;
191 }
#define FALSE
Definition: auxiliary.h:95
static void ipPrint_MA0(matrix m, const char *name)
Definition: ipprint.cc:60
const char * Name()
Definition: subexpr.h:121
ip_smatrix * matrix
int m
Definition: cfEzgcd.cc:119
void * Data()
Definition: subexpr.cc:1146

§ ipPrint_MA0()

static void ipPrint_MA0 ( matrix  m,
const char *  name 
)
static

Definition at line 60 of file ipprint.cc.

61 {
62  if ((MATCOLS(m)>0)&&(MATROWS(m)>0))
63  {
64  char **s=(char **)omAlloc(MATCOLS(m)*MATROWS(m)*sizeof(char*));
65  char *ss;
66  int *l=(int *)omAlloc0(MATCOLS(m)*sizeof(int));
67  int i,j,k;
68  int vl=si_max(colmax/MATCOLS(m),8);
69 
70  /* make enough space for the "largest" name*/
71  ss=(char *)omAlloc(14+strlen(name));
72  sprintf(ss,"%s[%d,%d]",name,MATCOLS(m),MATROWS(m));
73  vl=si_max(vl,(int)strlen(ss));
74  omFree(ss);
75 
76  /* convert all polys to string */
77  i=MATCOLS(m)*MATROWS(m)-1;
78  ss=pString(m->m[i]);
79  if ((int)strlen(ss)>colmax) { s[i]=NULL; omFree(ss); }
80  else s[i]=ss;
81  for(i--;i>=0;i--)
82  {
83  StringSetS("");
84  pString0(m->m[i]);
85  StringAppendS(",");
86  ss=StringEndS();
87  if ((int)strlen(ss)>colmax) s[i]=NULL;
88  else s[i]=ss;
89  }
90  /* look up the width of all columns, put it in l[col_nr] */
91  /* insert names for very long entries */
92  for(i=MATROWS(m)-1;i>=0;i--)
93  {
94  for(j=MATCOLS(m)-1;j>=0;j--)
95  {
96  if (s[i*MATCOLS(m)+j]==NULL)
97  {
98  ss=(char *)omAlloc(14+strlen(name));
99  s[i*MATCOLS(m)+j]=ss;
100  ss[0]='\0';
101  sprintf(ss,"%s[%d,%d]",name,i+1,j+1);
102  if ((i!=MATROWS(m)-1) || (j!=MATCOLS(m)-1))
103  {
104  strcat(ss,",");
105  vl=si_max(vl,(int)strlen(ss));
106  }
107  }
108  k=strlen(s[i*MATCOLS(m)+j]);
109  if (k>l[j]) l[j]=k;
110  }
111  }
112  /* does it fit on a line ? */
113  int maxlen=0;
114  for(j=MATCOLS(m)-1;j>=0;j--)
115  {
116  maxlen+=l[j];
117  }
118  if (maxlen>colmax)
119  {
120  /* NO, it does not fit, so retry: */
121  /* look up the width of all columns, clear very long entriess */
122  /* put length in l[col_nr] */
123  /* insert names for cleared entries */
124  for(j=MATCOLS(m)-1;j>=0;j--)
125  {
126  for(i=MATROWS(m)-1;i>=0;i--)
127  {
128  k=strlen(s[i*MATCOLS(m)+j]);
129  if (/*strlen(s[i*MATCOLS(m)+j])*/ k > vl)
130  {
131  omFree((ADDRESS)s[i*MATCOLS(m)+j]);
132  ss=(char *)omAlloc(14+strlen(name));
133  s[i*MATCOLS(m)+j]=ss;
134  ss[0]='\0';
135  sprintf(ss,"%s[%d,%d]",name,i+1,j+1);
136  if ((i!=MATROWS(m)-1) || (j!=MATCOLS(m)-1))
137  {
138  strcat(ss,",");
139  }
140  l[j]=strlen(s[i*MATCOLS(m)+j]);
141  if (l[j]>vl)
142  {
143 //#ifdef TEST
144 // PrintS("pagewidth too small in print(matrix)\n");
145 //#endif
146  vl=l[j]; /* make large names fit*/
147  }
148  i=MATROWS(m);
149  }
150  else
151  {
152  if (k>l[j]) l[j]=k;
153  }
154  }
155  }
156  }
157  /*output of the matrix*/
158  for(i=0;i<MATROWS(m);i++)
159  {
160  k=l[0];
161  Print("%-*.*s",l[0],l[0],s[i*MATCOLS(m)]);
162  omFree(s[i*MATCOLS(m)]);
163  for(j=1;j<MATCOLS(m);j++)
164  {
165  if (k+l[j]>colmax)
166  {
167  PrintS("\n ");
168  k=2;
169  }
170  k+=l[j];
171  Print("%-*.*s",l[j],l[j],s[i*MATCOLS(m)+j]);
172  omFree(s[i*MATCOLS(m)+j]);
173  }
174  PrintLn();
175  }
176  /* clean up */
177  omFreeSize((ADDRESS)s,MATCOLS(m)*MATROWS(m)*sizeof(char*));
178  omFreeSize((ADDRESS)l,MATCOLS(m)*sizeof(int));
179  }
180  else Print("%d x %d zero matrix\n",MATROWS(m),MATCOLS(m));
181 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
char * pString(poly p)
Definition: polys.h:289
void PrintLn()
Definition: reporter.cc:310
#define Print
Definition: emacs.cc:83
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
void * ADDRESS
Definition: auxiliary.h:116
int k
Definition: cfEzgcd.cc:93
char * StringEndS()
Definition: reporter.cc:151
#define omAlloc(size)
Definition: omAllocDecl.h:210
poly * m
Definition: matpol.h:19
int j
Definition: myNF.cc:70
#define omFree(addr)
Definition: omAllocDecl.h:261
void StringSetS(const char *st)
Definition: reporter.cc:128
void StringAppendS(const char *st)
Definition: reporter.cc:107
static int si_max(const int a, const int b)
Definition: auxiliary.h:121
int i
Definition: cfEzgcd.cc:123
void PrintS(const char *s)
Definition: reporter.cc:284
char name(const Variable &v)
Definition: factory.h:178
void pString0(poly p)
Definition: polys.h:290
#define MATCOLS(i)
Definition: matpol.h:28
#define NULL
Definition: omList.c:10
#define MATROWS(i)
Definition: matpol.h:27
int colmax
Definition: febase.cc:43
#define omAlloc0(size)
Definition: omAllocDecl.h:211
int l
Definition: cfEzgcd.cc:94

§ ipPrint_RING()

static BOOLEAN ipPrint_RING ( leftv  u)
static

Definition at line 196 of file ipprint.cc.

197 {
198  ring r=(ring)u->Data();
199  PrintS("polynomial ring, over a ");
200  if (rField_is_Ring(r))
201  {
202  if (rField_is_Domain(r)) PrintS("domain");
203  else PrintS("ring (with zero-divisors)");
204  }
205  else PrintS("field");
206  if (r->OrdSgn==1) PrintS(", global");
207  else if (r->MixedOrder==1) PrintS(", mixed");
208  else PrintS(", local");
209  PrintS(" ordering\n");
210  rWrite(r, TRUE);
211  return FALSE;
212 }
#define FALSE
Definition: auxiliary.h:95
#define TRUE
Definition: auxiliary.h:99
static BOOLEAN rField_is_Domain(const ring r)
Definition: ring.h:480
const ring r
Definition: syzextra.cc:208
void PrintS(const char *s)
Definition: reporter.cc:284
void rWrite(ring r, BOOLEAN details)
Definition: ring.cc:236
static BOOLEAN rField_is_Ring(const ring r)
Definition: ring.h:477
void * Data()
Definition: subexpr.cc:1146

§ ipPrint_V()

static BOOLEAN ipPrint_V ( leftv  u)
static

Definition at line 231 of file ipprint.cc.

232 {
233  polyset m=NULL;
234  int l,j;
235  /*convert into an array of the components*/
236  p_Vec2Polys((poly)u->Data(), &m, &l, currRing);
237  /*output*/
238  PrintS("[");
239  j=0;
240  loop
241  {
242  PrintS(pString(m[j]));
243  j++;
244  if (j<l) PrintS(",");
245  else
246  {
247  PrintS("]\n");
248  break;
249  }
250  }
251  /* clean up */
252  for(j=l-1;j>=0;j--) pDelete(&m[j]);
253  omFreeSize((ADDRESS)m,l*sizeof(poly));
254  return FALSE;
255 }
char * pString(poly p)
Definition: polys.h:289
loop
Definition: myNF.cc:98
#define FALSE
Definition: auxiliary.h:95
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
void * ADDRESS
Definition: auxiliary.h:116
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:10
int j
Definition: myNF.cc:70
void p_Vec2Polys(poly v, poly **p, int *len, const ring r)
Definition: p_polys.cc:3474
int m
Definition: cfEzgcd.cc:119
void PrintS(const char *s)
Definition: reporter.cc:284
#define NULL
Definition: omList.c:10
poly * polyset
Definition: hutil.h:15
#define pDelete(p_ptr)
Definition: polys.h:169
void * Data()
Definition: subexpr.cc:1146
polyrec * poly
Definition: hilb.h:10
int l
Definition: cfEzgcd.cc:94

§ ipPrintBetti()

static void ipPrintBetti ( leftv  u)
static

Definition at line 352 of file ipprint.cc.

353 {
354  int i,j;
355  int row_shift=(int)((long)(atGet(u,"rowShift",INT_CMD)));
356  intvec * betti=(intvec *)u->Data();
357  // head line --------------------------------------------------------
358  PrintS(" "); // 6 spaces for no. and :
359  for(j=0;j<betti->cols();j++) Print(" %5d",j); // 6 spaces pro column
360  PrintS("\n------"); // 6 spaces for no. and :
361  for(j=0;j<betti->cols();j++) PrintS("------"); // 6 spaces pro column
362  PrintLn();
363  // the table --------------------------------------------------------
364  for(i=0;i<betti->rows();i++)
365  {
366  Print("%5d:",i+row_shift);
367  for(j=1;j<=betti->cols();j++)
368  {
369  int m=IMATELEM(*betti,i+1,j);
370  if (m==0)
371  PrintS(" -");
372  else
373  Print(" %5d",m);
374  }
375  PrintLn();
376  }
377  // sum --------------------------------------------------------------
378  PrintS("------"); // 6 spaces for no. and :
379  for(j=0;j<betti->cols();j++) PrintS("------"); // 6 spaces pro column
380  PrintS("\ntotal:");
381  for(j=0;j<betti->cols();j++)
382  {
383  int s=0;
384  for(i=0;i<betti->rows();i++)
385  {
386  s+=IMATELEM(*betti,i+1,j+1);
387  }
388  Print(" %5d",s); // 6 spaces pro column
389  }
390  PrintLn();
391 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
void PrintLn()
Definition: reporter.cc:310
#define Print
Definition: emacs.cc:83
Definition: tok.h:95
int rows() const
Definition: intvec.h:88
Definition: intvec.h:14
int j
Definition: myNF.cc:70
int m
Definition: cfEzgcd.cc:119
int i
Definition: cfEzgcd.cc:123
void PrintS(const char *s)
Definition: reporter.cc:284
void * atGet(idhdl root, const char *name, int t, void *defaultReturnValue)
Definition: attrib.cc:135
int cols() const
Definition: intvec.h:87
void * Data()
Definition: subexpr.cc:1146
#define IMATELEM(M, I, J)
Definition: intvec.h:77

§ jjDBPRINT()

BOOLEAN jjDBPRINT ( leftv  res,
leftv  u 
)

Definition at line 324 of file ipprint.cc.

325 {
326  BOOLEAN print=(printlevel>myynest);
327  if ((u->next!=NULL)&&(u->Typ()==INT_CMD))
328  {
329  print= (((int)((long)(u->Data()))) > 0);
330  u=u->next;
331  }
332  if (print)
333  {
334  // BOOLEAN r=FALSE;
335  leftv h=u;
336  leftv hh;
337  while (h!=NULL)
338  {
339  hh=h->next;
340  h->next=NULL;
341  if (jjPRINT(res, h)) return TRUE;
342  PrintS((char*)res->data);
343  omFree(res->data);
344  PrintLn();
345  h->next=hh;
346  h=hh;
347  }
348  }
349  return FALSE;
350 }
Class used for (list of) interpreter objects.
Definition: subexpr.h:83
void PrintLn()
Definition: reporter.cc:310
Definition: tok.h:95
#define FALSE
Definition: auxiliary.h:95
#define TRUE
Definition: auxiliary.h:99
int Typ()
Definition: subexpr.cc:1004
void * data
Definition: subexpr.h:89
int myynest
Definition: febase.cc:46
BOOLEAN jjPRINT(leftv res, leftv u)
Definition: ipprint.cc:257
#define omFree(addr)
Definition: omAllocDecl.h:261
void PrintS(const char *s)
Definition: reporter.cc:284
leftv next
Definition: subexpr.h:87
#define NULL
Definition: omList.c:10
void * Data()
Definition: subexpr.cc:1146
int printlevel
Definition: febase.cc:42
static Poly * h
Definition: janet.cc:978
int BOOLEAN
Definition: auxiliary.h:86

§ jjPRINT()

BOOLEAN jjPRINT ( leftv  res,
leftv  u 
)

Definition at line 257 of file ipprint.cc.

258 {
259  SPrintStart();
260  BOOLEAN bo=FALSE;
261  switch(u->Typ())
262  {
263  case INTVEC_CMD:
264  bo=ipPrint_INTVEC(u);
265  break;
266 
267  case INTMAT_CMD:
268  bo=ipPrint_INTMAT(u);
269  break;
270 
271  case MATRIX_CMD:
272  bo=ipPrint_MA(u);
273  break;
274 
275  case IDEAL_CMD:
276  {
277  char* s = u->String(NULL, FALSE, 2);
278  PrintS(s);
279  PrintLn();
280  omFree(s);
281  break;
282  }
283 
284  case MODUL_CMD:
285  {
287  ipPrint_MA0(m, u->Name());
288  id_Delete((ideal *) &m,currRing);
289  break;
290  }
291 
292  case VECTOR_CMD:
293  bo=ipPrint_V(u);
294  break;
295 
296  case RING_CMD:
297  bo=ipPrint_RING(u);
298  break;
299 
300  #ifdef SINGULAR_4_1
301  case CRING_CMD:
302  bo=ipPrint_CRING(u);
303  break;
304  #endif
305 
306  default:
307  u->Print();
308  break;
309  }
310  char *s=SPrintEnd();
311  if (u->next==NULL)
312  {
313  int l=strlen(s);
314  if (s[l-1]=='\n') s[l-1]='\0';
315  }
316  res->data=(void*)s;
317  return bo;
318 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
void PrintLn()
Definition: reporter.cc:310
#define FALSE
Definition: auxiliary.h:95
ideal id_Copy(ideal h1, const ring r)
copy an ideal
static BOOLEAN ipPrint_MA(leftv u)
Definition: ipprint.cc:186
void id_Delete(ideal *h, ring r)
deletes an ideal/module/matrix
static BOOLEAN ipPrint_RING(leftv u)
Definition: ipprint.cc:196
static void ipPrint_MA0(matrix m, const char *name)
Definition: ipprint.cc:60
int Typ()
Definition: subexpr.cc:1004
const char * Name()
Definition: subexpr.h:121
void Print(leftv store=NULL, int spaces=0)
Called by type_cmd (e.g. "r;") or as default in jPRINT.
Definition: subexpr.cc:73
char * String(void *d=NULL, BOOLEAN typed=FALSE, int dim=1)
Called for conversion to string (used by string(..), write(..),..)
Definition: subexpr.cc:758
void * data
Definition: subexpr.h:89
ring currRing
Widely used global variable which specifies the current polynomial ring for Singular interpreter and ...
Definition: polys.cc:10
Definition: tok.h:56
static BOOLEAN ipPrint_V(leftv u)
Definition: ipprint.cc:231
#define omFree(addr)
Definition: omAllocDecl.h:261
static BOOLEAN ipPrint_INTMAT(leftv u)
Definition: ipprint.cc:42
int m
Definition: cfEzgcd.cc:119
void PrintS(const char *s)
Definition: reporter.cc:284
matrix id_Module2Matrix(ideal mod, const ring R)
static BOOLEAN ipPrint_CRING(leftv u)
Definition: ipprint.cc:215
char * SPrintEnd()
Definition: reporter.cc:273
leftv next
Definition: subexpr.h:87
#define NULL
Definition: omList.c:10
static BOOLEAN ipPrint_INTVEC(leftv u)
Definition: ipprint.cc:31
void * Data()
Definition: subexpr.cc:1146
void SPrintStart()
Definition: reporter.cc:246
int BOOLEAN
Definition: auxiliary.h:86
int l
Definition: cfEzgcd.cc:94

§ jjPRINT_FORMAT()

BOOLEAN jjPRINT_FORMAT ( leftv  res,
leftv  u,
leftv  v 
)

Definition at line 397 of file ipprint.cc.

398 {
399 /* ==================== betti ======================================== */
400  if ((u->Typ()==INTMAT_CMD)&&(strcmp((char *)v->Data(),"betti")==0))
401  {
402  SPrintStart();
403  ipPrintBetti(u);
404  char *s = SPrintEnd();
405  s[strlen(s)]='\0';
406  res->data=s;
407  }
408  else
409 /* ======================== end betti ================================= */
410  {
411  char* ns = omStrDup((char*) v->Data());
412  int dim = 1;
413  if (strlen(ns) == 3 && ns[1] == '2')
414  {
415  dim = 2;
416  ns[1] = ns[2];
417  ns[2] = '\0';
418  }
419  if (strcmp(ns,"%l") == 0)
420  {
421  res->data = (char*) u->String(NULL, TRUE, dim);
422  if (dim == 2)
423  {
424  char* ns = (char*) omAlloc(strlen((char*) res->data) + 2);
425  strcpy(ns, (char*) res->data);
426  omFree(res->data);
427  strcat(ns, "\n");
428  res->data = ns;
429  }
430  }
431  else if (strcmp(ns,"%t") == 0)
432  {
433  SPrintStart();
434  type_cmd(u);
435  res->data = SPrintEnd();
436  if (dim != 2)
437  ((char*)res->data)[strlen((char*)res->data) -1] = '\0';
438  }
439  else if (strcmp(ns,"%;") == 0)
440  {
441  SPrintStart();
442  u->Print();
443  if (dim == 2) PrintLn();
444  res->data = SPrintEnd();
445  }
446  else if (strcmp(ns,"%p") == 0)
447  {
448  iiExprArith1(res, u, PRINT_CMD);
449  }
450  else if (strcmp(ns,"%b") == 0 && (u->Typ()==INTMAT_CMD))
451  {
452  SPrintStart();
453  ipPrintBetti(u);
454  if (dim == 2) PrintLn();
455  res->data = SPrintEnd();
456  }
457  else
458  {
459  res->data = u->String(NULL, FALSE, dim);
460  if (dim == 2)
461  {
462  char* ns = (char*) omAlloc(strlen((char*) res->data) + 2);
463  strcpy(ns, (char*) res->data);
464  omFree(res->data);
465  strcat(ns, "\n");
466  res->data = ns;
467  }
468  }
469  omFree(ns);
470  }
471  return FALSE;
472 }
Definition: tok.h:154
const CanonicalForm int s
Definition: facAbsFact.cc:55
void PrintLn()
Definition: reporter.cc:310
BOOLEAN iiExprArith1(leftv res, leftv a, int op)
Definition: iparith.cc:8284
#define FALSE
Definition: auxiliary.h:95
#define TRUE
Definition: auxiliary.h:99
void type_cmd(leftv v)
Definition: ipshell.cc:248
int Typ()
Definition: subexpr.cc:1004
#define omAlloc(size)
Definition: omAllocDecl.h:210
void Print(leftv store=NULL, int spaces=0)
Called by type_cmd (e.g. "r;") or as default in jPRINT.
Definition: subexpr.cc:73
char * String(void *d=NULL, BOOLEAN typed=FALSE, int dim=1)
Called for conversion to string (used by string(..), write(..),..)
Definition: subexpr.cc:758
void * data
Definition: subexpr.h:89
#define omFree(addr)
Definition: omAllocDecl.h:261
int dim(ideal I, ring r)
char * SPrintEnd()
Definition: reporter.cc:273
#define NULL
Definition: omList.c:10
static void ipPrintBetti(leftv u)
Definition: ipprint.cc:352
void * Data()
Definition: subexpr.cc:1146
void SPrintStart()
Definition: reporter.cc:246
#define omStrDup(s)
Definition: omAllocDecl.h:263