protobuf-generate 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fa660a22bbbf1df9773fa0d2740b8379c39f50b2
-  data.tar.gz: 1115bc3ce6f5054a2153bfe71c7625b471dbdd51
+  metadata.gz: 62a9a7dc427851854af74f77d0143aa950a5c8ab
+  data.tar.gz: c464d9c4aacdc84106511b5c47aac741053af044
 SHA512:
-  metadata.gz: 2d47e29531f20c161ed8d3f0c84ef7263540fe4c20ebd30cd96d02aac0cd5b43556387589d527ba33dc018fdb9e03ae9cef621dba79c998c35f936590c389be0
-  data.tar.gz: 1ccba34aed35c2fb0ce4007cd37ded06cee2eaaa9091641eab08ef323b6b363ac8cf0a0b5e5b8ad18428925054c970cb5a9530f0a3cf4d33bcefd09f48d8eaf4
+  metadata.gz: 0770f71df505d61ab1e3ebaef17e52cd949ec1113cabe6d84f1c706bfa31ed3c24adabada7dd97177dff4d51a335978fa3f43d09bdd7d662b2c7c810ca1bbc82
+  data.tar.gz: 646e176dbd99611c6524de75bf4c4f025d183cc3edab890460553e4fee4344737eeb8ebb634079798d4c5ff14840044963c7575bd5938693a20b414a0c5e163f

data/bin/protobuf-generate

@@ -30,7 +30,7 @@ begin
     # TODO: Each language should take care of file naming conventions as well.
     postfix  = File.basename(template).gsub(/\.erb$/, '') # c.erb, h.erb, demo.c.erb becomes .c, .h, demo.c
     package  = ast.find{|e| e.kind_of?(Protobuf::Generate::Ast::Package)}
-    package  = package ? package.name : File.basename(proto).gsub(/\.proto$/)
+    package  = package ? package.name : File.basename(proto).gsub(/\.proto$/, '')
     package  = package.gsub('.', '_').gsub(/([^A-Z_])([A-Z]+)/, '\1_\2').gsub(/_+/, '_').downcase
     filename = File.join(File.dirname(proto), [package, postfix].join('.'))
 

data/lib/protobuf/generate/language.rb

@@ -18,6 +18,12 @@ module Protobuf
           Hash[*%w{int32 0 int64 0 sint32 0 sint64 0 uint32 0 uint64 0 string 2 bool 0 float 5 double 1 fixed32 5 fixed64 1 sfixed32 5 sfixed64 1 bytes 2}][type]
         end
 
+        def type_count *types
+          select{|e| e.kind_of?(Protobuf::Generate::Ast::Message)}.inject(0) do |count, message|
+            count += message.fields.count{|f| types.map(&:to_s).include?(f.type)}
+          end
+        end
+
         def type_enum_default type, default
           enum = find{|e| e.kind_of?(Protobuf::Generate::Ast::Enum) && e.name == type} # TODO: Or raise unknown type.
           (enum.fields.find{|f| f.name == default.to_s} || enum.fields.first).name

data/lib/protobuf/generate/language/c.rb

@@ -7,6 +7,8 @@ module Protobuf
         match     %r{^ (?:gnu|[Cc]) (?:99|11) $}x
         templates Dir.glob(File.join(File.expand_path(File.dirname(__FILE__)), 'c', '*.erb'))
 
+        #--
+        # TODO: Base conventions with snake_case, camel_case and studly_caps converters.
         module Conventions
           def type     *name; snake_case *name, 't'    end
           def variable *name; snake_case *name         end
@@ -15,14 +17,35 @@ module Protobuf
 
           protected
             def snake_case *name
-              name.map(&:to_s).join('_').gsub(/([^A-Z_])([A-Z]+)/, '\1_\2').gsub(/[_.]+/, '_').downcase
+              name.compact.map(&:to_s).join('_').gsub(/([^A-Z_])([A-Z]+)/, '\1_\2').gsub(/[_.]+/, '_').downcase
             end
         end # Conventions
 
+        #--
+        # TODO: Break C into base class, c-static, c-dynamic.
+        # @size_max is only required for static C.
         def initialize ast, conventions = Conventions
+          validate ast
           ast.extend(conventions)
           super ast
         end
+
+        private
+          #--
+          # TODO: Pass in validations as you do conventions.
+          def validate ast
+            ast.each do |e| # TODO: ast.messages
+              next unless e.kind_of?(Protobuf::Generate::Ast::Message) # TODO: e.message?
+              e.fields.each do |field|
+                if field.label.match(/repeated/)
+                  raise "Message %s.%s field repeating is unsupported." % [e.name, field.name]
+                end
+                if field.type.match(/string|bytes/) && field.meta["size"].to_i <= 0
+                  raise "Message %s.%s %s field requires size meta comment > 0 // @size = DIGITS" % [e.name, field.name, field.type]
+                end
+              end
+            end
+          end
       end # C
     end # Langage
   end # Generate

data/lib/protobuf/generate/language/c/c.erb

@@ -4,20 +4,23 @@
 #include <stdint.h>
 #include <string.h>
 
-static int write_raw_byte(uint8_t value, uint8_t *buffer, int offset) {
+static inline int write_raw_byte(uint8_t value, uint8_t *buffer, int offset) {
   *(buffer + offset) = value;
   return ++offset;
 }
 
-int write_raw_little_endian32(uint32_t value, uint8_t *buffer, int offset) {
+<% if type_count(:float, :fixed32, :sfixed32) > 0 %>
+static int write_raw_little_endian32(uint32_t value, uint8_t *buffer, int offset) {
   offset = write_raw_byte((uint8_t)((value      ) & 0xFF), buffer, offset);
   offset = write_raw_byte((uint8_t)((value >>  8) & 0xFF), buffer, offset);
   offset = write_raw_byte((uint8_t)((value >> 16) & 0xFF), buffer, offset);
   offset = write_raw_byte((uint8_t)((value >> 24) & 0xFF), buffer, offset);
   return offset;
 }
+<% end %>
 
-int write_raw_little_endian64(uint64_t value, uint8_t *buffer, int offset) {
+<% if type_count(:double, :fixed64, :sfixed64) > 0 %>
+static int write_raw_little_endian64(uint64_t value, uint8_t *buffer, int offset) {
   offset = write_raw_byte((uint8_t)((value      ) & 0xFF), buffer, offset);
   offset = write_raw_byte((uint8_t)((value >>  8) & 0xFF), buffer, offset);
   offset = write_raw_byte((uint8_t)((value >> 16) & 0xFF), buffer, offset);
@@ -28,20 +31,25 @@ int write_raw_little_endian64(uint64_t value, uint8_t *buffer, int offset) {
   offset = write_raw_byte((uint8_t)((value >> 56) & 0xFF), buffer, offset);
   return offset;
 }
+<% end %>
 
-int write_raw_float(float value, uint8_t *buffer, int offset) {
+<% if type_count(:float) > 0 %>
+static int write_raw_float(float value, uint8_t *buffer, int offset) {
   union { uint32_t i; float f; } punner;
   punner.f = value;
   return write_raw_little_endian32(punner.i, buffer, offset);
 }
+<% end %>
 
-int write_raw_double(double value, uint8_t *buffer, int offset) {
+<% if type_count(:double) > 0 %>
+static int write_raw_double(double value, uint8_t *buffer, int offset) {
   union { uint64_t i; double f; } punner;
   punner.f = value;
   return write_raw_little_endian64(punner.i, buffer, offset);
 }
+<% end %>
 
-int write_raw_varint32(uint32_t value, uint8_t *buffer, int offset) {
+static int write_raw_varint32(uint32_t value, uint8_t *buffer, int offset) {
   while (1) {
     if ((value & ~0x7F) == 0) {
       offset = write_raw_byte((uint8_t)value, buffer, offset);
@@ -54,7 +62,8 @@ int write_raw_varint32(uint32_t value, uint8_t *buffer, int offset) {
   return offset;
 }
 
-int write_raw_varint64(uint64_t value, uint8_t *buffer, int offset) {
+<% if type_count(:int32, :int64, :sint64, :uint64) > 0 %>
+static int write_raw_varint64(uint64_t value, uint8_t *buffer, int offset) {
   while (1) {
     if ((value & ~0x7FL) == 0) {
       offset = write_raw_byte((uint8_t)value, buffer, offset);
@@ -66,6 +75,7 @@ int write_raw_varint64(uint64_t value, uint8_t *buffer, int offset) {
   }
   return offset;
 }
+<% end %>
 
 static int write_raw_bytes(uint8_t *bytes, int bytes_size, uint8_t *buffer, int offset) {
   for (int i = 0; i < bytes_size; ++i)
@@ -94,7 +104,8 @@ static inline int read_raw_byte(uint8_t *tag, const uint8_t *buffer, int offset)
   return ++offset;
 }
 
-int read_raw_little_endian32(uint32_t *tag, const uint8_t *buffer, int offset) {
+<% if type_count(:float, :fixed32, :sfixed32) > 0 %>
+static int read_raw_little_endian32(uint32_t *tag, const uint8_t *buffer, int offset) {
   offset = read_raw_byte((uint8_t *)tag, buffer, offset);
   uint8_t b1 = (uint8_t)*tag;
   offset = read_raw_byte((uint8_t *)tag, buffer, offset);
@@ -110,8 +121,10 @@ int read_raw_little_endian32(uint32_t *tag, const uint8_t *buffer, int offset) {
          (((uint32_t)b4 & 0xff) << 24);
   return offset;
 }
+<% end %>
 
-int read_raw_little_endian64(uint64_t *tag, const uint8_t *buffer, int offset) {
+<% if type_count(:double, :fixed64, :sfixed64) > 0 %>
+static int read_raw_little_endian64(uint64_t *tag, const uint8_t *buffer, int offset) {
   offset = read_raw_byte((uint8_t *)tag, buffer, offset);
   uint8_t b1 = (uint8_t)*tag;
   offset = read_raw_byte((uint8_t *)tag, buffer, offset);
@@ -140,22 +153,27 @@ int read_raw_little_endian64(uint64_t *tag, const uint8_t *buffer, int offset) {
 
   return offset;
 }
+<% end %>
 
-int read_raw_float(float *value, const uint8_t *buffer, int offset) {
+<% if type_count(:float) > 0 %>
+static int read_raw_float(float *value, const uint8_t *buffer, int offset) {
   union { uint32_t i; float f; } punner;
   offset = read_raw_little_endian32(&punner.i, buffer, offset);
   *value = punner.f;
   return offset;
 }
+<% end %>
 
-int read_raw_double(double *value, const uint8_t *buffer, int offset) {
+<% if type_count(:double) > 0 %>
+static int read_raw_double(double *value, const uint8_t *buffer, int offset) {
   union { uint64_t i; double f; } punner;
   offset = read_raw_little_endian64(&punner.i, buffer, offset);
   *value = punner.f;
   return offset;
 }
+<% end %>
 
-int read_raw_varint32(uint32_t *tag, const uint8_t *buffer, int offset) {
+static int read_raw_varint32(uint32_t *tag, const uint8_t *buffer, int offset) {
   uint8_t result;
 
   offset = read_raw_byte(&result, buffer, offset);
@@ -198,7 +216,8 @@ int read_raw_varint32(uint32_t *tag, const uint8_t *buffer, int offset) {
   return offset;
 }
 
-int read_raw_varint64(uint64_t *tag, const uint8_t *buffer, int offset) {
+<% if type_count(:int64, :sint64, :uint64) > 0 %>
+static int read_raw_varint64(uint64_t *tag, const uint8_t *buffer, int offset) {
   short shift = 0;
   uint8_t b;
   *tag = 0;
@@ -213,6 +232,7 @@ int read_raw_varint64(uint64_t *tag, const uint8_t *buffer, int offset) {
   /* return error code. */
   return -1;
 }
+<% end %>
 
 <% each do |exp| %>
   <% if exp.kind_of?(Protobuf::Generate::Ast::Message) %>
@@ -228,12 +248,12 @@ int read_raw_varint64(uint64_t *tag, const uint8_t *buffer, int offset) {
           <%= function exp.package, field.type, 'init', 'optional', 'attributes' %>(&pb-><%= field.name %>);
         <% elsif type_enum?(field.type) %>
           pb-><%= field.name %> = <%= constant exp.package, field.type, type_enum_default(field.type, field.options.fetch('default', nil)) %>;
-        <% elsif field.type =~ /bool/ %>
+        <% elsif field.type == 'bool' %>
           pb-><%= field.name %> = <%= field.options.fetch(:default, 'false') %>;
-        <% elsif field.type =~ /string/ %>
+        <% elsif field.type == 'string' %>
           memcpy(pb-><%= field.name %>.data, <%= field.options.fetch('default', '""') %>, <%= size = (field.options.fetch('default', '').bytesize - 1); size > 0 ? size : 0 %>);
           pb-><%= field.name %>.size = <%= field.options.fetch('default', '').bytesize %>;
-        <% elsif field.type =~ /bytes/ %>
+        <% elsif field.type == 'bytes' %>
           memcpy(pb-><%= field.name %>.data, <%= field.options.fetch('default', '""') %>, <%= field.options.fetch('default', '').bytesize %>);
           pb-><%= field.name %>.size = <%= field.options.fetch('default', '').bytesize %>;
         <% else %>
@@ -251,8 +271,8 @@ int read_raw_varint64(uint64_t *tag, const uint8_t *buffer, int offset) {
         && <%= function exp.package, field.type, 'is', 'default', 'message' %>(&pb-><%= field.name %>)
       <% elsif type_enum?(field.type) %>
         && pb-><%= field.name %> == <%= constant exp.package, field.type, type_enum_default(field.type, field.options.fetch('default', nil)) %>
-      <% elsif field.type =~ /string|bytes/ %>
-        && memcmp(&pb-><%= field.name %>.data, <%= field.options.fetch('default', '""') %>, <%= field.meta.fetch('size_max', field.options.fetch('default', '').bytesize) %>) == 0
+      <% elsif %w{string bytes}.include?(field.type) %>
+        && memcmp(&pb-><%= field.name %>.data, <%= field.options.fetch('default', '""') %>, <%= field.meta.fetch('size', field.options.fetch('default', '').bytesize) %>) == 0
         && pb-><%= field.name %>.size == <%= field.options.fetch('default', '').bytesize %>
       <% else %>
         && pb-><%= field.name %> == <%= field.options.fetch('default', 0) %>
@@ -272,70 +292,70 @@ int read_raw_varint64(uint64_t *tag, const uint8_t *buffer, int offset) {
             offset = write_raw_varint32((<%= field.tag %><<3)+0, buffer, offset);
             offset = write_raw_varint32(pb-><%= field.name %>, buffer, offset);
           }
-        <% elsif field.type =~ /double/ %>
+        <% elsif field.type == 'double' %>
           if (pb-><%= field.name %> != <%= field.options.fetch('default', 0) %>) {
             offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
             offset = write_raw_double(pb-><%= field.name %>, buffer, offset);
           }
-        <% elsif field.type =~ /float/ %>
+        <% elsif field.type == 'float' %>
           if (pb-><%= field.name %> != <%= field.options.fetch('default', 0) %>) {
             offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
             offset = write_raw_float(pb-><%= field.name %>, buffer, offset);
           }
-        <% elsif field.type =~ /int32/%>
+        <% elsif field.type == 'int32' %>
           if (pb-><%= field.name %> != <%= field.options.fetch('default', 0) %>) {
             offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
             if (pb-><%= field.name %> >= 0) offset = write_raw_varint32(pb-><%= field.name %>, buffer, offset);
             else offset = write_raw_varint64(pb-><%= field.name %>, buffer, offset);
           }
-        <% elsif field.type =~ /int64/ %>
+        <% elsif field.type == 'int64' %>
           if (pb-><%= field.name %> != <%= field.options.fetch('default', 0) %>) {
             offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
             offset = write_raw_varint64(pb-><%= field.name %>, buffer, offset);
           }
-        <% elsif field.type =~ /sint32/ %>
+        <% elsif field.type == 'sint32' %>
           if (pb-><%= field.name %> != <%= field.options.fetch('default', 0) %>) {
             offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
             offset = write_raw_varint32(encode_zig_zag32(pb-><%= field.name %>), buffer, offset);
           }
-        <% elsif field.type =~ /sint62/ %>
+        <% elsif field.type == 'sint64' %>
           if (pb-><%= field.name %> != <%= field.options.fetch('default', 0) %>) {
             offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
             offset = write_raw_varint64(encode_zig_zag64(pb-><%= field.name %>), buffer, offset);
           }
-        <% elsif field.type =~ /uint32/ %>
+        <% elsif field.type == 'uint32' %>
           if (pb-><%= field.name %> != <%= field.options.fetch('default', 0) %>) {
             offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
             offset = write_raw_varint32(pb-><%= field.name %>, buffer, offset);
           }
-        <% elsif field.type =~ /uint64/ %>
+        <% elsif field.type == 'uint64' %>
           if (pb-><%= field.name %> != <%= field.options.fetch('default', 0) %>) {
             offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
             offset = write_raw_varint64(pb-><%= field.name %>, buffer, offset);
           }
-        <% elsif field.type =~ /s?fixed32/ %>
+        <% elsif %w{fixed32 sfixed32}.include?(field.type) %>
           if (pb-><%= field.name %> != <%= field.options.fetch('default', 0) %>) {
             offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
             offset = write_raw_little_endian32(pb-><%= field.name %>, buffer, offset);
           }
-        <% elsif field.type =~ /s?fixed64/ %>
+        <% elsif %w{fixed64 sfixed64}.include?(field.type) %>
           if (pb-><%= field.name %> != <%= field.options.fetch('default', 0) %>) {
             offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
             offset = write_raw_little_endian64(pb-><%= field.name %>, buffer, offset);
           }
-        <% elsif field.type =~ /bool/ %>
+        <% elsif field.type == 'bool' %>
           if (pb-><%= field.name %> != <%= field.options.fetch('default', 'false') %>) {
             offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
             offset = write_raw_byte(pb-><%= field.name %>, buffer, offset);
           }
-        <% elsif field.type =~ /string/ %>
-          if (memcmp(&pb-><%= field.name %>.data, <%= field.options.fetch('default', '""') %>, <%= field.meta.fetch('size_max', field.options.fetch('default', '').bytesize) %>) != 0) {
+        <% elsif field.type == 'string' %>
+          if (memcmp(&pb-><%= field.name %>.data, <%= field.options.fetch('default', '""') %>, <%= field.meta.fetch('size', field.options.fetch('default', '').bytesize) %>) != 0) {
             offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
             offset = write_raw_varint32(pb-><%= field.name %>.size, buffer, offset);
             offset = write_raw_bytes((uint8_t *)pb-><%= field.name %>.data, pb-><%= field.name %>.size, buffer, offset);
           }
-        <% elsif field.type =~ /bytes/ %>
-          if (memcmp(&pb-><%= field.name %>.data, <%= field.options.fetch('default', '""') %>, <%= field.meta.fetch('size_max', field.options.fetch('default', '').bytesize) %>) != 0) {
+        <% elsif field.type == 'bytes' %>
+          if (memcmp(&pb-><%= field.name %>.data, <%= field.options.fetch('default', '""') %>, <%= field.meta.fetch('size', field.options.fetch('default', '').bytesize) %>) != 0) {
             offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
             offset = write_raw_varint32(pb-><%= field.name %>.size, buffer, offset);
             offset = write_raw_bytes((uint8_t *)pb-><%= field.name %>.data, pb-><%= field.name %>.size, buffer, offset);
@@ -347,45 +367,45 @@ int read_raw_varint64(uint64_t *tag, const uint8_t *buffer, int offset) {
         <% elsif type_enum?(field.type) %>
           offset = write_raw_varint32((<%= field.tag %><<3)+0, buffer, offset);
           offset = write_raw_varint32(pb-><%= field.name %>, buffer, offset);
-        <% elsif field.type =~ /double/ %>
+        <% elsif field.type == 'double' %>
           offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
           offset = write_raw_double(pb-><%= field.name %>, buffer, offset);
-        <% elsif field.type =~ /float/ %>
+        <% elsif field.type == 'float' %>
           offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
           offset = write_raw_float(pb-><%= field.name %>, buffer, offset);
-        <% elsif field.type =~ /int32/ %>
+        <% elsif field.type == 'int32' %>
           offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
           if (pb-><%= field.name %> >= 0) offset = write_raw_varint32(pb-><%= field.name %>, buffer, offset);
           else offset = write_raw_varint64(pb-><%= field.name %>, buffer, offset);
-        <% elsif field.type =~ /int64/ %>
+        <% elsif field.type == 'int64' %>
           offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
           offset = write_raw_varint64(pb-><%= field.name %>, buffer, offset);
-        <% elsif field.type =~ /sint32/ %>
+        <% elsif field.type == 'sint32' %>
           offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
           offset = write_raw_varint32(encode_zig_zag32(pb-><%= field.name %>), buffer, offset);
-        <% elsif field.type =~ /sint62/ %>
+        <% elsif field.type == 'sint64' %>
           offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
           offset = write_raw_varint64(encode_zig_zag64(pb-><%= field.name %>), buffer, offset);
-        <% elsif field.type =~ /uint32/ %>
+        <% elsif field.type == 'uint32' %>
           offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
           offset = write_raw_varint32(pb-><%= field.name %>, buffer, offset);
-        <% elsif field.type =~ /uint64/ %>
+        <% elsif field.type == 'uint64' %>
           offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
           offset = write_raw_varint64(pb-><%= field.name %>, buffer, offset);
-        <% elsif field.type =~ /s?fixed32/ %>
+        <% elsif %w{fixed32 sfixed32}.include?(field.type) %>
           offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
           offset = write_raw_little_endian32(pb-><%= field.name %>, buffer, offset);
-        <% elsif field.type =~ /s?fixed64/ %>
+        <% elsif %w{fixed64 sfixed64}.include?(field.type) %>
           offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
           offset = write_raw_little_endian64(pb-><%= field.name %>, buffer, offset);
-        <% elsif field.type =~ /bool/ %>
+        <% elsif field.type == 'bool' %>
           offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
           offset = write_raw_byte(pb-><%= field.name %>, buffer, offset);
-        <% elsif field.type =~ /string/ %>
+        <% elsif field.type == 'string' %>
           offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
           offset = write_raw_varint32(pb-><%= field.name %>.size, buffer, offset);
           offset = write_raw_bytes((uint8_t *)pb-><%= field.name %>.data, pb-><%= field.name %>.size, buffer, offset);
-        <% elsif field.type =~ /bytes/ %>
+        <% elsif field.type == 'bytes' %>
           offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
           offset = write_raw_varint32(pb-><%= field.name %>.size, buffer, offset);
           offset = write_raw_bytes((uint8_t *)pb-><%= field.name %>.data, pb-><%= field.name %>.size, buffer, offset);
@@ -438,59 +458,59 @@ int read_raw_varint64(uint64_t *tag, const uint8_t *buffer, int offset) {
         <% elsif type_enum?(field.type) %>
           offset = read_raw_varint32(&tag, buffer, offset);
           pb-><%= field.name %> = tag;
-        <% elsif field.type =~ /float/ %>
+        <% elsif field.type == 'float' %>
           offset = read_raw_float(&pb-><%= field.name %>, buffer, offset);
-        <% elsif field.type =~ /double/ %>
+        <% elsif field.type == 'double' %>
           offset = read_raw_double(&pb-><%= field.name %>, buffer, offset);
-        <% elsif field.type =~ /int32/ %>
+        <% elsif field.type == 'int32' %>
           offset = read_raw_varint32(&tag, buffer, offset);
           pb-><%= field.name %> = (int32_t)tag;
-        <% elsif field.type =~ /int64/ %>
+        <% elsif field.type == 'int64' %>
         {
           uint64_t value = 0;
           offset = read_raw_varint64(&value, buffer, offset);
           pb-><%= field.name %> = (int64_t)tag;
         }
-        <% elsif field.type =~ /sint32/ %>
+        <% elsif field.type == 'sint32' %>
           offset = read_raw_varint32(&tag, buffer, offset);
           pb-><%= field.name %> = decode_zig_zag32(tag);
-        <% elsif field.type =~ /sint64/ %>
+        <% elsif field.type == 'sint64' %>
         {
           uint64_t value = 0;
           offset = read_raw_varint64(&value, buffer, offset);
           pb-><%= field.name %> = decode_zig_zag64(value);
         }
-        <% elsif field.type =~ /uint32/ %>
+        <% elsif field.type == 'uint32' %>
           offset = read_raw_varint32(&tag, buffer, offset);
           pb-><%= field.name %> = tag;
-        <% elsif field.type =~ /uint64/ %>
+        <% elsif field.type == 'uint64' %>
         {
           uint64_t value = 0;
           offset = read_raw_varint64(&value, buffer, offset);
           pb-><%= field.name %> = value;
         }
-        <% elsif field.type =~ /fixed32/ %>
+        <% elsif field.type == 'fixed32' %>
           offset = read_raw_little_endian32(&tag, buffer, offset);
           pb-><%= field.name %> = tag;
-        <% elsif field.type =~ /fixed64/ %>
+        <% elsif field.type == 'fixed64' %>
         {
           uint64_t value = 0;
           offset = read_raw_little_endian64(&value, buffer, offset);
           pb-><%= field.name %> = value;
         }
-        <% elsif field.type =~ /sfixed32/ %>
+        <% elsif field.type == 'sfixed32' %>
           offset = read_raw_little_endian32(&tag, buffer, offset);
           pb-><%= field.name %> = (int32_t)tag;
-        <% elsif field.type =~ /sfixed64/ %>
+        <% elsif field.type == 'sfixed64' %>
         {
           uint64_t value = 0;
           offset = read_raw_little_endian64(&value, buffer, offset);
           pb-><%= field.name %> = (int64_t)value;
         }
-        <% elsif field.type =~ /bool/ %>
+        <% elsif field.type == 'bool' %>
           offset = read_raw_varint32(&tag, buffer, offset);
           pb-><%= field.name %> = tag & 1;
-        <% elsif field.type =~ /string|bytes/ %>
+        <% elsif %w{string bytes}.include?(field.type) %>
           offset = read_raw_varint32(&tag, buffer, offset);
           pb-><%= field.name %>.size = (size_t)tag;
           for (size_t i = 0; i < (size_t)tag; ++i)

data/lib/protobuf/generate/language/c/h.erb

@@ -8,21 +8,6 @@
   extern "C" {
 #endif
 
-// TODO: Export to avoid unused function errors with -Werror.
-// Remove. Have parser count type usage and only include the code if required.
-int write_raw_little_endian32(uint32_t value, uint8_t *buffer, int offset);
-int write_raw_little_endian64(uint64_t value, uint8_t *buffer, int offset);
-int write_raw_float(float value, uint8_t *buffer, int offset);
-int write_raw_double(double value, uint8_t *buffer, int offset);
-int write_raw_varint32(uint32_t value, uint8_t *buffer, int offset);
-int write_raw_varint64(uint64_t value, uint8_t *buffer, int offset);
-int read_raw_little_endian32(uint32_t *tag, const uint8_t *buffer, int offset);
-int read_raw_little_endian64(uint64_t *tag, const uint8_t *buffer, int offset);
-int read_raw_float(float *tag, const uint8_t *buffer, int offset);
-int read_raw_double(double *tag, const uint8_t *buffer, int offset);
-int read_raw_varint32(uint32_t *tag, const uint8_t *buffer, int offset);
-int read_raw_varint64(uint64_t *tag, const uint8_t *buffer, int offset);
-
 <% each do |exp| %>
   <% if exp.kind_of?(Protobuf::Generate::Ast::Enum) %>
 
@@ -39,28 +24,23 @@ int read_raw_varint64(uint64_t *tag, const uint8_t *buffer, int offset);
         <%= type exp.package, field.type %> <%= field.name %>;
       <% elsif type_enum?(field.type) %>
         <%= type exp.package, field.type %> <%= field.name %>;
-      <% elsif field.type =~ /double/ %>
+      <% elsif field.type == 'double' %>
         double <%= field.name %>;
-      <% elsif field.type =~ /float/ %>
+      <% elsif field.type == 'float' %>
         float <%= field.name %>;
-      <% elsif field.type =~ /int32|sint32|sfixed32/ %>
+      <% elsif %w{int32 sint32 sfixed32}.include?(field.type) %>
         int32_t <%= field.name %>;
-      <% elsif field.type =~ /int64|sint64|sfixed64/ %>
+      <% elsif %w{int64 sint64 sfixed64}.include?(field.type) %>
         int64_t <%= field.name %>;
-      <% elsif field.type =~ /uint32|fixed32/ %>
+      <% elsif %w{uint32 fixed32}.include?(field.type) %>
         uint32_t <%= field.name %>;
-      <% elsif field.type =~ /uint64|fixed64/ %>
+      <% elsif %w{uint64 fixed64}.include?(field.type) %>
         uint64_t <%= field.name %>;
-      <% elsif field.type =~ /bool/ %>
+      <% elsif field.type == 'bool' %>
         bool <%= field.name %>;
-      <% elsif field.type =~ /string/ %>
-        struct {
-          uint8_t data[<%= field.meta["size_max"] %>];
-          size_t  size;
-        } <%= field.name %>;
-      <% elsif field.type =~ /bytes/ %>
+      <% elsif %w{bytes string}.include?(field.type) %>
         struct {
-          uint8_t data[<%= field.meta["size_max"] %>];
+          uint8_t data[<%= field.meta["size"] %>];
           size_t  size;
         } <%= field.name %>;
       <% end %>

data/lib/protobuf/generate/parser.rb

@@ -19,7 +19,7 @@ module Protobuf
       rule(:bracket_close) { str('}') >> whitespace? }
 
       rule(:digit)   { match('[0-9]') }
-      rule(:integer) { str('-').maybe >> match('[1-9]') >> digit.repeat }
+      rule(:integer) { str('-').maybe >> digit.repeat(1) }
       rule(:float)   { str('-').maybe >> digit.repeat(1) >> str('.') >> digit.repeat(1) }
 
       rule(:string_special)  { match['\0\t\n\r"\\\\'] }
@@ -29,7 +29,7 @@ module Protobuf
       rule(:identifier)          { match('[a-zA-Z_]') >> match('[a-zA-Z0-9_]').repeat }
       rule(:identifier_dot_list) { identifier >> (str('.') >> identifier).repeat }
 
-      rule(:constant) { identifier | integer | float | string }
+      rule(:constant) { identifier | float | integer | string }
 
       rule(:field_option)      { str('default').as(:name) >> whitespace? >> equals >> constant.as(:value) }
       rule(:field_option_list) { (str('[') >> whitespace? >> (field_option.as(:option) >> whitespace?).repeat(1) >> whitespace? >> str(']') >> whitespace?) }
@@ -37,11 +37,11 @@ module Protobuf
       rule(:field_label)       { (str('required') | str('optional') | str('repeated')).as(:label) >> whitespace? }
 
       rule(:message_field)       { (field_label >> field_type >> identifier.as(:name) >> whitespace? >> equals >> integer.as(:tag) >> whitespace? >> field_option_list.maybe.as(:options) >> str(';') >> space? >> comment.maybe.as(:comment) ).as(:message_field) }
-      rule(:message_field_list)  { (message_field >> whitespace?).repeat(1).as(:fields) }
+      rule(:message_field_list)  { ((message_field | comment) >> whitespace?).repeat(1).as(:fields) }
       rule(:message)             { (comment_list.maybe.as(:comments) >> str('message') >> whitespace? >> identifier.as(:name) >> whitespace? >> bracket_open >> message_field_list.maybe >> bracket_close >> whitespace?).as(:message) }
 
       rule(:enum_field)      { (identifier.as(:name) >> whitespace? >> equals >> integer.as(:tag) >> whitespace? >> str(';')).as(:enum_field) }
-      rule(:enum_field_list) { (enum_field >> whitespace?).repeat(1).as(:fields) }
+      rule(:enum_field_list) { ((enum_field | comment) >> whitespace?).repeat(1).as(:fields) }
       rule(:enum)            { (str('enum') >> whitespace? >> identifier.as(:name) >> whitespace? >> bracket_open >> enum_field_list >> bracket_close >> whitespace?).as(:enum) }
 
       rule(:package) { (str('package') >> whitespace? >> identifier_dot_list.as(:name) >> whitespace? >> str(';') >> whitespace?).as(:package) }

data/protobuf-generate.gemspec

@@ -2,7 +2,7 @@ $:.unshift(File.join(File.dirname(__FILE__), 'lib'))
 
 spec = Gem::Specification.new do |s|
   s.name        = 'protobuf-generate'
-  s.version     = '0.1.1'
+  s.version     = '0.2.0'
   s.summary     = 'A multi-language concrete protobuf code generator.'
   s.description = 'A simple PEG parser, AST and template based approach to code generation.'
   s.authors     = ['Shane Hanna']

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: protobuf-generate
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Shane Hanna
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-13 00:00:00.000000000 Z
+date: 2013-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
@@ -78,9 +78,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.0
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: A multi-language concrete protobuf code generator.
 test_files: []
-has_rdoc: