packcr 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1797f847b90f8c53e2745592691b7f7ae12a5e18a1861f25b7e84825278529d
-  data.tar.gz: f593a9234386b345f4af1de58467c31640ad2233918f3149f00d53c8df70c379
+  metadata.gz: ec849cdb4d638eb308cdefaf4a2e743ec49e71b46b7343265f8f8b78f5508c5a
+  data.tar.gz: d9c7e0db4c53e247edfb28ca9a6266364e0647152a202c92ca94bdf60ed0e5e0
 SHA512:
-  metadata.gz: ba48fc2f71db11977fd9c1f12f520d639d9618383f08fcbe5b7e71930084f29f32e3fed2baac800ccedd8f3e50f026daf530636ebabd31e9bc682a4798e17b8e
-  data.tar.gz: 1cad26bb87e543e4404df9f5e491398655e3fdc36dbe50452a6805229c06db196ba7c2c2878e461e595321376f00c65110ccba78dad3474f8039991cdff0fd9b
+  metadata.gz: d7b5ec64eb5ea1a407efb518ee0a169f7d0a24294e9d0924fbd7c9bf7a95fd20de13f0ccda290e8deea34b4745d08e07022576fa120dc58f2d81cb4c0e12ee4e
+  data.tar.gz: aa881736505df4e86e9a511b48941781e89a3618445e71a88034097624750e902edaa986ea0d875e537933034c4e0e12b5e8a971206732f2084f0b06d2db2b90

data/README.md

@@ -2,7 +2,7 @@
 
 ## Overview
 
-PackCR is a parser generator for C or Ruby.
+PackCR is a parser generator for C, Ruby, and Rust.
 This library is a port of PackCC rewritten in ruby.
 The Original PackCC is https://github.com/arithy/packcc.
 

data/lib/packcr/generated/context.rb

@@ -486,7 +486,7 @@ class Packcr
         erbout
       when :rs
         erbout = +""
-        erbout << "/* A packrat parser generated by PackCR #{Packcr::VERSION} */\n\nuse std::cell::RefCell;\nuse std::collections::{HashMap, HashSet};\nuse std::io::Read;\nuse std::rc::Rc;\n\n".freeze
+        erbout << "/* A packrat parser generated by PackCR #{Packcr::VERSION} */\n\nuse std::cell::RefCell;\nuse std::collections::{HashMap, HashSet};\nuse std::io::Read;\nuse std::rc::Rc;\n".freeze
 
         if !code(:esource).empty?
           erbout << "\n".freeze
@@ -496,32 +496,27 @@ class Packcr
           end
         end
         use_value = @root.rules.map { |r| r.vars.size }.max > 0
