protobuf-generate 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 78cf665e01a339bcdf515cee143af388685ef34a
+  data.tar.gz: 268a8fa0d167f93f8c86ec0f4f9ad304bb4650d2
+SHA512:
+  metadata.gz: 30773411e397dbb87a547de33809646493fd3350c83c2fca83c6a2f9e4ed7a64a792780aa626ee60c7febea25d16d973da8550c5a6b4034196f8c46cbdd7c56f
+  data.tar.gz: ca1613fe95fa0e2a3a02c2616f2b23c19089e7d71a8bc63caed895907a7d6f4d3ba67cdc2f159e411ffb1728e3ccb02eee4b08e154c3ea8087aee45d35855a7c

data/.gitignore

@@ -0,0 +1,13 @@
+# Junk
+._*
+.DS_Store
+*.swp
+*.swo
+gems/
+tmp/
+*.gem
+.bundle
+*.lock
+
+bin/*
+!bin/protobuf-generate

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE

@@ -0,0 +1,10 @@
+NOTE: Fuck restrictive 'open' source licenses honestly. You can pretty much do whatever the fuck you want with my code under MIT but the C templates [ch].erb are probably considered derivative works because I stole them originally from from the Apache 2 (http://www.apache.org/licenses/LICENSE-2.0) licensed https://code.google.com/p/protobuf-embedded-c
+
+Copyright (C) 2013 Shane Hanna
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README.md

@@ -0,0 +1,56 @@
+# protobuf-generate
+
+[source](https://bitbucket.org/shanehanna/protobuf-generate)
+
+## Description
+
+A multi-language concrete protobuf code generator in Ruby.
+
+## Synopsis
+
+A simple PEG parser, AST and template based approach to code generation.
+
+[protobuf-embedded-c](https://code.google.com/p/protobuf-embedded-c/) uses the same approach but requires a page of
+rage inducing instructions to install obsolete Eclipse plugins and Java bullshit if you want to be able to develop
+and customize any of the C it generates. Ruby and scripting languages in general are ideal for this sort of thing
+so that's what I've done.
+
+## Install
+
+```
+gem install protobuf-generate
+```
+
+## Usage
+
+```
+protobuf-generate <language> <protofile>
+```
+
+## Languages
+
+### C - Embedded
+
+C99+ suitable for embedded systems.
+
+#### string and byte
+
+A fixed size string and byte structure is generated using a required @size_max meta attribute to avoid dynamic
+allocation. Strings sent from other protobuf implementations that are too long for the structure will be truncated and
+null terminated to fit within the maximum size. Bytes will just be truncated.
+
+```
+message Message {
+  required string name = 1; // @size_max = 32
+}
+```
+
+```
+typedef struct message_t {
+  struct {
+    uint8_t data[32];
+    site_t  size;
+  } name;
+} message_t;
+```
+

data/bin/protobuf-generate

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+require 'protobuf-generate'
+
+# Usage.
+unless ARGV.size == 2
+  puts %q{
+Generate native code from protobuf files.
+
+usage: protobuf-generate <language> <proto>
+  language - Native language to generate.
+  proto    - The protobuf file to generate from.
+  }
+  exit 0
+end
+
+unless generator = Protobuf::Generate::Language.find(ARGV[0])
+  puts 'ERROR: Unknown language "%s".' % ARGV[0]
+  exit -1
+end
+
+begin
+  proto = ARGV[1]
+  tree  = Protobuf::Generate::Parser.new.parse(File.read(proto))
+  ast   = Protobuf::Generate::Transform.new.apply(tree)
+  gen   = generator.new(ast)
+
+  # TODO: Think about how best to have generator deal with multiple templates. e.g. *.c and *.h
+  gen.templates.each do |template|
+    # 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.gsub('.', '_').gsub(/([^A-Z_])([A-Z]+)/, '\1_\2').gsub(/_+/, '_').downcase
+    filename = File.join(File.dirname(proto), [package, postfix].join('.'))
+
+    File.open(filename, File::CREAT | File::TRUNC | File::WRONLY) do |fh|
+     fh.puts gen.generate(template, filename)
+    end
+  end
+rescue Parslet::ParseFailed => error
+  puts error.cause.ascii_tree
+end
+

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

@@ -0,0 +1,502 @@
+#include "<%= filename.sub(/\.c$/, '.h') %>" <%# Hack job. %>
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <string.h>
+
+static int write_raw_byte(uint8_t value, uint8_t *buffer, int offset) {
+  *(buffer + offset) = value;
+  return ++offset;
+}
+
+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;
+}
+
+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);
+  offset = write_raw_byte((uint8_t)((value >> 24) & 0xFF), buffer, offset);
+  offset = write_raw_byte((uint8_t)((value >> 32) & 0xFF), buffer, offset);
+  offset = write_raw_byte((uint8_t)((value >> 40) & 0xFF), buffer, offset);
+  offset = write_raw_byte((uint8_t)((value >> 48) & 0xFF), buffer, offset);
+  offset = write_raw_byte((uint8_t)((value >> 56) & 0xFF), buffer, offset);
+  return 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);
+      return offset;
+    } else {
+      offset = write_raw_byte((uint8_t)((value & 0x7F) | 0x80), buffer, offset);
+      value  = value >> 7;
+    }
+  }
+  return offset;
+}
+
+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);
+      return offset;
+    } else {
+      offset = write_raw_byte((uint8_t)((value & 0x7F) | 0x80), buffer, offset);
+      value  = value >> 7;
+    }
+  }
+  return offset;
+}
+
+static int write_raw_bytes(uint8_t *bytes, int bytes_size, uint8_t *buffer, int offset) {
+  for (int i = 0; i < bytes_size; ++i)
+    offset = write_raw_byte(*(bytes + i), buffer, offset);
+  return offset;
+}
+
+static inline uint32_t encode_zig_zag32(int32_t n) {
+  return (n << 1) ^ (n >> 31);
+}
+
+static inline uint64_t encode_zig_zag64(int64_t n) {
+  return (n << 1) ^ (n >> 63);
+}
+
+static inline int32_t decode_zig_zag32(uint32_t n) {
+  return (n >> 1) ^ -(n & 1);
+}
+
+static inline int64_t decode_zig_zag64(uint64_t n) {
+  return (n >> 1) ^ -(n & 1);
+}
+
+static inline int read_raw_byte(uint8_t *tag, const uint8_t *buffer, int offset) {
+  *tag = *(buffer + offset);
+  return ++offset;
+}
+
+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);
+  uint8_t b2 = (uint8_t)*tag;
+  offset = read_raw_byte((uint8_t *)tag, buffer, offset);
+  uint8_t b3 = (uint8_t)*tag;
+  offset = read_raw_byte((uint8_t *)tag, buffer, offset);
+  uint8_t b4 = (uint8_t)*tag;
+
+  *tag = (((uint32_t)b1 & 0xff)      ) |
+         (((uint32_t)b2 & 0xff) <<  8) |
+         (((uint32_t)b3 & 0xff) << 16) |
+         (((uint32_t)b4 & 0xff) << 24);
+  return offset;
+}
+
+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);
+  uint8_t b2 = (uint8_t)*tag;
+  offset = read_raw_byte((uint8_t *)tag, buffer, offset);
+  uint8_t b3 = (uint8_t)*tag;
+  offset = read_raw_byte((uint8_t *)tag, buffer, offset);
+  uint8_t b4 = (uint8_t)*tag;
+  offset = read_raw_byte((uint8_t *)tag, buffer, offset);
+  uint8_t b5 = (uint8_t)*tag;
+  offset = read_raw_byte((uint8_t *)tag, buffer, offset);
+  uint8_t b6 = (uint8_t)*tag;
+  offset = read_raw_byte((uint8_t *)tag, buffer, offset);
+  uint8_t b7 = (uint8_t)*tag;
+  offset = read_raw_byte((uint8_t *)tag, buffer, offset);
+  uint8_t b8 = (uint8_t)*tag;
+
+  *tag = (((uint64_t)b1 & 0xff)      ) |
+         (((uint64_t)b2 & 0xff) <<  8) |
+         (((uint64_t)b3 & 0xff) << 16) |
+         (((uint64_t)b4 & 0xff) << 24) |
+         (((uint64_t)b5 & 0xff) << 32) |
+         (((uint64_t)b6 & 0xff) << 40) |
+         (((uint64_t)b7 & 0xff) << 48) |
+         (((uint64_t)b8 & 0xff) << 56);
+
+  return 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);
+  if (result >= 0) {
+    *tag = result;
+    return offset;
+  }
+  *tag = result & 0x7f;
+  offset = read_raw_byte(&result, buffer, offset);
+  if (result >= 0) {
+    *tag |= result << 7;
+  } else {
+    *tag |= (result & 0x7f) << 7;
+    offset = read_raw_byte(&result, buffer, offset);
+    if (result >= 0) {
+      *tag |= result << 14;
+    } else {
+      *tag |= (result & 0x7f) << 14;
+      offset = read_raw_byte(&result, buffer, offset);
+      if (result >= 0) {
+        *tag |= ((uint32_t)result) << 21;
+      } else {
+        *tag |= (((uint32_t)result) & 0x7f) << 21;
+        offset = read_raw_byte(&result, buffer, offset);
+        *tag |= ((uint32_t)result) << 28;
+        if (result < 0) {
+          /* Discard upper 32 bits. */
+          int i;
+          for (i = 0; i < 5; ++ i) {
+            offset = read_raw_byte(&result, buffer, offset);
+            if (result >= 0) {
+              return offset;
+            }
+          }
+          /* Invalid state. */
+        }
+      }
+    }
+  }
+  return offset;
+}
+
+static int read_raw_varint64(uint64_t *tag, uint8_t *buffer, int offset) {
+  short shift = 0;
+  uint8_t b;
+  *tag = 0;
+  while (shift < 64) {
+    offset = read_raw_byte(&b, buffer, offset);
+    *tag |= (uint64_t)(b & 0x7F) << shift;
+    if ((b & 0x80) == 0) {
+      return offset;
+    }
+    shift += 7;
+  }
+  /* return error code. */
+  return -1;
+}
+
+<% each do |exp| %>
+  <%
+    if exp.kind_of?(Protobuf::Generate::Ast::Package)
+      package exp.name
+    elsif exp.kind_of?(Protobuf::Generate::Ast::Enum)
+  %>
+  <% elsif exp.kind_of?(Protobuf::Generate::Ast::Message) %>
+
+  void <%= namespaced_function exp.name, 'clear' %>(<%= namespaced_type exp.name %> *pb) {
+    memset(pb, 0, sizeof(*pb));
+  }
+
+  void <%= namespaced_function exp.name, 'init', 'optional', 'attributes' %>(<%= namespaced_type exp.name %> *pb) {
+    <% exp.fields.each do |field| %>
+      <% if field.optional? %>
+        <% if type_message?(field.type) %>
+          <%= namespaced_function field.type, 'init', 'optional', 'attributes' %>(&pb-><%= field.name %>);
+        <% elsif type_enum?(field.type) %>
+          pb-><%= field.name %> = <%= namespaced_constant field.type, type_enum_default(field.type, field.options.fetch('default', nil)) %>;
+        <% elsif field.type =~ /bool/ %>
+          pb-><%= field.name %> = <%= field.options.fetch(:default, 'false') %>;
+        <% 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/ %>
+          memcpy(pb-><%= field.name %>.data, <%= field.options.fetch('default', '""') %>, <%= field.options.fetch('default', '').bytesize %>);
+          pb-><%= field.name %>.size = <%= field.options.fetch('default', '').bytesize %>;
+        <% else %>
+          pb-><%= field.name %> = <%= field.options.fetch('default', 0) %>;
+        <% end %>
+      <% end %>
+    <% end %>
+    return;
+  }
+
+  bool <%= namespaced_function exp.name, 'is', 'default', 'message' %>(const <%= namespaced_type exp.name %> *pb) {
+    return true
+    <% exp.fields.each do |field| %>    // <%= field.name %>
+      <% if type_message?(field.type) %>
+        && <%= namespaced_function field.type, 'is', 'default', 'message' %>(&pb-><%= field.name %>)
+      <% elsif type_enum?(field.type) %>
+        && pb-><%= field.name %> == <%= namespaced_constant 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
+        && pb-><%= field.name %>.size == <%= field.options.fetch('default', '').bytesize %>
+      <% else %>
+        && pb-><%= field.name %> == <%= field.options.fetch('default', 0) %>
+      <% end %>
+    <% end %>;
+  }
+
+  int <%= namespaced_function exp.name, 'write' %>(const <%= namespaced_type exp.name %> *pb, uint8_t *buffer, int offset) {
+    <% exp.fields.each do |field| %>      // <%= field.name %>
+      <% if field.optional? %>
+        <% if type_message?(field.type) %>
+          if (!<%= namespaced_function field.type, 'is', 'default', 'message' %>(&pb-><%= field.name %>)) {
+            offset = <%= namespaced_function field.type, 'write', 'with', 'tag' %>(&pb-><%= field.name %>, buffer, offset, <%= field.tag %>);
+          }
+        <% elsif type_enum?(field.type) %>
+          if (pb-><%= field.name %> != <%= namespaced_constant field.type, type_enum_default(field.type, field.options.fetch('default', nil)) %>) {
+            offset = write_raw_varint32((<%= field.tag %><<3)+0, buffer, offset);
+            offset = write_raw_varint32(pb-><%= field.name %>, buffer, offset);
+          }
+        <% 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_little_endian64(*(uint64_t *)&pb-><%= field.name %>, buffer, offset);
+          }
+        <% 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_little_endian32(*(uint32_t *)&pb-><%= field.name %>, buffer, offset);
+          }
+        <% 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_varin32(pb-><%= field.name %>, buffer, offset);
+            else offset = write_raw_varint64(pb-><%= field.name %>, buffer, offset);
+          }
+        <% 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/ %>
+          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/ %>
+          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/ %>
+          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/ %>
+          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/ %>
+          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/ %>
+          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/ %>
+          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) {
+            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) {
+            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);
+          }
+        <% end %>
+      <% else %>
+        <% if type_message?(field.type) %>
+          offset = <%= namespaced_function field.type, 'write', 'with', 'tag' %>(&pb-><%= field.name %>, buffer, offset, <%= field.tag %>);
+        <% 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/ %>
+          offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
+          offset = write_raw_little_endian64(*(uint64_t *)&pb-><%= field.name %>, buffer, offset);
+        <% elsif field.type =~ /float/ %>
+          offset = write_raw_varint32((<%= field.tag %><<3)+<%= type_wire field.type %>, buffer, offset);
+          offset = write_raw_little_endian32(*(uint32_t *)&pb-><%= field.name %>, buffer, offset);
+        <% 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_varin32(pb-><%= field.name %>, buffer, offset);
+          else offset = write_raw_varint64(pb-><%= field.name %>, buffer, offset);
+        <% 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/ %>
+          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/ %>
+          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/ %>
+          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/ %>
+          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/ %>
+          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/ %>
+          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/ %>
+          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/ %>
+          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/ %>
+          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);
+        <% end %>
+      <% end %>
+    <% end %>
+    return offset;
+  }
+
+  int <%= namespaced_function exp.name, 'write', 'delimited', 'to' %>(const <%= namespaced_type exp.name %> *pb, uint8_t *buffer, int offset) {
+    int i, shift, new_offset, size;
+
+    new_offset = <%= namespaced_function exp.name, 'write' %>(pb, buffer, offset);
+    size       = new_offset - offset;
+    shift      = (size > 127) ? 2 : 1;
+    for (i = new_offset - 1; i >= offset; -- i)
+      *(buffer + i + shift) = *(buffer + i);
+
+    write_raw_varint32((uint32_t)size, buffer, offset);
+    return new_offset + shift;
+  }
+
+  int <%= namespaced_function exp.name, 'write', 'with', 'tag' %>(const <%= namespaced_type exp.name %> *pb, uint8_t *buffer, int offset, int tag) {
+      offset = write_raw_varint32((tag<<3)+2, buffer, offset);
+      offset = <%= namespaced_function exp.name, 'write', 'delimited', 'to' %>(pb, buffer, offset);
+      return offset;
+  }
+
+  int <%= namespaced_function exp.name, 'encode' %>(const <%= namespaced_type exp.name %> *pb, uint8_t *data, size_t data_size, size_t *encoded_size) {
+    *encoded_size = <%= namespaced_function exp.name, 'write', 'delimited', 'to' %>(pb, data, -1);
+    return 0; // TODO: Encoding errors.
+  }
+
+  int <%= namespaced_function exp.name, 'read', 'delimited', 'from' %>(<%= namespaced_type exp.name %> *pb, const uint8_t *buffer, int offset);
+
+  int <%= namespaced_function exp.name, 'read' %>(<%= namespaced_type exp.name %> *pb, const uint8_t *buffer, int offset, int limit) {
+    <%= namespaced_function exp.name, 'clear' %>(pb);
+    <%= namespaced_function exp.name, 'init', 'optional', 'attributes' %>(pb);
+
+    uint32_t tag   = 0;
+    while (offset < limit) {
+      offset = read_raw_varint32(&tag, buffer, offset);
+      tag    = tag>>3;
+      switch (tag) {
+      <% exp.fields.each do |field| %>
+      case <%= field.tag %>:
+          // <%= field.name %>
+        <% if type_message?(field.type) %>
+          offset = <%= namespaced_function field.type, 'read', 'delimited', 'from' %>(&pb-><%= field.name %>, buffer, offset);
+        <% elsif type_enum?(field.type) %>
+          offset = read_raw_varint32(&tag, buffer, offset);
+          pb-><%= field.name %> = tag;
+        <% elsif field.type =~ /float/ %>
+          offset = read_raw_little_endian32(&tag, buffer, offset);
+          pb-><%= field.name %> = *(float *)(&tag);
+        <% elsif field.type =~ /double/ %>
+        {
+          uint64_t value = 0;
+          offset = read_raw_little_endian64(&value, buffer, offset);
+          pb-><%= field.name %> = *(double *)(&value);
+        }
+        <% elsif field.type =~ /int32/ %>
+          offset = read_raw_varint32(&tag, buffer, offset);
+          pb-><%= field.name %> = (int32_t)tag;
+        <% 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/ %>
+          offset = read_raw_varint32(&tag, buffer, offset);
+          pb-><%= field.name %> = decode_zig_zag32(tag);
+        <% 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/ %>
+          offset = read_raw_varint32(&tag, buffer, offset);
+          pb-><%= field.name %> = tag;
+        <% elsif field.type =~ /uint64/ %>
+        {
+          uint64_t value = 0;
+          offset = read_raw_varint64(&value, buffer, offset);
+          pb-><%= field.name %> = value;
+        }
+        <% elsif field.type =~ /fixed32/ %>
+          offset = read_raw_little_endian32(&tag, buffer, offset);
+          pb-><%= field.name %> = tag;
+        <% elsif field.type =~ /fixed64/ %>
+        {
+          uint64_t value = 0;
+          offset = read_raw_little_endian64(&value, buffer, offset);
+          pb-><%= field.name %> = value;
+        }
+        <% elsif field.type =~ /sfixed32/ %>
+          offset = read_raw_little_endian32(&tag, buffer, offset);
+          pb-><%= field.name %> = (int32_t)tag;
+        <% 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/ %>
+          offset = read_raw_varint32(&tag, buffer, offset);
+          pb-><%= field.name %> = tag & 1;
+        <% elsif field.type =~ /string|bytes/ %>
+          offset = read_raw_varint32(&tag, buffer, offset);
+          pb-><%= field.name %>.size = (size_t)tag;
+          for (size_t i = 0; i < (size_t)tag; ++i)
+            offset = read_raw_byte((pb-><%= field.name %>.data + i), buffer, offset);
+        <% end %>
+          break;
+      <% end %>
+      }
+    }
+    return offset;
+  }
+
+  int <%= namespaced_function exp.name, 'read', 'delimited', 'from' %>(<%= namespaced_type exp.name %> *pb, const uint8_t *buffer, int offset) {
+    uint32_t size;
+    offset = read_raw_varint32(&size, buffer, offset);
+    <%= namespaced_function exp.name, 'read' %>(pb, buffer, offset, size + offset);
+    return offset + size;
+  }
+
+  int <%= namespaced_function exp.name, 'decode' %>(<%= namespaced_type exp.name %> *pb, const uint8_t *data, size_t data_size, size_t *encoded_size) {
+    *encoded_size = <%= namespaced_function exp.name, 'read' %>(pb, data, 0, data_size);
+    return 0; // TODO: Decoding errors.
+  }
+  <% end %>
+<% end %>

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

@@ -0,0 +1,71 @@
+#pragma once
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+
+#ifdef __cplusplus
+  extern "C" {
+#endif
+<%
+  each do |exp|
+    if exp.kind_of?(Protobuf::Generate::Ast::Package)
+      package exp.name
+    elsif exp.kind_of?(Protobuf::Generate::Ast::Enum)
+%>
+
+  typedef enum {
+    <% exp.fields.each do |field| %>
+      <%= namespaced_constant exp.name, field.name %> = <%= field.tag %>,
+    <% end %>
+  } <%= namespaced_type exp.name %>;
+<%
+    elsif exp.kind_of?(Protobuf::Generate::Ast::Message)
+%>
+
+  typedef struct <%= namespaced_type exp.name %> {
+    <% exp.fields.each do |field| %>
+      <% if type_message?(field.type) %>
+        <%= namespaced_type field.type %> <%= field.name %>;
+      <% elsif type_enum?(field.type) %>
+        <%= namespaced_type field.type %> <%= field.name %>;
+      <% elsif field.type =~ /double/ %>
+        double <%= field.name %>;
+      <% elsif field.type =~ /float/ %>
+        float <%= field.name %>;
+      <% elsif field.type =~ /int32|sint32|sfixed32/ %>
+        int32_t <%= field.name %>;
+      <% elsif field.type =~ /int64|sint64|sfixed64/ %>
+        int64_t <%= field.name %>;
+      <% elsif field.type =~ /uint32|fixed32/ %>
+        uint32_t <%= field.name %>;
+      <% elsif field.type =~ /uint64|fixed64/ %>
+        uint64_t <%= field.name %>;
+      <% 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/ %>
+        struct {
+          uint8_t data[<%= field.meta["size_max"] %>];
+          size_t  size;
+        } <%= field.name %>;
+      <% end %>
+    <% end %>
+  } <%= namespaced_type exp.name %>;
+
+  // TODO: Replace int with an protobuf_(encode|decode)_t type.
+  // TODO: Move encode_size into result type.
+  int <%= namespaced_function exp.name, 'encode' %>(const <%= namespaced_type exp.name %> *pb, uint8_t *data, size_t data_size, size_t *encoded_size);
+  int <%= namespaced_function exp.name, 'decode' %>(<%= namespaced_type exp.name %> *pb, const uint8_t *data, size_t data_size, size_t *encoded_size);
+<%
+    end
+  end
+%>
+
+#ifdef __cplusplus
+  }
+#endif

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

@@ -0,0 +1,39 @@
+require 'protobuf/generate/language'
+
+module Protobuf
+  module Generate
+    class Language
+      class C < Language
+        match     %r{^ (?:gnu|[Cc]) (?:99|11) $}x
+        templates Dir.glob(File.join(File.expand_path(File.dirname(__FILE__)), 'c', '*.erb'))
+
+        module Conventions
+          def package name = nil
+            @naming_namespace = name.to_s if name
+            (@naming_namespace ||= '').gsub('.', '_')
+          end
+
+          def type     *name; snake_case *name, 't'    end
+          def variable *name; snake_case *name         end
+          def constant *name; snake_case(*name).upcase end
+          def function *name; snake_case *name         end
+
+          def namespaced_type     *name; type     package, *name end
+          def namespaced_variable *name; variable package, *name end
+          def namespaced_constant *name; constant package, *name end
+          def namespaced_function *name; function package, *name end
+
+          protected
+            def snake_case *name
+              name.map(&:to_s).join('_').gsub(/([^A-Z_])([A-Z]+)/, '\1_\2').gsub(/_+/, '_').downcase
+            end
+        end # Conventions
+
+        def initialize ast, conventions = Conventions
+          ast.extend(conventions)
+          super ast
+        end
+      end # C
+    end # Langage
+  end # Generate
+end # Protobuf

