packcr 0.1.0 → 0.1.1

data/lib/packcr/node/action_node.rb

@@ -33,8 +33,8 @@ class Packcr
         end
       end
 
-      def generate_code(gen, onfail, indent, bare, oncut: nil)
-        gen.write Packcr.format_code(get_code(gen, onfail, indent, bare, oncut), indent: indent, unwrap: bare)
+      def generate_code(gen, onfail, indent, unwrap, oncut: nil)
+        get_code(gen, onfail, indent, unwrap, oncut)
       end
 
       def reachability

data/lib/packcr/node/alternate_node.rb

@@ -27,8 +27,8 @@ class Packcr
         m
       end
 
-      def generate_code(gen, onfail, indent, bare, oncut: nil)
-        gen.write Packcr.format_code(get_code(gen, onfail, indent, bare, oncut), indent: indent, unwrap: bare)
+      def generate_code(gen, onfail, indent, unwrap, oncut: nil)
+        get_code(gen, onfail, indent, unwrap, oncut)
       end
 
       def reachability

data/lib/packcr/node/capture_node.rb

@@ -15,8 +15,8 @@ class Packcr
         $stdout.print "#{" " * indent}}\n"
       end
 
-      def generate_code(gen, onfail, indent, bare, oncut: nil)
-        gen.write Packcr.format_code(get_code(gen, onfail, indent, bare, oncut), indent: indent)
+      def generate_code(gen, onfail, indent, unwrap, oncut: nil)
+        get_code(gen, onfail, indent, unwrap, oncut)
       end
 
       def reachability

data/lib/packcr/node/charclass_node.rb

@@ -17,16 +17,16 @@ class Packcr
         gen.lang == :rb && !gen.ascii
       end
 
-      def generate_code(gen, onfail, indent, bare, oncut: nil)
-        return generate_ascii_code(gen, onfail, indent, bare) if gen.ascii
+      def generate_code(gen, onfail, indent, unwrap, oncut: nil)
+        return generate_ascii_code(gen, onfail, indent, unwrap) if gen.ascii
 
-        generate_utf8_charclass_code(gen, onfail, indent, bare)
+        generate_utf8_charclass_code(gen, onfail, indent, unwrap)
       end
 
-      def generate_reverse_code(gen, onsuccess, indent, bare, oncut: nil)
+      def generate_reverse_code(gen, onsuccess, indent, unwrap, oncut: nil)
         raise "unexpected" if gen.ascii
 
-        generate_utf8_charclass_reverse_code(gen, onsuccess, indent, bare)
+        generate_utf8_charclass_reverse_code(gen, onsuccess, indent, unwrap)
       end
 
       def reachability
@@ -39,20 +39,20 @@ class Packcr
 
       private
 
-      def generate_utf8_charclass_code(gen, onfail, indent, bare)
+      def generate_utf8_charclass_code(gen, onfail, indent, unwrap)
         charclass = value
         if charclass && charclass.encoding != Encoding::UTF_8
           charclass = charclass.dup.force_encoding(Encoding::UTF_8)
         end
         n = charclass&.length || 0
         if charclass.nil? || n > 0
-          gen.write Packcr.format_code(get_utf8_code(gen, onfail, indent, bare, charclass, n), indent: indent, unwrap: bare)
+          get_utf8_code(gen, onfail, indent, unwrap, charclass, n)
         else
-          gen.write Packcr.format_code(get_fail_code(gen, onfail, indent, bare), indent: indent)
+          get_fail_code(gen, onfail, indent, unwrap)
         end
       end
 
-      def generate_utf8_charclass_reverse_code(gen, onsuccess, indent, bare)
+      def generate_utf8_charclass_reverse_code(gen, onsuccess, indent, unwrap)
         charclass = value
         if charclass && charclass.encoding != Encoding::UTF_8
           charclass = charclass.dup.force_encoding(Encoding::UTF_8)
@@ -60,10 +60,10 @@ class Packcr
         n = charclass&.length || 0
         return unless charclass.nil? || n > 0
 
-        gen.write Packcr.format_code(get_utf8_reverse_code(gen, onsuccess, indent, bare, charclass, n), indent: indent, unwrap: bare)
+        get_utf8_reverse_code(gen, onsuccess, indent, unwrap, charclass, n)
       end
 
