projects / Faustine.git / blob
? search:


e198f7737eaaf8afce2b3f5b12154678db68552c
[Faustine.git] / interpretor / faust-0.9.47mr3 / compiler / parser / faustparser.y
1 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4 -*- */
2
3 /* Parser for the Faust language */
4
5 %{
6
7 #include "tree.hh"
8 #include "xtended.hh"
9 #include "boxes.hh"
10 #include "prim2.hh"
11 #include "signals.hh"
12 #include "errormsg.hh"
13 #include "sourcereader.hh"
14 #include "doc.hh"
15 #include "ppbox.hh"
16
17 #include <string>
18 #include <list>
19
20 #define YYDEBUG 1
21 #define YYERROR_VERBOSE 1
22 #define YYMAXDEPTH 100000
23
24 using namespace std;
25
26 extern char* yytext;
27 extern const char* yyfilename;
28 extern int yylineno;
29 extern int yyerr;
30 extern Tree gResult;
31 extern bool gStripDocSwitch;
32 extern bool gLstDependenciesSwitch;
33 extern bool gLstDistributedSwitch;
34 extern bool gLstMdocTagsSwitch;
35
36 extern map<Tree, set<Tree> > gMetaDataSet;
37 extern vector<Tree> gDocVector;
38
39
40 int yylex();
41
42 //----------------------------------------------------------
43 // unquote() : remove enclosing quotes and carriage return
44 // characters from string. Returns a Tree
45 //----------------------------------------------------------
46 char replaceCR(char c)
47 {
48 return (c!='\n') ? c : ' ';
49 }
50
51 Tree unquote(char* str)
52 {
53 //-----------copy unquoted filename-------------
54 char buf[512];
55 int j=0;
56
57 if (str[0] == '"') {
58 //it is a quoted string, we remove the quotes
59 for (int i=1; j<511 && str[i];) {
60 buf[j++] = replaceCR(str[i++]);
61 }
62 // remove last quote
63 if (j>0) buf[j-1] = 0;
64 } else {
65 for (int i=0; j<511 && str[i];) {
66 buf[j++] = replaceCR(str[i++]);
67 }
68 }
69 buf[j] = 0;
70
71 return tree(buf);
72 //----------------------------------------------
73 }
74
75 %}
76
77
78 %union {
79 CTree* exp;
80 char* str;
81 string* cppstr;
82 bool b;
83 }
84
85 %start program
86
87 /* With local environment (lowest priority)*/
88 %left WITH
89
90 /* Block Diagram Algebra */
91 /*%left SEQ SPLIT MIX*/
92 %right SPLIT MIX
93 %right SEQ
94 %right PAR
95 %left REC
96
97 /* Primitive boxes */
98
99 %left LT LE EQ GT GE NE
100
101 %left ADD SUB OR
102 %left MUL DIV MOD AND XOR LSH RSH
103 %left POWOP
104 %left FDELAY
105 %left DELAY1
106 %left APPL DOT
107
108 %left HASH
109
110 %token MEM
111 %token PREFIX
112
113 %token INTCAST
114 %token FLOATCAST
115 %token FFUNCTION
116 %token FCONSTANT
117 %token FVARIABLE
118
119 %token BUTTON
120 %token CHECKBOX
121 %token VSLIDER
122 %token HSLIDER
123 %token NENTRY
124 %token VGROUP
125 %token HGROUP
126 %token TGROUP
127
128 %token HBARGRAPH
129 %token VBARGRAPH
130 %token ATTACH
131
132
133 %token ACOS
134 %token ASIN
135 %token ATAN
136 %token ATAN2
137 %token COS
138 %token SIN
139 %token TAN
140
141 %token EXP
142 %token LOG
143 %token LOG10
144 %token POWFUN
145 %token SQRT
146
147 %token ABS
148 %token MIN
149 %token MAX
150
151 %token FMOD
152 %token REMAINDER
153
154 %token FLOOR
155 %token CEIL
156 %token RINT
157
158
159
160 %token RDTBL
161 %token RWTBL
162
163 %token SELECT2
164 %token SELECT3
165
166 %token INT
167 %token FLOAT
168
169
170 %token LAMBDA
171 %token DOT
172
173 %token WIRE
174 %token CUT
175 %token ENDDEF
176 %token VIRG
177 %right LPAR
178 %left RPAR
179 %right LBRAQ
180 %left RBRAQ
181 %right LCROC
182 %left RCROC
183 %token WITH
184 %token DEF
185
186 %token IMPORT
187 %token COMPONENT
188 %token LIBRARY
189 %token ENVIRONMENT
190
191 %token IPAR
192 %token ISEQ
193 %token ISUM
194 %token IPROD
195
196 %token STRING
197 %token FSTRING
198 %token IDENT
199 %token EXTRA
200
201 %token DECLARE
202
203 %token CASE
204 %token ARROW
205
206 %token VECTORIZE
207 %token SERIALIZE
208 %token HASH
209 %token RATE
210 %token UPSAMPLE
211 %token DOWNSAMPLE
212
213 /* Begin and End tags for documentations, equations and diagrams */
214 %token BDOC
215 %token EDOC
216 %token BEQN
217 %token EEQN
218 %token BDGM
219 %token EDGM
220 %token BLST
221 %token ELST
222 %token BMETADATA
223 %token EMETADATA
224 %token <cppstr> DOCCHAR
225 %token NOTICE
226 %token LISTING
227
228 %token LSTTRUE
229 %token LSTFALSE
230 %token LSTDEPENDENCIES
231 %token LSTMDOCTAGS
232 %token LSTDISTRIBUTED
233 %token LSTEQ
234 %token LSTQ
235
236
237 %type <exp> program
238
239 %type <exp> stmtlist
240 %type <exp> statement
241
242 %type <exp> deflist
243 %type <exp> definition
244
245 %type <exp> params
246
247 %type <exp> expression
248
249 %type <exp> defname
250 %type <exp> infixexp
251 %type <exp> primitive
252 %type <exp> argument
253 %type <exp> arglist
254
255 %type <exp> ident
256 %type <exp> name
257
258 %type <exp> ffunction
259 %type <exp> fconst
260 %type <exp> fvariable
261 %type <exp> signature
262 %type <exp> string
263 %type <exp> uqstring
264 %type <exp> fstring
265 %type <exp> type
266 %type <exp> typelist
267 %type <exp> fun
268
269 %type <exp> fpar
270 %type <exp> fseq
271 %type <exp> fsum
272 %type <exp> fprod
273
274 %type <exp> button
275 %type <exp> checkbox
276 %type <exp> vslider
277 %type <exp> hslider
278 %type <exp> nentry
279 %type <exp> vgroup
280 %type <exp> hgroup
281 %type <exp> tgroup
282
283 %type <exp> vbargraph
284 %type <exp> hbargraph
285
286 %type <exp> rule
287 %type <exp> rulelist
288
289 %type <exp> doc
290 %type <exp> docelem
291 %type <cppstr> doctxt
292 %type <exp> doceqn
293 %type <exp> docdgm
294 %type <exp> docntc
295 %type <exp> doclst
296 %type <exp> docmtd
297
298 %type <exp> lstattrlist
299 %type <exp> lstattrdef
300 %type <b> lstattrval
301
302
303
304
305
306 %% /* grammar rules and actions follow */
307
308 program : stmtlist { $$ = $1; gResult = formatDefinitions($$); }
309 ;
310
311 stmtlist : /*empty*/ { $$ = nil; }
312 | stmtlist statement { $$ = cons ($2,$1); }
313
314 deflist : /*empty*/ { $$ = nil; }
315 | deflist definition { $$ = cons ($2,$1); }
316 ;
317
318 statement : IMPORT LPAR uqstring RPAR ENDDEF { $$ = importFile($3); }
319 | DECLARE name string ENDDEF { declareMetadata($2,$3); $$ = nil; }
320 | definition { $$ = $1; }
321 | BDOC doc EDOC { declareDoc($2); $$ = nil; /* cerr << "Yacc : doc : " << *$2 << endl; */ }
322 ;
323
324 doc : /* empty */ { $$ = nil; }
325 | doc docelem { $$ = cons ($2,$1); }
326 ;
327
328 docelem : doctxt { $$ = docTxt($1->c_str()); delete $1; }
329 | doceqn { $$ = docEqn($1); }
330 | docdgm { $$ = docDgm($1); }
331 | docntc { $$ = docNtc(); }
332 | doclst { $$ = docLst(); }
333 | docmtd { $$ = docMtd($1); }
334 ;
335
336 doctxt : /* empty */ { $$ = new string(); }
337 | doctxt DOCCHAR { $$ = &($1->append(yytext)); }
338 ;
339
340 doceqn : BEQN expression EEQN { $$ = $2; }
341 ;
342
343 docdgm : BDGM expression EDGM { $$ = $2; }
344 ;
345
346 docntc : NOTICE { }
347 ;
348
349 doclst : BLST lstattrlist ELST { }
350 ;
351
352 lstattrlist : /* empty */ { }
353 | lstattrlist lstattrdef { }
354 ;
355
356 lstattrdef : LSTDEPENDENCIES LSTEQ LSTQ lstattrval LSTQ { gLstDependenciesSwitch = $4; }
357 | LSTMDOCTAGS LSTEQ LSTQ lstattrval LSTQ { gStripDocSwitch = $4; gStripDocSwitch==true ? gStripDocSwitch=false : gStripDocSwitch=true; }
358 | LSTDISTRIBUTED LSTEQ LSTQ lstattrval LSTQ { gLstDistributedSwitch = $4; }
359 ;
360
361 lstattrval : LSTTRUE { $$ = true; }
362 | LSTFALSE { $$ = false; }
363 ;
364
365 docmtd : BMETADATA name EMETADATA { $$ = $2; }
366 ;
367
368 definition : defname LPAR arglist RPAR DEF expression ENDDEF { $$ = cons($1,cons($3,$6)); }
369 | defname DEF expression ENDDEF { $$ = cons($1,cons(nil,$3)); }
370 | error ENDDEF { $$ = nil; yyerr++; }
371 ;
372
373 defname : ident { $$=$1; setDefProp($1, yyfilename, yylineno); }
374 ;
375
376 params : ident { $$ = cons($1,nil); }
377 | params PAR ident { $$ = cons($3,$1); }
378 ;
379
380 expression : expression WITH LBRAQ deflist RBRAQ { $$ = boxWithLocalDef($1,formatDefinitions($4)); }
381 | expression PAR expression { $$ = boxPar($1,$3); }
382 | expression SEQ expression { $$ = boxSeq($1,$3); }
383 | expression SPLIT expression { $$ = boxSplit($1,$3); }
384 | expression MIX expression { $$ = boxMerge($1,$3); }
385 | expression REC expression { $$ = boxRec($1,$3); }
386 | infixexp { $$ = $1; }
387 ;
388
389 infixexp : infixexp ADD infixexp { $$ = boxSeq(boxPar($1,$3),boxPrim2(sigAdd)); }
390 | infixexp SUB infixexp { $$ = boxSeq(boxPar($1,$3),boxPrim2(sigSub)); }
391 | infixexp MUL infixexp { $$ = boxSeq(boxPar($1,$3),boxPrim2(sigMul)); }
392 | infixexp DIV infixexp { $$ = boxSeq(boxPar($1,$3),boxPrim2(sigDiv)); }
393 | infixexp MOD infixexp { $$ = boxSeq(boxPar($1,$3),boxPrim2(sigRem)); }
394 | infixexp POWOP infixexp { $$ = boxSeq(boxPar($1,$3),gPowPrim->box()); }
395 | infixexp FDELAY infixexp { $$ = boxSeq(boxPar($1,$3),boxPrim2(sigFixDelay)); }
396 | infixexp DELAY1 { $$ = boxSeq($1,boxPrim1(sigDelay1)); }
397 | infixexp DOT ident { $$ = boxAccess($1,$3); }
398
399 | infixexp AND infixexp { $$ = boxSeq(boxPar($1,$3),boxPrim2(sigAND)); }
400 | infixexp OR infixexp { $$ = boxSeq(boxPar($1,$3),boxPrim2(sigOR)); }
401 | infixexp XOR infixexp { $$ = boxSeq(boxPar($1,$3),boxPrim2(sigXOR)); }
402
403 | infixexp LSH infixexp { $$ = boxSeq(boxPar($1,$3),boxPrim2(sigLeftShift)); }
404 | infixexp RSH infixexp { $$ = boxSeq(boxPar($1,$3),boxPrim2(sigRightShift)); }
405
406 | infixexp LT infixexp { $$ = boxSeq(boxPar($1,$3),boxPrim2(sigLT)); }
407 | infixexp LE infixexp { $$ = boxSeq(boxPar($1,$3),boxPrim2(sigLE)); }
408 | infixexp GT infixexp { $$ = boxSeq(boxPar($1,$3),boxPrim2(sigGT)); }
409 | infixexp GE infixexp { $$ = boxSeq(boxPar($1,$3),boxPrim2(sigGE)); }
410 | infixexp EQ infixexp { $$ = boxSeq(boxPar($1,$3),boxPrim2(sigEQ)); }
411 | infixexp NE infixexp { $$ = boxSeq(boxPar($1,$3),boxPrim2(sigNE)); }
412
413 | infixexp HASH infixexp { $$ = boxSeq(boxPar($1,$3),boxPrim2(sigConcat)); }
414
415 | infixexp LPAR arglist RPAR %prec APPL { $$ = buildBoxAppl($1,$3); }
416 | infixexp LCROC deflist RCROC %prec APPL { $$ = boxModifLocalDef($1,formatDefinitions($3)); }
417
418 | primitive { $$ = $1; }
419 ;
420
421 primitive : INT { $$ = boxInt(atoi(yytext)); }
422 | FLOAT { $$ = boxReal(atof(yytext)); }
423
424 | ADD INT { $$ = boxInt (atoi(yytext)); }
425 | ADD FLOAT { $$ = boxReal(atof(yytext)); }
426
427 | SUB INT { $$ = boxInt ( -atoi(yytext) ); }
428 | SUB FLOAT { $$ = boxReal( -atof(yytext) ); }
429
430 | WIRE { $$ = boxWire(); }
431 | CUT { $$ = boxCut(); }
432
433 | MEM { $$ = boxPrim1(sigDelay1); }
434 | PREFIX { $$ = boxPrim2(sigPrefix); }
435
436 | INTCAST { $$ = boxPrim1(sigIntCast); }
437 | FLOATCAST { $$ = boxPrim1(sigFloatCast); }
438
439 | ADD { $$ = boxPrim2(sigAdd); }
440 | SUB { $$ = boxPrim2(sigSub); }
441 | MUL { $$ = boxPrim2(sigMul); }
442 | DIV { $$ = boxPrim2(sigDiv); }
443 | MOD { $$ = boxPrim2(sigRem); }
444 | FDELAY { $$ = boxPrim2(sigFixDelay); }
445
446 | AND { $$ = boxPrim2(sigAND); }
447 | OR { $$ = boxPrim2(sigOR); }
448 | XOR { $$ = boxPrim2(sigXOR); }
449
450 | LSH { $$ = boxPrim2(sigLeftShift); }
451 | RSH { $$ = boxPrim2(sigRightShift); }
452
453 | LT { $$ = boxPrim2(sigLT); }
454 | LE { $$ = boxPrim2(sigLE); }
455 | GT { $$ = boxPrim2(sigGT); }
456 | GE { $$ = boxPrim2(sigGE); }
457 | EQ { $$ = boxPrim2(sigEQ); }
458 | NE { $$ = boxPrim2(sigNE); }
459
460 | ATTACH { $$ = boxPrim2(sigAttach); }
461
462 | ACOS { $$ = gAcosPrim->box(); }
463 | ASIN { $$ = gAsinPrim->box(); }
464 | ATAN { $$ = gAtanPrim->box(); }
465 | ATAN2 { $$ = gAtan2Prim->box(); }
466 | COS { $$ = gCosPrim->box(); }
467 | SIN { $$ = gSinPrim->box(); }
468 | TAN { $$ = gTanPrim->box(); }
469
470 | EXP { $$ = gExpPrim->box(); }
471 | LOG { $$ = gLogPrim->box(); }
472 | LOG10 { $$ = gLog10Prim->box(); }
473 | POWOP { $$ = gPowPrim->box(); }
474 | POWFUN { $$ = gPowPrim->box(); }
475 | SQRT { $$ = gSqrtPrim->box(); }
476
477 | ABS { $$ = gAbsPrim->box(); }
478 | MIN { $$ = gMinPrim->box(); }
479 | MAX { $$ = gMaxPrim->box(); }
480
481 | FMOD { $$ = gFmodPrim->box(); }
482 | REMAINDER { $$ = gRemainderPrim->box(); }
483
484 | FLOOR { $$ = gFloorPrim->box(); }
485 | CEIL { $$ = gCeilPrim->box(); }
486 | RINT { $$ = gRintPrim->box(); }
487
488
489 | RDTBL { $$ = boxPrim3(sigReadOnlyTable); }
490 | RWTBL { $$ = boxPrim5(sigWriteReadTable); }
491
492 | SELECT2 { $$ = boxPrim3(sigSelect2); }
493 | SELECT3 { $$ = boxPrim4(sigSelect3); }
494
495 | VECTORIZE { $$ = boxPrim2(sigVectorize); }
496 | SERIALIZE { $$ = boxPrim1(sigSerialize); }
497 | HASH { $$ = boxPrim2(sigConcat); }
498
499 | UPSAMPLE { $$ = boxPrim2(sigUpSample); }
500 | DOWNSAMPLE { $$ = boxPrim2(sigDownSample); }
501
502 | LCROC RCROC { $$ = boxPrim2(sigVectorAt); }
503 | LCROC infixexp RCROC { $$ = boxSeq(boxPar(boxWire(),$2),boxPrim2(sigVectorAt)); }
504
505 | ident { $$ = $1; }
506 | SUB ident { $$ = boxSeq(boxPar(boxInt(0),$2),boxPrim2(sigSub)); }
507
508 | LPAR expression RPAR { $$ = $2; }
509 | LAMBDA LPAR params RPAR DOT LPAR expression RPAR
510 { $$ = buildBoxAbstr($3,$7); }
511
512 | CASE LBRAQ rulelist RBRAQ { $$ = boxCase(checkRulelist($3)); }
513
514 | ffunction { $$ = boxFFun($1); }
515 | fconst { $$ = $1; }
516 | fvariable { $$ = $1; }
517 | COMPONENT LPAR uqstring RPAR { $$ = boxComponent($3); }
518 | LIBRARY LPAR uqstring RPAR { $$ = boxLibrary($3); }
519 | ENVIRONMENT LBRAQ deflist RBRAQ { $$ = boxWithLocalDef(boxEnvironment(),formatDefinitions($3)); }
520
521 | button { $$ = $1; }
522 | checkbox { $$ = $1; }
523 | vslider { $$ = $1; }
524 | hslider { $$ = $1; }
525 | nentry { $$ = $1; }
526 | vgroup { $$ = $1; }
527 | hgroup { $$ = $1; }
528 | tgroup { $$ = $1; }
529 | vbargraph { $$ = $1; }
530 | hbargraph { $$ = $1; }
531
532 | fpar { $$ = $1; }
533 | fseq { $$ = $1; }
534 | fsum { $$ = $1; }
535 | fprod { $$ = $1; }
536 ;
537
538
539 ident : IDENT { $$ = boxIdent(yytext); }
540 ;
541
542 name : IDENT { $$ = tree(yytext); }
543 ;
544
545
546
547 arglist : argument { $$ = cons($1,nil); }
548 | arglist PAR argument { $$ = cons($3,$1); }
549 ;
550
551 argument : argument SEQ argument { $$ = boxSeq($1,$3); }
552 | argument SPLIT argument { $$ = boxSplit($1,$3); }
553 | argument MIX argument { $$ = boxMerge($1,$3); }
554 | argument REC argument { $$ = boxRec($1,$3); }
555 | infixexp { $$ = $1; }
556 ;
557
558 string : STRING { $$ = tree(yytext); }
559 ;
560
561 uqstring : STRING { $$ = unquote(yytext); }
562 ;
563
564 fstring : STRING { $$ = tree(yytext); }
565 | FSTRING { $$ = tree(yytext); }
566 ;
567
568 /* description of iterative expressions */
569
570 fpar : IPAR LPAR ident PAR argument PAR expression RPAR
571 { $$ = boxIPar($3,$5,$7); }
572 ;
573
574 fseq : ISEQ LPAR ident PAR argument PAR expression RPAR
575 { $$ = boxISeq($3,$5,$7); }
576 ;
577
578 fsum : ISUM LPAR ident PAR argument PAR expression RPAR
579 { $$ = boxISum($3,$5,$7); }
580 ;
581
582 fprod : IPROD LPAR ident PAR argument PAR expression RPAR
583 { $$ = boxIProd($3,$5,$7); }
584 ;
585
586
587 /* description of foreign functions */
588
589 ffunction : FFUNCTION LPAR signature PAR fstring PAR string RPAR
590 { $$ = ffunction($3,$5,$7); }
591 ;
592
593 fconst : FCONSTANT LPAR type name PAR fstring RPAR
594 { $$ = boxFConst($3,$4,$6); }
595
596 fvariable : FVARIABLE LPAR type name PAR fstring RPAR
597 { $$ = boxFVar($3,$4,$6); }
598 ;
599
600 /* Description of user interface building blocks */
601 button : BUTTON LPAR uqstring RPAR { $$ = boxButton($3); }
602 ;
603
604 checkbox : CHECKBOX LPAR uqstring RPAR { $$ = boxCheckbox($3); }
605 ;
606
607 vslider : VSLIDER LPAR uqstring PAR argument PAR argument PAR argument PAR argument RPAR
608 { $$ = boxVSlider($3,$5,$7,$9,$11); }
609 ;
610 hslider : HSLIDER LPAR uqstring PAR argument PAR argument PAR argument PAR argument RPAR
611 { $$ = boxHSlider($3,$5,$7,$9,$11); }
612 ;
613 nentry : NENTRY LPAR uqstring PAR argument PAR argument PAR argument PAR argument RPAR
614 { $$ = boxNumEntry($3,$5,$7,$9,$11); }
615 ;
616 vgroup : VGROUP LPAR uqstring PAR expression RPAR
617 { $$ = boxVGroup($3, $5); }
618 ;
619 hgroup : HGROUP LPAR uqstring PAR expression RPAR
620 { $$ = boxHGroup($3, $5); }
621 ;
622 tgroup : TGROUP LPAR uqstring PAR expression RPAR
623 { $$ = boxTGroup($3, $5); }
624 ;
625
626 vbargraph : VBARGRAPH LPAR uqstring PAR argument PAR argument RPAR
627 { $$ = boxVBargraph($3,$5,$7); }
628 ;
629 hbargraph : HBARGRAPH LPAR uqstring PAR argument PAR argument RPAR
630 { $$ = boxHBargraph($3,$5,$7); }
631 ;
632
633 /* Description of foreign functions */
634
635 signature : type fun LPAR typelist RPAR { $$ = cons($1, cons($2, $4)); }
636 | type fun LPAR RPAR { $$ = cons($1, cons($2, nil)); }
637 ;
638
639 fun : IDENT { $$ = tree(yytext); }
640 ;
641
642 typelist : type { $$ = cons($1,nil); }
643 | typelist PAR type { $$ = cons($3,$1); }
644 ;
645
646 rulelist : rule { $$ = cons($1,nil); }
647 | rulelist rule { $$ = cons($2,$1); }
648 ;
649
650 rule : LPAR arglist RPAR ARROW expression ENDDEF
651 { $$ = cons($2,$5); }
652 ;
653
654 type : INTCAST { $$ = tree(0); }
655 | FLOATCAST { $$ = tree(1); }
656 ;
657
658 %%
659
An OCaml-based interpreter for Faust and its vector extension