stark 0.7.0 → 0.8.0

data/lib/stark.rb

@@ -1,7 +1,16 @@
 require 'thrift'
+require 'logger'
 
 module Stark
-  VERSION = '0.7.0'
+  VERSION = '0.8.0'
+
+  def self.logger
+    @logger ||= ::Logger.new($stdout)
+  end
+
+  def self.logger=(logger)
+    @logger = logger
+  end
 
   def self.pipe_transport
     cr, cw = IO.pipe
@@ -18,7 +27,12 @@ module Stark
     require 'stark/ruby'
     require 'stringio'
 
-    ast = Stark::Parser.ast File.read(file)
+    begin
+      contents = file.respond_to?(:read) ? file.read : File.read(file)
+      ast = Stark::Parser.ast contents
+    rescue => e
+      raise e, e.message + " while processing #{file} -\n#{e.backtrace.join("\n")}"
+    end
 
     stream = StringIO.new
 

data/lib/stark/ast.rb

@@ -49,5 +49,10 @@ class Stark::Parser
         obj.process_exception self
       end
     end
+
+    class Comment
+      def accept(obj)
+      end
+    end
   end
 end

data/lib/stark/client.rb

@@ -1,7 +1,10 @@
 require 'stark'
+require 'stark/protocol_helpers'
 
 module Stark
   class Client
+    include ProtocolHelpers
+
     def initialize(iprot, oprot)
       @iprot = iprot
       @oprot = oprot
@@ -15,72 +18,5 @@ module Stark
         raise x
       end
     end
-
-    def handle_throw(cls)
-      ip = @iprot
-
-      obj = cls::Struct.new
-
-      ip.read_struct_begin
-
-      while true
-        _, ftype, fid = ip.read_field_begin
-        break if ftype == ::Thrift::Types::STOP
-
-        obj.set_from_index ftype, fid, ip
-
-        ip.read_field_end
-      end
-
-      ip.read_struct_end
-
-      ip.read_message_end
-
-      raise cls.new(obj)
-    end
-
-    def handle_unexpected(rtype)
-      return if rtype == ::Thrift::Types::STOP
-      @iprot.skip(rtype)
-    end
-
-    def handle_bad_list(rtype, size)
-      size.times { @iprot.skip(rtype) }
-    end
-
-    def handle_bad_map(key, value, size)
-      size.times do
-        @iprot.skip(key)
-        @iprot.skip(value)
-      end
-    end
-
-    def hash_cast(obj)
-      return obj if obj.kind_of? Hash
-      return obj.to_h if obj.respond_to? :to_h
-
-      raise TypeError, "Unable to convert #{obj.class} to Hash"
-    end
-
-    def read_generic(type, id, cls)
-      ip = @iprot
-
-      obj = cls.new
-
-      ip.read_struct_begin
-
-      while true
-        _, ftype, fid = ip.read_field_begin
-        break if ftype == ::Thrift::Types::STOP
-
-        obj.set_from_index ftype, fid, ip
-
-        ip.read_field_end
-      end
-
-      ip.read_struct_end
-
-      obj
-    end
   end
 end

data/lib/stark/exception.rb

@@ -1,15 +1,15 @@
 module Stark
   class Exception < RuntimeError
-    def initialize(struct)
-      super "A remote exception occurred"
-
-      if struct.kind_of? Hash
-        @struct = self.class::Struct.new(struct)
-      else
-        @struct = struct
+    def initialize(fields_or_msg = nil)
+      case fields_or_msg
+      when Hash
+        fields_or_msg.each do |k,v|
+          send(:"#{k}=", v) if respond_to?(:"#{k}=")
+        end
+      when nil
+        fields_or_msg = "A remote exception occurred"
       end
+      super
     end
-
-    attr_reader :struct
   end
 end

data/lib/stark/processor.rb

@@ -1,5 +1,9 @@
+require 'stark/protocol_helpers'
+
 module Stark
   class Processor
+    include ProtocolHelpers
+
     def initialize(handler)
       @handler = handler
     end
@@ -8,6 +12,7 @@ module Stark
       name, type, seqid  = iprot.read_message_begin
       fail unless type == Thrift::MessageTypes::CALL
 
+      x = nil
       if respond_to?("process_#{name}")
         send("process_#{name}", seqid, iprot, oprot)
         true