-      def generate_ascii_code(gen, onfail, indent, bare)
+      def generate_ascii_code(gen, onfail, indent, unwrap)
         charclass = value
         if charclass
           n = charclass.length
@@ -74,15 +74,15 @@ class Packcr
           end
           if n > 0
             if n > 1
-              gen.write Packcr.format_code(get_code(gen, onfail, indent, bare, charclass, n, a), indent: indent, unwrap: bare)
+              get_code(gen, onfail, indent, unwrap, charclass, n, a)
             else
-              gen.write Packcr.format_code(get_one_code(gen, onfail, indent, bare, charclass, n, a), indent: indent)
+              get_one_code(gen, onfail, indent, unwrap, charclass, n, a)
             end
           else
-            gen.write Packcr.format_code(get_fail_code(gen, onfail, indent, bare), indent: indent)
+            get_fail_code(gen, onfail, indent, unwrap)
           end
         else
-          gen.write Packcr.format_code(get_any_code(gen, onfail, indent, bare, charclass), indent: indent)
+          get_any_code(gen, onfail, indent, unwrap, charclass)
         end
       end
 

data/lib/packcr/node/eof_node.rb

@@ -5,8 +5,8 @@ class Packcr
         $stdout.print "#{" " * indent}Eof()\n"
       end
 
-      def generate_code(gen, onfail, indent, bare, oncut: nil)
-        gen.write Packcr.format_code(get_code(gen, onfail, indent, bare, oncut), indent: indent, unwrap: bare)
+      def generate_code(gen, onfail, indent, unwrap, oncut: nil)
+        get_code(gen, onfail, indent, unwrap, oncut)
       end
 
       def reachability

data/lib/packcr/node/error_node.rb

@@ -29,8 +29,8 @@ class Packcr
         $stdout.print "#{" " * indent}}\n"
       end
 
-      def generate_code(gen, onfail, indent, bare, oncut: nil)
-        gen.write Packcr.format_code(get_code(gen, onfail, indent, bare, oncut), indent: indent, unwrap: bare)
+      def generate_code(gen, onfail, indent, unwrap, oncut: nil)
+        get_code(gen, onfail, indent, unwrap, oncut)
       end
 
       def reachability

data/lib/packcr/node/expand_node.rb

@@ -15,8 +15,8 @@ class Packcr
         $stdout.print ")\n"
       end
 
-      def generate_code(gen, onfail, indent, bare, oncut: nil)
-        gen.write Packcr.format_code(get_code(gen, onfail, indent, bare, oncut), indent: indent, unwrap: bare)
+      def generate_code(gen, onfail, indent, unwrap, oncut: nil)
+        get_code(gen, onfail, indent, unwrap, oncut)
       end
 
       def reachability

data/lib/packcr/node/predicate_node.rb

@@ -15,11 +15,11 @@ class Packcr
         $stdout.print "#{" " * indent}}\n"
       end
 
-      def generate_code(gen, onfail, indent, bare, oncut: nil)
+      def generate_code(gen, onfail, indent, unwrap, oncut: nil)
         if neg
-          gen.write Packcr.format_code(get_neg_code(gen, onfail, indent, bare, oncut), indent: indent, unwrap: bare)
+          get_neg_code(gen, onfail, indent, unwrap, oncut)
         else
-          gen.write Packcr.format_code(get_code(gen, onfail, indent, bare, oncut), indent: indent, unwrap: bare)
+          get_code(gen, onfail, indent, unwrap, oncut)
         end
       end
 

data/lib/packcr/node/quantity_node.rb

@@ -16,14 +16,14 @@ class Packcr
         $stdout.print "#{" " * indent}}\n"
       end
 
-      def generate_code(gen, onfail, indent, bare, oncut: nil)
+      def generate_code(gen, onfail, indent, unwrap, oncut: nil)
         if max > 1 || max < 0
-          gen.write Packcr.format_code(get_many_code(gen, onfail, indent, bare, oncut), indent: indent, unwrap: bare)
+          get_many_code(gen, onfail, indent, unwrap, oncut)
         elsif max == 1
           if min > 0