-        erbout << "\nstruct LrMemoTable {\n    memos: HashMap<usize, LrMemoMap>,\n}\nimpl LrMemoTable {\n    fn new() -> Self {\n        Self {\n            memos: HashMap::new(),\n        }\n    }\n\n    fn clear(&mut self) {\n        self.memos.clear();\n    }\n\n    fn set(&mut self, index: usize, rule: Rule, memo: LrMemo) {\n        let memo_map = self.memos.entry(index).or_default();\n        memo_map.insert(rule, memo);\n    }\n\n    fn get(&mut self, index: usize, rule: Rule) -> &mut LrMemo {\n        self.memos.get_mut(&index).unwrap().get_mut(&rule).unwrap()\n    }\n    fn has(&mut self, index: usize, rule: Rule) -> bool {\n        let memo_opt = self.memos.get_mut(&index);\n        if memo_opt.is_none() {\n            return false;\n        }\n        memo_opt.unwrap().contains_key(&rule)\n    }\n}\n\nstruct LrMemo {\n    offset: usize,\n    answer: Option<Rc<RefCell<ThunkChunk>>>,\n    grow: bool,\n}\n\nimpl LrMemo {\n    fn new(offset: usize) -> Self {\n        Self {\n            offset,\n            answer: None,\n            grow: false,\n        }\n    }\n\n    fn start_grow(&mut self) -> bool {\n        if self.grow || self.answer.is_some() {\n            return false;\n        }\n        self.answer = None;\n        self.grow = true;\n        true\n    }\n\n    fn start_match(&mut self, answer: Option<ThunkChunk>, offset: usize) {\n        self.answer = answer.map(|c| Rc::new(RefCell::new(c)));\n        self.offset = offset;\n    }\n\n    fn answer_as_deref_mut(&mut self) -> Option<Rc<RefCell<ThunkChunk>>> {\n        self.answer.as_ref()?;\n        self.answer.as_ref().map(Rc::clone)\n    }\n}\n\nstruct ThunkChunk {\n    thunks: Rc<RefCell<Vec<Thunk>>>,\n    capts: CaptureTable,\n    pos: usize,\n    values: ValueTable,\n}\n\nimpl ThunkChunk {\n    fn new(pos: usize) -> Self {\n        Self {\n            values: ValueTable::new(),\n            capts: CaptureTable::new(),\n            thunks: Rc::new(RefCell::new(Vec::new())),\n            pos,\n        }\n    }\n\n    fn push_leaf(\n        &self,\n        action: Action,\n        end: usize,\n        value_indices: &[usize],\n        capt_indices: &[usize],\n    ) {\n        {\n            let start = self.pos;\n            let mut value_refs = HashMap::new();\n            for &index in value_indices {\n                value_refs.insert(index, ValueRef::new(index, self.values.clone()));\n            }\n            let mut capts = HashMap::new();\n            for &index in capt_indices {\n                capts.insert(index, self.capts[index].clone());\n            }\n            let leaf = Thunk::Leaf(ThunkLeaf::new(action, start, end, value_refs, capts));\n            self.thunks.borrow_mut().push(leaf);\n        }\n    }\n\n    fn value_ref(&self, index: usize) -> ValueRef {\n        ValueRef::new(index, self.values.clone())\n    }\n}\n\nenum Thunk {\n    Leaf(ThunkLeaf),\n    Node(ThunkNode),\n}\nimpl Thunk {\n    fn do_action(&self, processor: &ThunkProcessor, value: ValueRef) {\n        match self {\n            Thunk::Leaf(leaf) => leaf.do_action(processor, value),\n            Thunk::Node(node) => node.do_action(processor),\n        }\n    }\n}\n\n#[allow(dead_code)]\nstruct ThunkLeaf {\n    value_refs: HashMap<usize, ValueRef>,\n    capts: HashMap<usize, Capture>,\n    capt0: Capture,\n    action: Action,\n}\nimpl ThunkLeaf {\n    fn new(\n        action: Action,\n        start: usize,\n        end: usize,\n        value_refs: HashMap<usize, ValueRef>,\n        capts: HashMap<usize, Capture>,\n    ) -> Self {\n        Self {\n            value_refs,\n            capts,\n            capt0: Capture { start, end },\n            action,\n        }\n    }\n\n    fn do_action(&self, processor: &ThunkProcessor, mut value: ValueRef) {\n        value.with_mut(|v| {\n            processor.call_action(self.action, self, v);\n        });\n    }\n".freeze
+        erbout << "\nstruct LrMemoTable {\n    memos: HashMap<usize, LrMemoMap>,\n}\nimpl LrMemoTable {\n    fn new() -> Self {\n        Self {\n            memos: HashMap::new(),\n        }\n    }\n\n    fn clear(&mut self) {\n        self.memos.clear();\n    }\n\n    fn set(&mut self, index: usize, rule: Rule, memo: LrMemo) {\n        let memo_map = self.memos.entry(index).or_default();\n        memo_map.insert(rule, memo);\n    }\n\n    fn get(&mut self, index: usize, rule: Rule) -> &mut LrMemo {\n        self.memos.get_mut(&index).unwrap().get_mut(&rule).unwrap()\n    }\n    fn has(&self, index: usize, rule: Rule) -> bool {\n        self.memos\n            .get(&index)\n            .is_some_and(|memo_map| memo_map.contains_key(&rule))\n    }\n}\n\nstruct LrMemo {\n    offset: usize,\n    answer: Option<Rc<RefCell<ThunkChunk>>>,\n    grow: bool,\n}\n\nimpl LrMemo {\n    fn new(offset: usize) -> Self {\n        Self {\n            offset,\n            answer: None,\n            grow: false,\n        }\n    }\n\n    fn start_grow(&mut self) -> bool {\n        if !self.grow && self.answer.is_none() {\n            self.grow = true;\n            true\n        } else {\n            false\n        }\n    }\n\n    fn update(&mut self, answer: Option<ThunkChunk>, offset: usize) {\n        self.answer = answer.map(|c| Rc::new(RefCell::new(c)));\n        self.offset = offset;\n    }\n\n    fn clone_answer(&mut self) -> Option<Rc<RefCell<ThunkChunk>>> {\n        self.answer.as_ref().map(Rc::clone)\n    }\n}\n\nstruct ThunkChunk {\n    thunks: Rc<RefCell<Vec<Thunk>>>,\n    capts: CaptureTable,\n    pos: usize,\n    values: ValueTable,\n}\n\nimpl ThunkChunk {\n    fn new(pos: usize) -> Self {\n        Self {\n            values: ValueTable::new(),\n            capts: CaptureTable::new(),\n            thunks: Rc::new(RefCell::new(Vec::new())),\n            pos,\n        }\n    }\n\n    fn push_leaf(\n        &self,\n        action: Action,\n        end: usize,\n        value_indices: &[usize],\n        capt_indices: &[usize],\n    ) {\n        {\n            let start = self.pos;\n            let mut value_refs = HashMap::new();\n            for &index in value_indices {\n                value_refs.insert(index, ValueRef::new(index, self.values.clone()));\n            }\n            let mut capts = HashMap::new();\n            for &index in capt_indices {\n                capts.insert(index, self.capts[index].clone());\n            }\n            let leaf = Thunk::Leaf(ThunkLeaf::new(action, start, end, value_refs, capts));\n            self.thunks.borrow_mut().push(leaf);\n        }\n    }\n\n    fn value_ref(&self, index: usize) -> ValueRef {\n        ValueRef::new(index, self.values.clone())\n    }\n}\n\nenum Thunk {\n    Leaf(ThunkLeaf),\n    Node(ThunkNode),\n}\nimpl Thunk {\n    fn do_action(&self, processor: &ThunkProcessor, value: ValueRef) -> Value {\n        match self {\n            Thunk::Leaf(leaf) => leaf.do_action(processor, value),\n            Thunk::Node(node) => node.do_action(processor),\n        }\n    }\n}\n\n#[allow(dead_code)]\nstruct ThunkLeaf {\n    value_refs: HashMap<usize, ValueRef>,\n    capts: HashMap<usize, Capture>,\n    capt0: Capture,\n    action: Action,\n}\nimpl ThunkLeaf {\n    fn new(\n        action: Action,\n        start: usize,\n        end: usize,\n        value_refs: HashMap<usize, ValueRef>,\n        capts: HashMap<usize, Capture>,\n    ) -> Self {\n        Self {\n            value_refs,\n            capts,\n            capt0: Capture { start, end },\n            action,\n        }\n    }\n\n    fn do_action(&self, processor: &ThunkProcessor, mut value: ValueRef) -> Value {\n        value.with_mut(|v| {\n            processor.call_action(self.action, self, v);\n        });\n        value.get()\n    }\n".freeze
 
         if use_value
           erbout << "\n    fn values(&self) -> HashMap<usize, Value> {\n        self.value_refs.iter().map(|(k, v)| (*k, v.get())).collect()\n    }\n".freeze
         end
-        erbout << "}\n\nstruct ThunkNode {\n    thunks: Rc<RefCell<Vec<Thunk>>>,\n    value: ValueRef,\n}\nimpl ThunkNode {\n    fn do_action(&self, processor: &ThunkProcessor) {\n        for thunk in self.thunks.borrow().iter() {\n            thunk.do_action(processor, self.value.clone());\n        }\n    }\n}\n\n#[derive(Clone)]\nstruct Capture {\n    start: usize,\n    end: usize,\n}\n\ntype Value = i32;\n\nstruct ValueTable {\n    table: Rc<RefCell<HashMap<usize, Value>>>,\n}\nimpl ValueTable {\n    fn new() -> Self {\n        Self {\n            table: Rc::new(RefCell::new(HashMap::new())),\n        }\n    }\n".freeze
+        erbout << "}\n\nstruct ThunkNode {\n    thunks: Rc<RefCell<Vec<Thunk>>>,\n    value: ValueRef,\n}\nimpl ThunkNode {\n    fn do_action(&self, processor: &ThunkProcessor) -> Value {\n        let mut v = 0;\n        for thunk in self.thunks.borrow_mut().iter_mut() {\n            v = thunk.do_action(processor, self.value.clone());\n        }\n        v\n    }\n}\n\n#[derive(Clone)]\nstruct Capture {\n    start: usize,\n    end: usize,\n}\n\ntype Value = i32;\n\nstruct ValueTable {\n    table: Rc<RefCell<HashMap<usize, Value>>>,\n}\nimpl ValueTable {\n    fn new() -> Self {\n        Self {\n            table: Rc::new(RefCell::new(HashMap::new())),\n        }\n    }\n".freeze
 
         if use_value
           erbout << "\n    fn clear(&mut self) {\n        self.table.borrow_mut().clear();\n    }\n".freeze
         end
