packcr 0.0.7 → 0.1.0

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

@@ -7,11 +7,12 @@ class Packcr
           erbout = +""
           erbout << "{\n".freeze
 
+          r = expr.reachability
           if min > 0
             erbout << "    const size_t p0 = ctx->position_offset;\n".freeze
 
             if gen.location
-              erbout << "    const pcc_location_t p0_loc = ctx->position_offset_loc;\n".freeze
+              erbout << "    const packcr_location_t p0_loc = ctx->position_offset_loc;\n".freeze
             end
             erbout << "    const size_t n0 = chunk->thunks.len;\n".freeze
           end
@@ -25,13 +26,13 @@ class Packcr
           end
           erbout << "        const size_t p = ctx->position_offset;\n".freeze
 
-          if gen.location
-            erbout << "        const pcc_location_t p_loc = ctx->position_offset_loc;\n".freeze
+          if r != Packcr::CODE_REACH__ALWAYS_SUCCEED
+            if gen.location
+              erbout << "        const packcr_location_t p_loc = ctx->position_offset_loc;\n".freeze
+            end
+            erbout << "        const size_t n = chunk->thunks.len;\n".freeze
           end
-          erbout << "        const size_t n = chunk->thunks.len;\n".freeze
-
           l = gen.next_label
-          r = expr.reachability
           erbout << "#{gen.generate_code(expr, l, 8, false)}        if (ctx->position_offset == p) break;\n".freeze
 
           if r != Packcr::CODE_REACH__ALWAYS_SUCCEED
@@ -40,7 +41,7 @@ class Packcr
             if gen.location
               erbout << "        ctx->position_offset_loc = p_loc;\n".freeze
             end
-            erbout << "        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);\n        break;\n".freeze
+            erbout << "        packcr_thunk_array__revert(ctx->auxil, &chunk->thunks, n);\n        break;\n".freeze
           end
           erbout << "    }\n".freeze
 
@@ -50,7 +51,7 @@ class Packcr
             if gen.location
               erbout << "        ctx->position_offset_loc = p0_loc;\n".freeze
             end
-            erbout << "        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);\n        goto L#{format("%04d", onfail)};\n    }\n".freeze
+            erbout << "        packcr_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);\n        goto L#{format("%04d", onfail)};\n    }\n".freeze
           end
           erbout << "}\n".freeze
 
@@ -105,6 +106,58 @@ class Packcr
             erbout << "  answer.thunks[m#{gen.level}..-1] = []\n  throw(#{onfail})\nend\n".freeze
           end
           erbout
+        when :rs
+          erbout = +""
+          if min > 0
+            erbout << "let p0 = self.input.position_offset;\n".freeze
+
+            if gen.location
+              erbout << "TODO\n".freeze
+            end
+          end
+          use_count = max >= 0 || min > 0
+          if use_count
+            erbout << "let mut i = -1;\n".freeze
+          end
+          m = gen.next_label
+          erbout << "'L#{format("%04d", m)}: loop {\n".freeze
+
+          if use_count
+            erbout << "    i += 1;\n".freeze
+          end
+          if max >= 0
+            erbout << "    if i >= #{max} { break; }\n".freeze
+          end
+          erbout << "    let p = self.input.position_offset;\n".freeze
+
+          if (r != Packcr::CODE_REACH__ALWAYS_SUCCEED) && gen.location
+            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 << "        continue 'L#{format("%04d", m)};\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 min > 0
+            erbout << "if i < #{min} {\n    self.input.position_offset = p0;\n".freeze
+
+            if gen.location
+              erbout << "    TODO\n".freeze
+            end
+            erbout << "    break 'L#{format("%04d", onfail)};\n}\n".freeze
+          end
+          erbout
+        else
+          raise "unknown lang #{gen.lang}"
         end
       end
 
@@ -112,45 +165,43 @@ class Packcr
         case gen.lang
         when :c
           erbout = +""
-          erbout << "{\n".freeze
-
-          l = gen.next_label
-          erbout << "    const size_t p = ctx->position_offset;\n".freeze
+          r = expr.reachability
+          if r == Packcr::CODE_REACH__ALWAYS_SUCCEED
+            erbout << "#{gen.generate_code(expr, nil, 0, true)}".freeze
+          else
+            erbout << "{\n".freeze
 
-          if gen.location
-            erbout << "    const pcc_location_t p_loc = ctx->position_offset_loc;\n".freeze
-          end
-          erbout << "    const size_t n = chunk->thunks.len;\n".freeze
+            l = gen.next_label
+            erbout << "    const size_t p = ctx->position_offset;\n".freeze
 
-          r = expr.reachability
-          erbout << "#{gen.generate_code(expr, l, 4, false)}".freeze
-          if r != Packcr::CODE_REACH__ALWAYS_SUCCEED
+            if gen.location
+              erbout << "    const packcr_location_t p_loc = ctx->position_offset_loc;\n".freeze
+            end
+            erbout << "    const size_t n = chunk->thunks.len;\n#{gen.generate_code(expr, l, 4, false)}".freeze
             m = gen.next_label
             erbout << "    goto L#{format("%04d", m)};\nL#{format("%04d", l)}:;\n".freeze
 
             if gen.location
               erbout << "    ctx->position_offset_loc = p_loc;\n".freeze
             end
-            erbout << "    ctx->position_offset = p;\n    pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);\nL#{format("%04d", m)}:;\n".freeze
+            erbout << "    ctx->position_offset = p;\n    packcr_thunk_array__revert(ctx->auxil, &chunk->thunks, n);\nL#{format("%04d", m)}:;\n}\n".freeze
           end
-          erbout << "}\n".freeze
-
           erbout
         when :rb
           erbout = +""
-          l = gen.next_label
-          erbout << "pos#{gen.level} = @position_offset\n".freeze
-
-          if gen.location
-            erbout << "p_loc#{gen.level} = @position_offset_loc\n".freeze
-          end
-          erbout << "n#{gen.level} = answer.thunks.length\n".freeze
-
           r = expr.reachability
           if r == Packcr::CODE_REACH__ALWAYS_SUCCEED
 
-            erbout << "#{gen.generate_code(expr, l, 0, false)}".freeze
+            erbout << "#{gen.generate_code(expr, nil, 0, true)}".freeze
           else
+            l = gen.next_label
+            erbout << "pos#{gen.level} = @position_offset\n".freeze
+
+            if gen.location
+              erbout << "p_loc#{gen.level} = @position_offset_loc\n".freeze
+            end
+            erbout << "n#{gen.level} = answer.thunks.length\n".freeze
+
             m = gen.next_label
             erbout << "catch(#{m}) do\n  catch(#{l}) do\n#{gen.generate_code(expr, l, 4, false)}    throw(#{m})\n  end\n".freeze
 
@@ -160,6 +211,8 @@ class Packcr
             erbout << "  @position_offset = pos#{gen.level}\n  answer.thunks[n#{gen.level}..-1] = []\nend\n".freeze
           end
           erbout
+        else
+          raise "unknown lang #{gen.lang}"
         end
       end
     end

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

@@ -6,9 +6,9 @@ class Packcr
         when :c
           erbout = +""
           if index.nil?
-            erbout << "{\n    pcc_rule_set_t *l = NULL;\n    if (limits && ctx->position_offset == offset && pcc_rule_set__index(ctx->auxil, limits, pcc_evaluate_rule_#{name}) == PCC_VOID_VALUE) {\n        l = limits;\n    }\n    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_#{name}, &chunk->thunks, NULL, offset".freeze
+            erbout << "{\n    packcr_rule_set_t *l = NULL;\n    if (limits && ctx->position_offset == offset && packcr_rule_set__index(ctx->auxil, limits, packcr_evaluate_rule_#{name}) == PACKCR_VOID_VALUE) {\n        l = limits;\n    }\n    if (!packcr_apply_rule(ctx, packcr_evaluate_rule_#{name}, &chunk->thunks, NULL, offset".freeze
           else
-            erbout << "{\n    pcc_rule_set_t *l = NULL;\n    if (limits && ctx->position_offset == offset && pcc_rule_set__index(ctx->auxil, limits, pcc_evaluate_rule_#{name}) == PCC_VOID_VALUE) {\n        l = limits;\n    }\n    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_#{name}, &chunk->thunks, &(chunk->values.buf[#{index}]), offset".freeze
+            erbout << "{\n    packcr_rule_set_t *l = NULL;\n    if (limits && ctx->position_offset == offset && packcr_rule_set__index(ctx->auxil, limits, packcr_evaluate_rule_#{name}) == PACKCR_VOID_VALUE) {\n        l = limits;\n    }\n    if (!packcr_apply_rule(ctx, packcr_evaluate_rule_#{name}, &chunk->thunks, &(chunk->values.buf[#{index}]), offset".freeze
 
           end
           if gen.location
@@ -37,6 +37,13 @@ class Packcr
           end
           erbout << ")\n    throw(#{onfail})\n  end\nend\n".freeze
           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
+        else
+          raise "unknown lang #{gen.lang}"
         end
       end
 
@@ -63,6 +70,13 @@ class Packcr
           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}"
         end
       end
     end

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

@@ -5,26 +5,26 @@ class Packcr
         case gen.lang
         when :c
           erbout = +""
-          erbout << "static pcc_thunk_chunk_t *pcc_evaluate_rule_#{name}(pcc_context_t *ctx, size_t offset".freeze
+          erbout << "static packcr_thunk_chunk_t *packcr_evaluate_rule_#{name}(packcr_context_t *ctx, size_t offset".freeze
           if gen.location
-            erbout << ", pcc_location_t offset_loc".freeze
+            erbout << ", packcr_location_t offset_loc".freeze
           end
-          erbout << ", pcc_rule_set_t *limits) {\n    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);\n    chunk->pos = ctx->position_offset;\n".freeze
+          erbout << ", packcr_rule_set_t *limits) {\n    packcr_thunk_chunk_t *const chunk = packcr_thunk_chunk__create(ctx);\n    chunk->pos = ctx->position_offset;\n".freeze
 
           if gen.location
             erbout << "    chunk->pos_loc = ctx->position_offset_loc;\n".freeze
           end
-          erbout << "    PCC_DEBUG(ctx->auxil, PCC_DBG_EVALUATE, \"#{name}\", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));\n    ctx->level++;\n    pcc_value_table__resize(ctx->auxil, &chunk->values, #{vars.length});\n    pcc_capture_table__resize(ctx->auxil, &chunk->capts, #{capts.length});\n".freeze
+          erbout << "    PACKCR_DEBUG(ctx->auxil, PACKCR_DBG_EVALUATE, \"#{name}\", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));\n    ctx->level++;\n    packcr_value_table__resize(ctx->auxil, &chunk->values, #{vars.length});\n    packcr_capture_table__resize(ctx->auxil, &chunk->capts, #{capts.length});\n".freeze
 
           if !vars.empty?
-            erbout << "    pcc_value_table__clear(ctx->auxil, &chunk->values);\n".freeze
+            erbout << "    packcr_value_table__clear(ctx->auxil, &chunk->values);\n".freeze
           end
           r = expr.reachability
 
-          erbout << "#{gen.generate_code(expr, 0, 4, false)}    ctx->level--;\n    PCC_DEBUG(ctx->auxil, PCC_DBG_MATCH, \"#{name}\", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->position_offset - chunk->pos));\n    return chunk;\n".freeze
+          erbout << "#{gen.generate_code(expr, 0, 4, false)}    ctx->level--;\n    PACKCR_DEBUG(ctx->auxil, PACKCR_DBG_MATCH, \"#{name}\", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->position_offset - chunk->pos));\n    return chunk;\n".freeze
 
           if r != Packcr::CODE_REACH__ALWAYS_SUCCEED
-            erbout << "L0000:;\n    ctx->level--;\n    PCC_DEBUG(ctx->auxil, PCC_DBG_NOMATCH, \"#{name}\", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->position_offset - chunk->pos));\n    pcc_thunk_chunk__destroy(ctx, chunk);\n    return NULL;\n".freeze
+            erbout << "L0000:;\n    ctx->level--;\n    PACKCR_DEBUG(ctx->auxil, PACKCR_DBG_NOMATCH, \"#{name}\", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->position_offset - chunk->pos));\n    packcr_thunk_chunk__destroy(ctx, chunk);\n    return NULL;\n".freeze
           end
           erbout << "}\n".freeze
 
@@ -56,6 +56,37 @@ class Packcr
           erbout << "end\n".freeze
 
           erbout
+        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
+
+          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
+
+          if gen.location
+            erbout << "    TODO\n".freeze
+          end
+          erbout << "    self.level += 1;\n    answer.capts.resize(#{capts.length});\n".freeze
+
+          if !vars.empty?
+            erbout << "    answer.values.clear();\n".freeze
+          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
+
+          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
+          end
+          erbout << "}\n".freeze
+
+          erbout
+        else
+          raise "unknown lang #{gen.lang}"
         end
       end
     end

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

@@ -35,6 +35,24 @@ class Packcr
             break
           end
           erbout