-            gen.write gen.generate_code(expr, onfail, indent, bare, oncut: oncut)
+            gen.generate_code(expr, onfail, indent, unwrap, oncut: oncut)
           else
-            gen.write Packcr.format_code(get_one_code(gen, onfail, indent, bare, oncut), indent: indent, unwrap: bare)
+            get_one_code(gen, onfail, indent, unwrap, oncut)
           end
         end
       end

data/lib/packcr/node/reference_node.rb

@@ -20,12 +20,12 @@ class Packcr
         gen.lang == :rb
       end
 
-      def generate_code(gen, onfail, indent, bare, oncut: nil)
-        gen.write Packcr.format_code(get_code(gen, onfail, indent, bare, oncut), indent: indent, unwrap: bare)
+      def generate_code(gen, onfail, indent, unwrap, oncut: nil)
+        get_code(gen, onfail, indent, unwrap, oncut)
       end
 
-      def generate_reverse_code(gen, onsuccess, indent, bare, oncut: nil)
-        gen.write Packcr.format_code(get_reverse_code(gen, onsuccess, indent, bare, oncut), indent: indent)
+      def generate_reverse_code(gen, onsuccess, indent, unwrap, oncut: nil)
+        get_reverse_code(gen, onsuccess, indent, unwrap, oncut)
       end
 
       def reachability

data/lib/packcr/node/rule_node.rb

@@ -22,8 +22,8 @@ class Packcr
         $stdout.print "#{" " * indent}}\n"
       end
 
-      def generate_code(gen, onfail, indent, bare, oncut: nil)
-        gen.write Packcr.format_code(get_code(gen, onfail, indent, bare, oncut), indent: indent, unwrap: bare)
+      def generate_code(gen, onfail, indent, unwrap, oncut: nil)
+        get_code(gen, onfail, indent, unwrap, oncut)
       end
 
       def reachability

data/lib/packcr/node/sequence_node.rb

@@ -53,8 +53,8 @@ class Packcr
         m
       end
 
-      def generate_code(gen, onfail, indent, bare, oncut: nil)
-        gen.write Packcr.format_code(get_code(gen, onfail, indent, bare, oncut), indent: indent)
+      def generate_code(gen, onfail, indent, unwrap, oncut: nil)
+        get_code(gen, onfail, indent, unwrap, oncut)
       end
 
       def reachability

data/lib/packcr/node/string_node.rb

@@ -17,14 +17,28 @@ class Packcr
         $stdout.print "')\n"
       end
 
-      def generate_code(gen, onfail, indent, bare, oncut: nil)
+      def reversible?(gen)
+        gen.lang == :rs
+      end
+
+      def generate_code(gen, onfail, indent, unwrap, oncut: nil)
         n = value&.length || 0
         return unless n > 0
 
         if n > 1
-          gen.write Packcr.format_code(get_many_code(gen, onfail, indent, bare, oncut, n), indent: indent)
+          get_many_code(gen, onfail, indent, unwrap, oncut, n)
+        else
+          get_one_code(gen, onfail, indent, unwrap, oncut, n)
+        end
+      end
+
+      def generate_reverse_code(gen, onsuccess, indent, unwrap, oncut: nil)
+        n = value&.length || 0
+
+        if n > 1
+          get_many_reverse_code(gen, onsuccess, indent, unwrap, oncut, n)
         else
-          gen.write Packcr.format_code(get_one_code(gen, onfail, indent, bare, oncut, n), indent: indent)
+          get_one_reverse_code(gen, onsuccess, indent, unwrap, oncut, n)
         end
       end
 

data/lib/packcr/parser.rb

@@ -1,4 +1,4 @@
-# A packrat parser generated by PackCR 0.1.0
+# A packrat parser generated by PackCR 0.1.1
 
 class Packcr
   class Parser

data/lib/packcr/templates/context/source.rs.erb

@@ -4,7 +4,6 @@ use std::cell::RefCell;
 use std::collections::{HashMap, HashSet};
 use std::io::Read;
 use std::rc::Rc;
-
 <%- if !code(:esource).empty? -%>
 
 <%-   code(:esource).each do |code| -%>