@@ -15,63 +20,19 @@ module Stark
         iprot.skip(::Thrift::Types::STRUCT)
         iprot.read_message_end
         x = ::Thrift::ApplicationException.new(Thrift::ApplicationException::UNKNOWN_METHOD, 'Unknown function '+name)
+        false
+      end
+    rescue ::Exception => e
+      Stark.logger.error "#{self.class.name}#process_#{name}: #{e.message}\n  " + e.backtrace.join("\n  ")
+      x = Thrift::ApplicationException.new(Thrift::ApplicationException::INTERNAL_ERROR, e.message)
+      false
+    ensure
+      if x
         oprot.write_message_begin(name, ::Thrift::MessageTypes::EXCEPTION, seqid)
         x.write(oprot)
         oprot.write_message_end
         oprot.trans.flush
-        false
-      end
-    end
-
-    def check_raise_specific(name, seqid, op, c)
-      begin
-        yield
-      rescue c => e
-        op.write_message_begin name, ::Thrift::MessageTypes::REPLY, seqid
-        op.write_struct_begin 'result_struct'
-
-        op.write_field_begin 'result', ::Thrift::Types::STRUCT, 1
-        op.write_struct_begin c.class.name
-        e.struct.write_fields op
-        op.write_field_end
-        op.write_field_stop
-        op.write_struct_end
-
-        op.write_field_end
-        op.write_field_stop
-        op.write_struct_end
-
-        op.write_message_end
-        op.trans.flush
-
-        nil
       end
     end
-
-    def hash_cast(obj)
-      return obj if obj.kind_of? Hash
-      return obj.to_h if obj.respond_to? :to_h
-
-      raise TypeError, "Unable to convert #{obj.class} to Hash"
-    end
-
-    def read_struct(ip, type, id, cls)
-      obj = cls.new
-
-      ip.read_struct_begin
-
-      while true
-        _, ftype, fid = ip.read_field_begin
-        break if ftype == ::Thrift::Types::STOP
-
-        obj.set_from_index ftype, fid, ip
-
-        ip.read_field_end
-      end
-
-      ip.read_struct_end
-
-      obj
-    end
   end
 end

data/lib/stark/protocol_helpers.rb

