Changes between Initial Version and Version 1 of NQP-rx Tricks

Timestamp:

03/22/10 21:35:18 (3 years ago)

Author:

Austin_Hastings

Comment:

--

NQP-rx Tricks

@@ +1 @@
+= NQP-rx Tricks =
+
+Here are some tricks for parsing with NQP-rx:
+
+== Global Variables ==
+
+A bunch of stuff in -rx is still done with globals. This will all move to contextuals, or to attributes of a common object, or something. Eventually.
+
+=== HLL::Grammar::%!MARKHASH ===
+
+The MARKED/MARKER special rules, which are used by default in the <ws> rule, tracks mark info in a global hash. In order to parse a different source, you need to reset this hash.
+{{{
+Q:PIR {
+    $P0 = null
+    set_hll_global ['HLL';'Grammar'], '%!MARKHASH', $P0
+};
+}}}
+
+I use this to enable test cases for the grammar. The code below (built with the Kakapo library) runs the parser over and over again:
+{{{
+method code_test(%code_matchers) {
+        my $slam := Slam::Compiler.new;
+        my $past;
+        
+        for %code_matchers -> $pair {
+                my $code := $pair.key;
+                say("Code: $code");
+
+                Q:PIR {
+                        $P0 = null
+                        set_hll_global ['HLL';'Grammar'], '%!MARKHASH', $P0
+                };
+                
+                $past := $slam.compile: $code, :rule<EXPR>, :target<past>; #, :parsetrace;
+                #_dumper($past);
+                
+                my $matcher := $pair.value;
+                assert_match($past, $matcher,
+                        'Failed to parse {' ~  $code ~ '} as expected');
+        }
+}
+
+method test_postcircumfix_array_index() {
+        my %code_matchers;
+        %code_matchers<x[0]>            := var( :scope<keyed>, var( :name<x> ), val( :value<0> ));
+        %code_matchers<x[ 1]>           := var( :scope<keyed>, var( :name<x> ), val( :value<1> ));
+        %code_matchers<x[ 2 ]>  := var( :scope<keyed>, var( :name<x> ), val( :value<2> ));
+
+        %code_matchers<x[ y ]>          := var( :scope<keyed>, var( :name<x> ), var( :name<y> ));
+        
+        self.code_test: %code_matchers;
+}
+}}}
+
+The `var(...)` functions are syntactic sugar that generate a special Matcher for validating PCT trees.
+
+== HLL::Compiler ==
+
+=== Debugging ===
+
+The Regex code supports debugging with a `!cursor_debug` call. To enable this, the topmost regex (your grammar) has to be called with the `'rxtrace'` flag. The default compiler doesn't appear to support this, so I overrode the `parse` method:
+{{{
+class Slam::Compiler;
+
+method parse($source, *%adverbs) {
+        unless %adverbs<actions> {
+                %adverbs<actions> := %adverbs<target> eq 'parse' 
+                        ?? pir::null__P()
+                        !! self.parseactions;
+        }
+
+        my %options_map := hash(
+                actions => 'actions',
+                parsetrace => 'rxtrace',
+                rule => 'rule',
+        );
+        
+        my %parse_flags;
+        
+        for %options_map -> $map {
+                %parse_flags{$map.value} := %adverbs{$map.key}
+                        if %adverbs.contains: $map.key;
+        }
+        
+        my $match := self.parsegrammar.parse($source, :p(0), |%parse_flags);
+        
+        self.panic('Failed to parse source')
+                unless $match;
+        
+        $match;
+}
+}}}