Data Structures | Macros | Functions | Variables
gentable.cc File Reference
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include "kernel/mod2.h"
#include "Singular/tok.h"
#include "table.h"

Go to the source code of this file.

Data Structures

struct  cmdnames
 
struct  sValCmd2
 
struct  sValCmd1
 
struct  sValCmd3
 
struct  sValCmdM
 
struct  sValAssign_sys
 
struct  sValAssign
 
struct  sConvertTypes
 

Macros

#define RING_MASK   4
 
#define ZERODIVISOR_MASK   8
 
#define NO_NC   0
 
#define ALLOW_PLURAL   1
 
#define COMM_PLURAL   2
 
#define ALLOW_LP   64
 
#define NC_MASK   (3+64)
 
#define ALLOW_NC   ALLOW_LP|ALLOW_PLURAL
 
#define ALLOW_RING   4
 
#define NO_RING   0
 
#define NO_ZERODIVISOR   8
 
#define ALLOW_ZERODIVISOR   0
 
#define ZERODIVISOR_MASK   8
 
#define ALLOW_ZZ   (ALLOW_RING|NO_ZERODIVISOR)
 
#define WARN_RING   16
 
#define NO_CONVERSION   32
 
#define jjWRONG   1
 
#define jjWRONG2   1
 
#define jjWRONG3   1
 
#define D(A)   2
 
#define NULL_VAL   0
 
#define IPARITH
 
#define GENTABLE
 
#define IPCONV
 
#define IPASSIGN
 

Functions

int RingDependend (int t)
 
const char * Tok2Cmdname (int tok)
 
static int _gentable_sort_cmds (const void *a, const void *b)
 compares to entry of cmdsname-list More...
 
static int _texi_sort_cmds (const void *a, const void *b)
 
const char * iiTwoOps (int t)
 
int iiTestConvert (int inputType, int outputType)
 
void ttGen1 ()
 
void ttGen2b ()
 generate cmds initialisation More...
 
int is_ref_cmd (cmdnames *c)
 
void ttGen2c ()
 
void ttGen4 ()
 
int main (int argc, char **)
 

Variables

VAR int produce_convert_table =0
 
VAR char * iparith_inc
 

Data Structure Documentation

◆ _scmdnames

struct _scmdnames

Definition at line 59 of file gentable.cc.

Data Fields
short alias
const char * name
char * name
short toktype
short tokval

◆ sValCmd2

struct sValCmd2

Definition at line 69 of file gentable.cc.

Data Fields
short arg1
short arg2
short cmd
int p
proc2 p
short res
short valid_for

◆ sValCmd1

struct sValCmd1

Definition at line 78 of file gentable.cc.

Data Fields
short arg
short cmd
int p
proc1 p
short res
short valid_for

◆ sValCmd3

struct sValCmd3

Definition at line 86 of file gentable.cc.

Data Fields
short arg1
short arg2
short arg3
short cmd
int p
proc3 p
short res
short valid_for

◆ sValCmdM

struct sValCmdM

Definition at line 96 of file gentable.cc.

Data Fields
short cmd
short number_of_args
int p
proc1 p
short res
short valid_for

◆ sValAssign_sys

struct sValAssign_sys

Definition at line 104 of file gentable.cc.

Data Fields
short arg
int p
proc1 p
short res

◆ sValAssign

struct sValAssign

Definition at line 111 of file gentable.cc.

Data Fields
short arg
int p
proci p
short res

◆ sConvertTypes

struct sConvertTypes

Definition at line 118 of file gentable.cc.

Data Fields
int i_typ
int o_typ
iiConvertProc p
int p
iiConvertProcL pl
int pl

Macro Definition Documentation

◆ ALLOW_LP

#define ALLOW_LP   64

Definition at line 38 of file gentable.cc.

◆ ALLOW_NC

#define ALLOW_NC   ALLOW_LP|ALLOW_PLURAL

Definition at line 40 of file gentable.cc.

◆ ALLOW_PLURAL

#define ALLOW_PLURAL   1

Definition at line 35 of file gentable.cc.

◆ ALLOW_RING

#define ALLOW_RING   4

Definition at line 43 of file gentable.cc.

◆ ALLOW_ZERODIVISOR

#define ALLOW_ZERODIVISOR   0

Definition at line 48 of file gentable.cc.

◆ ALLOW_ZZ

#define ALLOW_ZZ   (ALLOW_RING|NO_ZERODIVISOR)

Definition at line 51 of file gentable.cc.

◆ COMM_PLURAL

#define COMM_PLURAL   2

Definition at line 36 of file gentable.cc.

◆ D

#define D (   A)    2

Definition at line 131 of file gentable.cc.

◆ GENTABLE

#define GENTABLE

Definition at line 134 of file gentable.cc.

◆ IPARITH

#define IPARITH

Definition at line 133 of file gentable.cc.

◆ IPASSIGN

#define IPASSIGN

Definition at line 136 of file gentable.cc.

◆ IPCONV

#define IPCONV

Definition at line 135 of file gentable.cc.

◆ jjWRONG

#define jjWRONG   1

Definition at line 127 of file gentable.cc.

◆ jjWRONG2

#define jjWRONG2   1

Definition at line 128 of file gentable.cc.

◆ jjWRONG3

#define jjWRONG3   1

Definition at line 129 of file gentable.cc.

◆ NC_MASK

#define NC_MASK   (3+64)

Definition at line 39 of file gentable.cc.

◆ NO_CONVERSION

#define NO_CONVERSION   32

Definition at line 56 of file gentable.cc.

◆ NO_NC

#define NO_NC   0

Definition at line 34 of file gentable.cc.

◆ NO_RING

#define NO_RING   0

Definition at line 44 of file gentable.cc.

◆ NO_ZERODIVISOR

#define NO_ZERODIVISOR   8

Definition at line 47 of file gentable.cc.

◆ NULL_VAL

#define NULL_VAL   0

Definition at line 132 of file gentable.cc.

◆ RING_MASK

#define RING_MASK   4

Definition at line 21 of file gentable.cc.

◆ WARN_RING

#define WARN_RING   16

Definition at line 54 of file gentable.cc.

◆ ZERODIVISOR_MASK [1/2]

#define ZERODIVISOR_MASK   8

Definition at line 49 of file gentable.cc.

◆ ZERODIVISOR_MASK [2/2]

#define ZERODIVISOR_MASK   8

Definition at line 49 of file gentable.cc.

Function Documentation

◆ _gentable_sort_cmds()

static int _gentable_sort_cmds ( const void *  a,
const void *  b 
)
static

compares to entry of cmdsname-list

Parameters
[in]a
[in]b
Returns
<ReturnValue>

Definition at line 194 of file gentable.cc.

195 {
196  cmdnames *pCmdL = (cmdnames*)a;
197  cmdnames *pCmdR = (cmdnames*)b;
198 
199  if(a==NULL || b==NULL) return 0;
200 
201  /* empty entries goes to the end of the list for later reuse */
202  if(pCmdL->name==NULL) return 1;
203  if(pCmdR->name==NULL) return -1;
204 
205  /* $INVALID$ must come first */
206  if(strcmp(pCmdL->name, "$INVALID$")==0) return -1;
207  if(strcmp(pCmdR->name, "$INVALID$")==0) return 1;
208 
209  /* tokval=-1 are reserved names at the end */
210  if (pCmdL->tokval==-1)
211  {
212  if (pCmdR->tokval==-1)
213  return strcmp(pCmdL->name, pCmdR->name);
214  /* pCmdL->tokval==-1, pCmdL goes at the end */
215  return 1;
216  }
217  /* pCmdR->tokval==-1, pCmdR goes at the end */
218  if(pCmdR->tokval==-1) return -1;
219 
220  return strcmp(pCmdL->name, pCmdR->name);
221 }
CanonicalForm b
Definition: cfModGcd.cc:4044
#define NULL
Definition: omList.c:12

◆ _texi_sort_cmds()

static int _texi_sort_cmds ( const void *  a,
const void *  b 
)
static

Definition at line 223 of file gentable.cc.

224 {
225  cmdnames *pCmdL = (cmdnames*)a;
226  cmdnames *pCmdR = (cmdnames*)b;
227 
228  if(a==NULL || b==NULL) return 0;
229 
230  /* empty entries goes to the end of the list for later reuse */
231  if(pCmdL->name==NULL) return 1;
232  if(pCmdR->name==NULL) return -1;
233 
234  /* $INVALID$ must come first */
235  if(strcmp(pCmdL->name, "$INVALID$")==0) return -1;
236  if(strcmp(pCmdR->name, "$INVALID$")==0) return 1;
237  char *ls=strdup(pCmdL->name);
238  char *rs=strdup(pCmdR->name);
239  char *s=ls;
240  while (*s) { *s=tolower(*s); s++; }
241  s=rs;
242  while (*s) { *s=tolower(*s); s++; }
243 
244  /* tokval=-1 are reserved names at the end */
245  if (pCmdL->tokval==-1)
246  {
247  if (pCmdR->tokval==-1)
248  { int r=strcmp(ls,rs); free(ls); free(rs); return r; }
249  /* pCmdL->tokval==-1, pCmdL goes at the end */
250  free(ls);free(rs);
251  return 1;
252  }
253  /* pCmdR->tokval==-1, pCmdR goes at the end */
254  if(pCmdR->tokval==-1)
255  { free(ls);free(rs);return -1;}
256 
257  { int r=strcmp(ls,rs); free(ls); free(rs); return r; }
258 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
CanonicalForm b
Definition: cfModGcd.cc:4044
#define free
Definition: omAllocFunc.c:14
#define strdup
Definition: omAllocFunc.c:19
#define NULL
Definition: omList.c:12

◆ iiTestConvert()

int iiTestConvert ( int  inputType,
int  outputType 
)

Definition at line 301 of file gentable.cc.

302 {
303  if ((inputType==outputType)
304  || (outputType==DEF_CMD)
305  || (outputType==IDHDL)
306  || (outputType==ANY_TYPE))
307  {
308  return -1;
309  }
310  if (inputType==UNKNOWN) return 0;
311 
312  // search the list
313  int i=0;
314  while (dConvertTypes[i].i_typ!=0)
315  {
316  if((dConvertTypes[i].i_typ==inputType)
317  &&(dConvertTypes[i].o_typ==outputType))
318  {
319  //Print("test convert %d to %d (%s -> %s):%d\n",inputType,outputType,
320  //Tok2Cmdname(inputType), Tok2Cmdname(outputType),i+1);
321  return i+1;
322  }
323  i++;
324  }
325  //Print("test convert %d to %d (%s -> %s):0\n",inputType,outputType,
326  // Tok2Cmdname(inputType), Tok2Cmdname(outputType));
327  return 0;
328 }
const struct sConvertTypes dConvertTypes[]
Definition: table.h:1267
#define ANY_TYPE
Definition: tok.h:30
#define UNKNOWN
Definition: tok.h:221
#define IDHDL
Definition: tok.h:31
Definition: tok.h:58
int i
Definition: cfEzgcd.cc:125

◆ iiTwoOps()

const char* iiTwoOps ( int  t)

Definition at line 261 of file gentable.cc.

262 {
263  if (t<127)
264  {
265  STATIC_VAR char ch[2];
266  switch (t)
267  {
268  case '&':
269  return "and";
270  case '|':
271  return "or";
272  default:
273  ch[0]=t;
274  ch[1]='\0';
275  return ch;
276  }
277  }
278  switch (t)
279  {
280  case COLONCOLON: return "::";
281  case DOTDOT: return "..";
282  //case PLUSEQUAL: return "+=";
283  //case MINUSEQUAL: return "-=";
284  case MINUSMINUS: return "--";
285  case PLUSPLUS: return "++";
286  case EQUAL_EQUAL: return "==";
287  case LE: return "<=";
288  case GE: return ">=";
289  case NOTEQUAL: return "<>";
290  default: return Tok2Cmdname(t);
291  }
292 }
Definition: grammar.cc:270
Definition: grammar.cc:269
#define STATIC_VAR
Definition: globaldefs.h:7
const char * Tok2Cmdname(int tok)
Definition: gentable.cc:140

◆ is_ref_cmd()

int is_ref_cmd ( cmdnames *  c)

Definition at line 654 of file gentable.cc.

655 {
656  if( c->tokval==0) return 0;
657  if (c->alias > 0) return 0;
658  if ((c->toktype==CMD_1)
659  || (c->toktype==CMD_2)
660  || (c->toktype==CMD_3)
661  || (c->toktype==CMD_M)
662  || (c->toktype==CMD_12)
663  || (c->toktype==CMD_13)
664  || (c->toktype==CMD_23)
665  || (c->toktype==CMD_123)) return 1;
666  return 0;
667 }

◆ main()

int main ( int  argc,
char **   
)

Definition at line 979 of file gentable.cc.

980 {
981  if (argc>1)
982  {
983  produce_convert_table=1; /* for ttGen1 */
984  ttGen1();
985  unlink(iparith_inc);
986  ttGen4();
987  ttGen2c();
988  }
989  else
990  {
991  ttGen1();
992  ttGen2b();
993  rename(iparith_inc,"iparith.inc");
994  }
995  return 0;
996 }
VAR int produce_convert_table
Definition: gentable.cc:31
void ttGen1()
Definition: gentable.cc:330
void ttGen2b()
generate cmds initialisation
Definition: gentable.cc:572
void ttGen4()
Definition: gentable.cc:844
void ttGen2c()
Definition: gentable.cc:668
VAR char * iparith_inc
Definition: gentable.cc:329

◆ RingDependend()

int RingDependend ( int  t)
inline

Definition at line 28 of file gentable.cc.

28 { return (BEGIN_RING<t)&&(t<END_RING); }

◆ Tok2Cmdname()

const char* Tok2Cmdname ( int  tok)

Definition at line 140 of file gentable.cc.

141 {
142  if (tok < 0)
143  {
144  return cmds[0].name;
145  }
146  if (tok==COMMAND) return "command";
147  if (tok==ANY_TYPE) return "any_type";
148  if (tok==NONE) return "nothing";
149  //if (tok==IFBREAK) return "if_break";
150  //if (tok==VECTOR_FROM_POLYS) return "vector_from_polys";
151  //if (tok==ORDER_VECTOR) return "ordering";
152  //if (tok==REF_VAR) return "ref";
153  //if (tok==OBJECT) return "object";
154  //if (tok==PRINT_EXPR) return "print_expr";
155  if (tok==IDHDL) return "identifier";
156  // we do not blackbox objects during table generation:
157  //if (tok>MAX_TOK) return getBlackboxName(tok);
158  int i = 0;
159  while (cmds[i].tokval!=0)
160  {
161  if ((cmds[i].tokval == tok)&&(cmds[i].alias==0))
162  {
163  return cmds[i].name;
164  }
165  i++;
166  }
167  i=0;// try again for old/alias names:
168  while (cmds[i].tokval!=0)
169  {
170  if (cmds[i].tokval == tok)
171  {
172  return cmds[i].name;
173  }
174  i++;
175  }
176  #if 0
177  char *s=(char*)malloc(10);
178  sprintf(s,"(%d)",tok);
179  return s;
180  #else
181  return cmds[0].name;
182  #endif
183 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
#define ANY_TYPE
Definition: tok.h:30
#define IDHDL
Definition: tok.h:31
void * malloc(size_t size)
Definition: omalloc.c:92
VAR cmdnames cmds[]
Definition: table.h:977
int i
Definition: cfEzgcd.cc:125
#define NONE
Definition: tok.h:220
#define COMMAND
Definition: tok.h:29

◆ ttGen1()

void ttGen1 ( )

Definition at line 330 of file gentable.cc.

331 {
332  iparith_inc=strdup("iparith.xxxxxx");
333  int pid=getpid();
334  iparith_inc[8]=(pid %10)+'0'; pid/=10;
335  iparith_inc[9]=(pid %10)+'0'; pid/=10;
336  iparith_inc[10]=(pid %10)+'0'; pid/=10;
337  iparith_inc[11]=(pid %10)+'0'; pid/=10;
338  iparith_inc[12]=(pid %10)+'0'; pid/=10;
339  iparith_inc[13]=(pid %10)+'0';
340  FILE *outfile = fopen(iparith_inc,"w");
341  int i,j,l1=0,l2=0;
342  fprintf(outfile,
343  "/****************************************\n"
344  "* Computer Algebra System SINGULAR *\n"
345  "****************************************/\n\n");
346 /*-------------------------------------------------------------------*/
347  fprintf(outfile,"// syntax table for Singular\n//\n");
348  fprintf(outfile,"// - search for an exact match of the argument types\n");
349  fprintf(outfile,"// - otherwise search for the first possibility\n");
350  fprintf(outfile,"// with converted types of the arguments\n");
351  fprintf(outfile,"// - otherwise report an error\n//\n");
352 
353  int op;
354  i=0;
355  while ((op=dArith1[i].cmd)!=0)
356  {
357  if (dArith1[i].p==jjWRONG)
358  fprintf(outfile,"// DUMMY ");
359  const char *s = iiTwoOps(op);
360  fprintf(outfile,"// operation: %s (%s) -> %s",
361  s,
362  Tok2Cmdname(dArith1[i].arg),
363  Tok2Cmdname(dArith1[i].res));
364  if (RingDependend(dArith1[i].res) && (!RingDependend(dArith1[i].arg)))
365  fprintf(outfile," requires currRing");
366  if ((dArith1[i].valid_for & NC_MASK)==2)
367  fprintf(outfile,", commutative subalgebra");
368  else if ((dArith1[i].valid_for & NC_MASK)==ALLOW_LP)
369  fprintf(outfile,", letterplace rings");
370  else if ((dArith1[i].valid_for & NC_MASK)==0)
371  fprintf(outfile,", only commutative rings");
372  if ((dArith1[i].valid_for & RING_MASK)==0)
373  fprintf(outfile,", field coeffs");
374  else if ((dArith1[i].valid_for & ZERODIVISOR_MASK)==NO_ZERODIVISOR)
375  fprintf(outfile,", domain coeffs");
376  else if ((dArith1[i].valid_for & WARN_RING)==WARN_RING)
377  fprintf(outfile,", QQ coeffs");
378 
379  fprintf(outfile,"\n");
380  i++;
381  }
382  fprintf(outfile,"/*---------------------------------------------*/\n");
383  i=0;
384  while ((op=dArith2[i].cmd)!=0)
385  {
386  if (dArith2[i].p==jjWRONG2)
387  fprintf(outfile,"// DUMMY ");
388  const char *s = iiTwoOps(op);
389  fprintf(outfile,"// operation: %s (%s, %s) -> %s",
390  s,
391  Tok2Cmdname(dArith2[i].arg1),
392  Tok2Cmdname(dArith2[i].arg2),
393  Tok2Cmdname(dArith2[i].res));
394  if (RingDependend(dArith2[i].res)
395  && (!RingDependend(dArith2[i].arg1))
396  && (!RingDependend(dArith2[i].arg2)))
397  {
398  fprintf(outfile," requires currRing");
399  }
400  if ((dArith2[i].valid_for & NC_MASK)==COMM_PLURAL)
401  fprintf(outfile,", commutative subalgebra");
402  else if ((dArith2[i].valid_for & NC_MASK)==0)
403  fprintf(outfile,", only commutative rings");
404  if ((dArith2[i].valid_for & RING_MASK)==0)
405  fprintf(outfile,", field coeffs");
406  else if ((dArith2[i].valid_for & ZERODIVISOR_MASK)==NO_ZERODIVISOR)
407  fprintf(outfile,", domain coeffs");
408  else if ((dArith2[i].valid_for & WARN_RING)==WARN_RING)
409  fprintf(outfile,", QQ coeffs");
410 
411  fprintf(outfile,"\n");
412  i++;
413  }
414  fprintf(outfile,"/*---------------------------------------------*/\n");
415  i=0;
416  while ((op=dArith3[i].cmd)!=0)
417  {
418  const char *s = iiTwoOps(op);
419  if (dArith3[i].p==jjWRONG3)
420  fprintf(outfile,"// DUMMY ");
421  fprintf(outfile,"// operation: %s (%s, %s, %s) -> %s",
422  s,
423  Tok2Cmdname(dArith3[i].arg1),
424  Tok2Cmdname(dArith3[i].arg2),
425  Tok2Cmdname(dArith3[i].arg3),
426  Tok2Cmdname(dArith3[i].res));
427  if (RingDependend(dArith3[i].res)
428  && (!RingDependend(dArith3[i].arg1))
429  && (!RingDependend(dArith3[i].arg2))
430  && (!RingDependend(dArith3[i].arg3)))
431  {
432  fprintf(outfile," requires currRing");
433  }
434  if ((dArith3[i].valid_for & NC_MASK)==COMM_PLURAL)
435  fprintf(outfile,", commutative subalgebra");
436  else if ((dArith3[i].valid_for & NC_MASK)==0)
437  fprintf(outfile,", only commutative rings");
438  if ((dArith3[i].valid_for & RING_MASK)==0)
439  fprintf(outfile,", field coeffs");
440  else if ((dArith3[i].valid_for & ZERODIVISOR_MASK)==NO_ZERODIVISOR)
441  fprintf(outfile,", domain coeffs");
442  else if ((dArith3[i].valid_for & WARN_RING)==WARN_RING)
443  fprintf(outfile,", QQ coeffs");
444 
445  fprintf(outfile,"\n");
446  i++;
447  }
448  fprintf(outfile,"/*---------------------------------------------*/\n");
449  i=0;
450  while ((op=dArithM[i].cmd)!=0)
451  {
452  const char *s = iiTwoOps(op);
453  fprintf(outfile,"// operation: %s (...) -> %s",
454  s,
455  Tok2Cmdname(dArithM[i].res));
456  switch(dArithM[i].number_of_args)
457  {
458  case -2:
459  fprintf(outfile," ( number of arguments >0 )\n");
460  break;
461  case -1:
462  fprintf(outfile," ( any number of arguments )\n");
463  break;
464  default:
465  fprintf(outfile," ( %d arguments )\n",dArithM[i].number_of_args);
466  break;
467  }
468  i++;
469  }
470  fprintf(outfile,"/*---------------------------------------------*/\n");
471  i=0;
472  while ((op=dAssign[i].res)!=0)
473  {
474  fprintf(outfile,"// assign: %s = %s\n",
475  Tok2Cmdname(op/*dAssign[i].res*/),
476  Tok2Cmdname(dAssign[i].arg));
477  i++;
478  }
479 /*-------------------------------------------------------------------*/
480  fprintf(outfile,"/*---------------------------------------------*/\n");
481  FILE *doctable=NULL; /*to silence "may be used uninitialized"*/
483  {
484  doctable=fopen("convert_table.texi","w");
485  fprintf(doctable,"@multitable @columnfractions .05 .18 .81\n");
486  }
487  int doc_nr=1;
488  for (j=257;j<=MAX_TOK+1;j++)
489  {
490  for(i=257;i<=MAX_TOK+1;i++)
491  {
492  if ((i!=j) && (j!=IDHDL) && (j!=DEF_CMD) && (j!=ANY_TYPE)
493  && iiTestConvert(i,j))
494  {
495  fprintf(outfile,"// convert %s -> %s\n",
496  Tok2Cmdname(i), Tok2Cmdname(j));
498  {
499  fprintf(doctable,
500  "@item\n@ %d. @tab @code{%s} @tab @expansion{} @code{%s}\n",
501  doc_nr,Tok2Cmdname(i),Tok2Cmdname(j));
502  doc_nr++;
503  }
504  if (j==ANY_TYPE) break;
505  }
506  }
507  }
509  {
510  fprintf(doctable,"@end multitable\n");
511  fclose(doctable);
512  }
513  fprintf(outfile,"/*---------------------------------------------*/\n");
514  char ops[]="=><+*/[.^,%(;";
515  for(i=0;ops[i]!='\0';i++)
516  fprintf(outfile,"// token %d : %c\n", (int)ops[i], ops[i]);
517  for (i=257;i<=MAX_TOK;i++)
518  {
519  const char *s=iiTwoOps(i);
520  if (s[0]!='$')
521  {
522  fprintf(outfile,"// token %d : %s\n", i, s);
523  }
524  }
525 /*-------------------------------------------------------------------*/
526  fprintf(outfile,"/*--max. token: %d, gr: %d --*/\n",MAX_TOK,UMINUS);
527 /*-------------------------------------------------------------------*/
528  fprintf(outfile,"/*---------------------------------------------*/\n");
529  fprintf(outfile,
530  "const struct sValCmdTab dArithTab1[]=\n"
531  "{\n");
532  for (j=1;j<=MAX_TOK+1;j++)
533  {
534  for(i=0;dArith1[i].cmd!=0;i++)
535  {
536  if (dArith1[i].cmd==j)
537  {
538  fprintf(outfile," { %d,%d },\n",j,i);
539  l1++;
540  break;
541  }
542  }
543  }
544  fprintf(outfile," { 10000,0 }\n};\n");
545  fprintf(outfile,"#define JJTAB1LEN %d\n",l1);
546 /*-------------------------------------------------------------------*/
547  fprintf(outfile,
548  "const struct sValCmdTab dArithTab2[]=\n"
549  "{\n");
550  for (j=1;j<=MAX_TOK+1;j++)
551  {
552  for(i=0;dArith2[i].cmd!=0;i++)
553  {
554  if (dArith2[i].cmd==j)
555  {
556  fprintf(outfile," { %d,%d },\n",j,i);
557  l2++;
558  break;
559  }
560  }
561  }
562  fprintf(outfile," { 10000,0 }\n};\n");
563  fprintf(outfile,"#define JJTAB2LEN %d\n",l2);
564  fclose(outfile);
565 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
int iiTestConvert(int inputType, int outputType)
Definition: gentable.cc:301
int j
Definition: facHensel.cc:105
#define ANY_TYPE
Definition: tok.h:30
#define ALLOW_LP
Definition: gentable.cc:38
#define ZERODIVISOR_MASK
Definition: gentable.cc:49
Definition: tok.h:217
#define NO_ZERODIVISOR
Definition: gentable.cc:47
VAR int produce_convert_table
Definition: gentable.cc:31
const struct sValCmd2 dArith2[]
Definition: table.h:321
const struct sValCmdM dArithM[]
Definition: table.h:898
short cmd
Definition: gentable.cc:72
#define IDHDL
Definition: tok.h:31
const struct sValCmd3 dArith3[]
Definition: table.h:773
int RingDependend(int t)
Definition: gentable.cc:28
short cmd
Definition: gentable.cc:81
CanonicalForm res
Definition: facAbsFact.cc:64
const char * iiTwoOps(int t)
Definition: gentable.cc:261
#define RING_MASK
Definition: gentable.cc:21
Definition: tok.h:58
const struct sValAssign dAssign[]
Definition: table.h:1361
#define COMM_PLURAL
Definition: gentable.cc:36
int i
Definition: cfEzgcd.cc:125
#define strdup
Definition: omAllocFunc.c:19
#define jjWRONG3
Definition: gentable.cc:129
#define NC_MASK
Definition: gentable.cc:39
#define NULL
Definition: omList.c:12
const char * Tok2Cmdname(int tok)
Definition: gentable.cc:140
#define jjWRONG2
Definition: gentable.cc:128
#define WARN_RING
Definition: gentable.cc:54
#define jjWRONG
Definition: gentable.cc:127
const struct sValCmd1 dArith1[]
Definition: table.h:37
int p
Definition: cfModGcd.cc:4019
VAR char * iparith_inc
Definition: gentable.cc:329

◆ ttGen2b()

void ttGen2b ( )

generate cmds initialisation

Definition at line 572 of file gentable.cc.

573 {
574  int cmd_size = (sizeof(cmds)/sizeof(cmdnames))-1;
575 
576  FILE *outfile = fopen(iparith_inc,"a");
577  fprintf(outfile,
578  "/****************************************\n"
579  "* Computer Algebra System SINGULAR *\n"
580  "****************************************/\n\n");
581 /*-------------------------------------------------------------------*/
582  fprintf(outfile,"// identifier table for Singular\n//\n");
583 
584  fprintf(
585  outfile,
586  "#ifdef MODULE_GENERATOR\n"
587  "#define omAlloc0(A) malloc(A)\n"
588  "#endif\n"
589  "void iiInitCmdName()\n{\n"
590  " sArithBase.nCmdUsed = 0;\n"
591  " sArithBase.nCmdAllocated = %d;\n"
592  " sArithBase.sCmds = (cmdnames*)omAlloc0(sArithBase.nCmdAllocated*sizeof(cmdnames));\n"
593  "\n"
594  " // name-string alias tokval toktype index\n",
595  cmd_size);
596  int m=0;
597  int id_nr=0;
598 
599  qsort(&cmds, cmd_size, sizeof(cmdnames), (&_gentable_sort_cmds));
600 
601  for(m=0; m<cmd_size; m++)
602  {
603  if(cmds[m].tokval>0) id_nr++;
604  fprintf(outfile," iiArithAddCmd(\"%s\", %*d, %3d, ",cmds[m].name,
605  (int)(20-strlen(cmds[m].name)),
606  cmds[m].alias,
607  cmds[m].tokval);
608  switch(cmds[m].toktype)
609  {
610  case CMD_1: fprintf(outfile,"CMD_1"); break;
611  case CMD_2: fprintf(outfile,"CMD_2"); break;
612  case CMD_3: fprintf(outfile,"CMD_3"); break;
613  case CMD_12: fprintf(outfile,"CMD_12"); break;
614  case CMD_123 : fprintf(outfile,"CMD_123"); break;
615  case CMD_23: fprintf(outfile,"CMD_23"); break;
616  case CMD_M: fprintf(outfile,"CMD_M"); break;
617  case SYSVAR: fprintf(outfile,"SYSVAR"); break;
618  case ROOT_DECL: fprintf(outfile,"ROOT_DECL"); break;
619  case ROOT_DECL_LIST: fprintf(outfile,"ROOT_DECL_LIST"); break;
620  case RING_DECL: fprintf(outfile,"RING_DECL"); break;
621  case NONE: fprintf(outfile,"NONE"); break;
622  default:
623  if((cmds[m].toktype>' ') &&(cmds[m].toktype<127))
624  {
625  fprintf(outfile,"'%c'",cmds[m].toktype);
626  }
627  else
628  {
629  fprintf(outfile,"%d",cmds[m].toktype);
630  }
631  break;
632 #if 0
633  fprintf(outfile," iiArithAddCmd(\"%s\", %*d, -1, 0 );\n",
634  cmds[m].name, 20-strlen(cmds[m].name),
635  0/*cmds[m].alias*/
636  /*-1 cmds[m].tokval*/
637  /*0 cmds[m].toktype*/);
638 #endif
639  }
640  fprintf(outfile,", %d);\n", m);
641  }
642  fprintf(outfile, "/* end of list marker */\n");
643  fprintf(outfile,
644  " sArithBase.nLastIdentifier = %d;\n",
645  id_nr);
646 
647 
648  fprintf(outfile,
649 "}\n"
650 "#define LAST_IDENTIFIER %d\n"
651  ,id_nr);
652  fclose(outfile);
653 }
static int _gentable_sort_cmds(const void *a, const void *b)
compares to entry of cmdsname-list
Definition: gentable.cc:194
VAR cmdnames cmds[]
Definition: table.h:977
int m
Definition: cfEzgcd.cc:121
char name(const Variable &v)
Definition: factory.h:180
#define NONE
Definition: tok.h:220
VAR char * iparith_inc
Definition: gentable.cc:329

◆ ttGen2c()

void ttGen2c ( )

Definition at line 668 of file gentable.cc.

669 {
670  int cmd_size = (sizeof(cmds)/sizeof(cmdnames))-1;
671 
672  FILE *outfile = fopen("reference_table.texi","w");
673  fprintf(outfile, "@menu\n");
674 /*-------------------------------------------------------------------*/
675  qsort(&cmds, cmd_size, sizeof(cmdnames), (&_texi_sort_cmds));
676 
677  int m;
678  for(m=0; m<cmd_size; m++)
679  {
680  // assume that cmds[0].tokval== -1 and all others with tokval -1 at the end
681  if(is_ref_cmd(&(cmds[m])))
682  {
683  fprintf(outfile,"* %s::\n",cmds[m].name);
684  }
685  }
686  fprintf(outfile, "@end menu\n@c ---------------------------\n");
687  for(m=0; m<cmd_size; m++)
688  {
689  // assume that cmds[0].tokval== -1 and all others with tokval -1 at the end
690  if(is_ref_cmd(&(cmds[m])))
691  {
692  fprintf(outfile,"@node %s,",cmds[m].name);
693  // next:
694  int mm=m-1;
695  while((mm>0)&& (is_ref_cmd(&cmds[mm]))) mm--;
696  if((mm>0)&& (is_ref_cmd(&cmds[mm])))
697  fprintf(outfile,"%s,",cmds[mm].name);
698  else
699  fprintf(outfile,",");
700  // prev:
701  mm=m+1;
702  while((mm>0)&& (is_ref_cmd(&cmds[mm]))) mm++;
703  if((mm>0)&& (is_ref_cmd(&cmds[mm])))
704  fprintf(outfile,"%s,",cmds[m-1].name);
705  else
706  fprintf(outfile,",");
707  // up:, and header
708  fprintf(outfile,"Functions\n"
709  "@subsection %s\n"
710  "@cindex %s\n",cmds[m].name,cmds[m].name);
711  fprintf(outfile,"@include %s.part\n",cmds[m].name);
712  char partName[50];
713  sprintf(partName,"%s.part",cmds[m].name);
714  struct stat buf;
715  if (lstat(partName,&buf)!=0)
716  {
717  int op,i;
718  int only_field=0,only_comm=0,no_zerodiv=0;
719  FILE *part=fopen(partName,"w");
720  fprintf(part,"@table @code\n@item @strong{Syntax:}\n");
721  if ((cmds[m].toktype==CMD_1)
722  || (cmds[m].toktype==CMD_12)
723  || (cmds[m].toktype==CMD_13)
724  || (cmds[m].toktype==CMD_123))
725  {
726  op= cmds[m].tokval;
727  i=0;
728  while ((dArith1[i].cmd!=op) && (dArith1[i].cmd!=0)) i++;
729  while (dArith1[i].cmd==op)
730  {
731  if (dArith1[i].p!=jjWRONG)
732  {
733  fprintf(part,"@code{%s (} %s @code{)}\n",cmds[m].name,Tok2Cmdname(dArith1[i].arg));
734  fprintf(part,"@item @strong{Type:}\n%s\n",Tok2Cmdname(dArith1[i].res));
735  if ((dArith1[i].valid_for & ALLOW_PLURAL)==0)
736  only_comm=1;
737  if ((dArith1[i].valid_for & ALLOW_RING)==0)
738  only_field=1;
739  if ((dArith1[i].valid_for & ZERODIVISOR_MASK)==NO_ZERODIVISOR)
740  no_zerodiv=1;
741  }
742  i++;
743  }
744  }
745  if ((cmds[m].toktype==CMD_23)
746  || (cmds[m].toktype==CMD_12)
747  || (cmds[m].toktype==CMD_2)
748  || (cmds[m].toktype==CMD_123))
749  {
750  op= cmds[m].tokval;
751  i=0;
752  while ((dArith2[i].cmd!=op) && (dArith2[i].cmd!=0)) i++;
753  while (dArith2[i].cmd==op)
754  {
755  if (dArith2[i].p!=jjWRONG)
756  {
757  fprintf(part,"@code{%s (} %s, %s @code{)}\n",cmds[m].name,Tok2Cmdname(dArith2[i].arg1),Tok2Cmdname(dArith2[i].arg2));
758  fprintf(part,"@item @strong{Type:}\n%s\n",Tok2Cmdname(dArith2[i].res));
759  if ((dArith2[i].valid_for & ALLOW_PLURAL)==0)
760  only_comm=1;
761  if ((dArith2[i].valid_for & ALLOW_RING)==0)
762  only_field=1;
763  if ((dArith2[i].valid_for & ZERODIVISOR_MASK)==NO_ZERODIVISOR)
764  no_zerodiv=1;
765  }
766  i++;
767  }
768  }
769  if ((cmds[m].toktype==CMD_23)
770  || (cmds[m].toktype==CMD_13)
771  || (cmds[m].toktype==CMD_3)
772  || (cmds[m].toktype==CMD_123))
773  {
774  op= cmds[m].tokval;
775  i=0;
776  while ((dArith3[i].cmd!=op) && (dArith3[i].cmd!=0)) i++;
777  while (dArith3[i].cmd==op)
778  {
779  if (dArith3[i].p!=jjWRONG)
780  {
781  fprintf(part,"@code{%s (} %s, %s, %s @code{)}\n",cmds[m].name,
782  Tok2Cmdname(dArith3[i].arg1),
783  Tok2Cmdname(dArith3[i].arg2),
784  Tok2Cmdname(dArith3[i].arg3));
785  fprintf(part,"@item @strong{Type:}\n%s\n",Tok2Cmdname(dArith3[i].res));
786  if ((dArith3[i].valid_for & ALLOW_PLURAL)==0)
787  only_comm=1;
788  if ((dArith3[i].valid_for & ALLOW_RING)==0)
789  only_field=1;
790  if ((dArith3[i].valid_for & ZERODIVISOR_MASK)==NO_ZERODIVISOR)
791  no_zerodiv=1;
792  }
793  i++;
794  }
795  }
796  if (cmds[m].toktype==CMD_M)
797  {
798  op= cmds[m].tokval;
799  i=0;
800  while ((dArithM[i].cmd!=op) && (dArithM[i].cmd!=0)) i++;
801  while (dArithM[i].cmd==op)
802  {
803  if (dArithM[i].p!=jjWRONG)
804  {
805  fprintf(part,"@code{%s (} ... @code{)}\n",cmds[m].name);
806  fprintf(part,"@item @strong{Type:}\n%s\n",Tok2Cmdname(dArithM[i].res));
807  if ((dArithM[i].valid_for & ALLOW_PLURAL)==0)
808  only_comm=1;
809  if ((dArithM[i].valid_for & ALLOW_RING)==0)
810  only_field=1;
811  if ((dArithM[i].valid_for & ZERODIVISOR_MASK)==NO_ZERODIVISOR)
812  no_zerodiv=1;
813  }
814  i++;
815  }
816  }
817  if (only_comm)
818  fprintf(part,"@item @strong{Remark:}\n"
819  "only for commutive polynomial rings\n");
820  if (only_field)
821  fprintf(part,"@item @strong{Remark:}\n"
822  "only for polynomial rings over fields\n");
823  if (no_zerodiv)
824  fprintf(part,"@item @strong{Remark:}\n"
825  "only for polynomial rings over domains\n");
826  fprintf(part,"@item @strong{Purpose:}\n"
827  "@item @strong{Example:}\n"
828  "@smallexample\n"
829  "@c example\n"
830  "@c example\n"
831  "@end smallexample\n"
832  "@c ref\n"
833  "@c See\n"
834  "@c ref{....};\n"
835  "@c ref{....}.\n"
836  "@c ref\n");
837  fclose(part);
838  }
839  }
840  }
841  fclose(outfile);
842 }
#define ALLOW_PLURAL
Definition: gentable.cc:35
#define ZERODIVISOR_MASK
Definition: gentable.cc:49
#define NO_ZERODIVISOR
Definition: gentable.cc:47
const struct sValCmd2 dArith2[]
Definition: table.h:321
const struct sValCmdM dArithM[]
Definition: table.h:898
const struct sValCmd3 dArith3[]
Definition: table.h:773
CanonicalForm res
Definition: facAbsFact.cc:64
int status int void * buf
Definition: si_signals.h:59
static int _texi_sort_cmds(const void *a, const void *b)
Definition: gentable.cc:223
VAR cmdnames cmds[]
Definition: table.h:977
int m
Definition: cfEzgcd.cc:121
int i
Definition: cfEzgcd.cc:125
char name(const Variable &v)
Definition: factory.h:180
#define ALLOW_RING
Definition: gentable.cc:43
const char * Tok2Cmdname(int tok)
Definition: gentable.cc:140
#define jjWRONG
Definition: gentable.cc:127
const struct sValCmd1 dArith1[]
Definition: table.h:37
int p
Definition: cfModGcd.cc:4019
int is_ref_cmd(cmdnames *c)
Definition: gentable.cc:654

◆ ttGen4()

void ttGen4 ( )

Definition at line 844 of file gentable.cc.

845 {
846  FILE *outfile = fopen("plural_cmd.xx","w");
847  int i;
848  const char *old_s="";
849  fprintf(outfile,
850  "@c *****************************************\n"
851  "@c * Computer Algebra System SINGULAR *\n"
852  "@c *****************************************\n\n");
853 /*-------------------------------------------------------------------*/
854  fprintf(outfile,"@multicolumn .45 .45\n");
855  int op;
856  i=0;
857  while ((op=dArith1[i].cmd)!=0)
858  {
859  if (dArith1[i].p!=jjWRONG)
860  {
861  const char *s = iiTwoOps(op);
862  if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
863  {
864  old_s=s;
865  #ifdef HAVE_PLURAL
866  switch (dArith1[i].valid_for & NC_MASK)
867  {
868  case NO_NC:
869  fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
870  break;
871  case ALLOW_PLURAL:
872  fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
873  break;
874  case COMM_PLURAL:
875  fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
876  break;
877  }
878  #endif
879  #ifdef HAVE_RINGS
880  #endif
881  }
882  }
883  i++;
884  }
885  fprintf(outfile,"@c ---------------------------------------------\n");
886  i=0;
887  while ((op=dArith2[i].cmd)!=0)
888  {
889  if (dArith2[i].p!=jjWRONG2)
890  {
891  const char *s = iiTwoOps(op);
892  if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
893  {
894  old_s=s;
895  #ifdef HAVE_PLURAL
896  switch (dArith2[i].valid_for & NC_MASK)
897  {
898  case NO_NC:
899  fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
900  break;
901  case ALLOW_PLURAL:
902  fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
903  break;
904  case COMM_PLURAL:
905  fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
906  break;
907  }
908  #endif
909  #ifdef HAVE_RINGS
910  #endif
911  }
912  }
913  i++;
914  }
915  fprintf(outfile,"@c ---------------------------------------------\n");
916  i=0;
917  while ((op=dArith3[i].cmd)!=0)
918  {
919  const char *s = iiTwoOps(op);
920  if (dArith3[i].p!=jjWRONG3)
921  {
922  if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
923  {
924  old_s=s;
925  #ifdef HAVE_PLURAL
926  switch (dArith3[i].valid_for & NC_MASK)
927  {
928  case NO_NC:
929  fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
930  break;
931  case ALLOW_PLURAL:
932  fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
933  break;
934  case COMM_PLURAL:
935  fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
936  break;
937  }
938  #endif
939  #ifdef HAVE_RINGS
940  #endif
941  }
942  }
943  i++;
944  }
945  fprintf(outfile,"@c ---------------------------------------------\n");
946  i=0;
947  while ((op=dArithM[i].cmd)!=0)
948  {
949  const char *s = iiTwoOps(op);
950  if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
951  {
952  old_s=s;
953  #ifdef HAVE_PLURAL
954  switch (dArithM[i].valid_for & NC_MASK)
955  {
956  case NO_NC:
957  fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
958  break;
959  case ALLOW_PLURAL:
960  fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
961  break;
962  case COMM_PLURAL:
963  fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
964  break;
965  }
966  #endif
967  #ifdef HAVE_RINGS
968  #endif
969  }
970  i++;
971  }
972  fprintf(outfile,"@c ---------------------------------------------\n");
973  fprintf(outfile,"@end table\n");
974  fclose(outfile);
975  rename("plural_cmd.xx","plural_cmd.inc");
976 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
#define ALLOW_PLURAL
Definition: gentable.cc:35
const struct sValCmd2 dArith2[]
Definition: table.h:321
const struct sValCmdM dArithM[]
Definition: table.h:898
const struct sValCmd3 dArith3[]
Definition: table.h:773
const char * iiTwoOps(int t)
Definition: gentable.cc:261
#define COMM_PLURAL
Definition: gentable.cc:36
int i
Definition: cfEzgcd.cc:125
#define jjWRONG3
Definition: gentable.cc:129
#define NC_MASK
Definition: gentable.cc:39
#define NULL
Definition: omList.c:12
#define jjWRONG2
Definition: gentable.cc:128
#define jjWRONG
Definition: gentable.cc:127
const struct sValCmd1 dArith1[]
Definition: table.h:37
int p
Definition: cfModGcd.cc:4019
#define NO_NC
Definition: gentable.cc:34

Variable Documentation

◆ iparith_inc

VAR char* iparith_inc

Definition at line 329 of file gentable.cc.

◆ produce_convert_table

VAR int produce_convert_table =0

Definition at line 31 of file gentable.cc.