root/src/ss_parser.y

Revision aaca19fb68c3cfe89e2acb105d2c3e8f5e028275, 26.1 kB (checked in by redbrain <redbrain@…>, 2 years ago)

bug fix on many references to single objects in a single context
  • Property mode set to 100644
Line 
1%{
2/**
3 * ss_parser.y -> Part of Crules Programming language
4 *
5 * Crules is the legal property of its developers. Please refer to the
6 * COPYRIGHT file distributed with this source distribution.
7 *
8 * This program is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
20 **/
21
22/**
23 * The parser crldot code generator!
24 * IMPORTANT: We require GNU/Bison to generate the parser now!
25 * Whoop
26 **/
27
28#ifdef HAVE_CONFIG_H
29# include "config.h"
30#else
31# define CMAKE 1
32# include "config.h.cmake"
33#endif
34
35#include <stdio.h>
36#include <stdlib.h>
37#include <string.h>
38
39#include <crules/crules.h>
40#include <crules/opcodes.h>
41#include <crules/symbols.h>
42#include <crules/objects.h>
43#include <crules/backend.h>
44#include <crules/runtime.h>
45#include <crules/garbage.h>
46#include <crules/operators.h>
47
48// to prototype's to get rid of warnings
49extern int yylex( void );
50extern void yyerror( const char * );
51
52extern bool crl_interactive;
53extern int yylineno;
54
55 bool crl_parse_error = false;
56
57// Helps build up symbol tables to have
58// pointers at heads of tables etc
59crl_stack_t *crl_parse_stk= NULL;
60// very important keeps stack frames for localization
61extern crl_context_table *crl_runtime_ctx_table;
62%}
63
64%union {
65  char *string;
66  unsigned char character;
67  long int integer;
68  long double floating_point;
69  //for internal rules
70  crl_symbol_obj *symbol;
71  crl_table_t *list;
72  crl_stack_t *stack;
73}
74
75%error-verbose
76
77%token OBJECT "object"
78%token DEFUN  "defun"
79
80%token BREAK  "break"
81%token CONTINUE "conintue"
82%token RETURN "return"
83%token WHILE "while"
84%token FOR "for"
85%token NEW "new"
86
87%token IF "if"
88%token ELIF "elif"
89%token ELSE "else"
90%token TRUE "true"
91%token FALSE "false"
92%token NIL "nil"
93
94%token INT_T "Int"
95%token FLOAT_T "Float"
96%token CHAR_T "Char"
97%token STRING_T "String"
98%token LIST_T "List"
99%token OBJECT_T "Object"
100%token CALLBACK_T "Callback"
101%token VARADIC_T "..."
102
103%token OR "||"
104%token AND "&&"
105%token EQUAL "=="
106%token PLUS_EQUAL "+="
107%token MULTIPLY_EQUAL "*="
108%token MINUS_EQUAL "-="
109%token DIVIDE_EQUAL "/="
110%token NOT_EQUAL "!="
111%token LESS "<"
112%token LESS_EQUAL "<="
113%token GREATER ">"
114%token GREATER_EQUAL ">="
115%token PLUSPLUS "++"
116%token MINMIN "--"
117
118%token<character> CHAR
119%token<string> STRING
120%token<integer> INTEGER
121%token<floating_point> DOUBLE
122%token<string> IDENTIFIER
123
124%type<symbol> primitive
125%type<symbol> expression
126%type<symbol> accessor
127%type<symbol> symbol_accessor
128%type<symbol> member_accessor
129%type<symbol> dot_accessor
130%type<symbol> dot_accessor__
131%type<symbol> object_creation
132%type<symbol> express
133%type<symbol> statement
134%type<symbol> arbitrary_call
135%type<symbol> break_keyword
136%type<symbol> return_keyword
137%type<symbol> continue_keyword
138%type<symbol> procedure
139%type<symbol> pblock
140%type<symbol> function_definition
141%type<symbol> class_definition
142%type<symbol> loop_while
143%type<symbol> loop_for
144%type<symbol> control_structure
145%type<symbol> struct_if struct_elif struct_else
146%type<symbol> elif_block else_block struct_elif_block
147%type<symbol> conditionals
148%type<symbol> list_symbol
149%type<symbol> param_type
150
151%type<stack> arguments
152%type<stack> parameters
153
154%left '-' '+'
155%left '*' '/'
156%left LESS LESS_EQUAL
157%left GREATER GREATER_EQUAL
158%left NOT_EQUAL EQUAL
159%left AND OR
160%right '^' '='
161%nonassoc UMINUS
162%right PLUSPLUS MINMIN
163%right PLUS_EQUAL MINUS_EQUAL
164%right MULTIPLY_EQUAL DIVIDE_EQUAL
165
166%start declarations
167
168%%
169
170declarations:
171            | declarations statement
172            {
173              crl_runtime_exec_toplevel( $2, crl_runtime_ctx_table );
174              if( !crl_parse_error )
175                {
176                  if( (( $2->type != STRUCTURE_FUNCTION_DEF) &&
177                       ($2->type != STRUCTURE_OBJECT_DEF)) )
178                    {
179                      crl_garbage_mark_obj( &$2 );
180                    }
181                }
182              else
183                {
184                  if( crl_interactive )
185                    {
186                      crl_parse_error = false;
187                      crl_garbage_mark_obj( &$2 );
188                    }
189                }
190            }
191            | error
192            {
193              crl_error("malformed declaration!\n");
194              crl_parse_error = true;
195            }
196            ;
197
198class_definition: OBJECT IDENTIFIER '{' procedure '}'
199            {
200              crl_symbol_obj *sym;
201              Crl_Symbol_Init( sym );
202
203              sym->type = STRUCTURE_OBJECT_DEF;
204              sym->op_a_t = TYPE_STRING;
205              sym->op_b_t = TYPE_SYMBOL;
206
207              sym->op_a.string = $2;
208              sym->op_b.symbol_table = $4;
209              $$ = sym;
210            }
211            ;
212
213object_creation: NEW arbitrary_call
214            {
215              crl_symbol_obj *sym;
216              Crl_Symbol_Init( sym );
217
218              sym->exp = OP_EXPRESS;
219              sym->type = OP_NEW_OBJ;
220              sym->op_a_t = TYPE_SYMBOL;
221              sym->op_a.symbol_table = $2;
222
223              $$ = sym;
224            }
225            ;
226
227dot_accessor__: dot_accessor__ '.' accessor
228              {
229                crl_symbol_obj * t1;
230                Crl_Symbol_Init( t1 );
231
232                t1->exp = OP_EXPRESS;
233                t1->type = OP_BIN_ACCESSOR;
234                t1->op_a_t = TYPE_SYMBOL;
235                t1->op_a.symbol_table = $1;
236
237                t1->op_b_t = TYPE_SYMBOL;
238                t1->op_b.symbol_table = $3;
239
240                $$ = t1;
241              }
242              | accessor
243              {
244                $$ = $1;
245              }
246              ;
247
248dot_accessor: dot_accessor__
249            {
250              $$ = $1;
251            }
252            ;
253
254member_accessor: dot_accessor
255            ;
256
257accessor: symbol_accessor
258        | arbitrary_call
259        ;
260
261symbol_accessor:
262        IDENTIFIER
263        {
264          crl_symbol_obj *sym;
265          Crl_Symbol_Init( sym );
266
267          sym->type= SYMBOL_REFERENCE;
268          sym->op_a_t= TYPE_STRING;
269
270          sym->op_a.string= $1;
271          $$= sym;
272        }
273        | IDENTIFIER '[' expression ']'
274        {
275          crl_symbol_obj* sym;
276          Crl_Symbol_Init( sym );
277
278          sym->type= SYMBOL_INDEX_REF;
279          sym->op_a_t= TYPE_STRING;
280          sym->op_b_t= TYPE_SYMBOL;
281
282          sym->op_a.string= $1;
283          sym->op_b.symbol_table= $3;
284          $$= sym;
285        }
286        ;
287
288function_definition:
289          DEFUN IDENTIFIER '{' procedure '}'
290          {
291            crl_symbol_obj *sym;
292            Crl_Symbol_Init( sym );
293
294            sym->identifier= $2;
295            sym->type= STRUCTURE_FUNCTION_DEF;
296            sym->op_a_t= TYPE_SYMBOL;
297            sym->op_b_t= TYPE_PARAMETERS_ANON;
298
299            sym->op_a.symbol_table= $4;
300            $$= sym;
301          }
302          | DEFUN IDENTIFIER '(' ')' '{' procedure '}'
303          {
304            crl_symbol_obj *sym;
305            Crl_Symbol_Init( sym );
306
307            sym->identifier= $2;
308            sym->type= STRUCTURE_FUNCTION_DEF;
309            sym->op_a_t= TYPE_SYMBOL;
310            sym->op_b_t= TYPE_SYMBOL_NIL;
311
312            sym->op_a.symbol_table= $6;
313            $$= sym;
314          }
315          | DEFUN IDENTIFIER '(' parameters ')' '{' procedure '}'
316          {
317            crl_symbol_obj *sym;
318            Crl_Symbol_Init( sym );
319
320            sym->identifier= $2;
321            sym->type= STRUCTURE_FUNCTION_DEF;
322            sym->op_a_t= TYPE_SYMBOL;
323            sym->op_b_t= TYPE_PARAMETERS;
324
325            sym->op_a.symbol_table= $7;
326            sym->op_b.stack_table= $4;
327            $$= sym;
328          }
329          ;
330
331expression: express
332         ;
333
334express: symbol_accessor '=' express
335        {
336          crl_symbol_obj *sym;
337          Crl_Symbol_Init( sym );
338
339          sym->exp= OP_EXPRESS;
340          sym->type= OP_ASSIGN_EVAL;
341          sym->op_a_t= TYPE_SYMBOL;
342          sym->op_b_t= TYPE_SYMBOL;
343
344          sym->op_a.symbol_table= $1;
345          sym->op_b.symbol_table= $3;
346          $$= sym;
347        }
348        | express '+' express
349        {
350          crl_symbol_obj* sym;
351          Crl_Symbol_Init( sym );
352
353          sym->exp= OP_EXPRESS;
354          sym->type= OP_BIN_ADDITION;
355          sym->op_a_t= TYPE_SYMBOL;
356          sym->op_b_t= TYPE_SYMBOL;
357
358          sym->op_a.symbol_table= $1;
359          sym->op_b.symbol_table= $3;
360          $$= sym;
361        }
362        | express '-' express
363        {
364          crl_symbol_obj* sym;
365          Crl_Symbol_Init( sym );
366
367          sym->exp= OP_EXPRESS;
368          sym->type= OP_BIN_SUBTRACTION;
369          sym->op_a_t= TYPE_SYMBOL;
370          sym->op_b_t= TYPE_SYMBOL;
371
372          sym->op_a.symbol_table= $1;
373          sym->op_b.symbol_table= $3;
374          $$= sym;
375        }
376        | express '/' express
377        {
378          crl_symbol_obj* sym;
379          Crl_Symbol_Init( sym );
380
381          sym->exp= OP_EXPRESS;
382          sym->type= OP_BIN_DIVIDE;
383          sym->op_a_t= TYPE_SYMBOL;
384          sym->op_b_t= TYPE_SYMBOL;
385
386          sym->op_a.symbol_table= $1;
387          sym->op_b.symbol_table= $3;
388          $$= sym;
389        }
390        | express '*' express
391        {
392          crl_symbol_obj* sym;
393          Crl_Symbol_Init( sym );
394
395          sym->exp= OP_EXPRESS;
396          sym->type= OP_BIN_MULTIPLY;
397          sym->op_a_t= TYPE_SYMBOL;
398          sym->op_b_t= TYPE_SYMBOL;
399
400          sym->op_a.symbol_table= $1;
401          sym->op_b.symbol_table= $3;
402          $$= sym;
403        }
404        | express '^' express
405        {
406          crl_symbol_obj* sym;
407          Crl_Symbol_Init( sym );
408
409          sym->exp= OP_EXPRESS;
410          sym->type= OP_BIN_POWER;
411          sym->op_a_t= TYPE_SYMBOL;
412          sym->op_b_t= TYPE_SYMBOL;
413
414          sym->op_a.symbol_table= $1;
415          sym->op_b.symbol_table= $3;
416          $$= sym;
417        }
418        | express LESS express
419        {
420          crl_symbol_obj* sym;
421          Crl_Symbol_Init( sym );
422
423          sym->exp= OP_EXPRESS;
424          sym->type= OP_BIN_LESS;
425          sym->op_a_t= TYPE_SYMBOL;
426          sym->op_b_t= TYPE_SYMBOL;
427
428          sym->op_a.symbol_table= $1;
429          sym->op_b.symbol_table= $3;
430          $$= sym;
431        }
432        | express GREATER express
433        {
434          crl_symbol_obj* sym;
435          Crl_Symbol_Init( sym );
436
437          sym->exp= OP_EXPRESS;
438          sym->type= OP_BIN_GREATER;
439          sym->op_a_t= TYPE_SYMBOL;
440          sym->op_b_t= TYPE_SYMBOL;
441
442          sym->op_a.symbol_table= $1;
443          sym->op_b.symbol_table= $3;
444          $$= sym;
445        }
446        | express LESS_EQUAL express
447        {
448          crl_symbol_obj* sym;
449          Crl_Symbol_Init( sym );
450
451          sym->exp= OP_EXPRESS;
452          sym->type= OP_BIN_LESS_EQ;
453          sym->op_a_t= TYPE_SYMBOL;
454          sym->op_b_t= TYPE_SYMBOL;
455
456          sym->op_a.symbol_table= $1;
457          sym->op_b.symbol_table= $3;
458          $$= sym;
459        }
460        | express GREATER_EQUAL express
461        {
462          crl_symbol_obj* sym;
463          Crl_Symbol_Init( sym );
464
465          sym->exp= OP_EXPRESS;
466          sym->type= OP_BIN_GREATER_EQ;
467          sym->op_a_t= TYPE_SYMBOL;
468          sym->op_b_t= TYPE_SYMBOL;
469
470          sym->op_a.symbol_table= $1;
471          sym->op_b.symbol_table= $3;
472          $$= sym;
473        }
474        | express EQUAL express
475        {
476          crl_symbol_obj* sym;
477          Crl_Symbol_Init( sym );
478
479          sym->exp= OP_EXPRESS;
480          sym->type= OP_BIN_EQ_EQ;
481          sym->op_a_t= TYPE_SYMBOL;
482          sym->op_b_t= TYPE_SYMBOL;
483
484          sym->op_a.symbol_table= $1;
485          sym->op_b.symbol_table= $3;
486          $$= sym;
487        }
488        | express NOT_EQUAL express
489        {
490          crl_symbol_obj* sym;
491          Crl_Symbol_Init( sym );
492
493          sym->exp= OP_EXPRESS;
494          sym->type= OP_BIN_NOT_EQ;
495          sym->op_a_t= TYPE_SYMBOL;
496          sym->op_b_t= TYPE_SYMBOL;
497
498          sym->op_a.symbol_table= $1;
499          sym->op_b.symbol_table= $3;
500          $$= sym;
501        }
502        | express OR express
503        {
504          crl_symbol_obj* sym;
505          Crl_Symbol_Init( sym );
506
507          sym->exp= OP_EXPRESS;
508          sym->type= OP_BIN_OR;
509          sym->op_a_t= TYPE_SYMBOL;
510          sym->op_b_t= TYPE_SYMBOL;
511
512          sym->op_a.symbol_table= $1;
513          sym->op_b.symbol_table= $3;
514          $$= sym;
515        }
516        | express AND express
517        {
518          crl_symbol_obj* sym;
519          Crl_Symbol_Init( sym );
520
521          sym->exp= OP_EXPRESS;
522          sym->type= OP_BIN_AND;
523          sym->op_a_t= TYPE_SYMBOL;
524          sym->op_b_t= TYPE_SYMBOL;
525
526          sym->exp= OP_EXPRESS;
527          sym->op_a.symbol_table= $1;
528          sym->op_b.symbol_table= $3;
529          $$= sym;
530        }
531        | '-' express %prec UMINUS
532        {
533          crl_symbol_obj *opa, *sym;
534          Crl_Symbol_Init( opa );
535          Crl_Symbol_Init( sym );
536
537          opa->type= SYMBOL_PRIMARY;
538          opa->op_a_t= TYPE_INTEGER;
539          opa->op_a.integer= 0;
540
541          sym->exp= OP_EXPRESS;
542          sym->type= OP_BIN_SUBTRACTION;
543          sym->op_a_t= TYPE_SYMBOL;
544          sym->op_b_t= TYPE_SYMBOL;
545
546          sym->op_a.symbol_table= opa;
547          sym->op_b.symbol_table= $2;
548          $$= sym;
549        }
550        | symbol_accessor PLUSPLUS
551        {
552          crl_symbol_obj *opa, *opb;
553          Crl_Symbol_Init( opa );
554          Crl_Symbol_Init( opb );
555
556          opb->type = SYMBOL_PRIMARY;
557          opb->op_a_t = TYPE_INTEGER;
558          opb->op_a.integer = 1;
559
560          opa->exp= OP_EXPRESS;
561          opa->type= OP_BIN_ADDITION;
562          opa->op_a_t= TYPE_SYMBOL;
563          opa->op_b_t= TYPE_SYMBOL;
564
565          opa->op_a.symbol_table= $1;
566          opa->op_b.symbol_table= opb;
567
568          crl_symbol_obj *sym;
569          Crl_Symbol_Init( sym );
570         
571          sym->exp= OP_EXPRESS;
572          sym->type= OP_ASSIGN_EVAL;
573          sym->op_a_t= TYPE_SYMBOL;
574          sym->op_b_t= TYPE_SYMBOL;
575         
576          sym->op_a.symbol_table= crl_runtime_obj_clone( &$1 ,false );
577          sym->op_b.symbol_table= opa;
578          $$= sym;
579        }
580        | symbol_accessor MINMIN
581        {
582          crl_symbol_obj *opa, *opb;
583          Crl_Symbol_Init( opa );
584          Crl_Symbol_Init( opb );
585
586          opb->type = SYMBOL_PRIMARY;
587          opb->op_a_t = TYPE_INTEGER;
588          opb->op_a.integer = 1;
589
590          opa->exp= OP_EXPRESS;
591          opa->type= OP_BIN_SUBTRACTION;
592          opa->op_a_t= TYPE_SYMBOL;
593          opa->op_b_t= TYPE_SYMBOL;
594
595          opa->op_a.symbol_table= $1;
596          opa->op_b.symbol_table= opb;
597
598          crl_symbol_obj *sym;
599          Crl_Symbol_Init( sym );
600         
601          sym->exp= OP_EXPRESS;
602          sym->type= OP_ASSIGN_EVAL;
603          sym->op_a_t= TYPE_SYMBOL;
604          sym->op_b_t= TYPE_SYMBOL;
605         
606          sym->op_a.symbol_table= crl_runtime_obj_clone( &$1 ,false );
607          sym->op_b.symbol_table= opa;
608          $$= sym;
609        }
610        | symbol_accessor PLUS_EQUAL express
611        {
612          crl_symbol_obj *sym, *cpy, *exp;
613          Crl_Symbol_Init( sym );
614          Crl_Symbol_Init( exp );
615
616          cpy = crl_runtime_obj_clone( &$1, false );
617          sym->exp = OP_EXPRESS;
618          sym->type = OP_ASSIGN_EVAL;
619          sym->op_a_t = TYPE_SYMBOL;
620          sym->op_b_t = TYPE_SYMBOL;
621
622          exp->exp = OP_EXPRESS;
623          exp->type = OP_BIN_ADDITION;
624          exp->op_a_t = TYPE_SYMBOL;
625          exp->op_b_t = TYPE_SYMBOL;
626          exp->op_a.symbol_table = cpy;
627          exp->op_b.symbol_table = $3;
628
629          sym->op_a.symbol_table = $1;
630          sym->op_b.symbol_table = exp;
631          $$ = sym;
632        }
633        | symbol_accessor MINUS_EQUAL express
634        {
635          crl_symbol_obj *sym, *cpy, *exp;
636          Crl_Symbol_Init( sym );
637          Crl_Symbol_Init( exp );
638
639          cpy = crl_runtime_obj_clone( &$1, false );
640          sym->exp = OP_EXPRESS;
641          sym->type = OP_ASSIGN_EVAL;
642          sym->op_a_t = TYPE_SYMBOL;
643          sym->op_b_t = TYPE_SYMBOL;
644
645          exp->exp = OP_EXPRESS;
646          exp->type = OP_BIN_SUBTRACTION;
647          exp->op_a_t = TYPE_SYMBOL;
648          exp->op_b_t = TYPE_SYMBOL;
649          exp->op_a.symbol_table = cpy;
650          exp->op_b.symbol_table = $3;
651
652          sym->op_a.symbol_table = $1;
653          sym->op_b.symbol_table = exp;
654          $$ = sym;
655        }
656        | symbol_accessor MULTIPLY_EQUAL express
657        {
658          crl_symbol_obj *sym, *cpy, *exp;
659          Crl_Symbol_Init( sym );
660          Crl_Symbol_Init( exp );
661
662          cpy = crl_runtime_obj_clone( &$1, false );
663          sym->exp = OP_EXPRESS;
664          sym->type = OP_ASSIGN_EVAL;
665          sym->op_a_t = TYPE_SYMBOL;
666          sym->op_b_t = TYPE_SYMBOL;
667
668          exp->exp = OP_EXPRESS;
669          exp->type = OP_BIN_MULTIPLY;
670          exp->op_a_t = TYPE_SYMBOL;
671          exp->op_b_t = TYPE_SYMBOL;
672          exp->op_a.symbol_table = cpy;
673          exp->op_b.symbol_table = $3;
674
675          sym->op_a.symbol_table = $1;
676          sym->op_b.symbol_table = exp;
677          $$ = sym;
678        }
679        | symbol_accessor DIVIDE_EQUAL express
680        {
681          crl_symbol_obj *sym, *cpy, *exp;
682          Crl_Symbol_Init( sym );
683          Crl_Symbol_Init( exp );
684
685          cpy = crl_runtime_obj_clone( &$1, false );
686          sym->exp = OP_EXPRESS;
687          sym->type = OP_ASSIGN_EVAL;
688          sym->op_a_t = TYPE_SYMBOL;
689          sym->op_b_t = TYPE_SYMBOL;
690
691          exp->exp = OP_EXPRESS;
692          exp->type = OP_BIN_DIVIDE;
693          exp->op_a_t = TYPE_SYMBOL;
694          exp->op_b_t = TYPE_SYMBOL;
695          exp->op_a.symbol_table = cpy;
696          exp->op_b.symbol_table = $3;
697
698          sym->op_a.symbol_table = $1;
699          sym->op_b.symbol_table = exp;
700          $$ = sym;
701        }
702        | '(' express ')'
703        {
704          $$= $2;
705        }
706        | primitive
707        ;
708
709procedure: pblock
710         {
711           crl_symbol_obj* pph= (crl_symbol_obj*)
712             crl_dd_stack_pop( crl_parse_stk );
713           $$ = pph;
714         }
715         ;
716
717pblock: pblock statement
718        {
719          $1->next = $2;
720          $$ = $2;
721        }
722        | statement
723        {
724          if( !crl_parse_stk )
725            {
726              crl_parse_stk= (crl_stack_t*)
727                crl_malloc(sizeof(crl_stack_t));
728              crl_dd_stack_init( &crl_parse_stk );
729            }
730          crl_dd_stack_push( crl_parse_stk, $1 );
731          $$ = $1;
732        }
733        ;
734
735loop_while: WHILE '(' expression ')' '{' procedure '}'
736        {
737          crl_symbol_obj *sym;
738          Crl_Symbol_Init( sym );
739
740          sym->type= STRUCTURE_LOOP_WHILE;
741          sym->op_a_t= TYPE_SYMBOL;
742          sym->op_a.symbol_table= $3;
743          sym->op_b_t= TYPE_SYMBOL;
744          sym->op_b.symbol_table= $6;
745          $$= sym;
746        }
747        ;
748
749loop_for: FOR '(' expression ';' expression ';'
750          expression ')' '{' procedure '}'
751        {
752          crl_symbol_obj *sym;
753          Crl_Symbol_Init( sym );
754
755          crl_symbol_obj *ctx;
756          Crl_Symbol_Init( ctx );
757
758          ctx->type = TYPE_LOOP_CTX;
759          ctx->op_a_t = TYPE_SYMBOL;
760          ctx->op_b_t = TYPE_SYMBOL;
761          ctx->op_a.symbol_table = $5;
762          ctx->op_b.symbol_table = $3;
763          $3->next = $7;
764
765          sym->type= STRUCTURE_LOOP_FOR;
766          sym->op_a_t= TYPE_SYMBOL;
767          sym->op_b_t= TYPE_SYMBOL;
768          sym->op_a.symbol_table= ctx;
769          sym->op_b.symbol_table= $10;
770
771          $$= sym;
772        }
773        ;
774
775control_structure:
776          loop_while
777        | loop_for
778        | conditionals
779        | function_definition
780        | class_definition
781        ;
782
783struct_if: IF '(' expression ')' '{' procedure '}'
784        {;
785          crl_symbol_obj *sym;
786          Crl_Symbol_Init( sym );
787
788          sym->type= STRUCTURE_IF;
789          sym->op_a_t= TYPE_SYMBOL;
790          sym->op_b_t= TYPE_SYMBOL;
791          sym->op_a.symbol_table= $3;
792          sym->op_b.symbol_table= $6;
793          $$= sym;
794        }
795        ;
796
797struct_elif: ELIF '(' expression ')' '{' procedure '}'
798        {
799          crl_symbol_obj *sym;
800          Crl_Symbol_Init( sym );
801
802          sym->type= STRUCTURE_ELIF;
803          sym->op_a_t= TYPE_SYMBOL;
804          sym->op_b_t= TYPE_SYMBOL;
805          sym->op_a.symbol_table= $3;
806          sym->op_b.symbol_table= $6;
807          $$= sym;
808        }
809        ;
810
811struct_else: ELSE '{' procedure '}'
812        {
813          crl_symbol_obj *sym;
814          Crl_Symbol_Init( sym );
815
816          sym->type= STRUCTURE_ELSE;
817          sym->op_a_t= TYPE_SYMBOL;
818          sym->op_a.symbol_table= $3;
819          $$= sym;
820        }
821        ;
822
823struct_elif_block:
824        struct_elif_block struct_elif
825        {
826          $1->next= $2;
827          $$= $2;
828        }
829        | struct_elif
830        {
831          if( !crl_parse_stk )
832            {
833              crl_parse_stk= (crl_stack_t*)
834                crl_malloc( sizeof(crl_stack_t) );
835              crl_dd_stack_init( &crl_parse_stk );
836            }
837          crl_dd_stack_push( crl_parse_stk, $1 );
838          $$= $1;
839        }
840        ;
841
842elif_block:
843        {
844          $$= NULL;
845        }
846        | struct_elif_block
847        {
848          crl_symbol_obj *o= (crl_symbol_obj*)
849            crl_dd_stack_pop( crl_parse_stk );
850          $$= o;
851        }
852        ;
853
854else_block:
855        {
856          $$= NULL;
857        }
858        | struct_else
859        ;
860
861conditionals: struct_if elif_block else_block
862        {
863          crl_symbol_obj *sym= NULL, *condit_ctx= NULL;
864          Crl_Symbol_Init( sym );
865
866          if( ($2) || ($3) )
867            {
868              Crl_Symbol_Init( condit_ctx );
869              condit_ctx->type= STRUCTURE_ELIF_CTX;
870              if( $2 )
871                {
872                  condit_ctx->op_a_t= TYPE_SYMBOL;
873                  condit_ctx->op_a.symbol_table= $2;
874                }
875              if( $3 )
876                {
877                  condit_ctx->op_b_t= TYPE_SYMBOL;
878                  condit_ctx->op_b.symbol_table= $3;
879                }
880            }
881
882          sym->type= STRUCTURE_CONDIT_CTX;
883          sym->op_a_t= TYPE_SYMBOL;
884          sym->op_a.symbol_table= $1;
885
886          if( condit_ctx )
887            {
888              sym->op_b_t= TYPE_SYMBOL;
889              sym->op_b.symbol_table= condit_ctx;
890            }
891          $$= sym;
892        }
893
894statement: expression ';'
895         | break_keyword ';'
896         | return_keyword ';'
897         | continue_keyword ';'
898         | control_structure
899         ;
900
901continue_keyword: CONTINUE
902         {
903           crl_symbol_obj *sym;
904           Crl_Symbol_Init( sym );
905           sym->type= KEY_CONTINUE;
906           $$= sym;
907         }
908         ;
909
910break_keyword: BREAK
911         {
912           crl_symbol_obj *sym;
913           Crl_Symbol_Init( sym );
914           sym->type= KEY_BREAK;
915           $$= sym;
916         }
917         ;
918
919return_keyword: RETURN expression
920         {
921           crl_symbol_obj *sym;
922           Crl_Symbol_Init( sym );
923           sym->type= KEY_RETURN;
924           sym->op_a_t= TYPE_SYMBOL;
925           sym->op_a.symbol_table= $2;
926           $$= sym;
927         }
928         ;
929
930arbitrary_call: IDENTIFIER '(' ')'
931        {
932          crl_symbol_obj *sym = NULL;
933          Crl_Symbol_Init( sym );
934         
935          sym->exp = OP_EXPRESS;
936          sym->type = OP_CALL_GOTO;
937          sym->op_a_t = TYPE_STRING;
938          sym->op_a.string = $1;
939          $$= sym;
940        }
941        | IDENTIFIER '(' arguments ')'
942        {
943          crl_symbol_obj *sym= NULL;
944          Crl_Symbol_Init( sym );
945
946          sym->exp = OP_EXPRESS;
947          sym->type= OP_CALL_GOTO;
948          sym->op_a_t= TYPE_STRING;
949          sym->op_b_t= TYPE_ARGUMENTS;
950          sym->op_a.string= $1;
951          sym->op_b.stack_table= $3;
952          $$= sym;
953        }
954        ;
955
956list_symbol: '[' arguments ']'
957          {
958            crl_symbol_obj * sym;
959            Crl_Symbol_Init( sym );
960
961            sym->type= SYMBOL_PRIMARY;
962            sym->op_a_t = TYPE_LIST;
963            sym->op_a.stack_table = $2;
964
965            $$ = sym;
966          }
967          ;
968
969param_type: IDENTIFIER
970          {
971            crl_symbol_obj * sym;
972            Crl_Symbol_Init( sym );
973
974            sym->type = TYPE_PARAMETER;
975            sym->op_a_t = TYPE_STRING;
976            sym->op_a.string = $1;
977
978            sym->op_b_t = TYPE_STRING;
979            sym->op_b.string = crl_strdup( "Object" );
980            $$ = sym;
981          }
982          | IDENTIFIER IDENTIFIER
983          {
984            crl_symbol_obj * sym;
985            Crl_Symbol_Init( sym );
986
987            sym->type = TYPE_PARAMETER;
988            sym->op_a_t = TYPE_STRING;
989            sym->op_a.string = $2;
990
991            sym->op_b_t = TYPE_STRING;
992            sym->op_b.string = crl_strdup( $1 );
993            $$ = sym;
994          }
995          | INT_T IDENTIFIER
996          {
997            crl_symbol_obj * sym;
998            Crl_Symbol_Init( sym );
999
1000            sym->type = TYPE_PARAMETER;
1001            sym->op_a_t = TYPE_STRING;
1002            sym->op_a.string = $2;
1003
1004            sym->op_b_t = TYPE_STRING;
1005            sym->op_b.string = crl_strdup( "Int" );
1006
1007            $$ = sym;
1008          }
1009          | FLOAT_T IDENTIFIER
1010          {
1011            crl_symbol_obj * sym;
1012            Crl_Symbol_Init( sym );
1013
1014            sym->type = TYPE_PARAMETER;
1015            sym->op_a_t = TYPE_STRING;
1016            sym->op_a.string = $2;
1017
1018            sym->op_b_t = TYPE_STRING;
1019            sym->op_b.string = crl_strdup( "Float" );
1020
1021            $$ = sym;
1022          }
1023          ;
1024
1025parameters_expression:
1026         parameters_expression ',' param_type
1027         {
1028           unsigned int s= crl_dd_stack_get_size( crl_parse_stk );
1029           crl_stack_t* t= (crl_stack_t*) crl_parse_stk->array[ (s-1) ];
1030           crl_dd_stack_push( t, $3 );
1031         }
1032         | param_type
1033         {
1034           if( !crl_parse_stk )
1035             {
1036               crl_parse_stk= (crl_stack_t*)
1037                 crl_malloc(sizeof(crl_stack_t));
1038               crl_dd_stack_init( &crl_parse_stk );
1039             }
1040           crl_stack_t *t= (crl_stack_t*)
1041             crl_malloc(sizeof(crl_stack_t));
1042           crl_dd_stack_init( &t );
1043           crl_dd_stack_push( t, $1 );
1044
1045           crl_dd_stack_push( crl_parse_stk, t );
1046         }
1047         ;
1048
1049parameters: parameters_expression
1050         {
1051           crl_stack_t *t= (crl_stack_t*)
1052             crl_dd_stack_pop( crl_parse_stk );
1053           if( t )
1054             $$= t;
1055           else {
1056             crl_error("null argument list!\n");
1057           }
1058         }
1059         ;
1060
1061
1062arguments: argument_list
1063        {
1064          crl_stack_t *t= (crl_stack_t*)
1065            crl_dd_stack_pop( crl_parse_stk );
1066          if( t )
1067            $$= t;
1068          else {
1069            crl_error("null argument list!\n");
1070          }
1071        }
1072        ;
1073
1074argument_list: argument_list ',' expression
1075        {
1076          unsigned int s= crl_dd_stack_get_size( crl_parse_stk );
1077          crl_stack_t* t= (crl_stack_t*) crl_parse_stk->array[ (s-1) ];
1078          crl_dd_stack_push( t, $3 );
1079        }
1080        | expression
1081        {
1082          if( !crl_parse_stk )
1083            {
1084              crl_parse_stk= (crl_stack_t*)
1085                crl_malloc(sizeof(crl_stack_t));
1086              crl_dd_stack_init( &crl_parse_stk );
1087            }
1088          crl_stack_t *t= (crl_stack_t*)
1089            crl_malloc(sizeof(crl_stack_t));
1090          crl_dd_stack_init( &t );
1091          crl_dd_stack_push( t, $1 );
1092
1093          crl_dd_stack_push( crl_parse_stk, t );
1094        }
1095        ;
1096
1097primitive: member_accessor
1098        | list_symbol
1099        | object_creation
1100        | NIL
1101        {
1102          crl_symbol_obj *sym;
1103          Crl_Symbol_Init( sym );
1104          // already default init to 'nil'
1105          $$= sym;
1106        }
1107        | INTEGER
1108        {
1109          crl_symbol_obj *sym;
1110          Crl_Symbol_Init( sym );
1111
1112          sym->type= SYMBOL_PRIMARY;
1113          sym->op_a_t= TYPE_INTEGER;
1114
1115          sym->op_a.integer= $1;
1116          $$= sym;
1117        }
1118        | DOUBLE
1119        {
1120          crl_symbol_obj *sym;
1121          Crl_Symbol_Init( sym );
1122
1123          sym->type= SYMBOL_PRIMARY;
1124          sym->op_a_t= TYPE_FLOAT;
1125
1126          sym->op_a.floating_point= $1;
1127          $$= sym;
1128        }
1129        | TRUE
1130        {
1131          crl_symbol_obj *sym;
1132          Crl_Symbol_Init( sym );
1133
1134          sym->type= SYMBOL_PRIMARY;
1135          sym->op_a_t= TYPE_BOOLEAN;
1136
1137          sym->op_a.boolean= true;
1138          $$= sym;
1139        }
1140        | FALSE
1141        {
1142          crl_symbol_obj *sym;
1143          Crl_Symbol_Init( sym );
1144
1145          sym->type= SYMBOL_PRIMARY;
1146          sym->op_a_t= TYPE_BOOLEAN;
1147
1148          sym->op_a.boolean= false;
1149          $$= sym;
1150        }
1151        | CHAR
1152        {
1153          crl_symbol_obj *sym;
1154          Crl_Symbol_Init( sym );
1155
1156          sym->type= SYMBOL_PRIMARY;
1157          sym->op_a_t= TYPE_CHAR;
1158
1159          sym->op_a.character= $1;
1160          $$= sym;
1161        }
1162        | STRING
1163        {
1164          crl_symbol_obj *sym;
1165          Crl_Symbol_Init( sym );
1166
1167          sym->type= SYMBOL_PRIMARY;
1168          sym->op_a_t= TYPE_STRING;
1169
1170          sym->op_a.string= $1;
1171          $$= sym;
1172        }
1173        ;
1174
1175%%
1176
1177void yyerror( const char *msg )
1178{
1179  crl_error( "syntax error :: line %i:'%s'\n",
1180             yylineno, msg );
1181  if( !crl_interactive )
1182    {
1183      // reading from file better to stop!
1184      crl_fatal("error parsing source code!\n");
1185    }
1186}
Note: See TracBrowser for help on using the browser.