source: git/modules/modgen/grammar.y @ ccebcd

fieker-DuValspielwiese
Last change on this file since ccebcd was ccebcd, checked in by Kai Krüger <krueger@…>, 24 years ago
Added write_singular_end() git-svn-id: file:///usr/local/Singular/svn/trunk@4719 2c84dea3-7e68-4137-9b89-c4e89433aadc
  • Property mode set to 100644
File size: 20.4 KB
Line 
1/*
2 * $Id: grammar.y,v 1.15 2000-11-09 21:58:13 krueger Exp $
3 */
4
5%{
6
7#include <stdio.h>
8#include <stddef.h>
9#include <stdlib.h>
10#include <stdarg.h>
11#include <string.h>
12#include <limits.h>
13
14#include <mod2.h>
15#include <tok.h>
16
17#include "modgen.h"
18#include "stype.h"
19
20int sectnum = 1;
21int iseof = 0;
22extern moddef module_def;
23extern int yylineno;
24extern int do_create_makefile;
25extern char *sectname[];
26 
27extern int init_modgen(moddef *module_def, char *filename);
28extern int write_intro(moddefv module);
29extern void write_mod_init(moddefv module, FILE *fp);
30extern void enter_id(FILE *fp, char *name, char *value,
31                     int lineno, char *file);
32 
33procdef procedure_decl;
34
35 
36void yyerror(char * fmt)
37  {
38    if(!iseof) printf("%s at line %d\n", fmt, yylineno);
39  }
40
41%}
42
43/* %expect 22 */
44%pure_parser
45
46%token MCOLONCOLON
47%token MEQUAL
48
49/* special symbols */
50%token <i> MMODULE_CMD
51%token <i> MVERSION_CMD
52%token <i> MINFO_CMD
53%token <i> MINFOFILE_CMD
54%token <i> MHELP_CMD
55%token <i> MHELPFILE_CMD
56%token <i> MCXXSRC_CMD
57%token <i> MPROC_CMD
58
59%token SECTEND
60/* SECT2: Singular procedure declaration */
61%token SECT2START
62%token SECT2END
63/* SECT3: procedure declaration */
64%token SECT3START
65%token SECT3END
66/* SECT4: C/C++ text */
67%token SECT4START
68%token SECT4END
69
70/*%token PROCEND*/
71%token PROCDECLTOK
72%token EXAMPLETOK
73%token STATICTOK
74
75/* BISON Declarations */
76
77%token VARNAMETOK
78/*%token MSTRINGTOK */
79%token <sv>   MSTRINGTOK
80%token <name> NAME
81%token <name> FILENAME
82%token <name> MCCODETOK
83%token <name> MCODETOK
84%token <name> CODEPART
85%token <name> CMTPART
86%token <name> PROCCMD
87%token <name> ANYTOK
88%token  <tp> VARTYPETOK
89%token <i>    NUMTOK
90%token <i>    BOOLTOK
91
92%type <i>    '='
93%type <name> identifier
94
95%nonassoc '='
96%%
97goal: part1 sect3 sect3end sect4
98      {
99          if(trace)printf("Finish modules 1\n");
100          return 0;
101      }
102      | part1 sect3full sect4
103      {
104          if(trace)printf("Finish modules 2\n");
105          return 0;
106      }
107      | part1 sect2full sect3full sect4
108      {
109          if(trace)printf("Finish modules 3\n");
110          return 0;
111      }
112      | part1 sect3full sect2full sect4
113      {
114          if(trace)printf("Finish modules 4\n");
115          return 0;
116      }
117;
118
119part1: initmod sect1 sect1end
120        {
121          if(do_create_makefile)mod_create_makefile(&module_def);
122          if(write_intro(&module_def)) {
123            return(myyyerror("Error while creating files\n"));
124          }
125        }
126        | sect1 sect1end
127        {
128          write_mod_init(&module_def, module_def.fmtfp);
129          if(do_create_makefile)mod_create_makefile(&module_def);
130          if(write_intro(&module_def)) {
131            return(myyyerror("Error while creating files\n"));
132          }
133        }
134        | sect1end
135        {
136          write_mod_init(&module_def, module_def.fmtfp);
137          if(do_create_makefile)mod_create_makefile(&module_def);
138          if(write_intro(&module_def)) {
139            return(myyyerror("Error while creating files\n"));
140          }
141        };
142
143initmod:
144        MCCODETOK
145        {
146          fprintf(module_def.fmtfp, "%s", $1);
147          fprintf(module_def.fmtfp, "#line %d \"%s\"\n",
148                                          yylineno, module_def.filename);
149          free($1);
150          write_mod_init(&module_def, module_def.fmtfp);
151        }
152
153sect1: expr ';'
154       | sect1 expr ';'
155;
156
157       
158sect1end: SECTEND
159        {
160          memset(&procedure_decl, 0, sizeof(procdef));
161          if(debug>2)printf("End of section 1 (new=%d)\n", sectnum);
162        }
163        ;
164
165expr:   NAME '=' MSTRINGTOK
166        {
167          var_token vt;
168          int rc = 0;
169          void (*write_cmd)(moddefv module, var_token type = VAR_NONE,
170                            idtyp t, void *arg1 = NULL, void *arg2 = NULL);
171         
172          switch(sectnum) {
173              case 1: /* pass 1: */
174                if( (vt=checkvar($1, VAR_STRING, &write_cmd)) ) {
175                  if(write_cmd!=0)
176                    write_cmd(&module_def, vt, STRING_CMD, $1, $3.string);
177                  if(vt==VAR_VERSION)
178                    make_version($3.string, &module_def);
179                }
180                else {
181                  rc=myyyerror("Line %d: Unknown variable '%s' in section %d\n",
182                            yylineno, $1, sectnum);
183                }
184                break;
185              case 3: /* pass 3: procedure declaration */
186                if( (vt=checkvar($1, VAR_STRING, &write_cmd)) ) {
187                  proc_set_var(&procedure_decl, VAR_STRING, vt, $1, $3.string);
188                }
189                else {
190                  rc=myyyerror("Line %d: Unknown variable '%s' in section %d\n",
191                            yylineno, $1, sectnum);
192                }
193                break;
194              default: break;
195               
196          }
197          free($1);
198          free($3.string);
199          if(rc)return(rc);
200        }
201        | NAME '=' FILENAME
202        { var_token vt;
203          void (*write_cmd)(moddefv module, var_token type = VAR_NONE,
204                            idtyp t, void *arg1 = NULL, void *arg2 = NULL);
205          switch(sectnum) {
206              case 1: /* pass 1: */
207                Add2files(&module_def, $3);
208                break;
209              case 3: /* pass 3: procedure declaration */
210                if( (vt=checkvar($1, VAR_FILE, &write_cmd)) ) {
211                  proc_set_var(&procedure_decl, VAR_FILE, vt, $1, $3);
212                }
213                break;
214              default: break;
215               
216          }
217          free($1);
218          free($3);
219        }
220        | NAME '=' files
221        { var_token vt;
222          void (*write_cmd)(moddefv module, var_token type = VAR_NONE,
223                            idtyp t, void *arg1 = NULL, void *arg2 = NULL);
224          switch(sectnum) {
225              case 1: /* pass 1: */
226                break;
227              case 3: /* pass 3: procedure declaration */
228                if( (vt=checkvar($1, VAR_FILES, &write_cmd)) ) {
229                  proc_set_var(&procedure_decl, VAR_FILES, vt, $1, &$3);
230                }
231                break;
232              default: break;
233               
234          }
235          free($1);
236          //free($3);
237        }
238        | NAME '=' NUMTOK
239        { var_token vt;
240          void (*write_cmd)(moddefv module, var_token type = VAR_NONE,
241                            idtyp t, void *arg1 = NULL, void *arg2 = NULL);
242          switch(sectnum) {
243              case 1: /* pass 1: */
244                break;
245              case 3: /* pass 3: procedure declaration */
246                if( (vt=checkvar($1, VAR_NUM, &write_cmd)) ) {
247                  proc_set_var(&procedure_decl, VAR_NUM, vt, $1, &$3);
248                }
249                break;
250              default: break;
251               
252          }
253          free($1);
254        }
255        | NAME '=' BOOLTOK
256        {
257          var_token vt;
258          int rc = 0;
259          void (*write_cmd)(moddefv module, var_token type = VAR_NONE,
260                            idtyp t, void *arg1 = NULL, void *arg2 = NULL);
261          switch(sectnum) {
262              case 1: /* pass 1: */
263                if( (vt=checkvar($1, VAR_BOOL, &write_cmd)) ) {
264                  proc_set_default_var(VAR_BOOL, vt, $1, &$3);
265                }
266                else {
267                  rc=myyyerror("Line %d: Unknown variable '%s' in section %d\n",
268                            yylineno, $1, sectnum);
269                }
270                break;
271              case 3: /* pass 3: procedure declaration */
272                if( (vt=checkvar($1, VAR_BOOL, &write_cmd)) ) {
273                  proc_set_var(&procedure_decl, VAR_BOOL, vt, $1, &$3);
274                }
275                else {
276                  rc=myyyerror("Line %d: Unknown variable '%s' in section %d\n",
277                            yylineno, $1, sectnum);
278                }
279                break;
280              default: break;
281               
282          }
283          free($1);
284          if(rc)return(rc);
285        }
286;
287
288files:  FILENAME ',' FILENAME
289        {
290          if(debug>2)printf(">>>>>>>>files '%s' , '%s'\n", $1, $3);
291          Add2files(&module_def, $1);
292          Add2files(&module_def, $3);
293          free($1);
294          free($3);
295        }
296;
297
298sect2full: SECT2START sect2 sect2end;
299
300sect2: procdefsg
301       | sect2 procdefsg
302       ;
303
304sect2end: SECT2END
305{
306          if(debug>2)printf("End of section 'Singular' 2 (%d)\n",
307                            sectnum);
308};
309
310
311sect3full: SECT3START sect3 sect3end;
312
313sect3:  procdef
314        | sect3 procdef
315        ;
316
317sect3end: SECT3END
318        {
319          write_finish_functions(&module_def, &procedure_decl);
320          if(debug>2)printf("End of section 'procedures' 3 (%d)\n",
321                            sectnum);
322        }
323        ;
324
325/*
326 */
327procdefsg: procdeclsg proccode
328        {
329          if(debug>2)printf("SG-PROCDEF:\n");
330          write_singular_end(&module_def, yylineno);
331        }
332        | procdecl proccode procdeclexample
333        {
334          if(debug>2)printf("SG-PROCDEF mit example:\n");
335          fflush(module_def.fmtfp);
336          write_singular_end(&module_def, yylineno);
337        }
338;
339
340procdeclsg: procdeclsg2 '{'
341        {
342          setup_proc(&module_def, &procedure_decl);
343        }
344        | procdeclsg2 procdeclhelp '{'
345        {
346          setup_proc(&module_def, &procedure_decl);
347        }
348        ;
349
350procdeclsg2: procdecl1 '(' sgtypelist ')'
351         {
352           write_singular_parameter(&module_def, yylineno, "list", "#");
353           procedure_decl.lineno_other = yylineno;
354         }
355        | procdecl1
356         {
357           write_singular_parameter(&module_def, yylineno, "list", "#");
358           procedure_decl.lineno_other = yylineno;
359         }
360        | procdecl1 '(' ')'
361         {
362           write_singular_parameter(&module_def, yylineno, "list", "#");
363           procedure_decl.lineno_other = yylineno;
364         }
365        ;
366
367procdecl1: PROCDECLTOK NAME
368        {
369          init_proc(&procedure_decl, $2, NULL, yylineno, LANG_SINGULAR);
370          free($2);
371          if(write_singular_procedures(&module_def, &procedure_decl))
372            return(myyyerror("Error while creating bin-file\n"));
373        }
374        | STATICTOK PROCDECLTOK NAME
375        {
376          init_proc(&procedure_decl, $3, NULL, yylineno, LANG_SINGULAR);
377          procedure_decl.is_static = TRUE;
378          free($3);
379          if(write_singular_procedures(&module_def, &procedure_decl))
380            return(myyyerror("Error while creating bin-file\n"));
381        };
382
383procdef: procdecl proccode
384        {
385          if(debug>2)printf("PROCDEF:\n");
386        }
387        | procdecl proccode procdeclexample
388        {
389          if(debug>2)printf("PROCDEF mit example:\n");
390          fflush(module_def.fmtfp);
391        }
392        ;
393
394procdecl: procdecl2 '{'
395        {
396          setup_proc(&module_def, &procedure_decl);
397        }
398        | procdecl2 procdeclhelp '{'
399        {
400          setup_proc(&module_def, &procedure_decl);
401        }
402        ;
403
404procdecl2: funcdecl1
405        | funcdecl1 '(' ')'
406        | funcdecl1 '(' typelist ')';
407
408funcdecl1: VARTYPETOK NAME
409        {
410          if(debug>2)printf("funcdecl1-2\n");
411          init_proc(&procedure_decl, $2, &$1, yylineno);
412          free($2);
413        }
414        | STATICTOK VARTYPETOK NAME
415        {
416          if(debug>2)printf("funcdecl1-4\n");
417          init_proc(&procedure_decl, $3, &$2, yylineno);
418          free($3);
419          procedure_decl.is_static = TRUE;
420        };
421
422 
423procdeclhelp: MSTRINGTOK
424        {
425          procedure_decl.help_string = $1.string;
426          procedure_decl.lineno_other = $1.lineno;
427          if(debug>2)printf("\t\thelp at %d\n", yylineno);
428          write_help(&module_def, &procedure_decl);
429        }
430        ;
431
432proccode: proccodeline MCODETOK
433          {
434            write_function_errorhandling(&module_def, &procedure_decl);
435          };
436
437
438proccodeline: CODEPART
439        {
440          printf(">>>>(%d) %s<<<<\n", procedure_decl.flags.start_of_code, $1);
441          write_codeline(&module_def, &procedure_decl, $1, yylineno-1);
442        }
443        | proccodeline CODEPART
444        {
445          printf(">>>>(%d) %s<<<<\n", procedure_decl.flags.start_of_code, $2);
446          write_codeline(&module_def, &procedure_decl, $2);
447        }
448        | proccodeline CMTPART
449        {
450          printf(">>>>(%d) %s<<<<\n", procedure_decl.flags.start_of_code, $2);
451          write_codeline(&module_def, &procedure_decl, $2);
452        }
453        | proccodeline proccmd
454        {
455        };
456
457procdeclexample: examplestart '{' examplecodeline MCODETOK
458        {
459          write_example(&module_def, &procedure_decl);
460        }
461        ;
462
463examplestart: EXAMPLETOK
464        {
465          if(procedure_decl.procname == NULL) {
466            return(myyyerror("example without proc-declaration at line %d\n",
467                     yylineno));
468          }
469          if(debug>2)printf("Example at %d\n", yylineno);
470          procedure_decl.lineno_other = yylineno;
471        };
472 
473examplecodeline: CODEPART
474        {
475          int len = strlen($1);
476          procedure_decl.example_len = len;
477          procedure_decl.example_string = (char *)malloc(len+1);
478          memset(procedure_decl.example_string, 0, len+1);
479          memcpy(procedure_decl.example_string, $1, len);
480        }
481        | examplecodeline CODEPART
482        {
483          long len = strlen($2);
484          long newlen = procedure_decl.example_len + len;
485         
486          procedure_decl.example_string =
487            (char *)realloc((void *)procedure_decl.example_string, newlen+1);
488          memset(procedure_decl.example_string+procedure_decl.example_len,
489                 0, len+1);
490          memcpy(procedure_decl.example_string+procedure_decl.example_len,
491                 $2, len);
492          procedure_decl.example_len = newlen;
493          //strncat(procedure_decl.example_string, $2, strlen($2));
494          //procedure_decl.example_string[procedure_decl.example_len] = '\0';
495        };
496
497proccmd: '%' NAME ';'
498        { cmd_token vt;
499          void (*write_cmd)(moddefv module, procdefv pi, void *arg = NULL);
500         
501          switch(vt=checkcmd($2, &write_cmd, CMDT_SINGLE, 0)) {
502              case CMD_NONE:
503                return(myyyerror("Line %d: Unknown command '%s' in section %d\n",
504                          yylineno, $2, sectnum));
505                break;
506              case CMD_BADSYNTAX:
507                return(myyyerror("Line %d: bad syntax of command '%s' in section %d\n",
508                          yylineno, $2, sectnum));
509                break;
510
511              case CMD_DECL:
512              case CMD_CHECK:
513                procedure_decl.flags.auto_header = 0;
514              case CMD_NODECL:
515                write_cmd(&module_def, &procedure_decl);
516                break;
517
518              default:
519                write_function_header(&module_def, &procedure_decl);
520                write_cmd(&module_def, &procedure_decl);
521          }
522          free($2);
523        }
524        | '%' NAME '(' ')' ';'
525        {
526          cmd_token vt;
527          void (*write_cmd)(moddefv module, procdefv pi, void *arg = NULL);
528         
529          switch(vt=checkcmd($2, &write_cmd, CMDT_0, 1)) {
530              case CMD_NONE:
531                return(myyyerror("Line %d: Unknown command '%s' in section %d\n",
532                          yylineno, $2, sectnum));
533                break;
534              case CMD_BADSYNTAX:
535                return(myyyerror("Line %d: bad syntax of command '%s' in section %d\n",
536                          yylineno, $2, sectnum));
537                break;
538              default:
539                write_function_header(&module_def, &procedure_decl);
540              case CMD_DECL:
541              case CMD_CHECK:
542                write_cmd(&module_def, &procedure_decl);
543          }
544          free($2);
545        }
546        | '%' NAME '(' NAME ')' ';'
547        {
548          cmd_token vt;
549          void (*write_cmd)(moddefv module, procdefv pi, void *arg = NULL);
550         
551          switch(vt=checkcmd($2, &write_cmd, CMDT_ANY, 1)) {
552              case CMD_NONE:
553                return(myyyerror("Line %d: Unknown command '%s' in section %d\n",
554                          yylineno, $2, sectnum));
555                break;
556              case CMD_BADSYNTAX:
557                return(myyyerror("Line %d: bad syntax of command '%s' in section %d\n",
558                          yylineno, $2, sectnum));
559                break;
560              default:
561                write_function_header(&module_def, &procedure_decl);
562              case CMD_DECL:
563              case CMD_CHECK:
564                write_cmd(&module_def, &procedure_decl, $4);
565          }
566          free($2); free($4);
567        }
568        | '%' NAME '(' identifier '(' arglist ')' ')' ';'
569        {
570          cmd_token vt;
571          void (*write_cmd)(moddefv module, procdefv pi, void *arg = NULL);
572         
573          switch(vt=checkcmd($2, &write_cmd, CMDT_ANY, 1)) {
574              case CMD_NONE:
575                return(myyyerror("Line %d: Unknown command '%s' in section %d\n",
576                          yylineno, $2, sectnum));
577                break;
578              case CMD_BADSYNTAX:
579                return(myyyerror("Line %d: bad syntax of command '%s' in section %d\n",
580                          yylineno, $2, sectnum));
581                break;
582              default:
583                write_function_header(&module_def, &procedure_decl);
584              case CMD_DECL:
585              case CMD_CHECK:
586                write_cmd(&module_def, &procedure_decl, $4);
587          }
588          free($2);
589        }
590        | '%' NAME MEQUAL ANYTOK
591        {
592          cmd_token vt;
593          void (*write_cmd)(moddefv module, procdefv pi, void *arg = NULL);
594         
595          switch(vt=checkcmd($2, &write_cmd, CMDT_EQ, 0)) {
596              case CMD_NONE:
597                return(myyyerror("Line %d: Unknown command '%s' in section %d\n",
598                          yylineno, $2, sectnum));
599                break;
600              case CMD_BADSYNTAX:
601                return(myyyerror("Line %d: bad syntax of command '%s' in section %d\n",
602                          yylineno, $2, sectnum));
603                break;
604              default:
605                write_function_header(&module_def, &procedure_decl);
606              case CMD_DECL:
607              case CMD_CHECK:
608                write_cmd(&module_def, &procedure_decl, $4);
609          }
610          free($2);
611        };
612
613
614identifier: NAME
615        {
616          if(debug>2)printf("### ID ### Name %s\n", $1);
617          $$ = $1;
618        }
619        | identifier MCOLONCOLON NAME
620        {
621          int len = strlen($$) + strlen($3) + 2;
622          if(debug>2)printf("### ID ### Name %s\n", $3);
623          $$ = (char *)realloc($$, len);
624          strcat($$, "::");
625          strcat($$, $3);
626        };
627
628arglist: NAME
629        {
630          if(debug>2)printf("### ARGS %s\n", $1);
631        }
632        | arglist ',' NAME
633        {
634          if(debug>2)printf("### ARGS %s\n", $3);
635        };
636       
637sgtypelist: VARTYPETOK NAME
638        {
639          if(debug>2)printf("\tsgtypelist %s %s\n", $1.name, $2);
640          write_singular_parameter(&module_def, yylineno, $1.name, $2);
641          free($1.name);
642          free($2);
643        }
644        | VARTYPETOK '#'
645        {
646          if(debug>2)printf("\tsgtypelist %s %s\n", $1.name, $2);
647          write_singular_parameter(&module_def, yylineno, $1.name, "#");
648          free($1.name);
649        }
650        | sgtypelist ',' VARTYPETOK NAME
651        {
652          if(debug>2)printf("\tsgtypelist next  %s %s\n", $3.name, $4);
653          write_singular_parameter(&module_def, yylineno, $3.name, $4);
654          free($3.name);
655          free($4);
656        }
657        | sgtypelist ',' VARTYPETOK '#'
658        {
659          if(debug>2)printf("\tsgtypelist next  %s %s\n", $3.name, $4);
660          write_singular_parameter(&module_def, yylineno, $3.name, "#");
661          free($3.name);
662        }
663        ;
664
665typelist: VARTYPETOK
666        {
667          AddParam(&procedure_decl, &$1);
668          free($1.name);
669        }
670        | VARTYPETOK NAME
671        {
672          if(check_reseverd($2))
673            return(myyyerror("Line %d: variablename '%s' is reserved\n",
674                            yylineno, $2));
675          AddParam(&procedure_decl, &$1, $2);
676          free($1.name); free($2);
677        }
678        | typelist ',' VARTYPETOK
679        {
680          AddParam(&procedure_decl, &$3);
681          free($3.name);
682        }
683        | typelist ',' VARTYPETOK NAME
684        {
685          if(check_reseverd($4))
686            return(myyyerror("Line %d: variablename '%s' is reserved\n",
687                            yylineno, $4));
688          AddParam(&procedure_decl, &$3, $4);
689          free($3.name); free($4);
690        }
691        ;
692
693sect4:  SECT4START codeline SECT4END
694        {
695          fprintf(module_def.modfp, "%s", $2);
696        };
697
698codeline: CODEPART
699        {
700          fprintf(module_def.modfp, "#line %d \"%s\"\n",
701                                          yylineno, module_def.filename);
702        }
703        | codeline CODEPART
704        {
705        }
706        ;
707
708
709%%
710
Note: See TracBrowser for help on using the repository browser.