-        erbout << "\n    fn with_mut<F>(&mut self, index: usize, f: F)\n    where\n        F: FnOnce(&mut Value),\n    {\n        let mut table = self.table.borrow_mut();\n        let value = table.entry(index).or_insert(0);\n        f(value);\n    }\n}\nimpl Clone for ValueTable {\n    fn clone(&self) -> Self {\n        Self {\n            table: self.table.clone(),\n        }\n    }\n}\n\nstruct ValueRef {\n    values: ValueTable,\n    index: usize,\n}\nimpl ValueRef {\n    fn new(index: usize, values: ValueTable) -> Self {\n        Self { index, values }\n    }\n\n    fn with_mut<F>(&mut self, f: F)\n    where\n        F: FnOnce(&mut i32),\n    {\n        self.values.with_mut(self.index, f);\n    }\n\n".freeze
-
-        if use_value
-          erbout << "    fn get(&self) -> i32 {\n        *self.values.table.borrow().get(&self.index).unwrap_or(&0)\n    }\n".freeze
-        end
-        erbout << "}\nimpl Clone for ValueRef {\n    fn clone(&self) -> Self {\n        Self {\n            index: self.index,\n            values: self.values.clone(),\n        }\n    }\n}\n\nstruct CaptureTable {\n    table: HashMap<usize, Capture>,\n    len: usize,\n}\n\ntype RuleSet = HashSet<Rule>;\n\ntype LrMemoMap = HashMap<Rule, LrMemo>;\n\nimpl CaptureTable {\n    fn new() -> Self {\n        Self {\n            table: HashMap::new(),\n            len: 0,\n        }\n    }\n\n    fn resize(&mut self, len: usize) {\n        let current_len = self.len;\n        if len > current_len {\n            for i in current_len..len {\n                self.table.insert(i, Capture { start: 0, end: 0 });\n            }\n        } else if len < current_len {\n            for i in len..current_len {\n                self.table.remove(&i);\n            }\n        }\n        self.len = len;\n    }\n}\nimpl std::ops::Index<usize> for CaptureTable {\n    type Output = Capture;\n\n    fn index(&self, index: usize) -> &Self::Output {\n        &self.table[&index]\n    }\n}\nimpl std::ops::IndexMut<usize> for CaptureTable {\n    fn index_mut(&mut self, index: usize) -> &mut Self::Output {\n        if self.len <= index {\n            self.resize(index + 1);\n        }\n        self.table.get_mut(&index).unwrap()\n    }\n}\n\nstruct Input {\n    input: Box<dyn std::io::Read>,\n    start_position: usize,\n    position_offset: usize,\n    buffer: String,\n}\n\nimpl Input {\n    fn new(input: impl std::io::Read + 'static) -> Self {\n        Self {\n            input: Box::new(input),\n            start_position: 0,\n            position_offset: 0,\n            buffer: String::new(),\n        }\n    }\n\n    fn refill_buffer(&mut self, num: usize) -> usize {\n        let mut len = self.buffer.len();\n        if len >= self.position_offset + num {\n            return len - self.position_offset;\n        }\n\n        let mut input_buffer = [0u8; 1024];\n\n        while len < self.position_offset + num {\n            match self.input.read(&mut input_buffer) {\n                Ok(0) => break,\n                Ok(bytes_read) => {\n                    let s = std::string::String::from_utf8_lossy(&input_buffer[..bytes_read]);\n                    self.buffer.push_str(&s);\n                }\n                Err(_) => break,\n            }\n            len = self.buffer.len();\n        }\n\n        len - self.position_offset\n    }\n\n    fn commit_buffer(&mut self) {\n        let position_offset = self.position_offset;\n\n        self.buffer.drain(..position_offset);\n\n        self.start_position += position_offset;\n        self.position_offset = 0;\n    }\n\n    #[allow(dead_code)]\n    fn get_char_as_utf32(&mut self) -> (i32, usize) {\n        if self.refill_buffer(1) < 1 {\n            return (0, 0);\n        }\n\n        let current_position = self.position_offset;\n        let remaining_chars: &str = &self.buffer[current_position..];\n\n        if let Some(ch) = remaining_chars.chars().next() {\n            let bytes_used = ch.len_utf8();\n\n            if self.refill_buffer(bytes_used) < bytes_used {\n                return (0, 0);\n            }\n\n            let utf32_value = ch as u32 as i32;\n\n            return (utf32_value, bytes_used);\n        }\n\n        (0, 0)\n    }\n\n    fn back_to(&mut self, memo: &mut LrMemo) -> Option<Rc<RefCell<ThunkChunk>>> {\n        self.position_offset = memo.offset;\n        memo.answer_as_deref_mut()\n    }\n}\n\nstruct #{class_name} {\n    level: usize,\n    memos: LrMemoTable,\n    input: Input,\n}\n\nimpl #{class_name} {\n    fn new(input: impl std::io::Read + 'static) -> Self {\n        Self {\n            level: 0,\n            memos: LrMemoTable::new(),\n            input: Input::new(input),\n        }\n    }\n\n    fn error(&self) -> ! {\n        eprintln!(\"Syntax error\");\n        std::process::exit(1);\n    }\n\n    fn refill_buffer(&mut self, num: usize) -> usize {\n        self.input.refill_buffer(num)\n    }\n\n    fn commit_buffer(&mut self) {\n        self.input.commit_buffer();\n        self.memos.clear();\n    }\n\n    fn parse(&mut self) -> bool {\n        let mut answer = ThunkChunk::new(0);\n        let pos = self.input.start_position;\n\n".freeze
+        erbout << "\n    fn with_mut<F>(&mut self, index: usize, f: F)\n    where\n        F: FnOnce(&mut Value),\n    {\n        let mut table = self.table.borrow_mut();\n        let value = table.entry(index).or_insert(0);\n        f(value);\n    }\n}\nimpl Clone for ValueTable {\n    fn clone(&self) -> Self {\n        Self {\n            table: self.table.clone(),\n        }\n    }\n}\n\nstruct ValueRef {\n    values: ValueTable,\n    index: usize,\n}\nimpl ValueRef {\n    fn new(index: usize, values: ValueTable) -> Self {\n        Self { index, values }\n    }\n\n    fn with_mut<F>(&mut self, f: F)\n    where\n        F: FnOnce(&mut i32),\n    {\n        self.values.with_mut(self.index, f);\n    }\n\n    fn get(&self) -> i32 {\n        *self.values.table.borrow().get(&self.index).unwrap_or(&0)\n    }\n}\nimpl Clone for ValueRef {\n    fn clone(&self) -> Self {\n        Self {\n            index: self.index,\n            values: self.values.clone(),\n        }\n    }\n}\n\nstruct CaptureTable {\n    table: HashMap<usize, Capture>,\n    len: usize,\n}\n\ntype RuleSet = HashSet<Rule>;\ntype RuleLimit = Option<RuleSet>;\n\ntype LrMemoMap = HashMap<Rule, LrMemo>;\n\nimpl CaptureTable {\n    fn new() -> Self {\n        Self {\n            table: HashMap::new(),\n            len: 0,\n        }\n    }\n\n    fn resize(&mut self, len: usize) {\n        let current_len = self.len;\n        if len > current_len {\n            for i in current_len..len {\n                self.table.insert(i, Capture { start: 0, end: 0 });\n            }\n        } else if len < current_len {\n            for i in len..current_len {\n                self.table.remove(&i);\n            }\n        }\n        self.len = len;\n    }\n}\nimpl std::ops::Index<usize> for CaptureTable {\n    type Output = Capture;\n\n    fn index(&self, index: usize) -> &Self::Output {\n        &self.table[&index]\n    }\n}\nimpl std::ops::IndexMut<usize> for CaptureTable {\n    fn index_mut(&mut self, index: usize) -> &mut Self::Output {\n        if self.len <= index {\n            self.resize(index + 1);\n        }\n        self.table.get_mut(&index).unwrap()\n    }\n}\n\nstruct Input {\n    input: Box<dyn std::io::Read>,\n    start_position: usize,\n    position_offset: usize,\n    buffer: String,\n    closed: bool,\n}\n\nimpl Input {\n    fn new(input: impl std::io::Read + 'static) -> Self {\n        Self {\n            input: Box::new(input),\n            start_position: 0,\n            position_offset: 0,\n            buffer: String::new(),\n            closed: false,\n        }\n    }\n\n    fn refill_buffer(&mut self, num: usize) -> usize {\n        let mut len = self.buffer.len();\n        if len >= self.position_offset + num {\n            return len - self.position_offset;\n        }\n\n        let mut input_buffer = [0u8; 1024];\n\n        while len < self.position_offset + num {\n            match self.input.read(&mut input_buffer) {\n                Ok(0) => break,\n                Ok(bytes_read) => {\n                    let s = std::string::String::from_utf8_lossy(&input_buffer[..bytes_read]);\n                    self.buffer.push_str(&s);\n                }\n                Err(_) => break,\n            }\n            len = self.buffer.len();\n        }\n\n        len - self.position_offset\n    }\n\n    fn commit_buffer(&mut self) {\n        let position_offset = self.position_offset;\n\n        self.buffer.drain(..position_offset);\n\n        self.start_position += position_offset;\n        self.position_offset = 0;\n    }\n\n    #[allow(dead_code)]\n    fn get_char_as_utf32(&mut self) -> (i32, usize) {\n        if self.refill_buffer(1) < 1 {\n            return (0, 0);\n        }\n\n        let current_position = self.position_offset;\n        let remaining_chars: &str = &self.buffer[current_position..];\n\n        if let Some(ch) = remaining_chars.chars().next() {\n            let bytes_used = ch.len_utf8();\n\n            if self.refill_buffer(bytes_used) < bytes_used {\n                return (0, 0);\n            }\n\n            let utf32_value = ch as u32 as i32;\n\n            return (utf32_value, bytes_used);\n        }\n\n        (0, 0)\n    }\n\n    fn back_to(&mut self, memo: &mut LrMemo) -> Option<Rc<RefCell<ThunkChunk>>> {\n        self.position_offset = memo.offset;\n        memo.clone_answer()\n    }\n}\n\nconst NOP: Result<usize, usize> = Ok(0);\nconst fn throw(label: usize) -> Result<usize, usize> {\n    Err(label)\n}\n\nfn catch(label: usize, f: impl FnOnce() -> Result<usize, usize>) -> Result<usize, usize> {\n    match f() {\n        Ok(_) => NOP,\n        Err(e) if e == label => NOP,\n        Err(e) => throw(e),\n    }\n}\n\nstruct #{class_name} {\n    level: usize,\n    memos: LrMemoTable,\n    input: Input,\n}\n\nimpl #{class_name} {\n    fn new(input: impl std::io::Read + 'static) -> Self {\n        Self {\n            level: 0,\n            memos: LrMemoTable::new(),\n            input: Input::new(input),\n        }\n    }\n\n    fn parse(&mut self) -> Option<Value> {\n        if self.input.closed {\n            return None;\n        }\n\n        let mut answer = ThunkChunk::new(0);\n        let pos = self.input.start_position;\n".freeze
 
         if !@root.rules.empty?