@@ -0,0 +1,161 @@
+module Stark
+  module ProtocolHelpers
+    COERCION_TO_STRING = Hash.new {|h,k|
+      lambda {|ip| ip.skip k; nil }
+    }.update({
+      ::Thrift::Types::BOOL   => lambda {|ip| ip.read_bool.to_s },
+      ::Thrift::Types::BYTE   => lambda {|ip| ip.read_byte.to_s },
+      ::Thrift::Types::I16    => lambda {|ip| ip.read_i16.to_s },
+      ::Thrift::Types::I32    => lambda {|ip| ip.read_i32.to_s },
+      ::Thrift::Types::I64    => lambda {|ip| ip.read_i64.to_s },
+      ::Thrift::Types::DOUBLE => lambda {|ip| ip.read_double.to_s },
+    })
+
+    COERCION_FROM_STRING = Hash.new {|h,k|
+      lambda {|val| nil }
+    }.update({
+      ::Thrift::Types::BOOL   => lambda {|val|
+        val =~ /^(1|y|t|on)/ ? true : false },
+      ::Thrift::Types::BYTE   => lambda {|val| val.to_i },
+      ::Thrift::Types::I16    => lambda {|val| val.to_i },
+      ::Thrift::Types::I32    => lambda {|val| val.to_i },
+      ::Thrift::Types::I64    => lambda {|val| val.to_i },
+      ::Thrift::Types::DOUBLE => lambda {|val| val.to_f },
+    })
+
+    def expect(ip, expected, actual)
+      return nil if actual == ::Thrift::Types::STOP
+
+      if expected == actual
+        yield
+      elsif expected == ::Thrift::Types::STRING
+        COERCION_TO_STRING[actual][ip]
+      elsif actual == ::Thrift::Types::STRING
+        COERCION_FROM_STRING[expected][ip.read_string]
+      else
+        ip.skip actual
+        nil
+      end
+    end
+
+    def valid_element_type?(expected, actual)
+      expected == actual ||
+        expected == ::Thrift::Types::STRING ||
+        actual == ::Thrift::Types::STRING
+    end
+
+    def expect_list(ip, expected)
+      actual, size = ip.read_list_begin
+      if valid_element_type?(expected, actual)
+        yield actual, size
+      else
+        size.times { ip.skip actual }
+        nil
+      end
+    ensure
+      ip.read_list_end
+    end
+
+    def expect_map(ip, expected_key, expected_value)
+      actual_key, actual_value, size = ip.read_map_begin
+      if valid_element_type?(expected_key, actual_key) &&
+          valid_element_type?(expected_value, actual_value)
+        yield actual_key, actual_value, size
+      else
+        size.times do
+          ip.skip actual_key
+          ip.skip actual_value
+        end
+        nil
+      end
+    ensure
+      ip.read_map_end
+    end
+
+    def expect_set(ip, expected)
+      actual, size = ip.read_set_begin
+      if valid_element_type?(expected, actual)
+        yield actual, size
+      else
+        size.times { ip.skip actual }
+        nil
+      end
+    ensure
+      ip.read_set_end
+    end
+
+    def hash_cast(obj)
+      return obj if obj.kind_of? Hash
+      return obj.to_h if obj.respond_to? :to_h
+
+      raise TypeError, "Unable to convert #{obj.class} to Hash"
+    end
+
+    THRIFT_TO_RUBY = {
+      ::Thrift::Types::BOOL => [TrueClass, FalseClass, NilClass],
+      ::Thrift::Types::BYTE => [Fixnum],
+      ::Thrift::Types::I16 => [Fixnum],
+      ::Thrift::Types::I32 => [Fixnum],
+      ::Thrift::Types::I64 => [Fixnum],
+      ::Thrift::Types::DOUBLE => [Float],
+      ::Thrift::Types::STRING => [String],
+      ::Thrift::Types::MAP    => [Hash],
+      ::Thrift::Types::SET    => [Set],
+      ::Thrift::Types::LIST   => [Array]
+    }
+
+    def value_for_write(val, expected, additional = nil)
+      return val if val.nil?
+
+      ruby_types = nil
+      if additional
+        case expected
+        when ::Thrift::Types::STRUCT
+          if Class === additional && # Struct or Exception
+            (additional < Stark::Struct || additional < Stark::Exception)
+            ruby_types = [additional]
+          end
+        when ::Thrift::Types::I32
+          if Hash === additional # Enum hash
+            ruby_types = [Symbol]
+          end
+        end
+      else
+        ruby_types = THRIFT_TO_RUBY[expected]
+      end
+
+      raise TypeError, "Unknown Thrift type #{expected}" unless ruby_types
+
+      return val if ruby_types.any? {|t| t === val }
+
+      if String === val
+        obj = COERCION_FROM_STRING[expected][val]
+        raise TypeError, "Cannot coerce #{val.class} to #{ruby_types.join(' ')}" unless obj
+        return obj
+      end
+
+      case expected
+      when ::Thrift::Types::BOOL
+        return val
+      when ::Thrift::Types::STRING
+        return val.to_s
+      when ::Thrift::Types::MAP
+        return val.to_hash if val.respond_to?(:to_hash)
+      when ::Thrift::Types::SET
+        return Set.new(val.to_a) if val.respond_to?(:to_a)
+      when ::Thrift::Types::LIST
+        return val.to_a if val.respond_to?(:to_a)
+      when ::Thrift::Types::BYTE, ::Thrift::Types::I16, ::Thrift::Types::I64
+        return val.to_i if val.respond_to?(:to_i)
+      when ::Thrift::Types::I32
+        if Hash === additional # Enum hash
+          return val.to_sym if val.respond_to?(:to_sym)
+        end
+        return additional[val.to_i] if val.respond_to?(:to_i)
+      when ::Thrift::Types::DOUBLE
+        return val.to_f if val.respond_to?(:to_f)
+      end
+      raise TypeError, "Unexpected type #{val.class} (#{val.inspect}); was expecting #{ruby_types.join(' ')}"
+    end
+  end
+end

data/lib/stark/raw_parser.rb

@@ -613,7 +613,7 @@ class Stark::Parser
     return _tmp
   end
 
