Add Invoke and GetProp

grammar_parser.meta

@@ -337,8 +337,8 @@ rules = [];
 
 
 // grammar        = - g:mklist
-//                ( d:definition                                         { Object_push(g, d); }
-//                ) + end-of-file                                        { printTree(g); }
+//                ( d:definition                                         { g.push(d); }
+//                ) + end-of-file                                        { print(g, full: Object.new()); }
 
 rules.grammar = Sequence.new()
                     .push(RuleCall.new(name: #ws))
@@ -348,7 +348,7 @@ rules.grammar = Sequence.new()
                         .push(Action.new(parseTree: `{ g[d.name] = d.expression; }))
                     ))
                     .push(RuleCall.new(name: #end_of_file))
-                    .push(Action.new(parseTree: `{ print(g, full: 1) }));
+                    .push(Action.new(parseTree: `{ print(g, full: Object.new()); }));
 
 
 Definition = Object.subtype(#Definition);
@@ -513,7 +513,7 @@ rules.ruleCallIdent = Sequence.new()
                         .push(Star.new(expression: CharacterClass.new(value: "-a-zA-Z_0-9")))
                         .push(End.new())
                         .push(RuleCall.new(name: #ws))
-                        .push(Action.new(parseTree: `{ RuleCall.new(intern(yytext)); }));
+                        .push(Action.new(parseTree: `{ RuleCall.new(name: intern(yytext)); }));
 
 // literal        = ['] < ( !['] char )* > ['] -                         { newStringEscaped(yytext); }
 //                | ["] < ( !["] char )* > ["] -                         { newStringEscaped(yytext); }
@@ -643,6 +643,7 @@ rules.metaExpression = Alternation.new(id: 1234)
                                     .push(RuleCall.new(name: #rbrak))
                                     .push(RuleCall.new(name: #assign))
                                     .push(Assignment.new(name: #e, rule: RuleCall.new(name: #metaExpression)))
+                                    .push(Action.new(parseTree: `{ SetArray.new(object: p, index: i, value: e); }))
                                 )
                             )
                         )
@@ -658,15 +659,35 @@ rules.metaExpression = Alternation.new(id: 1234)
                         );
 
 // metaPostfix    = p:metaPrimary
-//                ( a:args !ASSIGN                                       { p = newCall(p, a); }
+//                ( DOT   i:id a:args  !ASSIGN !LBRACE	                 { p = newInvoke(p, i, a) }
+//                | DOT   i:id         !ASSIGN                           { p = newGetProp(p, i) }
+//                | a:args !ASSIGN !LBRACE                               { p = newCall(p, a); }
 //                ) *                                                    { p; }
 
 rules.metaPostfix = Sequence.new()
                         .push(Assignment.new(name: #p, rule: RuleCall.new(name: #metaPrimary)))
-                        .push(Star.new(expression: Sequence.new()
-                            .push(Assignment.new(name: #a, rule: RuleCall.new(name: #args)))
-                            .push(Not.new(expression: RuleCall.new(name: #assign)))
-                            .push(Action.new(parseTree: `{ p = Call.new(function: p, arguments: a); }))
+                        .push(Star.new(expression: Alternation.new()
+                            .push(Sequence.new()
+                                .push(RuleCall.new(name: #dot))
+                                .push(Assignment.new(name: #i, rule: RuleCall.new(name: #metaId)))
+                                .push(Assignment.new(name: #a, rule: RuleCall.new(name: #args)))
+                                .push(Not.new(expression: RuleCall.new(name: #assign)))
+                                .push(Not.new(expression: RuleCall.new(name: #lbrace)))
+                                .push(Action.new(parseTree: `{ p = Invoke.new(self: p, method: i, arguments: a); }))
+                            )
+                            .push(Sequence.new()
+                                .push(RuleCall.new(name: #dot))
+                                .push(Assignment.new(name: #i, rule: RuleCall.new(name: #metaId)))
+                                .push(Not.new(expression: RuleCall.new(name: #assign)))
+                                .push(Action.new(parseTree: `{ p = GetProp.new(object: p, key: i); }))
+                            )
+                            .push(Sequence.new()
+                                .push(Assignment.new(name: #a, rule: RuleCall.new(name: #args)))
+                                .push(Not.new(expression: RuleCall.new(name: #assign)))
+                                .push(Not.new(expression: RuleCall.new(name: #lbrace)))
+                                .push(Action.new(parseTree: `{ p = Call.new(function: p, arguments: a); }))
+                                // TODO: Voir si c'est toujours bon avec le newApply()
+                            )
                         ))
                         .push(Action.new(parseTree: `{ p; }));
 
@@ -722,10 +743,7 @@ rules.args        = Sequence.new()
 
 // mklist         =                                                      { new(pObject); }
  
-// !!!!! TODO: ADD IMPLICIT RETURN    !!!!!
 // metaPrimary    = nil | metaVar | metaSubExpr
-// !!!!! CONVERTING TO THIS FOR NOW:  !!!!!
-// metaPrimary    = nil | x:metaVar | x:metaSubExpr {x;}
  
 // metaSubExpr    = LPAREN e:metaExpression RPAREN                       { e; }
  
@@ -735,9 +753,6 @@ rules.metaPrimary = Alternation.new()
                         .push(RuleCall.new(name: #nil))
                         .push(RuleCall.new(name: #metaVar))
                         .push(RuleCall.new(name: #metaSubExpr));
-                        //.push(Assignment.new(name: #x, rule: RuleCall.new(name: #metaVar)))
-                        //.push(Assignment.new(name: #x, rule: RuleCall.new(name: #metaSubExpr)))
-                        //.push(Action.new(parseTree: `{ x; }));
 
 rules.metaSubExpr = Sequence.new()
                         .push(RuleCall.new(name: #lparen))