-          erbout << "        let apply_result = self.apply_rule(\n            Rule::#{Packcr.camelize(@root.rules[0].name)},\n            &mut answer,\n            0,\n            self.input.position_offset,\n            None,\n        );\n\n        if apply_result {\n            if let Thunk::Node(node) = answer.thunks.borrow_mut().last().unwrap() {\n                node.do_action(&ThunkProcessor::new(&self.input.buffer));\n            }\n        } else {\n            self.error();\n        }\n\n".freeze
+          erbout << "\n        let value = {\n            let node = self.rule_thunk_node(\n                Rule::#{Packcr.camelize(@root.rules[0].name)},\n                &mut answer,\n                0,\n                self.input.position_offset,\n                &None,\n            );\n            self.memos.clear();\n            node.map(|node| node.do_action(&ThunkProcessor::new(&self.input.buffer)))\n        };\n        self.input.commit_buffer();\n        if pos == self.input.start_position || self.input.refill_buffer(1) < 1 {\n            self.input.closed = true;\n        }\n        value\n".freeze
         end
-        erbout << "        self.commit_buffer();\n        pos != self.input.start_position && self.refill_buffer(1) >= 1\n    }\n\n    #[allow(dead_code)]\n    fn get_char_as_utf32(&mut self) -> (i32, usize) {\n        self.input.get_char_as_utf32()\n    }\n\n    fn grow_lr(&mut self, rule: Rule, offset: usize) {\n        loop {\n            let old_offset = self.input.position_offset;\n            self.input.position_offset = offset;\n\n            let answer = self.call_rule(rule, offset, Some(RuleSet::new()));\n            if answer.is_none() || self.input.position_offset <= old_offset {\n                return;\n            }\n\n            let memo = self.memos.get(offset, rule);\n            memo.start_match(answer, self.input.position_offset);\n        }\n    }\n\n    fn rule_answer(&mut self, rule: Rule) -> Option<Rc<RefCell<ThunkChunk>>> {\n        let offset = self.input.position_offset;\n        if !self.memos.has(offset, rule) {\n            let memo = LrMemo::new(offset);\n            self.memos.set(offset, rule, memo);\n            let answer = self.call_rule(rule, offset, None);\n\n            let memo = self.memos.get(offset, rule);\n            memo.start_match(answer, self.input.position_offset);\n            if !memo.grow {\n                return self.input.back_to(memo);\n            }\n            self.grow_lr(rule, offset);\n\n            let memo = self.memos.get(offset, rule);\n            memo.grow = false;\n            return self.input.back_to(memo);\n        }\n\n        let memo = self.memos.get(offset, rule);\n        if memo.start_grow() {\n            return None;\n        }\n        self.input.back_to(memo)\n    }\n\n    fn rule_answer_with_limits(\n        &mut self,\n        rule: Rule,\n        limits: RuleSet,\n    ) -> Option<Rc<RefCell<ThunkChunk>>> {\n        let offset = self.input.position_offset;\n        let answer = self.call_rule(rule, offset, Some(limits));\n        if !self.memos.has(offset, rule) {\n            answer.as_ref()?;\n            return Some(Rc::new(RefCell::new(answer.unwrap())));\n        }\n        let memo = self.memos.get(offset, rule);\n\n        if self.input.position_offset > memo.offset {\n            memo.start_match(answer, self.input.position_offset);\n            return memo.answer_as_deref_mut();\n        }\n\n        self.input.back_to(memo)\n    }\n\n    fn apply_rule(\n        &mut self,\n        rule: Rule,\n        parent: &mut ThunkChunk,\n        value_index: usize,\n        offset: usize,\n        limits: Option<RuleSet>,\n    ) -> bool {\n        let answer = match &limits {\n            Some(limit_set)\n                if self.input.position_offset == offset && !limit_set.contains(&rule) =>\n            {\n                self.rule_answer_with_limits(rule, limits.unwrap())\n            }\n            _ => self.rule_answer(rule),\n        };\n\n        let Some(answer) = answer else {\n            return false;\n        };\n\n        let new_node = Thunk::Node(ThunkNode {\n            thunks: answer.borrow().thunks.clone(),\n            value: parent.value_ref(value_index),\n        });\n        parent.thunks.borrow_mut().push(new_node);\n\n        true\n    }\n\n    fn call_rule(\n        &mut self,\n        rule: Rule,\n        offset: usize,\n        mut limits: Option<RuleSet>,\n    ) -> Option<ThunkChunk> {\n        if let Some(ref mut limits) = limits {\n            limits.insert(rule);\n        }\n        match rule {\n".freeze
+        erbout << "    }\n\n    fn grow_lr(&mut self, rule: Rule, offset: usize) {\n        loop {\n            let old_offset = self.input.position_offset;\n            self.input.position_offset = offset;\n\n            let answer = self.call_rule(rule, offset, Some(RuleSet::new()));\n            match answer {\n                Some(answer) if self.input.position_offset > old_offset => {\n                    let memo = self.memos.get(offset, rule);\n                    memo.update(Some(answer), self.input.position_offset);\n                }\n                _ => {\n                    return;\n                }\n            }\n        }\n    }\n\n    fn rule_answer_without_limits(&mut self, rule: Rule) -> Option<Rc<RefCell<ThunkChunk>>> {\n        let offset = self.input.position_offset;\n        if !self.memos.has(offset, rule) {\n            let memo = LrMemo::new(offset);\n            self.memos.set(offset, rule, memo);\n            let answer = self.call_rule(rule, offset, None);\n\n            let memo = self.memos.get(offset, rule);\n            memo.update(answer, self.input.position_offset);\n            if !memo.grow {\n                return self.input.back_to(memo);\n            }\n            self.grow_lr(rule, offset);\n\n            let memo = self.memos.get(offset, rule);\n            memo.grow = false;\n            return self.input.back_to(memo);\n        }\n\n        let memo = self.memos.get(offset, rule);\n        if memo.start_grow() {\n            return None;\n        }\n        self.input.back_to(memo)\n    }\n\n    fn rule_answer_with_limits(\n        &mut self,\n        rule: Rule,\n        limits: RuleSet,\n    ) -> Option<Rc<RefCell<ThunkChunk>>> {\n        let offset = self.input.position_offset;\n        let answer = self.call_rule(rule, offset, Some(limits));\n        if !self.memos.has(offset, rule) {\n            return answer.map(|answer| Rc::new(RefCell::new(answer)));\n        }\n\n        let memo = self.memos.get(offset, rule);\n        if self.input.position_offset > memo.offset {\n            memo.update(answer, self.input.position_offset);\n        }\n        self.input.back_to(memo)\n    }\n\n    fn apply_rule(\n        &mut self,\n        rule: Rule,\n        parent: &mut ThunkChunk,\n        value_index: usize,\n        offset: usize,\n        limits: &RuleLimit,\n    ) -> bool {\n        let node = self.rule_thunk_node(rule, parent, value_index, offset, limits);\n        node.is_some_and(|node| {\n            parent.thunks.borrow_mut().push(Thunk::Node(node));\n            true\n        })\n    }\n\n    fn rule_thunk_node(\n        &mut self,\n        rule: Rule,\n        parent: &ThunkChunk,\n        value_index: usize,\n        offset: usize,\n        limits: &RuleLimit,\n    ) -> Option<ThunkNode> {\n        match limits {\n            Some(limit_set)\n                if self.input.position_offset == offset && !limit_set.contains(&rule) =>\n            {\n                self.rule_answer_with_limits(rule, limits.clone().unwrap())\n            }\n            _ => self.rule_answer_without_limits(rule),\n        }\n        .map(|answer| ThunkNode {\n            thunks: answer.borrow().thunks.clone(),\n            value: parent.value_ref(value_index),\n        })\n    }\n\n    fn call_rule(\n        &mut self,\n        rule: Rule,\n        offset: usize,\n        mut limits: RuleLimit,\n    ) -> Option<ThunkChunk> {\n        if let Some(ref mut limits) = limits {\n            limits.insert(rule);\n        }\n        match rule {\n".freeze
 
         @root.rules.each do |rule|
           erbout << "            Rule::#{Packcr.camelize(rule.name)} => self.evaluate_rule_#{rule.name}(offset, limits),\n".freeze
         end
-        erbout << "        }\n    }\n\n".freeze
+        erbout << "        }\n    }\n".freeze
 
         @root.rules.each do |rule|
           erbout << "\n".freeze
@@ -541,7 +536,7 @@ class Packcr
 
         @root.rules.each do |rule|
           rule.codes.each do |code|
-            erbout << "\n    #[allow(unused_variables,non_snake_case)]\n    fn action_#{rule.name}_#{code.index}(&self, leaf: &ThunkLeaf, out: &mut i32) {\n".freeze
+            erbout << "\n    #[allow(unused_variables, non_snake_case)]\n    fn action_#{rule.name}_#{code.index}(&self, leaf: &ThunkLeaf, out: &mut i32) {\n".freeze
 
             code.vars.each_with_index do |ref, i|
               if i == 0

data/lib/packcr/generated/node/action_node.rb

@@ -1,7 +1,7 @@
 class Packcr
   class Node
     class ActionNode
-      def get_code(gen, onfail, indent, bare, oncut)
+      def get_code(gen, onfail, indent, unwrap, oncut)
         case gen.lang
         when :c
           erbout = +""
@@ -55,17 +55,15 @@ class Packcr
           erbout
         when :rs
           erbout = +""
-          erbout << "answer.push_leaf(\n    Action::#{Packcr.camelize(gen.rule.name)}#{index},\n    self.input.position_offset,\n    &[".freeze
-
+          erbout << "answer.push_leaf(Action::#{Packcr.camelize(gen.rule.name)}#{index}, self.input.position_offset, &[".freeze
           vars.each_with_index do |var, i|
             erbout << "#{", " if i > 0}#{var.index}".freeze
           end
-          erbout << "],\n    &[".freeze
-
+          erbout << "], &[".freeze
           capts.each_with_index do |capt, i|
             erbout << "#{", " if i > 0}#{capt.index}".freeze
           end
-          erbout << "],\n);\n".freeze
+          erbout << "]);\n".freeze
 
           erbout
         else

data/lib/packcr/generated/node/alternate_node.rb

@@ -1,7 +1,7 @@
 class Packcr
   class Node
     class AlternateNode
-      def get_code(gen, onfail, indent, bare, oncut)
+      def get_code(gen, onfail, indent, unwrap, oncut)
         case gen.lang
         when :c
           erbout = +""
@@ -92,47 +92,41 @@ class Packcr
         when :rs
           erbout = +""
           m = gen.next_label
-          erbout << "'L#{format("%04d", m)}: {\n    let p = self.input.position_offset;\n".freeze
+          erbout << "catch(#{m}, || {\n    let p = self.input.position_offset;\n".freeze
 
           if gen.location
             erbout << "    TODO\n".freeze
           end
           nodes.each_with_index do |expr, i|
-            erbout << "    {\n".freeze
-
             c = i + 1 < nodes.length
             if expr.reversible?(gen)
 
-              erbout << "#{gen.generate_code(expr, m, 8, false, reverse: true, oncut: onfail)}".freeze
+              erbout << "#{gen.generate_code(expr, m, 4, false, reverse: true, oncut: onfail)}".freeze
             else
               l = gen.next_label
-              erbout << "        'L#{format("%04d", l)}: {\n".freeze
-
               r = expr.reachability
-
-              erbout << "#{gen.generate_code(expr, l, 12, false, oncut: onfail)}".freeze
               if r == Packcr::CODE_REACH__ALWAYS_SUCCEED
+                erbout << "    catch(#{l}, || {\n#{gen.generate_code(expr, l, 8, false, oncut: onfail)}".freeze
                 if c
-                  erbout << "            // unreachable codes omitted\n".freeze
+                  erbout << "        // unreachable codes omitted\n".freeze
                 end
-                erbout << "        }\n".freeze
+                erbout << "        NOP\n    })?\n".freeze
 
                 break
-              elsif r == Packcr::CODE_REACH__BOTH
-                erbout << "            break 'L#{format("%04d", m)};\n".freeze
+              else
+                erbout << "    catch(#{l}, || {\n#{gen.generate_code(expr, l, 8, false, oncut: onfail)}        throw(#{m})\n    })?;\n".freeze
               end
-              erbout << "        }\n".freeze
             end
-            erbout << "    }\n    self.input.position_offset = p;\n".freeze
+            erbout << "    self.input.position_offset = p;\n".freeze
 
             if gen.location
               erbout << "    TODO\n".freeze
             end
             next if c
 
-            erbout << "    break 'L#{format("%04d", onfail)};\n".freeze
+            erbout << "    throw(#{onfail})\n".freeze
           end
-          erbout << "} // 'L#{format("%04d", m)}\n".freeze
+          erbout << "})?;\n".freeze
 
           erbout
         else

data/lib/packcr/generated/node/capture_node.rb

@@ -1,7 +1,7 @@
 class Packcr
   class Node
     class CaptureNode
-      def get_code(gen, onfail, indent, bare, oncut)
+      def get_code(gen, onfail, indent, unwrap, oncut)
         case gen.lang
         when :c
           erbout = +""

data/lib/packcr/generated/node/charclass_node.rb

@@ -1,7 +1,7 @@
 class Packcr
   class Node
     class CharclassNode
-      def get_code(gen, onfail, indent, bare, charclass, n, a)
+      def get_code(gen, onfail, indent, unwrap, charclass, n, a)
         case gen.lang
         when :c
           erbout = +""
@@ -97,7 +97,7 @@ class Packcr
         end
       end
 
-      def get_any_code(gen, onfail, indent, bare, charclass)
+      def get_any_code(gen, onfail, indent, unwrap, charclass)
         case gen.lang
         when :c
           erbout = +""
@@ -124,7 +124,7 @@ class Packcr
         end
       end
 
-      def get_fail_code(gen, onfail, indent, bare)
+      def get_fail_code(gen, onfail, indent, unwrap)
         case gen.lang
         when :c
           erbout = +""
@@ -141,7 +141,7 @@ class Packcr
         end
       end
 
-      def get_one_code(gen, onfail, indent, bare, charclass, n, a)
+      def get_one_code(gen, onfail, indent, unwrap, charclass, n, a)
         case gen.lang
         when :c
           erbout = +""
@@ -176,7 +176,7 @@ class Packcr
         end
       end
 
-      def get_utf8_code(gen, onfail, indent, bare, charclass, n)
+      def get_utf8_code(gen, onfail, indent, unwrap, charclass, n)
         case gen.lang
         when :c
           erbout = +""
@@ -308,7 +308,7 @@ class Packcr
           a = charclass && charclass[0] == "^"
           i = a ? 1 : 0
           any_code = !charclass || (a && n == 1)
-          erbout << "let (#{any_code ? "_" : ""}u, n) = self.get_char_as_utf32();\nif n == 0 {\n    break 'L#{format("%04d", onfail)};\n}\n".freeze
+          erbout << "let (#{any_code ? "_" : ""}u, n) = self.input.get_char_as_utf32();\nif n == 0 {\n    return throw(#{onfail});\n}\n".freeze
 
           unless any_code
             erbout << "if ".freeze
@@ -353,7 +353,7 @@ class Packcr
               erbout << ") ".freeze
             end
 
-            erbout << "{\n    break 'L#{format("%04d", onfail)};\n}\n".freeze
+            erbout << "{\n    return throw(#{onfail});\n}\n".freeze
           end
           erbout << "self.input.position_offset += n;\n".freeze
 
@@ -363,7 +363,7 @@ class Packcr
         end
       end
 
-      def get_utf8_reverse_code(gen, onsuccess, indent, bare, charclass, n)
+      def get_utf8_reverse_code(gen, onsuccess, indent, unwrap, charclass, n)
         case gen.lang
         when :rb
           erbout = +""

data/lib/packcr/generated/node/eof_node.rb

@@ -1,7 +1,7 @@
 class Packcr
   class Node
     class EofNode
-      def get_code(gen, onfail, indent, bare, oncut)
+      def get_code(gen, onfail, indent, unwrap, oncut)
         case gen.lang
         when :c
           erbout = +""

data/lib/packcr/generated/node/error_node.rb

@@ -1,7 +1,7 @@
 class Packcr
   class Node
     class ErrorNode
-      def get_code(gen, onfail, indent, bare, oncut)
+      def get_code(gen, onfail, indent, unwrap, oncut)
         case gen.lang
         when :c
           erbout = +""

data/lib/packcr/generated/node/expand_node.rb

@@ -1,7 +1,7 @@
 class Packcr
   class Node
     class ExpandNode
-      def get_code(gen, onfail, indent, bare, oncut)
+      def get_code(gen, onfail, indent, unwrap, oncut)
         case gen.lang
         when :c
           erbout = +""