data/lib/protobuf/generate/language.rb

@@ -0,0 +1,64 @@
+require 'erubis'
+
+module Protobuf
+  module Generate
+    class Language
+      module Helpers
+        attr_accessor :template, :filename
+
+        def type_message? type
+          !!find{|e| e.kind_of?(Protobuf::Generate::Ast::Message) && e.name == type }
+        end
+
+        def type_enum? type
+          !!find{|e| e.kind_of?(Protobuf::Generate::Ast::Enum) && e.name == type }
+        end
+
+        def type_wire type
+          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_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
+        end
+      end
+
+      def self.match language = nil
+        @language = language if language
+        @language
+      end
+
+      def self.templates templates = nil
+        @templates = templates if templates
+        @templates
+      end
+
+      def self.find language
+        @@languages.find{|l| l.match(language.to_s)}
+      end
+
+      def self.inherited klass
+        (@@languages ||= []) << klass
+      end
+
+      #--
+      # TODO: AST tree should include name of .proto that generated it.
+      def initialize ast
+        @ast = ast
+      end
+
+      def templates
+        self.class.templates
+      end
+
+      def generate template, filename
+        ast = @ast
+        ast.extend(Helpers)
+        ast.template = template
+        ast.filename = filename
+        Erubis::Eruby.new(File.read(template), filename: template).evaluate(ast)
+      end
+    end # Language
+  end # Generate
+end # Protobuf