+        when :rs
+          erbout = +""
+          if @cut && oncut
+            onfail = oncut
+            oncut = nil
+          end
+          nodes.each_with_index do |expr, i|
+            erbout << "#{gen.generate_code(expr, onfail, 0, false, oncut: oncut)}".freeze
+            next unless expr.reachability == Packcr::CODE_REACH__ALWAYS_FAIL
+
+            if i < nodes.length - 1
+              erbout << "/* unreachable codes omitted */\n".freeze
+            end
+            break
+          end
+          erbout
+        else
+          raise "unknown lang #{gen.lang}"
         end
       end
     end

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

@@ -5,7 +5,7 @@ class Packcr
         case gen.lang
         when :c
           erbout = +""
-          erbout << "if (\n    pcc_refill_buffer(ctx, #{n}) < #{n} ||\n".freeze
+          erbout << "if (\n    packcr_refill_buffer(ctx, #{n}) < #{n} ||\n".freeze
 
           (n - 1).times do |i|
             erbout << "    (ctx->buffer.buf + ctx->position_offset)[#{i}] != '#{Packcr.escape_character(value[i])}' ||\n".freeze
@@ -13,7 +13,7 @@ class Packcr
           erbout << "    (ctx->buffer.buf + ctx->position_offset)[#{n - 1}] != '#{Packcr.escape_character(value[n - 1])}'\n) goto L#{format("%04d", onfail)};\n".freeze
 
           if gen.location
-            erbout << "pcc_location_forward(&ctx->position_offset_loc, ctx->buffer.buf + ctx->position_offset, n);\n".freeze
+            erbout << "packcr_location_forward(&ctx->position_offset_loc, ctx->buffer.buf + ctx->position_offset, #{n});\n".freeze
           end
           erbout << "ctx->position_offset += #{n};\n".freeze
 
@@ -28,6 +28,18 @@ class Packcr
           erbout << "@position_offset += #{n}\n".freeze
 
           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
+
+          if gen.location
+            erbout << "TODO\n".freeze
+          end
+          erbout << "self.input.position_offset += #{n};\n".freeze
+
+          erbout
+        else
+          raise "unknown lang #{gen.lang}"
         end
       end
 
@@ -35,10 +47,10 @@ class Packcr
         case gen.lang
         when :c
           erbout = +""
-          erbout << "if (\n    pcc_refill_buffer(ctx, 1) < 1 ||\n    ctx->buffer.buf[ctx->position_offset] != '#{Packcr.escape_character(value[0])}'\n) goto L#{format("%04d", onfail)};\n".freeze
+          erbout << "if (\n    packcr_refill_buffer(ctx, 1) < 1 ||\n    ctx->buffer.buf[ctx->position_offset] != '#{Packcr.escape_character(value[0])}'\n) goto L#{format("%04d", onfail)};\n".freeze
 
           if gen.location
-            erbout << "    pcc_location_forward(&ctx->position_offset_loc, ctx->buffer.buf + ctx->position_offset, 1);\n".freeze
+            erbout << "    packcr_location_forward(&ctx->position_offset_loc, ctx->buffer.buf + ctx->position_offset, 1);\n".freeze
           end
           erbout << "ctx->position_offset++;\n".freeze
 
@@ -53,6 +65,18 @@ class Packcr
           erbout << "@position_offset += 1\n".freeze
 
           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
+
+          if gen.location
+            erbout << "TODO\n".freeze
+          end
+          erbout << "self.input.position_offset += 1;\n".freeze
+
+          erbout
+        else
+          raise "unknown lang #{gen.lang}"
         end
       end
     end

data/lib/packcr/node/reference_node.rb

@@ -33,6 +33,7 @@ class Packcr
       end
 
       def setup_rule(rule)
+        rule.has_ref = true
         return unless var
 
         i = rule.vars.index do |ref|

data/lib/packcr/node/rule_node.rb

@@ -1,7 +1,7 @@
 class Packcr
   class Node
     class RuleNode < Packcr::Node
-      attr_accessor :codes, :name, :expr, :ref, :vars, :capts, :line, :col, :top
+      attr_accessor :codes, :name, :expr, :ref, :vars, :capts, :line, :col, :top, :has_ref
 
       def initialize(expr = nil, name = nil, line = nil, col = nil)
         super()
@@ -13,6 +13,7 @@ class Packcr
         @name = name
         @line = line
         @col = col
+        @has_ref = false
       end
 
       def debug_dump(indent = 0)