@@ -35,12 +34,10 @@ impl LrMemoTable {
     fn get(&mut self, index: usize, rule: Rule) -> &mut LrMemo {
         self.memos.get_mut(&index).unwrap().get_mut(&rule).unwrap()
     }
-    fn has(&mut self, index: usize, rule: Rule) -> bool {
-        let memo_opt = self.memos.get_mut(&index);
-        if memo_opt.is_none() {
-            return false;
-        }
-        memo_opt.unwrap().contains_key(&rule)
+    fn has(&self, index: usize, rule: Rule) -> bool {
+        self.memos
+            .get(&index)
+            .is_some_and(|memo_map| memo_map.contains_key(&rule))
     }
 }
 
@@ -60,21 +57,20 @@ impl LrMemo {
     }
 
     fn start_grow(&mut self) -> bool {
-        if self.grow || self.answer.is_some() {
-            return false;
+        if !self.grow && self.answer.is_none() {
+            self.grow = true;
+            true
+        } else {
+            false
         }
-        self.answer = None;
-        self.grow = true;
-        true
     }
 
-    fn start_match(&mut self, answer: Option<ThunkChunk>, offset: usize) {
+    fn update(&mut self, answer: Option<ThunkChunk>, offset: usize) {
         self.answer = answer.map(|c| Rc::new(RefCell::new(c)));
         self.offset = offset;
     }
 
-    fn answer_as_deref_mut(&mut self) -> Option<Rc<RefCell<ThunkChunk>>> {
-        self.answer.as_ref()?;
+    fn clone_answer(&mut self) -> Option<Rc<RefCell<ThunkChunk>>> {
         self.answer.as_ref().map(Rc::clone)
     }
 }
@@ -128,7 +124,7 @@ enum Thunk {
     Node(ThunkNode),
 }
 impl Thunk {
-    fn do_action(&self, processor: &ThunkProcessor, value: ValueRef) {
+    fn do_action(&self, processor: &ThunkProcessor, value: ValueRef) -> Value {
         match self {
             Thunk::Leaf(leaf) => leaf.do_action(processor, value),
             Thunk::Node(node) => node.do_action(processor),
@@ -159,10 +155,11 @@ impl ThunkLeaf {
         }
     }
 
-    fn do_action(&self, processor: &ThunkProcessor, mut value: ValueRef) {
+    fn do_action(&self, processor: &ThunkProcessor, mut value: ValueRef) -> Value {
         value.with_mut(|v| {
             processor.call_action(self.action, self, v);
         });
+        value.get()
     }
     <%- if use_value -%>
 
@@ -177,10 +174,12 @@ struct ThunkNode {
     value: ValueRef,
 }
 impl ThunkNode {
-    fn do_action(&self, processor: &ThunkProcessor) {
-        for thunk in self.thunks.borrow().iter() {
-            thunk.do_action(processor, self.value.clone());
+    fn do_action(&self, processor: &ThunkProcessor) -> Value {
+        let mut v = 0;
+        for thunk in self.thunks.borrow_mut().iter_mut() {
+            v = thunk.do_action(processor, self.value.clone());
         }
+        v
     }
 }
 
@@ -241,11 +240,9 @@ impl ValueRef {
         self.values.with_mut(self.index, f);
     }
 
-    <%- if use_value -%>
     fn get(&self) -> i32 {
         *self.values.table.borrow().get(&self.index).unwrap_or(&0)
     }
-    <%- end -%>
 }
 impl Clone for ValueRef {
     fn clone(&self) -> Self {
@@ -262,6 +259,7 @@ struct CaptureTable {
 }
 
 type RuleSet = HashSet<Rule>;
+type RuleLimit = Option<RuleSet>;
 
 type LrMemoMap = HashMap<Rule, LrMemo>;
 
@@ -308,6 +306,7 @@ struct Input {
     start_position: usize,
     position_offset: usize,
     buffer: String,
+    closed: bool,
 }
 
 impl Input {
@@ -317,6 +316,7 @@ impl Input {
             start_position: 0,
             position_offset: 0,
             buffer: String::new(),
+            closed: false,
         }
     }
 
@@ -378,7 +378,20 @@ impl Input {
 
     fn back_to(&mut self, memo: &mut LrMemo) -> Option<Rc<RefCell<ThunkChunk>>> {
         self.position_offset = memo.offset;
-        memo.answer_as_deref_mut()
+        memo.clone_answer()
+    }
+}
+
+const NOP: Result<usize, usize> = Ok(0);
+const fn throw(label: usize) -> Result<usize, usize> {
+    Err(label)
+}
+
+fn catch(label: usize, f: impl FnOnce() -> Result<usize, usize>) -> Result<usize, usize> {
+    match f() {
+        Ok(_) => NOP,
+        Err(e) if e == label => NOP,
+        Err(e) => throw(e),
     }
 }
 
@@ -397,49 +410,32 @@ impl <%= class_name %> {
         }
     }
 
-    fn error(&self) -> ! {
-        eprintln!("Syntax error");
-        std::process::exit(1);
-    }
-
-    fn refill_buffer(&mut self, num: usize) -> usize {
-        self.input.refill_buffer(num)
-    }
-
-    fn commit_buffer(&mut self) {
-        self.input.commit_buffer();
-        self.memos.clear();
-    }
+    fn parse(&mut self) -> Option<Value> {
+        if self.input.closed {
+            return None;
+        }
 
-    fn parse(&mut self) -> bool {
         let mut answer = ThunkChunk::new(0);
         let pos = self.input.start_position;
-
         <%- if !@root.rules.empty? -%>
-        let apply_result = self.apply_rule(
-            Rule::<%= Packcr.camelize(@root.rules[0].name) %>,
-            &mut answer,
-            0,
-            self.input.position_offset,
-            None,
-        );
-
-        if apply_result {
-            if let Thunk::Node(node) = answer.thunks.borrow_mut().last().unwrap() {
-                node.do_action(&ThunkProcessor::new(&self.input.buffer));
-            }
-        } else {
-            self.error();
-        }
 
+        let value = {
+            let node = self.rule_thunk_node(
+                Rule::<%= Packcr.camelize(@root.rules[0].name) %>,
+                &mut answer,
+                0,
+                self.input.position_offset,
+                &None,
+            );
+            self.memos.clear();
+            node.map(|node| node.do_action(&ThunkProcessor::new(&self.input.buffer)))
+        };
+        self.input.commit_buffer();
+        if pos == self.input.start_position || self.input.refill_buffer(1) < 1 {
+            self.input.closed = true;
+        }
+        value
         <%- end -%>
-        self.commit_buffer();
-        pos != self.input.start_position && self.refill_buffer(1) >= 1
-    }
-
-    #[allow(dead_code)]
-    fn get_char_as_utf32(&mut self) -> (i32, usize) {
-        self.input.get_char_as_utf32()
     }
 
     fn grow_lr(&mut self, rule: Rule, offset: usize) {
@@ -448,16 +444,19 @@ impl <%= class_name %> {
             self.input.position_offset = offset;
 
             let answer = self.call_rule(rule, offset, Some(RuleSet::new()));
-            if answer.is_none() || self.input.position_offset <= old_offset {
-                return;
+            match answer {
+                Some(answer) if self.input.position_offset > old_offset => {
+                    let memo = self.memos.get(offset, rule);
+                    memo.update(Some(answer), self.input.position_offset);
+                }
+                _ => {
+                    return;
+                }
             }
-
-            let memo = self.memos.get(offset, rule);
-            memo.start_match(answer, self.input.position_offset);
         }
     }
 
-    fn rule_answer(&mut self, rule: Rule) -> Option<Rc<RefCell<ThunkChunk>>> {
+    fn rule_answer_without_limits(&mut self, rule: Rule) -> Option<Rc<RefCell<ThunkChunk>>> {
         let offset = self.input.position_offset;
         if !self.memos.has(offset, rule) {
             let memo = LrMemo::new(offset);
@@ -465,7 +464,7 @@ impl <%= class_name %> {
             let answer = self.call_rule(rule, offset, None);
 
             let memo = self.memos.get(offset, rule);
-            memo.start_match(answer, self.input.position_offset);
+            memo.update(answer, self.input.position_offset);
             if !memo.grow {
                 return self.input.back_to(memo);
             }
@@ -491,16 +490,13 @@ impl <%= class_name %> {
         let offset = self.input.position_offset;
         let answer = self.call_rule(rule, offset, Some(limits));
         if !self.memos.has(offset, rule) {
-            answer.as_ref()?;
-            return Some(Rc::new(RefCell::new(answer.unwrap())));
+            return answer.map(|answer| Rc::new(RefCell::new(answer)));
         }
-        let memo = self.memos.get(offset, rule);
 
+        let memo = self.memos.get(offset, rule);
         if self.input.position_offset > memo.offset {
-            memo.start_match(answer, self.input.position_offset);
-            return memo.answer_as_deref_mut();
+            memo.update(answer, self.input.position_offset);
         }
-
         self.input.back_to(memo)
     }
 
@@ -510,35 +506,42 @@ impl <%= class_name %> {
         parent: &mut ThunkChunk,
         value_index: usize,
         offset: usize,
-        limits: Option<RuleSet>,
+        limits: &RuleLimit,
     ) -> bool {
-        let answer = match &limits {
+        let node = self.rule_thunk_node(rule, parent, value_index, offset, limits);
+        node.is_some_and(|node| {
+            parent.thunks.borrow_mut().push(Thunk::Node(node));
+            true
+        })
+    }
+
+    fn rule_thunk_node(
+        &mut self,
+        rule: Rule,
+        parent: &ThunkChunk,
+        value_index: usize,
+        offset: usize,
+        limits: &RuleLimit,
+    ) -> Option<ThunkNode> {
+        match limits {
             Some(limit_set)
                 if self.input.position_offset == offset && !limit_set.contains(&rule) =>
             {
-                self.rule_answer_with_limits(rule, limits.unwrap())
+                self.rule_answer_with_limits(rule, limits.clone().unwrap())
             }
-            _ => self.rule_answer(rule),
-        };
-
-        let Some(answer) = answer else {
-            return false;
-        };
-
-        let new_node = Thunk::Node(ThunkNode {
+            _ => self.rule_answer_without_limits(rule),
+        }
+        .map(|answer| ThunkNode {
             thunks: answer.borrow().thunks.clone(),
             value: parent.value_ref(value_index),
-        });
-        parent.thunks.borrow_mut().push(new_node);
-
-        true
+        })
     }
 
     fn call_rule(
         &mut self,
         rule: Rule,
         offset: usize,
-        mut limits: Option<RuleSet>,
+        mut limits: RuleLimit,
     ) -> Option<ThunkChunk> {
         if let Some(ref mut limits) = limits {
             limits.insert(rule);
@@ -549,7 +552,6 @@ impl <%= class_name %> {
             <%- end -%>
         }
     }
-
     <%- @root.rules.each do |rule| -%>
 
     <%-   gen = ::Packcr::Generator.new(rule, @ascii, @location, :rs) -%>
@@ -578,7 +580,7 @@ impl<'a> ThunkProcessor<'a> {
     <%- @root.rules.each do |rule| -%>
     <%-   rule.codes.each do |code| -%>
 
-    #[allow(unused_variables,non_snake_case)]
+    #[allow(unused_variables, non_snake_case)]
     fn action_<%= rule.name %>_<%= code.index %>(&self, leaf: &ThunkLeaf, out: &mut i32) {
         <%-   code.vars.each_with_index do |ref, i| -%>
         <%-     if i == 0 -%>

data/lib/packcr/templates/node/action.rs.erb

@@ -1,6 +1,6 @@
-answer.push_leaf(
-    Action::<%= Packcr.camelize(gen.rule.name) %><%= index %>,
-    self.input.position_offset,
-    &[<% vars.each_with_index do |var, i| %><%= ", " if i > 0 %><%= var.index %><% end %>],
-    &[<% capts.each_with_index do |capt, i| %><%= ", " if i > 0 %><%= capt.index %><% end %>],
+answer.push_leaf(<% -%>
+    <%- %>Action::<%= Packcr.camelize(gen.rule.name) %><%= index %>, <% -%>
+    <%- %>self.input.position_offset, <% -%>
+    <%- %>&[<% vars.each_with_index do |var, i| %><%= ", " if i > 0 %><%= var.index %><% end %>], <% -%>
+    <%- %>&[<% capts.each_with_index do |capt, i| %><%= ", " if i > 0 %><%= capt.index %><% end %>]<% -%>
 );