data/lib/protobuf/generate/parser.rb

@@ -0,0 +1,92 @@
+require 'parslet'
+
+module Protobuf
+  module Generate
+    class Parser < Parslet::Parser
+      rule(:newline)     { match('\n') }
+      rule(:whitespace)  { match('\s').repeat(1) }
+      rule(:whitespace?) { whitespace.maybe }
+      rule(:space)       { match('[\t ]').repeat(1) }
+      rule(:space?)      { space.maybe }
+
+      rule(:comment_option)      { str('@') >> identifier.as(:name) >> space? >> equals >> constant.as(:value) }
+      rule(:comment_option_list) { (comment_option.as(:option) >> space?).repeat(1) }
+      rule(:comment)             { str('//') >> (newline.absent? >> (comment_option_list.as(:meta) | any)).repeat >> newline }
+      rule(:comment_list)        { comment.repeat }
+
+      rule(:equals)        { str('=') >> whitespace? }
+      rule(:bracket_open)  { str('{') >> whitespace? }
+      rule(:bracket_close) { str('}') >> whitespace? }
+
+      rule(:digit)   { match('[0-9]') }
+      rule(:integer) { str('-').maybe >> match('[1-9]') >> digit.repeat }
+      rule(:float)   { str('-').maybe >> digit.repeat(1) >> str('.') >> digit.repeat(1) }
+
+      rule(:string_special)  { match['\0\t\n\r"\\\\'] }
+      rule(:escaped_special) { str("\\") >> match['0tnr"\\\\'] }
+      rule(:string)          { str('"') >> (escaped_special | string_special.absent? >> any).repeat >> str('"') }
+
+      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(: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?) }
+      rule(:field_type)        { identifier.as(:type) >> whitespace? }
+      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)             { (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)            { (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) }
+
+      rule(:expression) { whitespace? >> (package | enum | message | comment | whitespace).repeat }
+      root(:expression)
+    end # Parser
+
+    class Ast
+      class Package < Struct.new(:name); end
+      class Message < Struct.new(:name, :meta, :fields)
+        def empty?; fields.nil? or fields.empty? end
+      end
+      class MessageField < Struct.new(:label, :type, :name, :tag, :meta, :options)
+        def required?; !!label.match(/required/) end
+        def optional?; !required? end
+      end
+      class Enum < Struct.new(:name, :fields); end
+      class EnumField < Struct.new(:name, :tag); end
+    end
+
+    class Transform < Parslet::Transform
+      rule(option:  {name: simple(:name), value: simple(:value)}){ [name.to_s, value.to_s] }
+      rule(package: {name: simple(:name)}){ Ast::Package.new(name.to_s) }
+
+      rule(message_field: subtree(:f)) do
+        Ast::MessageField.new(
+          *f.values_at(:label, :type, :name, :tag).map(&:to_s),
+          f[:comment].kind_of?(Array) ? Hash[*f[:comment].map{|c| c[:meta]}.flatten.compact] : {},
+          f[:options].kind_of?(Array) ? Hash[*[f[:options]].flatten.compact] : {}
+        )
+      end
+
+      rule(message: subtree(:message)) do
+        Ast::Message.new(
+          message[:name].to_s,
+          # TODO: Parslet should return nil not "" when empty. Figure out what's going on.
+          message[:comments].kind_of?(Array) ? Hash[*message[:comments].map{|c| c[:meta]}.flatten.compact] : {},
+          [*message[:fields]].compact
+        )
+      end
+
+      rule(enum_field: {name: simple(:name), tag: simple(:tag)}){ Ast::EnumField.new(name.to_s, tag.to_s) }
+      rule(enum: subtree(:enum)){ Ast::Enum.new(enum[:name].to_s, enum[:fields]) }
+    end # Transform
+  end # Generate
+end # Protobuf
+

data/lib/protobuf-generate.rb

@@ -0,0 +1,2 @@
+require 'protobuf/generate/parser'
+require 'protobuf/generate/language/c'

data/protobuf-generate.gemspec

@@ -0,0 +1,22 @@
+$:.unshift(File.join(File.dirname(__FILE__), 'lib'))
+
+spec = Gem::Specification.new do |s|
+  s.name        = 'protobuf-generate'
+  s.version     = '0.0.1'
+  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']
+  s.email       = ['shane.hanna@gmail.com']
+  s.licenses    = ['MIT']
+  s.homepage    = 'https://bitbucket.org/shanehanna/protobuf-generate'
+
+  s.add_dependency('parslet')
+  s.add_dependency('erubis')
+
+  s.required_ruby_version = '>= 1.9.2'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- test/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: protobuf-generate
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Shane Hanna
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: erubis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A simple PEG parser, AST and template based approach to code generation.
+email:
+- shane.hanna@gmail.com
+executables:
+- protobuf-generate
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- bin/protobuf-generate
+- lib/protobuf-generate.rb
+- lib/protobuf/generate/language.rb
+- lib/protobuf/generate/language/c.rb
+- lib/protobuf/generate/language/c/c.erb
+- lib/protobuf/generate/language/c/h.erb
+- lib/protobuf/generate/parser.rb
+- protobuf-generate.gemspec
+homepage: https://bitbucket.org/shanehanna/protobuf-generate
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: A multi-language concrete protobuf code generator.
+test_files: []
+has_rdoc: