source: git/Singular/gentable.cc @ 73f3ca7

spielwiese
Last change on this file since 73f3ca7 was 73f3ca7, checked in by Hans Schoenemann <hannes@…>, 9 years ago
chg: table interface for iiAddCproc: 1 arg
  • Property mode set to 100644
File size: 25.1 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 <time.h>
13#include <unistd.h>
14#include <sys/types.h>
15#include <sys/stat.h>
16
17// need global defines:
18#include "kernel/mod2.h"
19// need to include all tokens: *_CMD:
20#include "grammar.h"
21#include "tok.h"
22
23// to produce convert_table.texi for doc:
24int produce_convert_table=0;
25
26// bits 0,1 for PLURAL
27#define NO_PLURAL        0
28#define ALLOW_PLURAL     1
29#define COMM_PLURAL      2
30#define PLURAL_MASK      3
31
32// bit 2 for RING-CF
33#define ALLOW_RING       4
34#define NO_RING          0
35
36// bit 3 for zerodivisors
37#define NO_ZERODIVISOR   8
38#define ALLOW_ZERODIVISOR  0
39#define ZERODIVISOR_MASK 8
40
41// bit 4 for warning, if used at toplevel
42#define WARN_RING        16
43
44/*=============== types =====================*/
45struct _scmdnames
46{
47  const char *name;
48  short alias;
49  short tokval;
50  short toktype;
51};
52typedef struct _scmdnames cmdnames;
53
54
55struct sValCmd2
56{
57  int p;
58  short cmd;
59  short res;
60  short arg1;
61  short arg2;
62  short valid_for;
63};
64struct sValCmd1
65{
66  int p;
67  short cmd;
68  short res;
69  short arg;
70  short valid_for;
71};
72struct sValCmd3
73{
74  int p;
75  short cmd;
76  short res;
77  short arg1;
78  short arg2;
79  short arg3;
80  short valid_for;
81};
82struct sValCmdM
83{
84  int p;
85  short cmd;
86  short res;
87  short number_of_args; /* -1: any, -2: any >0, .. */
88  short valid_for;
89};
90struct sValAssign_sys
91{
92  int p;
93  short res;
94  short arg;
95};
96
97struct sValAssign
98{
99  int p;
100  short res;
101  short arg;
102};
103
104struct sConvertTypes
105{
106  int i_typ;
107  int o_typ;
108  int p;
109  int pl;
110};
111
112
113#define jjWRONG   1
114#define jjWRONG2  1
115#define jjWRONG3  1
116
117#define D(A)     2
118#define NULL_VAL 0
119#define IPARITH
120#define GENTABLE
121#define IPCONV
122#define IPASSIGN
123
124#include "table.h"
125
126const char * Tok2Cmdname(int tok)
127{
128  if (tok < 0)
129  {
130    return cmds[0].name;
131  }
132  if (tok==COMMAND) return "command";
133  if (tok==ANY_TYPE) return "any_type";
134  if (tok==NONE) return "nothing";
135  //if (tok==IFBREAK) return "if_break";
136  //if (tok==VECTOR_FROM_POLYS) return "vector_from_polys";
137  //if (tok==ORDER_VECTOR) return "ordering";
138  //if (tok==REF_VAR) return "ref";
139  //if (tok==OBJECT) return "object";
140  //if (tok==PRINT_EXPR) return "print_expr";
141  if (tok==IDHDL) return "identifier";
142  if (tok==CRING_CMD) return "(c)ring";
143  // we do not blackbox objects during table generation:
144  //if (tok>MAX_TOK) return getBlackboxName(tok);
145  int i = 0;
146  while (cmds[i].tokval!=0)
147  {
148    if ((cmds[i].tokval == tok)&&(cmds[i].alias==0))
149    {
150      return cmds[i].name;
151    }
152    i++;
153  }
154  i=0;// try again for old/alias names:
155  while (cmds[i].tokval!=0)
156  {
157    if (cmds[i].tokval == tok)
158    {
159      return cmds[i].name;
160    }
161    i++;
162  }
163  #if 0
164  char *s=(char*)malloc(10);
165  sprintf(s,"(%d)",tok);
166  return s;
167  #else
168  return cmds[0].name;
169  #endif
170}
171/*---------------------------------------------------------------------*/
172/**
173 * @brief compares to entry of cmdsname-list
174
175 @param[in] a
176 @param[in] b
177
178 @return <ReturnValue>
179**/
180/*---------------------------------------------------------------------*/
181static int _gentable_sort_cmds( const void *a, const void *b )
182{
183  cmdnames *pCmdL = (cmdnames*)a;
184  cmdnames *pCmdR = (cmdnames*)b;
185
186  if(a==NULL || b==NULL)             return 0;
187
188  /* empty entries goes to the end of the list for later reuse */
189  if(pCmdL->name==NULL) return 1;
190  if(pCmdR->name==NULL) return -1;
191
192  /* $INVALID$ must come first */
193  if(strcmp(pCmdL->name, "$INVALID$")==0) return -1;
194  if(strcmp(pCmdR->name, "$INVALID$")==0) return  1;
195
196  /* tokval=-1 are reserved names at the end */
197  if (pCmdL->tokval==-1)
198  {
199    if (pCmdR->tokval==-1)
200       return strcmp(pCmdL->name, pCmdR->name);
201    /* pCmdL->tokval==-1, pCmdL goes at the end */
202    return 1;
203  }
204  /* pCmdR->tokval==-1, pCmdR goes at the end */
205  if(pCmdR->tokval==-1) return -1;
206
207  return strcmp(pCmdL->name, pCmdR->name);
208}
209
210static int _texi_sort_cmds( const void *a, const void *b )
211{
212  cmdnames *pCmdL = (cmdnames*)a;
213  cmdnames *pCmdR = (cmdnames*)b;
214
215  if(a==NULL || b==NULL)             return 0;
216
217  /* empty entries goes to the end of the list for later reuse */
218  if(pCmdL->name==NULL) return 1;
219  if(pCmdR->name==NULL) return -1;
220
221  /* $INVALID$ must come first */
222  if(strcmp(pCmdL->name, "$INVALID$")==0) return -1;
223  if(strcmp(pCmdR->name, "$INVALID$")==0) return  1;
224  char *ls=strdup(pCmdL->name);
225  char *rs=strdup(pCmdR->name);
226  char *s=ls;
227  while (*s) { *s=tolower(*s); s++; }
228  s=rs;
229  while (*s) { *s=tolower(*s); s++; }
230
231  /* tokval=-1 are reserved names at the end */
232  if (pCmdL->tokval==-1)
233  {
234    if (pCmdR->tokval==-1)
235       { int r=strcmp(ls,rs); free(ls); free(rs); return r; }
236    /* pCmdL->tokval==-1, pCmdL goes at the end */
237    free(ls);free(rs);
238    return 1;
239  }
240  /* pCmdR->tokval==-1, pCmdR goes at the end */
241  if(pCmdR->tokval==-1)
242  { free(ls);free(rs);return -1;}
243
244  { int r=strcmp(ls,rs); free(ls); free(rs); return r; }
245}
246
247/*generic*/
248const char * iiTwoOps(int t)
249{
250  if (t<127)
251  {
252    static char ch[2];
253    switch (t)
254    {
255      case '&':
256        return "and";
257      case '|':
258        return "or";
259      default:
260        ch[0]=t;
261        ch[1]='\0';
262        return ch;
263    }
264  }
265  switch (t)
266  {
267    case COLONCOLON:  return "::";
268    case DOTDOT:      return "..";
269    //case PLUSEQUAL:   return "+=";
270    //case MINUSEQUAL:  return "-=";
271    case MINUSMINUS:  return "--";
272    case PLUSPLUS:    return "++";
273    case EQUAL_EQUAL: return "==";
274    case LE:          return "<=";
275    case GE:          return ">=";
276    case NOTEQUAL:    return "<>";
277    default:          return Tok2Cmdname(t);
278  }
279}
280//
281// automatic conversions:
282//
283/*2
284* try to convert 'inputType' in 'outputType'
285* return 0 on failure, an index (<>0) on success
286* GENTABLE variant!
287*/
288int iiTestConvert (int inputType, int outputType)
289{
290  if ((inputType==outputType)
291  || (outputType==DEF_CMD)
292  || (outputType==IDHDL)
293  || (outputType==ANY_TYPE))
294  {
295    return -1;
296  }
297
298  // search the list
299  int i=0;
300  while (dConvertTypes[i].i_typ!=0)
301  {
302    if((dConvertTypes[i].i_typ==inputType)
303    &&(dConvertTypes[i].o_typ==outputType))
304    {
305      //Print("test convert %d to %d (%s -> %s):%d\n",inputType,outputType,
306      //Tok2Cmdname(inputType), Tok2Cmdname(outputType),i+1);
307      return i+1;
308    }
309    i++;
310  }
311  //Print("test convert %d to %d (%s -> %s):0\n",inputType,outputType,
312  // Tok2Cmdname(inputType), Tok2Cmdname(outputType));
313  return 0;
314}
315char *iparith_inc;
316void ttGen1()
317{
318  iparith_inc=strdup("iparith.xxxxxx");
319  int pid=getpid();
320  iparith_inc[8]=(pid %10)+'0'; pid/=10;
321  iparith_inc[9]=(pid %10)+'0'; pid/=10;
322  iparith_inc[10]=(pid %10)+'0'; pid/=10;
323  iparith_inc[11]=(pid %10)+'0'; pid/=10;
324  iparith_inc[12]=(pid %10)+'0'; pid/=10;
325  iparith_inc[13]=(pid %10)+'0';
326  FILE *outfile = fopen(iparith_inc,"w");
327  int i,j,l1=0,l2=0;
328  fprintf(outfile,
329  "/****************************************\n"
330  "*  Computer Algebra System SINGULAR     *\n"
331  "****************************************/\n\n");
332/*-------------------------------------------------------------------*/
333  fprintf(outfile,"// syntax table for Singular\n//\n");
334  fprintf(outfile,"// - search for an exact match of the argument types\n");
335  fprintf(outfile,"// - otherwise search for the first possibility\n");
336  fprintf(outfile,"//   with converted types of the arguments\n");
337  fprintf(outfile,"// - otherwise report an error\n//\n");
338
339  int op;
340  i=0;
341  while ((op=dArith1[i].cmd)!=0)
342  {
343    if (dArith1[i].p==jjWRONG)
344      fprintf(outfile,"// DUMMY ");
345    const char *s = iiTwoOps(op);
346    fprintf(outfile,"// operation: %s (%s)  ->  %s\n",
347          s,
348          Tok2Cmdname(dArith1[i].arg),
349          Tok2Cmdname(dArith1[i].res));
350    i++;
351  }
352  fprintf(outfile,"/*---------------------------------------------*/\n");
353  i=0;
354  while ((op=dArith2[i].cmd)!=0)
355  {
356    if (dArith2[i].p==jjWRONG2)
357      fprintf(outfile,"// DUMMY ");
358    const char *s = iiTwoOps(op);
359    fprintf(outfile,"// operation: %s (%s, %s)  ->  %s\n",
360          s,
361          Tok2Cmdname(dArith2[i].arg1),
362          Tok2Cmdname(dArith2[i].arg2),
363          Tok2Cmdname(dArith2[i].res));
364    i++;
365  }
366  fprintf(outfile,"/*---------------------------------------------*/\n");
367  i=0;
368  while ((op=dArith3[i].cmd)!=0)
369  {
370    const char *s = iiTwoOps(op);
371    if (dArith3[i].p==jjWRONG3)
372      fprintf(outfile,"// DUMMY ");
373    fprintf(outfile,"// operation: %s (%s, %s, %s)  ->  %s\n",
374          s,
375          Tok2Cmdname(dArith3[i].arg1),
376          Tok2Cmdname(dArith3[i].arg2),
377          Tok2Cmdname(dArith3[i].arg3),
378          Tok2Cmdname(dArith3[i].res));
379    i++;
380  }
381  fprintf(outfile,"/*---------------------------------------------*/\n");
382  i=0;
383  while ((op=dArithM[i].cmd)!=0)
384  {
385    const char *s = iiTwoOps(op);
386    fprintf(outfile,"// operation: %s (...)  ->  %s",
387          s,
388          Tok2Cmdname(dArithM[i].res));
389    switch(dArithM[i].number_of_args)
390    {
391      case -2:
392         fprintf(outfile," ( number of arguments >0 )\n");
393         break;
394      case -1:
395         fprintf(outfile," ( any number of arguments )\n");
396         break;
397      default:
398         fprintf(outfile," ( %d arguments )\n",dArithM[i].number_of_args);
399         break;
400    }
401    i++;
402  }
403  fprintf(outfile,"/*---------------------------------------------*/\n");
404  i=0;
405  while ((op=dAssign[i].res)!=0)
406  {
407    fprintf(outfile,"// assign: %s =  %s\n",
408          Tok2Cmdname(op/*dAssign[i].res*/),
409          Tok2Cmdname(dAssign[i].arg));
410    i++;
411  }
412/*-------------------------------------------------------------------*/
413  fprintf(outfile,"/*---------------------------------------------*/\n");
414  FILE *doctable;
415  if (produce_convert_table)
416  {
417    doctable=fopen("convert_table.texi","w");
418    fprintf(doctable,"@multitable @columnfractions .05 .18 .81\n");
419  }
420  int doc_nr=1;
421  for (j=257;j<=MAX_TOK+1;j++)
422  {
423    for(i=257;i<=MAX_TOK+1;i++)
424    {
425      if ((i!=j) && (j!=IDHDL) && (j!=DEF_CMD) && (j!=ANY_TYPE)
426      && iiTestConvert(i,j))
427      {
428        fprintf(outfile,"// convert %s -> %s\n",
429          Tok2Cmdname(i), Tok2Cmdname(j));
430        if (produce_convert_table)
431        {
432          fprintf(doctable,
433          "@item\n@   %d. @tab @code{%s}  @tab @expansion{} @code{%s}\n",
434          doc_nr,Tok2Cmdname(i),Tok2Cmdname(j));
435          doc_nr++;
436        }
437        if (j==ANY_TYPE) break;
438      }
439    }
440  }
441  if (produce_convert_table)
442  {
443    fprintf(doctable,"@end multitable\n");
444    fclose(doctable);
445  }
446  fprintf(outfile,"/*---------------------------------------------*/\n");
447  char ops[]="=><+*/[.^,%(;";
448  for(i=0;ops[i]!='\0';i++)
449    fprintf(outfile,"// token %d : %c\n", (int)ops[i], ops[i]);
450  for (i=257;i<=MAX_TOK;i++)
451  {
452    const char *s=iiTwoOps(i);
453    if (s[0]!='$')
454    {
455      fprintf(outfile,"// token %d : %s\n", i, s);
456    }
457  }
458/*-------------------------------------------------------------------*/
459  fprintf(outfile,"/*--max. token: %d, gr: %d --*/\n",MAX_TOK,UMINUS);
460/*-------------------------------------------------------------------*/
461  fprintf(outfile,"/*---------------------------------------------*/\n");
462  fprintf(outfile,
463  "struct sValCmdTab dArithTab1[]=\n"
464  "{\n");
465  for (j=1;j<=MAX_TOK+1;j++)
466  {
467    for(i=0;dArith1[i].cmd!=0;i++)
468    {
469      if (dArith1[i].cmd==j)
470      {
471        fprintf(outfile," { %d,%d },\n",j,i);
472        l1++;
473        break;
474      }
475    }
476  }
477  fprintf(outfile," { 10000,0 }\n};\n");
478  fprintf(outfile,"#define JJTAB1LEN %d\n",l1);
479/*-------------------------------------------------------------------*/
480  fprintf(outfile,
481  "struct sValCmdTab dArithTab2[]=\n"
482  "{\n");
483  for (j=1;j<=MAX_TOK+1;j++)
484  {
485    for(i=0;dArith2[i].cmd!=0;i++)
486    {
487      if (dArith2[i].cmd==j)
488      {
489        fprintf(outfile," { %d,%d },\n",j,i);
490        l2++;
491        break;
492      }
493    }
494  }
495  fprintf(outfile," { 10000,0 }\n};\n");
496  fprintf(outfile,"#define JJTAB2LEN %d\n",l2);
497  fclose(outfile);
498}
499/*---------------------------------------------------------------------*/
500/**
501 * @brief generate cmds initialisation
502**/
503/*---------------------------------------------------------------------*/
504
505void ttGen2b()
506{
507  int cmd_size = (sizeof(cmds)/sizeof(cmdnames))-1;
508
509  FILE *outfile = fopen(iparith_inc,"a");
510  fprintf(outfile,
511  "/****************************************\n"
512  "*  Computer Algebra System SINGULAR     *\n"
513  "****************************************/\n\n");
514/*-------------------------------------------------------------------*/
515  fprintf(outfile,"// identifier table for Singular\n//\n");
516
517  fprintf(
518    outfile,
519    "#ifdef MODULE_GENERATOR\n"
520    "#define omAlloc0(A) malloc(A)\n"
521    "#endif\n"
522    "void iiInitCmdName()\n{\n"
523    "  sArithBase.nCmdUsed      = 0;\n"
524    "  sArithBase.nCmdAllocated = %d;\n"
525    "  sArithBase.sCmds = (cmdnames*)omAlloc0(sArithBase.nCmdAllocated*sizeof(cmdnames));\n"
526    "\n"
527    "  // name-string                   alias  tokval toktype index\n",
528    cmd_size);
529  int m=0;
530  int id_nr=0;
531
532  qsort(&cmds, cmd_size, sizeof(cmdnames), (&_gentable_sort_cmds));
533
534  for(m=0; m<cmd_size; m++)
535  {
536    if(cmds[m].tokval>0) id_nr++;
537    fprintf(outfile,"  iiArithAddCmd(\"%s\", %*d, %3d, ",cmds[m].name,
538            (int)(20-strlen(cmds[m].name)),
539            cmds[m].alias,
540            cmds[m].tokval);
541    switch(cmds[m].toktype)
542    {
543        case CMD_1:            fprintf(outfile,"CMD_1"); break;
544        case CMD_2:            fprintf(outfile,"CMD_2"); break;
545        case CMD_3:            fprintf(outfile,"CMD_3"); break;
546        case CMD_12:           fprintf(outfile,"CMD_12"); break;
547        case CMD_123 :         fprintf(outfile,"CMD_123"); break;
548        case CMD_23:           fprintf(outfile,"CMD_23"); break;
549        case CMD_M:            fprintf(outfile,"CMD_M"); break;
550        case SYSVAR:           fprintf(outfile,"SYSVAR"); break;
551        case ROOT_DECL:        fprintf(outfile,"ROOT_DECL"); break;
552        case ROOT_DECL_LIST:   fprintf(outfile,"ROOT_DECL_LIST"); break;
553        case RING_DECL:        fprintf(outfile,"RING_DECL"); break;
554        case NONE:             fprintf(outfile,"NONE"); break;
555        default:
556          if((cmds[m].toktype>' ') &&(cmds[m].toktype<127))
557          {
558            fprintf(outfile,"'%c'",cmds[m].toktype);
559          }
560          else
561          {
562            fprintf(outfile,"%d",cmds[m].toktype);
563          }
564          break;
565#if 0
566          fprintf(outfile,"  iiArithAddCmd(\"%s\", %*d,  -1, 0 );\n",
567              cmds[m].name, 20-strlen(cmds[m].name),
568              0/*cmds[m].alias*/
569              /*-1 cmds[m].tokval*/
570              /*0 cmds[m].toktype*/);
571#endif
572    }
573    fprintf(outfile,", %d);\n", m);
574  }
575  fprintf(outfile, "/* end of list marker */\n");
576  fprintf(outfile,
577          "  sArithBase.nLastIdentifier = %d;\n",
578          id_nr);
579
580
581  fprintf(outfile,
582"}\n"
583"#define LAST_IDENTIFIER %d\n"
584  ,id_nr);
585  fclose(outfile);
586}
587int is_ref_cmd(cmdnames *c)
588{
589  if( c->tokval==0) return 0;
590  if (c->alias > 0) return 0;
591  if  ((c->toktype==CMD_1)
592        || (c->toktype==CMD_2)
593        || (c->toktype==CMD_3)
594        || (c->toktype==CMD_M)
595        || (c->toktype==CMD_12)
596        || (c->toktype==CMD_13)
597        || (c->toktype==CMD_23)
598        || (c->toktype==CMD_123)) return 1;
599  return 0;
600}
601void ttGen2c()
602{
603  int cmd_size = (sizeof(cmds)/sizeof(cmdnames))-1;
604
605  FILE *outfile = fopen("reference_table.texi","w");
606  fprintf(outfile, "@menu\n");
607/*-------------------------------------------------------------------*/
608  qsort(&cmds, cmd_size, sizeof(cmdnames), (&_texi_sort_cmds));
609
610  int m;
611  for(m=0; m<cmd_size; m++)
612  {
613    // assume that cmds[0].tokval== -1 and all others with tokval -1 at the end
614    if(is_ref_cmd(&(cmds[m])))
615    {
616      fprintf(outfile,"* %s::\n",cmds[m].name);
617    }
618  }
619  fprintf(outfile, "@end menu\n@c ---------------------------\n");
620  for(m=0; m<cmd_size; m++)
621  {
622    // assume that cmds[0].tokval== -1 and all others with tokval -1 at the end
623    if(is_ref_cmd(&(cmds[m])))
624    {
625      fprintf(outfile,"@node %s,",cmds[m].name);
626      // next:
627      int mm=m-1;
628      while((mm>0)&& (is_ref_cmd(&cmds[mm]))) mm--;
629      if((mm>0)&& (is_ref_cmd(&cmds[mm])))
630        fprintf(outfile,"%s,",cmds[mm].name);
631      else
632        fprintf(outfile,",");
633      // prev:
634      mm=m+1;
635      while((mm>0)&& (is_ref_cmd(&cmds[mm]))) mm++;
636      if((mm>0)&& (is_ref_cmd(&cmds[mm])))
637        fprintf(outfile,"%s,",cmds[m-1].name);
638      else
639        fprintf(outfile,",");
640      // up:, and header
641      fprintf(outfile,"Functions\n"
642      "@subsection %s\n"
643      "@cindex %s\n",cmds[m].name,cmds[m].name);
644      fprintf(outfile,"@include %s.part\n",cmds[m].name);
645      char partName[50];
646      sprintf(partName,"%s.part",cmds[m].name);
647      struct stat buf;
648      if (lstat(partName,&buf)!=0)
649      {
650        int op,i;
651        int only_field=0,only_comm=0,no_zerodiv=0;
652        FILE *part=fopen(partName,"w");
653        fprintf(part,"@table @code\n@item @strong{Syntax:}\n");
654        if ((cmds[m].toktype==CMD_1)
655        || (cmds[m].toktype==CMD_12)
656        || (cmds[m].toktype==CMD_13)
657        || (cmds[m].toktype==CMD_123))
658        {
659          op= cmds[m].tokval;
660          i=0;
661          while ((dArith1[i].cmd!=op) && (dArith1[i].cmd!=0)) i++;
662          while (dArith1[i].cmd==op)
663          {
664            if (dArith1[i].p!=jjWRONG)
665            {
666              fprintf(part,"@code{%s (} %s @code{)}\n",cmds[m].name,Tok2Cmdname(dArith1[i].arg));
667              fprintf(part,"@item @strong{Type:}\n%s\n",Tok2Cmdname(dArith1[i].res));
668              if ((dArith1[i].valid_for & ALLOW_PLURAL)==0)
669                only_comm=1;
670              if ((dArith1[i].valid_for & ALLOW_RING)==0)
671                only_field=1;
672              if ((dArith1[i].valid_for & ZERODIVISOR_MASK)==NO_ZERODIVISOR)
673                no_zerodiv=1;
674            }
675            i++;
676          }
677        }
678        if ((cmds[m].toktype==CMD_23)
679        || (cmds[m].toktype==CMD_12)
680        || (cmds[m].toktype==CMD_2)
681        || (cmds[m].toktype==CMD_123))
682        {
683          op= cmds[m].tokval;
684          i=0;
685          while ((dArith2[i].cmd!=op) && (dArith2[i].cmd!=0)) i++;
686          while (dArith2[i].cmd==op)
687          {
688            if (dArith2[i].p!=jjWRONG)
689            {
690              fprintf(part,"@code{%s (} %s, %s @code{)}\n",cmds[m].name,Tok2Cmdname(dArith2[i].arg1),Tok2Cmdname(dArith2[i].arg2));
691              fprintf(part,"@item @strong{Type:}\n%s\n",Tok2Cmdname(dArith2[i].res));
692              if ((dArith2[i].valid_for & ALLOW_PLURAL)==0)
693                 only_comm=1;
694              if ((dArith2[i].valid_for & ALLOW_RING)==0)
695                 only_field=1;
696              if ((dArith2[i].valid_for & ZERODIVISOR_MASK)==NO_ZERODIVISOR)
697                no_zerodiv=1;
698            }
699            i++;
700          }
701        }
702        if ((cmds[m].toktype==CMD_23)
703        || (cmds[m].toktype==CMD_13)
704        || (cmds[m].toktype==CMD_3)
705        || (cmds[m].toktype==CMD_123))
706        {
707          op= cmds[m].tokval;
708          i=0;
709          while ((dArith3[i].cmd!=op) && (dArith3[i].cmd!=0)) i++;
710          while (dArith3[i].cmd==op)
711          {
712            if (dArith3[i].p!=jjWRONG)
713            {
714              fprintf(part,"@code{%s (} %s, %s, %s @code{)}\n",cmds[m].name,
715                Tok2Cmdname(dArith3[i].arg1),
716                Tok2Cmdname(dArith3[i].arg2),
717                Tok2Cmdname(dArith3[i].arg3));
718              fprintf(part,"@item @strong{Type:}\n%s\n",Tok2Cmdname(dArith3[i].res));
719              if ((dArith3[i].valid_for & ALLOW_PLURAL)==0)
720                only_comm=1;
721              if ((dArith3[i].valid_for & ALLOW_RING)==0)
722                only_field=1;
723              if ((dArith3[i].valid_for & ZERODIVISOR_MASK)==NO_ZERODIVISOR)
724                no_zerodiv=1;
725            }
726            i++;
727          }
728        }
729        if (cmds[m].toktype==CMD_M)
730        {
731          op= cmds[m].tokval;
732          i=0;
733          while ((dArithM[i].cmd!=op) && (dArithM[i].cmd!=0)) i++;
734          while (dArithM[i].cmd==op)
735          {
736            if (dArithM[i].p!=jjWRONG)
737            {
738              fprintf(part,"@code{%s (} ... @code{)}\n",cmds[m].name);
739              fprintf(part,"@item @strong{Type:}\n%s\n",Tok2Cmdname(dArithM[i].res));
740              if ((dArithM[i].valid_for & ALLOW_PLURAL)==0)
741                only_comm=1;
742              if ((dArithM[i].valid_for & ALLOW_RING)==0)
743                only_field=1;
744              if ((dArithM[i].valid_for & ZERODIVISOR_MASK)==NO_ZERODIVISOR)
745                no_zerodiv=1;
746            }
747            i++;
748          }
749        }
750        if (only_comm)
751              fprintf(part,"@item @strong{Remark:}\n"
752                           "only for commutive polynomial rings\n");
753        if (only_field)
754              fprintf(part,"@item @strong{Remark:}\n"
755                           "only for polynomial rings over fields\n");
756        if (no_zerodiv)
757              fprintf(part,"@item @strong{Remark:}\n"
758                           "only for polynomial rings over domains\n");
759        fprintf(part,"@item @strong{Purpose:}\n"
760                     "@item @strong{Example:}\n"
761                     "@smallexample\n"
762                     "@c example\n"
763                     "@c example\n"
764                     "@end smallexample\n"
765                     "@c ref\n"
766                     "@c See\n"
767                     "@c ref{....};\n"
768                     "@c ref{....}.\n"
769                     "@c ref\n");
770        fclose(part);
771      }
772    }
773  }
774  fclose(outfile);
775}
776/*-------------------------------------------------------------------*/
777void ttGen4()
778{
779  FILE *outfile = fopen("plural_cmd.xx","w");
780  int i;
781  const char *old_s="";
782  fprintf(outfile,
783  "@c *****************************************\n"
784  "@c *  Computer Algebra System SINGULAR     *\n"
785  "@c *****************************************\n\n");
786/*-------------------------------------------------------------------*/
787  fprintf(outfile,"@multicolumn .45 .45\n");
788  int op;
789  i=0;
790  while ((op=dArith1[i].cmd)!=0)
791  {
792    if (dArith1[i].p!=jjWRONG)
793    {
794      const char *s = iiTwoOps(op);
795      if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
796      {
797        old_s=s;
798        #ifdef HAVE_PLURAL
799        switch (dArith1[i].valid_for & PLURAL_MASK)
800        {
801          case NO_PLURAL:
802            fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
803            break;
804          case ALLOW_PLURAL:
805            fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
806            break;
807          case COMM_PLURAL:
808            fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
809            break;
810        }
811        #endif
812        #ifdef HAVE_RINGS
813        #endif
814      }
815    }
816    i++;
817  }
818  fprintf(outfile,"@c ---------------------------------------------\n");
819  i=0;
820  while ((op=dArith2[i].cmd)!=0)
821  {
822    if (dArith2[i].p!=jjWRONG2)
823    {
824      const char *s = iiTwoOps(op);
825      if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
826      {
827        old_s=s;
828        #ifdef HAVE_PLURAL
829        switch (dArith2[i].valid_for & PLURAL_MASK)
830        {
831          case NO_PLURAL:
832            fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
833            break;
834          case ALLOW_PLURAL:
835            fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
836            break;
837          case COMM_PLURAL:
838            fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
839            break;
840        }
841        #endif
842        #ifdef HAVE_RINGS
843        #endif
844      }
845    }
846    i++;
847  }
848  fprintf(outfile,"@c ---------------------------------------------\n");
849  i=0;
850  while ((op=dArith3[i].cmd)!=0)
851  {
852    const char *s = iiTwoOps(op);
853    if (dArith3[i].p!=jjWRONG3)
854    {
855      if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
856      {
857        old_s=s;
858        #ifdef HAVE_PLURAL
859        switch (dArith3[i].valid_for & PLURAL_MASK)
860        {
861          case NO_PLURAL:
862            fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
863            break;
864          case ALLOW_PLURAL:
865            fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
866            break;
867          case COMM_PLURAL:
868            fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
869            break;
870        }
871        #endif
872        #ifdef HAVE_RINGS
873        #endif
874      }
875    }
876    i++;
877  }
878  fprintf(outfile,"@c ---------------------------------------------\n");
879  i=0;
880  while ((op=dArithM[i].cmd)!=0)
881  {
882    const char *s = iiTwoOps(op);
883    if ((s!=NULL) && (isalpha(s[0])) && (strcmp(s,old_s)!=0))
884    {
885        old_s=s;
886        #ifdef HAVE_PLURAL
887        switch (dArithM[i].valid_for & PLURAL_MASK)
888        {
889          case NO_PLURAL:
890            fprintf(outfile,"@item @ref{%s} @tab @code{---}\n",s);
891            break;
892          case ALLOW_PLURAL:
893            fprintf(outfile,"@item @ref{%s} @tab @ref{%s (plural)}\n",s,s);
894            break;
895          case COMM_PLURAL:
896            fprintf(outfile,"@item @ref{%s} @tab %s\n",s,s);
897            break;
898        }
899        #endif
900        #ifdef HAVE_RINGS
901        #endif
902    }
903    i++;
904  }
905  fprintf(outfile,"@c ---------------------------------------------\n");
906  fprintf(outfile,"@end table\n");
907  fclose(outfile);
908  rename("plural_cmd.xx","plural_cmd.inc");
909}
910/*-------------------------------------------------------------------*/
911
912int main(int argc, char** argv)
913{
914  if (argc>1)
915  {
916    produce_convert_table=1; /* for ttGen1 */
917    ttGen1();
918    unlink(iparith_inc);
919    ttGen4();
920    ttGen2c();
921  }
922  else
923  {
924    ttGen1();
925    ttGen2b();
926    rename(iparith_inc,"iparith.inc");
927  }
928  return 0;
929}
Note: See TracBrowser for help on using the repository browser.