data/lib/packcr/generated/node/predicate_node.rb

@@ -1,7 +1,7 @@
 class Packcr
   class Node
     class PredicateNode
-      def get_code(gen, onfail, indent, bare, oncut)
+      def get_code(gen, onfail, indent, unwrap, oncut)
         case gen.lang
         when :c
           erbout = +""
@@ -77,7 +77,7 @@ class Packcr
         end
       end
 
-      def get_neg_code(gen, onfail, indent, bare, oncut)
+      def get_neg_code(gen, onfail, indent, unwrap, oncut)
         case gen.lang
         when :c
           erbout = +""
@@ -144,17 +144,19 @@ class Packcr
           if gen.location
             erbout << "TODO\n".freeze
           end
-          erbout << "'L#{format("%04d", l)}: {\n    {\n#{gen.generate_code(expr, l, 4, false)}    }\n".freeze
-
-          if r != Packcr::CODE_REACH__ALWAYS_FAIL
+          erbout << "catch(#{l}, || {\n#{gen.generate_code(expr, l, 4, false)}".freeze
+          if r == Packcr::CODE_REACH__ALWAYS_FAIL
+            erbout << "    NOP\n".freeze
+          else
             erbout << "    self.input.position_offset = p;\n".freeze
 
             if gen.location
               erbout << "    TODO\n".freeze
             end
-            erbout << "    break 'L#{format("%04d", onfail)};\n".freeze
+            erbout << "    throw(#{onfail})\n".freeze
+
           end
-          erbout << "}\n".freeze
+          erbout << "})?;\n".freeze
 
           if r != Packcr::CODE_REACH__ALWAYS_SUCCEED
             erbout << "self.input.position_offset = p;\n".freeze

data/lib/packcr/generated/node/quantity_node.rb

@@ -1,7 +1,7 @@
 class Packcr
   class Node
     class QuantityNode
-      def get_many_code(gen, onfail, indent, bare, oncut)
+      def get_many_code(gen, onfail, indent, unwrap, oncut)
         case gen.lang
         when :c
           erbout = +""
@@ -120,32 +120,32 @@ class Packcr
             erbout << "let mut i = -1;\n".freeze
           end
           m = gen.next_label
-          erbout << "'L#{format("%04d", m)}: loop {\n".freeze
+          erbout << "catch(#{m}, || {\n    loop {\n".freeze
 
           if use_count
-            erbout << "    i += 1;\n".freeze
+            erbout << "        i += 1;\n".freeze
           end
           if max >= 0
-            erbout << "    if i >= #{max} { break; }\n".freeze
+            erbout << "        if i >= #{max} {\n            return NOP;\n        }\n".freeze
           end
-          erbout << "    let p = self.input.position_offset;\n".freeze
+          erbout << "        let p = self.input.position_offset;\n".freeze
 
           if (r != Packcr::CODE_REACH__ALWAYS_SUCCEED) && gen.location
-            erbout << "    TODO\n".freeze
+            erbout << "        TODO\n".freeze
           end
           l = gen.next_label
           r = expr.reachability
-          erbout << "    'L#{format("%04d", l)}: {\n#{gen.generate_code(expr, l, 8, false)}        if self.input.position_offset == p {\n            break 'L#{format("%04d", m)};\n        }\n".freeze
+          if r == Packcr::CODE_REACH__ALWAYS_SUCCEED
+            erbout << "        TODO\n        match (|| {\n#{gen.generate_code(expr, l, 12, false)}            if self.input.position_offset == p {\n                return throw(#{m});\n            }\n        })() {\n            NOP => continue,\n            Err(label) if label != #{l} => return throw(label),\n            _ => {\n                self.input.position_offset = p;\n".freeze
 
-          if r != Packcr::CODE_REACH__ALWAYS_SUCCEED
-            erbout << "        continue 'L#{format("%04d", m)};\n    }\n    self.input.position_offset = p;\n".freeze
+          else
+            erbout << "        match (|| {\n#{gen.generate_code(expr, l, 12, false)}            if self.input.position_offset == p {\n                return throw(#{m});\n            }\n            NOP\n        })() {\n            NOP => continue,\n            Err(label) if label != #{l} => return throw(label),\n            _ => {\n                self.input.position_offset = p;\n".freeze
 
-            if gen.location
-              erbout << "    TODO\n".freeze
-            end
-            erbout << "    break 'L#{format("%04d", m)};\n".freeze
           end
-          erbout << "}\n".freeze
+          if gen.location
+            erbout << "                TODO\n".freeze
+          end
+          erbout << "                return throw(#{m});\n            }\n        }\n    }\n})?;\n".freeze
 
           if min > 0
             erbout << "if i < #{min} {\n    self.input.position_offset = p0;\n".freeze
@@ -153,7 +153,7 @@ class Packcr
             if gen.location
               erbout << "    TODO\n".freeze
             end
-            erbout << "    break 'L#{format("%04d", onfail)};\n}\n".freeze
+            erbout << "    return throw(#{onfail});\n}\n".freeze
           end
           erbout
         else
@@ -161,7 +161,7 @@ class Packcr
         end
       end
 
-      def get_one_code(gen, onfail, indent, bare, oncut)
+      def get_one_code(gen, onfail, indent, unwrap, oncut)
         case gen.lang
         when :c
           erbout = +""

data/lib/packcr/generated/node/reference_node.rb

@@ -1,7 +1,7 @@
 class Packcr
   class Node
     class ReferenceNode
-      def get_code(gen, onfail, indent, bare, oncut)
+      def get_code(gen, onfail, indent, unwrap, oncut)
         case gen.lang
         when :c
           erbout = +""
@@ -39,7 +39,7 @@ class Packcr
           erbout
         when :rs
           erbout = +""
-          erbout << "if !self.apply_rule(Rule::#{Packcr.camelize(name)}, &mut answer, #{index || 0}, offset, limits.clone()) {\n    break 'L#{format("%04d", onfail)};\n}\n".freeze
+          erbout << "if !self.apply_rule(Rule::#{Packcr.camelize(name)}, &mut answer, #{index || 0}, offset, &limits) {\n    return throw(#{onfail});\n}\n".freeze
 
           erbout
         else
@@ -47,7 +47,7 @@ class Packcr
         end
       end
 
-      def get_reverse_code(gen, onsuccess, indent, bare, oncut)
+      def get_reverse_code(gen, onsuccess, indent, unwrap, oncut)
         case gen.lang
         when :rb
           erbout = +""
@@ -69,11 +69,6 @@ class Packcr
             erbout << ", offset_loc".freeze
           end
           erbout << ")\n    throw(#{onsuccess})\n  end\nend\n".freeze
-          erbout
-        when :rs
-          erbout = +""
-          erbout << "/* lib/packcr/templates/node/reference_reverse.rs.erb */\n\n".freeze
-
           erbout
         else
           raise "unknown lang #{gen.lang}"

data/lib/packcr/generated/node/rule_node.rb

@@ -1,7 +1,7 @@
 class Packcr
   class Node
     class RuleNode
-      def get_code(gen, onfail, indent, bare, oncut)
+      def get_code(gen, onfail, indent, unwrap, oncut)
         case gen.lang
         when :c
           erbout = +""
@@ -59,12 +59,13 @@ class Packcr
         when :rs
           erbout = +""
           for_ref = has_ref ? "" : "_"
-          erbout << "#[allow(non_snake_case)]\nfn evaluate_rule_#{name}(\n    &mut self,\n    #{for_ref}offset: usize,\n".freeze
+          erbout << "#[allow(non_snake_case)]\nfn evaluate_rule_#{name}(&mut self, #{for_ref}offset: usize, ".freeze
 
           if gen.location
             erbout << "    TODO\n".freeze
           end
-          erbout << "    #{for_ref}limits: Option<RuleSet>,\n) -> Option<ThunkChunk> {\n    let mut answer = ThunkChunk::new(self.input.position_offset);\n".freeze
+
+          erbout << "#{for_ref}limits: RuleLimit) -> Option<ThunkChunk> {\n    let mut answer = ThunkChunk::new(self.input.position_offset);\n".freeze
 
           if gen.location
             erbout << "    TODO\n".freeze
@@ -76,11 +77,10 @@ class Packcr
           end
           r = expr.reachability
           if r == Packcr::CODE_REACH__ALWAYS_SUCCEED
-
-            erbout << "#{gen.generate_code(expr, 0, 4, false)}    self.level -= 1;\n    return Some(answer);\n".freeze
+            erbout << "    let _ = (|| {\n#{gen.generate_code(expr, 0, 8, false)}        NOP\n    })();\n    self.level -= 1;\n    Some(answer)\n".freeze
 
           else
-            erbout << "    'L0000: {\n#{gen.generate_code(expr, 0, 8, false)}        self.level -= 1;\n        return Some(answer);\n    }\n    self.level -= 1;\n    return None;\n".freeze
+            erbout << "    match (|| {\n#{gen.generate_code(expr, 0, 8, false)}        NOP\n    })() {\n        NOP => {\n            self.level -= 1;\n            Some(answer)\n        }\n        _ => {\n            self.level -= 1;\n            None\n        }\n    }\n".freeze
           end
           erbout << "}\n".freeze
 

data/lib/packcr/generated/node/sequence_node.rb

@@ -1,7 +1,7 @@
 class Packcr
   class Node
     class SequenceNode
-      def get_code(gen, onfail, indent, bare, oncut)
+      def get_code(gen, onfail, indent, unwrap, oncut)
         case gen.lang
         when :c
           erbout = +""

data/lib/packcr/generated/node/string_node.rb

@@ -1,7 +1,7 @@
 class Packcr
   class Node
     class StringNode
-      def get_many_code(gen, onfail, indent, bare, oncut, n)
+      def get_many_code(gen, onfail, indent, unwrap, oncut, n)
         case gen.lang
         when :c
           erbout = +""
@@ -30,7 +30,7 @@ class Packcr
           erbout
         when :rs
           erbout = +""
-          erbout << "if self.refill_buffer(#{n}) < #{n}\n  || self.input.buffer.as_bytes()[self.input.position_offset..(self.input.position_offset + #{n})] != [#{value[0, n].each_char.map { |c| "b'#{Packcr.escape_character(c)}'" }.join(", ")}]\n{\n    break 'L#{format("%04d", onfail)};\n}\n".freeze
+          erbout << "if self.input.refill_buffer(#{n}) < #{n}\n    || !self.input.buffer[self.input.position_offset..] .starts_with(\"#{value[0, n].each_char.map { |c| "#{Packcr.escape_character(c)}" }.join}\")\n{\n    return throw(#{onfail});\n}\n".freeze
 
           if gen.location
             erbout << "TODO\n".freeze
@@ -43,7 +43,19 @@ class Packcr
         end
       end
 
-      def get_one_code(gen, onfail, indent, bare, oncut, n)
+      def get_many_reverse_code(gen, onsuccess, indent, unwrap, oncut, n)
+        case gen.lang
+        when :rs
+          erbout = +""
+          erbout << "if self.input.refill_buffer(#{n}) >= #{n}\n    && self.input.buffer[self.input.position_offset..].starts_with(\"#{value[0, n].each_char.map { |c| "#{Packcr.escape_character(c)}" }.join}\")\n{\n    self.input.position_offset += #{n};\n    return throw(#{onsuccess});\n}\n".freeze
+
+          erbout
+        else
+          raise "unknown lang #{gen.lang}"
+        end
+      end
+
+      def get_one_code(gen, onfail, indent, unwrap, oncut, n)
         case gen.lang
         when :c
           erbout = +""
@@ -67,7 +79,7 @@ class Packcr
           erbout
         when :rs
           erbout = +""
-          erbout << "if self.refill_buffer(1) < 1\n    || self.input.buffer.as_bytes()[self.input.position_offset] != b'#{Packcr.escape_character(value[0])}'\n{\n    break 'L#{format("%04d", onfail)};\n}\n".freeze
+          erbout << "if self.input.refill_buffer(1) < 1\n    || !self.input.buffer[self.input.position_offset..].starts_with(\"#{Packcr.escape_character(value[0])}\")\n{\n    return throw(#{onfail});\n}\n".freeze
 
           if gen.location
             erbout << "TODO\n".freeze
@@ -79,6 +91,18 @@ class Packcr
           raise "unknown lang #{gen.lang}"
         end
       end
+
+      def get_one_reverse_code(gen, onsuccess, indent, unwrap, oncut, n)
+        case gen.lang
+        when :rs
+          erbout = +""
+          erbout << "if self.input.refill_buffer(1) >= 1\n    && self.input.buffer[self.input.position_offset..].starts_with(\"#{Packcr.escape_character(value[0])}\")\n{\n    self.input.position_offset += 1;\n    return throw(#{onsuccess});\n}\n".freeze
+
+          erbout
+        else
+          raise "unknown lang #{gen.lang}"
+        end
+      end
     end
   end
 end

data/lib/packcr/generator.rb

@@ -15,16 +15,17 @@ class Packcr
       @label += 1
     end
 
-    def generate_code(node, onescape, indent, bare, reverse: false, oncut: nil)
+    def generate_code(node, onescape, indent, unwrap, reverse: false, oncut: nil)
       stream = @stream
       @stream = +""
       @level += 1
       begin
         if reverse
-          node.generate_reverse_code(self, onescape, indent, bare, oncut: oncut)
+          code = node.generate_reverse_code(self, onescape, indent, unwrap, oncut: oncut)
         else
-          node.generate_code(self, onescape, indent, bare, oncut: oncut)
+          code = node.generate_code(self, onescape, indent, unwrap, oncut: oncut)
         end
+        write Packcr.format_code(code, indent: indent, unwrap: unwrap)
         @stream
       ensure
         @level -= 1