-  # reserved = ("BEGIN" | "END" | "__CLASS__" | "__DIR__" | "__FILE__" | "__FUNCTION__" | "__LINE__" | "__METHOD__" | "__NAMESPACE__" | "abstract" | "alias" | "and" | "args" | "as" | "assert" | "begin" | "break" | "case" | "catch" | "class" | "clone" | "continue" | "declare" | "def" | "default" | "del" | "delete" | "do" | "dynamic" | "elif" | "else" | "elseif" | "elsif" | "end" | "enddeclare" | "endfor" | "endforeach" | "endif" | "endswitch" | "endwhile" | "ensure" | "except" | "exec" | "finally" | "float" | "for" | "foreach" | "function" | "global" | "goto" | "if" | "implements" | "import" | "in" | "inline" | "instanceof" | "interface" | "is" | "lambda" | "module" | "native" | "new" | "next" | "nil" | "not" | "or" | "pass" | "public" | "print" | "private" | "protected" | "public" | "raise" | "redo" | "rescue" | "retry" | "register" | "return" | "self" | "sizeof" | "static" | "super" | "switch" | "synchronized" | "then" | "this" | "throw" | "transient" | "try" | "undef" | "union" | "unless" | "unsigned" | "until" | "use" | "var" | "virtual" | "volatile" | "when" | "while" | "with" | "xor" | "yield")
+  # reserved = ("BEGIN" | "END" | "__CLASS__" | "__DIR__" | "__FILE__" | "__FUNCTION__" | "__LINE__" | "__METHOD__" | "__NAMESPACE__" | "abstract" | "alias" | "and" | "args" | "as" | "assert" | "begin" | "break" | "case" | "catch" | "class" | "clone" | "continue" | "declare" | "def" | "default" | "del" | "delete" | "do" | "dynamic" | "elif" | "else" | "elseif" | "elsif" | "end" | "enddeclare" | "endfor" | "endforeach" | "endif" | "endswitch" | "endwhile" | "ensure" | "except" | "exec" | "finally" | "float" | "for" | "foreach" | "function" | "global" | "goto" | "if" | "implements" | "import" | "in" | "inline" | "instanceof" | "interface" | "is" | "lambda" | "module" | "native" | "new" | "next" | "nil" | "not" | "or" | "pass" | "public" | "print" | "private" | "protected" | "public" | "raise" | "redo" | "rescue" | "retry" | "register" | "return" | "self" | "sizeof" | "static" | "super" | "switch" | "synchronized" | "then" | "this" | "throws" | "transient" | "try" | "undef" | "union" | "unless" | "unsigned" | "until" | "use" | "var" | "virtual" | "volatile" | "when" | "while" | "with" | "xor" | "yield")
   def _reserved
 
     _save = self.pos
@@ -876,7 +876,7 @@ class Stark::Parser
       _tmp = match_string("this")
       break if _tmp
       self.pos = _save
-      _tmp = match_string("throw")
+      _tmp = match_string("throws")
       break if _tmp
       self.pos = _save
       _tmp = match_string("transient")
@@ -1424,8 +1424,8 @@ class Stark::Parser
     return _tmp
   end
 
-  # CComment = "/*" < (!"*/" .)* > "*/" obsp {comment(text)}
-  def _CComment
+  # CMLComment = "/*" < (!"*/" .)* > "*/" obsp {comment(text)}
+  def _CMLComment
 
     _save = self.pos
     while true # sequence
@@ -1482,7 +1482,64 @@ class Stark::Parser
       break
     end # end sequence
 
-    set_failed_rule :_CComment unless _tmp
+    set_failed_rule :_CMLComment unless _tmp
+    return _tmp
+  end
+
+  # CSLComment = "//" < (!"\n" .)* > bsp {comment(text)}
+  def _CSLComment
+
+    _save = self.pos
+    while true # sequence
+      _tmp = match_string("//")
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _text_start = self.pos
+      while true
+
+        _save2 = self.pos
+        while true # sequence
+          _save3 = self.pos
+          _tmp = match_string("\n")
+          _tmp = _tmp ? nil : true
+          self.pos = _save3
+          unless _tmp
+            self.pos = _save2
+            break
+          end
+          _tmp = get_byte
+          unless _tmp
+            self.pos = _save2
+          end
+          break
+        end # end sequence
+
+        break unless _tmp
+      end
+      _tmp = true
+      if _tmp
+        text = get_text(_text_start)
+      end
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      _tmp = apply(:_bsp)
+      unless _tmp
+        self.pos = _save
+        break
+      end
+      @result = begin; comment(text); end
+      _tmp = true
+      unless _tmp
+        self.pos = _save
+      end
+      break
+    end # end sequence
+
+    set_failed_rule :_CSLComment unless _tmp
     return _tmp
   end
 
