source: git/Singular/gentable.cc @ 491658

fieker-DuValspielwiese
Last change on this file since 491658 was 491658, checked in by Hans Schoenemann <hannes@…>, 5 years ago
opt: gentable
  • Property mode set to 100644
File size: 27.6 KB
Line 
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
28inline int RingDependend(int t) { return (BEGIN_RING<t)&&(t<END_RING); }
29
30// to produce convert_table.texi for doc:
31VAR int produce_convert_table=0;
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 =====================*/
59struct _scmdnames
60{
61  const char *name;
62  short alias;
63  short tokval;
64  short toktype;
65};
66typedef struct _scmdnames cmdnames;
67
68
69struct sValCmd2
70{
71  int p;
72  short cmd;
73  short res;
74  short arg1;
75  short arg2;
76  short valid_for;
77};
78struct sValCmd1
79{
80  int p;
81  short cmd;
82  short res;
83  short arg;
84  short valid_for;
85};
86struct 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};
96struct 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};
104struct sValAssign_sys
105{
106  int p;
107  short res;
108  short arg;
109};
110
111struct sValAssign
112{
113  int p;
114  short res;
115  short arg;
116};
117
118struct sConvertTypes
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
140const 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/*---------------------------------------------------------------------*/
194static 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
223static 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*/
261const char * iiTwoOps(int t)
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}
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*/
301int 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}
329VAR char *iparith_inc;
330void 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),
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"*/
482  if (produce_convert_table)
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));
497        if (produce_convert_table)
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  }
508  if (produce_convert_table)
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
572void 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    "void iiInitCmdName()\n{\n"
587    "  sArithBase.nCmdUsed      = 0;\n"
588    "  sArithBase.nCmdAllocated = %d;\n"
589    "  sArithBase.sCmds = (cmdnames*)omAlloc0(%d/*sArithBase.nCmdAllocated*/ *sizeof(cmdnames));\n"
590    "\n"
591    "  // name-string                   alias  tokval toktype index\n",
592    cmd_size,cmd_size);
593  int m=0;
594  int id_nr=0;
595
596  qsort(&cmds, cmd_size, sizeof(cmdnames), (&_gentable_sort_cmds));
597
598  for(m=0; m<cmd_size; m++)
599  {
600    if(cmds[m].tokval>0) id_nr++;
601    fprintf(outfile,"  iiArithAddCmd(\"%s\", %*d, %3d, ",cmds[m].name,
602            (int)(20-strlen(cmds[m].name)),
603            cmds[m].alias,
604            cmds[m].tokval);
605    switch(cmds[m].toktype)
606    {
607        case CMD_1:            fprintf(outfile,"CMD_1"); break;
608        case CMD_2:            fprintf(outfile,"CMD_2"); break;
609        case CMD_3:            fprintf(outfile,"CMD_3"); break;
610        case CMD_12:           fprintf(outfile,"CMD_12"); break;
611        case CMD_123 :         fprintf(outfile,"CMD_123"); break;
612        case CMD_23:           fprintf(outfile,"CMD_23"); break;
613        case CMD_M:            fprintf(outfile,"CMD_M"); break;
614        case SYSVAR:           fprintf(outfile,"SYSVAR"); break;
615        case ROOT_DECL:        fprintf(outfile,"ROOT_DECL"); break;
616        case ROOT_DECL_LIST:   fprintf(outfile,"ROOT_DECL_LIST"); break;
617        case RING_DECL:        fprintf(outfile,"RING_DECL"); break;
618        case NONE:             fprintf(outfile,"NONE"); break;
619        default:
620          if((cmds[m].toktype>' ') &&(cmds[m].toktype<127))
621          {
622            fprintf(outfile,"'%c'",cmds[m].toktype);
623          }
624          else
625          {
626            fprintf(outfile,"%d",cmds[m].toktype);
627          }
628          break;
629#if 0
630          fprintf(outfile,"  iiArithAddCmd(\"%s\", %*d,  -1, 0 );\n",
631              cmds[m].name, 20-strlen(cmds[m].name),
632              0/*cmds[m].alias*/
633              /*-1 cmds[m].tokval*/
634              /*0 cmds[m].toktype*/);
635#endif
636    }
637    fprintf(outfile,", %d);\n", m);
638  }
639  fprintf(outfile, "/* end of list marker */\n");
640  fprintf(outfile,
641          "  sArithBase.nLastIdentifier = %d;\n",
642          id_nr);
643
644
645  fprintf(outfile,
646"}\n"
647"#define LAST_IDENTIFIER %d\n"
648  ,id_nr);
649  fclose(outfile);
650}
651int is_ref_cmd(cmdnames *c)
652{
653  if( c->tokval==0) return 0;
654  if (c->alias > 0) return 0;
655  if  ((c->toktype==CMD_1)
656        || (c->toktype==CMD_2)
657        || (c->toktype==CMD_3)
658        || (c->toktype==CMD_M)
659        || (c->toktype==CMD_12)
660        || (c->toktype==CMD_13)
661        || (c->toktype==CMD_23)
662        || (c->toktype==CMD_123)) return 1;
663  return 0;
664}
665void ttGen2c()
666{
667  int cmd_size = (sizeof(cmds)/sizeof(cmdnames))-1;
668
669  FILE *outfile = fopen("reference_table.texi","w");
670  fprintf(outfile, "@menu\n");
671/*-------------------------------------------------------------------*/
672  qsort(&cmds, cmd_size, sizeof(cmdnames), (&_texi_sort_cmds));
673
674  int m;
675  for(m=0; m<cmd_size; m++)
676  {
677    // assume that cmds[0].tokval== -1 and all others with tokval -1 at the end
678    if(is_ref_cmd(&(cmds[m])))
679    {
680      fprintf(outfile,"* %s::\n",cmds[m].name);
681    }
682  }
683  fprintf(outfile, "@end menu\n@c ---------------------------\n");
684  for(m=0; m<cmd_size; m++)
685  {
686    // assume that cmds[0].tokval== -1 and all others with tokval -1 at the end
687    if(is_ref_cmd(&(cmds[m])))
688    {
689      fprintf(outfile,"@node %s,",cmds[m].name);
690      // next:
691      int mm=m-1;
692      while((mm>0)&& (is_ref_cmd(&cmds[mm]))) mm--;
693      if((mm>0)&& (is_ref_cmd(&cmds[mm])))
694        fprintf(outfile,"%s,",cmds[mm].name);
695      else
696        fprintf(outfile,",");
697      // prev:
698      mm=m+1;
699      while((mm>0)&& (is_ref_cmd(&cmds[mm]))) mm++;
700      if((mm>0)&& (is_ref_cmd(&cmds[mm])))
701        fprintf(outfile,"%s,",cmds[m-1].name);
702      else
703        fprintf(outfile,",");
704      // up:, and header
705      fprintf(outfile,"Functions\n"
706      "@subsection %s\n"
707      "@cindex %s\n",cmds[m].name,cmds[m].name);
708      fprintf(outfile,"@include %s.part\n",cmds[m].name);
709      char partName[50];
710      sprintf(partName,"%s.part",cmds[m].name);
711      struct stat buf;
712      if (lstat(partName,&buf)!=0)
713      {
714        int op,i;
715        int only_field=0,only_comm=0,no_zerodiv=0;
716        FILE *part=fopen(partName,"w");
717        fprintf(part,"@table @code\n@item @strong{Syntax:}\n");
718        if ((cmds[m].toktype==CMD_1)
719        || (cmds[m].toktype==CMD_12)
720        || (cmds[m].toktype==CMD_13)
721        || (cmds[m].toktype==CMD_123))
722        {
723          op= cmds[m].tokval;
724          i=0;
725          while ((dArith1[i].cmd!=op) && (dArith1[i].cmd!=0)) i++;
726          while (dArith1[i].cmd==op)
727          {
728            if (dArith1[i].p!=jjWRONG)
729            {
730              fprintf(part,"@code{%s (} %s @code{)}\n",cmds[m].name,Tok2Cmdname(dArith1[i].arg));
731              fprintf(part,"@item @strong{Type:}\n%s\n",Tok2Cmdname(dArith1[i].res));
732              if ((dArith1[i].valid_for & ALLOW_PLURAL)==0)
733                only_comm=1;
734              if ((dArith1[i].valid_for & ALLOW_RING)==0)
735                only_field=1;
736              if ((dArith1[i].valid_for & ZERODIVISOR_MASK)==NO_ZERODIVISOR)
737                no_zerodiv=1;
738            }
739            i++;
740          }
741        }
742        if ((cmds[m].toktype==CMD_23)
743        || (cmds[m].toktype==CMD_12)
744        || (cmds[m].toktype==CMD_2)
745        || (cmds[m].toktype==CMD_123))
746        {
747          op= cmds[m].tokval;
748          i=0;
749          while ((dArith2[i].cmd!=op) && (dArith2[i].cmd!=0)) i++;
750          while (dArith2[i].cmd==op)
751          {
752            if (dArith2[i].p!=jjWRONG)
753            {
754              fprintf(part,"@code{%s (} %s, %s @code{)}\n",cmds[m].name,Tok2Cmdname(dArith2[i].arg1),Tok2Cmdname(dArith2[i].arg2));
755              fprintf(part,"@item @strong{Type:}\n%s\n",Tok2Cmdname(dArith2[i].res));
756              if ((dArith2[i].valid_for & ALLOW_PLURAL)==0)
757                 only_comm=1;
758              if ((dArith2[i].valid_for & ALLOW_RING)==0)
759                 only_field=1;
760              if ((dArith2[i].valid_for & ZERODIVISOR_MASK)==NO_ZERODIVISOR)
761                no_zerodiv=1;
762            }
763            i++;
764          }
765        }
766        if ((cmds[m].toktype==CMD_23)
767        || (cmds[m].toktype==CMD_13)
768        || (cmds[m].toktype==CMD_3)
769        || (cmds[m].toktype==CMD_123))
770        {
771          op= cmds[m].tokval;
772          i=0;
773          while ((dArith3[i].cmd!=op) && (dArith3[i].cmd!=0)) i++;
774          while (dArith3[i].cmd==op)
775          {
776            if (dArith3[i].p!=jjWRONG)
777            {
778              fprintf(part,"@code{%s (} %s, %s, %s @code{)}\n",cmds[m].name,
779                Tok2Cmdname(dArith3[i].arg1),
780                Tok2Cmdname(dArith3[i].arg2),
781                Tok2Cmdname(dArith3[i].arg3));
782              fprintf(part,"@item @strong{Type:}\n%s\n",Tok2Cmdname(dArith3[i].res));
783              if ((dArith3[i].valid_for & ALLOW_PLURAL)==0)
784                only_comm=1;
785              if ((dArith3[i].valid_for & ALLOW_RING)==0)
786                only_field=1;
787              if ((dArith3[i].valid_for & ZERODIVISOR_MASK)==NO_ZERODIVISOR)
788                no_zerodiv=1;
789            }
790            i++;
791          }
792        }
793        if (cmds[m].toktype==CMD_M)
794        {
795          op= cmds[m].tokval;
796          i=0;
797          while ((dArithM[i].cmd!=op) && (dArithM[i].cmd!=0)) i++;
798          while (dArithM[i].cmd==op)
799          {
800            if (dArithM[i].p!=jjWRONG)
801            {
802              fprintf(part,"@code{%s (} ... @code{)}\n",cmds[m].name);
803              fprintf(part,"@item @strong{Type:}\n%s\n",Tok2Cmdname(dArithM[i].res));
804              if ((dArithM[i].valid_for & ALLOW_PLURAL)==0)
805                only_comm=1;
806              if ((dArithM[i].valid_for & ALLOW_RING)==0)
807                only_field=1;
808              if ((dArithM[i].valid_for & ZERODIVISOR_MASK)==NO_ZERODIVISOR)
809                no_zerodiv=1;
810            }
811            i++;
812          }
813        }
814        if (only_comm)
815              fprintf(part,"@item @strong{Remark:}\n"
816                           "only for commutive polynomial rings\n");
817        if (only_field)
818              fprintf(part,"@item @strong{Remark:}\n"
819                           "only for polynomial rings over fields\n");
820        if (no_zerodiv)
821              fprintf(part,"@item @strong{Remark:}\n"
822                           "only for polynomial rings over domains\n");
823        fprintf(part,"@item @strong{Purpose:}\n"
824                     "@item @strong{Example:}\n"
825                     "@smallexample\n"
826                     "@c example\n"
827                     "@c example\n"
828                     "@end smallexample\n"
829                     "@c ref\n"
830                     "@c See\n"
831                     "@c ref{....};\n"
832                     "@c ref{....}.\n"
833                     "@c ref\n");
834        fclose(part);
835      }
836    }
837  }
838  fclose(outfile);
839}
840/*-------------------------------------------------------------------*/
841void ttGen4()
842{
843  FILE *outfile = fopen("plural_cmd.xx","w");
844  int i;
845  const char *old_s="";
846  fprintf(outfile,
847  "@c *****************************************\n"
848  "@c *  Computer Algebra System SINGULAR     *\n"
849  "@c *****************************************\n\n");
850/*-------------------------------------------------------------------*/
851  fprintf(outfile,"@multicolumn .45 .45\n");
852  int op;
853  i=0;
854  while ((op=dArith1[i].cmd)!=0)
855  {
856    if (dArith1[i].p!=jjWRONG)
857    {
858      const char *s = iiTwoOps(op);
859      if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
860      {
861        old_s=s;
862        #ifdef HAVE_PLURAL
863        switch (dArith1[i].valid_for & NC_MASK)
864        {
865          case NO_NC:
866            fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
867            break;
868          case ALLOW_PLURAL:
869            fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
870            break;
871          case COMM_PLURAL:
872            fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
873            break;
874        }
875        #endif
876        #ifdef HAVE_RINGS
877        #endif
878      }
879    }
880    i++;
881  }
882  fprintf(outfile,"@c ---------------------------------------------\n");
883  i=0;
884  while ((op=dArith2[i].cmd)!=0)
885  {
886    if (dArith2[i].p!=jjWRONG2)
887    {
888      const char *s = iiTwoOps(op);
889      if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
890      {
891        old_s=s;
892        #ifdef HAVE_PLURAL
893        switch (dArith2[i].valid_for & NC_MASK)
894        {
895          case NO_NC:
896            fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
897            break;
898          case ALLOW_PLURAL:
899            fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
900            break;
901          case COMM_PLURAL:
902            fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
903            break;
904        }
905        #endif
906        #ifdef HAVE_RINGS
907        #endif
908      }
909    }
910    i++;
911  }
912  fprintf(outfile,"@c ---------------------------------------------\n");
913  i=0;
914  while ((op=dArith3[i].cmd)!=0)
915  {
916    const char *s = iiTwoOps(op);
917    if (dArith3[i].p!=jjWRONG3)
918    {
919      if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
920      {
921        old_s=s;
922        #ifdef HAVE_PLURAL
923        switch (dArith3[i].valid_for & NC_MASK)
924        {
925          case NO_NC:
926            fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
927            break;
928          case ALLOW_PLURAL:
929            fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
930            break;
931          case COMM_PLURAL:
932            fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
933            break;
934        }
935        #endif
936        #ifdef HAVE_RINGS
937        #endif
938      }
939    }
940    i++;
941  }
942  fprintf(outfile,"@c ---------------------------------------------\n");
943  i=0;
944  while ((op=dArithM[i].cmd)!=0)
945  {
946    const char *s = iiTwoOps(op);
947    if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
948    {
949        old_s=s;
950        #ifdef HAVE_PLURAL
951        switch (dArithM[i].valid_for & NC_MASK)
952        {
953          case NO_NC:
954            fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
955            break;
956          case ALLOW_PLURAL:
957            fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
958            break;
959          case COMM_PLURAL:
960            fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
961            break;
962        }
963        #endif
964        #ifdef HAVE_RINGS
965        #endif
966    }
967    i++;
968  }
969  fprintf(outfile,"@c ---------------------------------------------\n");
970  fprintf(outfile,"@end table\n");
971  fclose(outfile);
972  rename("plural_cmd.xx","plural_cmd.inc");
973}
974/*-------------------------------------------------------------------*/
975
976int main(int argc, char**)
977{
978  if (argc>1)
979  {
980    produce_convert_table=1; /* for ttGen1 */
981    ttGen1();
982    unlink(iparith_inc);
983    ttGen4();
984    ttGen2c();
985  }
986  else
987  {
988    ttGen1();
989    ttGen2b();
990    rename(iparith_inc,"iparith.inc");
991  }
992  return 0;
993}
Note: See TracBrowser for help on using the repository browser.