My Project  UNKNOWN_GIT_VERSION
gentable.cc
Go to the documentation of this file.
1 /****************************************
2 * Computer Algebra System SINGULAR *
3 ****************************************/
4 /*
5 * ABSTRACT: generate iparith.inc etc.
6 */
7 
8 #include <stdlib.h>
9 #include <string.h>
10 #include <ctype.h>
11 #include <stdio.h>
12 #include <unistd.h>
13 #include <sys/stat.h>
14 
15 // need global defines:
16 #include "kernel/mod2.h"
17 // need to include all tokens: *_CMD:
18 #include "Singular/tok.h"
19 
20 #ifdef HAVE_RINGS
21  #define RING_MASK 4
22  #define ZERODIVISOR_MASK 8
23 #else
24  #define RING_MASK 0
25  #define ZERODIVISOR_MASK 0
26 #endif
27 
28 inline int RingDependend(int t) { return (BEGIN_RING<t)&&(t<END_RING); }
29 
30 // to produce convert_table.texi for doc:
32 
33 // bits 0,1 for PLURAL
34 #define NO_NC 0
35 #define ALLOW_PLURAL 1
36 #define COMM_PLURAL 2
37 // bit 6: non-commutative letterplace
38 #define ALLOW_LP 64
39 #define NC_MASK (3+64)
40 #define ALLOW_NC ALLOW_LP|ALLOW_PLURAL
41 
42 // bit 2 for RING-CF
43 #define ALLOW_RING 4
44 #define NO_RING 0
45 
46 // bit 3 for zerodivisors
47 #define NO_ZERODIVISOR 8
48 #define ALLOW_ZERODIVISOR 0
49 #define ZERODIVISOR_MASK 8
50 
51 #define ALLOW_ZZ (ALLOW_RING|NO_ZERODIVISOR)
52 
53 // bit 4 for warning, if used at toplevel
54 #define WARN_RING 16
55 // bit 5: do no try automatic conversions
56 #define NO_CONVERSION 32
57 
58 /*=============== types =====================*/
59 struct _scmdnames
60 {
61  const char *name;
62  short alias;
63  short tokval;
64  short toktype;
65 };
66 typedef struct _scmdnames cmdnames;
67 
68 
69 struct sValCmd2
70 {
71  int p;
72  short cmd;
73  short res;
74  short arg1;
75  short arg2;
76  short valid_for;
77 };
78 struct sValCmd1
79 {
80  int p;
81  short cmd;
82  short res;
83  short arg;
84  short valid_for;
85 };
86 struct sValCmd3
87 {
88  int p;
89  short cmd;
90  short res;
91  short arg1;
92  short arg2;
93  short arg3;
94  short valid_for;
95 };
96 struct sValCmdM
97 {
98  int p;
99  short cmd;
100  short res;
101  short number_of_args; /* -1: any, -2: any >0, .. */
102  short valid_for;
103 };
105 {
106  int p;
107  short res;
108  short arg;
109 };
110 
112 {
113  int p;
114  short res;
115  short arg;
116 };
117 
119 {
120  int i_typ;
121  int o_typ;
122  int p;
123  int pl;
124 };
125 
126 
127 #define jjWRONG 1
128 #define jjWRONG2 1
129 #define jjWRONG3 1
130 
131 #define D(A) 2
132 #define NULL_VAL 0
133 #define IPARITH
134 #define GENTABLE
135 #define IPCONV
136 #define IPASSIGN
137 
138 #include "table.h"
139 
140 const char * Tok2Cmdname(int tok)
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 }
184 /*---------------------------------------------------------------------*/
185 /**
186  * @brief compares to entry of cmdsname-list
187 
188  @param[in] a
189  @param[in] b
190 
191  @return <ReturnValue>
192 **/
193 /*---------------------------------------------------------------------*/
194 static int _gentable_sort_cmds( const void *a, const void *b )
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 }
222 
223 static int _texi_sort_cmds( const void *a, const void *b )
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 }
259 
260 /*generic*/
261 const char * iiTwoOps(int t)
262 {
263  if (t<127)
264  {
265  static 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 }
293 //
294 // automatic conversions:
295 //
296 /*2
297 * try to convert 'inputType' in 'outputType'
298 * return 0 on failure, an index (<>0) on success
299 * GENTABLE variant!
300 */
301 int iiTestConvert (int inputType, int outputType)
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 }
330 void ttGen1()
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),
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),
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),
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,
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",
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 }
566 /*---------------------------------------------------------------------*/
567 /**
568  * @brief generate cmds initialisation
569 **/
570 /*---------------------------------------------------------------------*/
571 
572 void ttGen2b()
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 }
654 int is_ref_cmd(cmdnames *c)
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 }
668 void ttGen2c()
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 }
843 /*-------------------------------------------------------------------*/
844 void ttGen4()
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 }
977 /*-------------------------------------------------------------------*/
978 
979 int main(int argc, char**)
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 }
sConvertTypes::p
int p
Definition: gentable.cc:122
sConvertTypes
Definition: gentable.cc:118
dAssign
const struct sValAssign dAssign[]
Definition: table.h:1345
CMD_M
@ CMD_M
Definition: grammar.cc:318
j
int j
Definition: facHensel.cc:105
ttGen2c
void ttGen2c()
Definition: gentable.cc:668
_scmdnames::name
const char * name
Definition: gentable.cc:61
sValAssign::p
int p
Definition: gentable.cc:113
NC_MASK
#define NC_MASK
Definition: gentable.cc:39
COLONCOLON
@ COLONCOLON
Definition: grammar.cc:275
CMD_23
@ CMD_23
Definition: grammar.cc:316
sValAssign::res
short res
Definition: gentable.cc:114
sValAssign_sys::res
short res
Definition: gentable.cc:107
sValCmd3::arg3
short arg3
Definition: gentable.cc:93
is_ref_cmd
int is_ref_cmd(cmdnames *c)
Definition: gentable.cc:654
sValCmd1::arg
short arg
Definition: gentable.cc:83
RING_MASK
#define RING_MASK
Definition: gentable.cc:21
WARN_RING
#define WARN_RING
Definition: gentable.cc:54
NONE
#define NONE
Definition: tok.h:219
CMD_12
@ CMD_12
Definition: grammar.cc:314
sValCmd2::res
short res
Definition: gentable.cc:73
MAX_TOK
@ MAX_TOK
Definition: tok.h:216
sValCmdM::number_of_args
short number_of_args
Definition: gentable.cc:101
dArith2
const struct sValCmd2 dArith2[]
Definition: table.h:316
sValAssign_sys::p
int p
Definition: gentable.cc:106
sValCmd1::valid_for
short valid_for
Definition: gentable.cc:84
jjWRONG
#define jjWRONG
Definition: gentable.cc:127
DEF_CMD
@ DEF_CMD
Definition: tok.h:58
sValCmd2::arg1
short arg1
Definition: gentable.cc:74
sValAssign_sys::arg
short arg
Definition: gentable.cc:108
sValAssign_sys
Definition: gentable.cc:104
sValCmd2::cmd
short cmd
Definition: gentable.cc:72
b
CanonicalForm b
Definition: cfModGcd.cc:4044
CMD_3
@ CMD_3
Definition: grammar.cc:313
sValCmd1::res
short res
Definition: gentable.cc:82
CMD_123
@ CMD_123
Definition: grammar.cc:317
RingDependend
int RingDependend(int t)
Definition: gentable.cc:28
iiTwoOps
const char * iiTwoOps(int t)
Definition: gentable.cc:261
ANY_TYPE
#define ANY_TYPE
Definition: tok.h:30
UMINUS
@ UMINUS
Definition: grammar.cc:351
main
int main(int argc, char **)
Definition: gentable.cc:979
jjWRONG3
#define jjWRONG3
Definition: gentable.cc:129
sConvertTypes::o_typ
int o_typ
Definition: gentable.cc:121
_scmdnames
Definition: gentable.cc:59
BEGIN_RING
@ BEGIN_RING
Definition: grammar.cc:282
ttGen4
void ttGen4()
Definition: gentable.cc:844
dArithM
const struct sValCmdM dArithM[]
Definition: table.h:885
i
int i
Definition: cfEzgcd.cc:125
ttGen1
void ttGen1()
Definition: gentable.cc:330
res
CanonicalForm res
Definition: facAbsFact.cc:64
ZERODIVISOR_MASK
#define ZERODIVISOR_MASK
Definition: gentable.cc:49
COMMAND
#define COMMAND
Definition: tok.h:29
jjWRONG2
#define jjWRONG2
Definition: gentable.cc:128
buf
int status int void * buf
Definition: si_signals.h:59
_texi_sort_cmds
static int _texi_sort_cmds(const void *a, const void *b)
Definition: gentable.cc:223
ALLOW_LP
#define ALLOW_LP
Definition: gentable.cc:38
malloc
void * malloc(size_t size)
Definition: omalloc.c:92
dArith3
const struct sValCmd3 dArith3[]
Definition: table.h:763
sValAssign
Definition: gentable.cc:111
sValCmd2::p
int p
Definition: gentable.cc:71
mod2.h
sValCmd1::cmd
short cmd
Definition: gentable.cc:81
EQUAL_EQUAL
@ EQUAL_EQUAL
Definition: grammar.cc:268
sValCmd2::valid_for
short valid_for
Definition: gentable.cc:76
LE
@ LE
Definition: grammar.cc:270
PLUSPLUS
@ PLUSPLUS
Definition: grammar.cc:274
free
#define free
Definition: omAllocFunc.c:12
sValCmd2::arg2
short arg2
Definition: gentable.cc:75
END_RING
@ END_RING
Definition: grammar.cc:310
iiTestConvert
int iiTestConvert(int inputType, int outputType)
Definition: gentable.cc:301
ALLOW_PLURAL
#define ALLOW_PLURAL
Definition: gentable.cc:35
ttGen2b
void ttGen2b()
generate cmds initialisation
Definition: gentable.cc:572
NO_ZERODIVISOR
#define NO_ZERODIVISOR
Definition: gentable.cc:47
CMD_13
@ CMD_13
Definition: grammar.cc:315
ROOT_DECL_LIST
@ ROOT_DECL_LIST
Definition: grammar.cc:320
_scmdnames::tokval
short tokval
Definition: gentable.cc:63
UNKNOWN
#define UNKNOWN
Definition: tok.h:220
sValCmdM::res
short res
Definition: gentable.cc:100
sValCmd3::res
short res
Definition: gentable.cc:90
sConvertTypes::i_typ
int i_typ
Definition: gentable.cc:120
CMD_1
@ CMD_1
Definition: grammar.cc:311
sValCmd3::arg2
short arg2
Definition: gentable.cc:92
COMM_PLURAL
#define COMM_PLURAL
Definition: gentable.cc:36
sValCmdM::cmd
short cmd
Definition: gentable.cc:99
sValCmdM::valid_for
short valid_for
Definition: gentable.cc:102
sConvertTypes::pl
int pl
Definition: gentable.cc:123
iparith_inc
char * iparith_inc
Definition: gentable.cc:329
name
char name(const Variable &v)
Definition: factory.h:180
tok.h
strdup
#define strdup
Definition: omAllocFunc.c:17
IDHDL
#define IDHDL
Definition: tok.h:31
m
int m
Definition: cfEzgcd.cc:121
NULL
#define NULL
Definition: omList.c:10
sValAssign::arg
short arg
Definition: gentable.cc:115
dArith1
const struct sValCmd1 dArith1[]
Definition: table.h:37
_scmdnames::toktype
short toktype
Definition: gentable.cc:64
sValCmdM
Definition: gentable.cc:96
sValCmd1
Definition: gentable.cc:78
sValCmd2
Definition: gentable.cc:69
sValCmd3
Definition: gentable.cc:86
sValCmdM::p
int p
Definition: gentable.cc:98
dConvertTypes
const struct sConvertTypes dConvertTypes[]
Definition: table.h:1251
GE
@ GE
Definition: grammar.cc:269
p
int p
Definition: cfModGcd.cc:4019
sValCmd3::p
int p
Definition: gentable.cc:88
NO_NC
#define NO_NC
Definition: gentable.cc:34
s
const CanonicalForm int s
Definition: facAbsFact.cc:55
sValCmd1::p
int p
Definition: gentable.cc:80
Tok2Cmdname
const char * Tok2Cmdname(int tok)
Definition: gentable.cc:140
NOTEQUAL
@ NOTEQUAL
Definition: grammar.cc:273
ALLOW_RING
#define ALLOW_RING
Definition: gentable.cc:43
_scmdnames::alias
short alias
Definition: gentable.cc:62
MINUSMINUS
@ MINUSMINUS
Definition: grammar.cc:271
produce_convert_table
int produce_convert_table
Definition: gentable.cc:31
sValCmd3::arg1
short arg1
Definition: gentable.cc:91
ROOT_DECL
@ ROOT_DECL
Definition: grammar.cc:319
table.h
sValCmd3::cmd
short cmd
Definition: gentable.cc:89
SYSVAR
@ SYSVAR
Definition: grammar.cc:350
CMD_2
@ CMD_2
Definition: grammar.cc:312
RING_DECL
@ RING_DECL
Definition: grammar.cc:321
cmds
cmdnames cmds[]
Definition: table.h:964
_gentable_sort_cmds
static int _gentable_sort_cmds(const void *a, const void *b)
compares to entry of cmdsname-list
Definition: gentable.cc:194
DOTDOT
@ DOTDOT
Definition: grammar.cc:267
sValCmd3::valid_for
short valid_for
Definition: gentable.cc:94