@@ -1543,12 +1600,15 @@ class Stark::Parser
     return _tmp
   end
 
-  # Comment = (CComment | HComment)
+  # Comment = (CMLComment | CSLComment | HComment)
   def _Comment
 
     _save = self.pos
     while true # choice
-      _tmp = apply(:_CComment)
+      _tmp = apply(:_CMLComment)
+      break if _tmp
+      self.pos = _save
+      _tmp = apply(:_CSLComment)
       break if _tmp
       self.pos = _save
       _tmp = apply(:_HComment)
@@ -3170,12 +3230,12 @@ class Stark::Parser
     return _tmp
   end
 
-  # Throws = - "throws" - "(" FieldList ")"
+  # Throws = osp "throws" osp "(" FieldList ")"
   def _Throws
 
     _save = self.pos
     while true # sequence
-      _tmp = apply(:__hyphen_)
+      _tmp = apply(:_osp)
       unless _tmp
         self.pos = _save
         break
@@ -3185,7 +3245,7 @@ class Stark::Parser
         self.pos = _save
         break
       end
-      _tmp = apply(:__hyphen_)
+      _tmp = apply(:_osp)
       unless _tmp
         self.pos = _save
         break
@@ -3969,7 +4029,7 @@ class Stark::Parser
   Rules[:_whitespace] = rule_info("whitespace", "/([ \\t\\r\\n]*)/")
   Rules[:_st_identifier] = rule_info("st_identifier", "/([a-zA-Z-][\\.a-zA-Z_0-9-]*)/")
   Rules[:_literal_begin] = rule_info("literal_begin", "/(['\\\"])/")
-  Rules[:_reserved] = rule_info("reserved", "(\"BEGIN\" | \"END\" | \"__CLASS__\" | \"__DIR__\" | \"__FILE__\" | \"__FUNCTION__\" | \"__LINE__\" | \"__METHOD__\" | \"__NAMESPACE__\" | \"abstract\" | \"alias\" | \"and\" | \"args\" | \"as\" | \"assert\" | \"begin\" | \"break\" | \"case\" | \"catch\" | \"class\" | \"clone\" | \"continue\" | \"declare\" | \"def\" | \"default\" | \"del\" | \"delete\" | \"do\" | \"dynamic\" | \"elif\" | \"else\" | \"elseif\" | \"elsif\" | \"end\" | \"enddeclare\" | \"endfor\" | \"endforeach\" | \"endif\" | \"endswitch\" | \"endwhile\" | \"ensure\" | \"except\" | \"exec\" | \"finally\" | \"float\" | \"for\" | \"foreach\" | \"function\" | \"global\" | \"goto\" | \"if\" | \"implements\" | \"import\" | \"in\" | \"inline\" | \"instanceof\" | \"interface\" | \"is\" | \"lambda\" | \"module\" | \"native\" | \"new\" | \"next\" | \"nil\" | \"not\" | \"or\" | \"pass\" | \"public\" | \"print\" | \"private\" | \"protected\" | \"public\" | \"raise\" | \"redo\" | \"rescue\" | \"retry\" | \"register\" | \"return\" | \"self\" | \"sizeof\" | \"static\" | \"super\" | \"switch\" | \"synchronized\" | \"then\" | \"this\" | \"throw\" | \"transient\" | \"try\" | \"undef\" | \"union\" | \"unless\" | \"unsigned\" | \"until\" | \"use\" | \"var\" | \"virtual\" | \"volatile\" | \"when\" | \"while\" | \"with\" | \"xor\" | \"yield\")")
+  Rules[:_reserved] = rule_info("reserved", "(\"BEGIN\" | \"END\" | \"__CLASS__\" | \"__DIR__\" | \"__FILE__\" | \"__FUNCTION__\" | \"__LINE__\" | \"__METHOD__\" | \"__NAMESPACE__\" | \"abstract\" | \"alias\" | \"and\" | \"args\" | \"as\" | \"assert\" | \"begin\" | \"break\" | \"case\" | \"catch\" | \"class\" | \"clone\" | \"continue\" | \"declare\" | \"def\" | \"default\" | \"del\" | \"delete\" | \"do\" | \"dynamic\" | \"elif\" | \"else\" | \"elseif\" | \"elsif\" | \"end\" | \"enddeclare\" | \"endfor\" | \"endforeach\" | \"endif\" | \"endswitch\" | \"endwhile\" | \"ensure\" | \"except\" | \"exec\" | \"finally\" | \"float\" | \"for\" | \"foreach\" | \"function\" | \"global\" | \"goto\" | \"if\" | \"implements\" | \"import\" | \"in\" | \"inline\" | \"instanceof\" | \"interface\" | \"is\" | \"lambda\" | \"module\" | \"native\" | \"new\" | \"next\" | \"nil\" | \"not\" | \"or\" | \"pass\" | \"public\" | \"print\" | \"private\" | \"protected\" | \"public\" | \"raise\" | \"redo\" | \"rescue\" | \"retry\" | \"register\" | \"return\" | \"self\" | \"sizeof\" | \"static\" | \"super\" | \"switch\" | \"synchronized\" | \"then\" | \"this\" | \"throws\" | \"transient\" | \"try\" | \"undef\" | \"union\" | \"unless\" | \"unsigned\" | \"until\" | \"use\" | \"var\" | \"virtual\" | \"volatile\" | \"when\" | \"while\" | \"with\" | \"xor\" | \"yield\")")
   Rules[:_tok_int_constant] = rule_info("tok_int_constant", "(< intconstant > { text.to_i } | < hexconstant > { text.to_i } | \"false\" { 0 } | \"true\" { 1 })")
   Rules[:_tok_dub_constant] = rule_info("tok_dub_constant", "dubconstant:f { f.to_f }")
   Rules[:_tok_identifier] = rule_info("tok_identifier", "< identifier > {text}")
@@ -3982,9 +4042,10 @@ class Stark::Parser
   Rules[:_obsp] = rule_info("obsp", "/[\\s]*/")
   Rules[:_root] = rule_info("root", "Program !.")
   Rules[:_Program] = rule_info("Program", "Element*:a { a }")
-  Rules[:_CComment] = rule_info("CComment", "\"/*\" < (!\"*/\" .)* > \"*/\" obsp {comment(text)}")
+  Rules[:_CMLComment] = rule_info("CMLComment", "\"/*\" < (!\"*/\" .)* > \"*/\" obsp {comment(text)}")
+  Rules[:_CSLComment] = rule_info("CSLComment", "\"//\" < (!\"\\n\" .)* > bsp {comment(text)}")
   Rules[:_HComment] = rule_info("HComment", "\"\#\" < (!\"\\n\" .)* > bsp {comment(text)}")
-  Rules[:_Comment] = rule_info("Comment", "(CComment | HComment)")
+  Rules[:_Comment] = rule_info("Comment", "(CMLComment | CSLComment | HComment)")
   Rules[:_CaptureDocText] = rule_info("CaptureDocText", "{}")
   Rules[:_DestroyDocText] = rule_info("DestroyDocText", "{}")
   Rules[:_HeaderList] = rule_info("HeaderList", "(HeaderList Header | Header)")
@@ -4021,7 +4082,7 @@ class Stark::Parser
   Rules[:_FunctionList] = rule_info("FunctionList", "(FunctionList:l Function:f { l + [f] } | Function:f { [f] })")
   Rules[:_Function] = rule_info("Function", "CaptureDocText OneWay?:o FunctionType:rt - tok_identifier:name osp \"(\" FieldList?:args \")\" Throws?:t CommaOrSemicolonOptional {function(name, rt, args, t, o)}")
   Rules[:_OneWay] = rule_info("OneWay", "(\"oneway\" | \"async\") - { :oneway }")
-  Rules[:_Throws] = rule_info("Throws", "- \"throws\" - \"(\" FieldList \")\"")
+  Rules[:_Throws] = rule_info("Throws", "osp \"throws\" osp \"(\" FieldList \")\"")
   Rules[:_FieldList] = rule_info("FieldList", "(FieldList:l Field:f { l + [f] } | Field:f { [f] })")
   Rules[:_Field] = rule_info("Field", "CaptureDocText FieldIdentifier?:i osp FieldRequiredness?:req osp FieldType:t osp tok_identifier:n osp FieldValue?:val CommaOrSemicolonOptional {field(i,t,n,val,req)}")
   Rules[:_FieldIdentifier] = rule_info("FieldIdentifier", "tok_int_constant:n \":\" {n}")