xdrgen 0.0.1

data/lib/xdrgen/generators/java/XdrDataInputStream.erb

@@ -0,0 +1,122 @@
+package <%= @namespace %>;
+
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.Charset;
+
+public class XdrDataInputStream extends DataInputStream {
+
+    // The underlying input stream
+    private final XdrInputStream mIn;
+
+    /**
+     * Creates a XdrDataInputStream that uses the specified
+     * underlying InputStream.
+     *
+     * @param in the specified input stream
+     */
+    public XdrDataInputStream(InputStream in) {
+        super(new XdrInputStream(in));
+        mIn = (XdrInputStream) super.in;
+    }
+
+    public int[] readIntArray() throws IOException {
+        int l = readInt();
+        return readIntArray(l);
+    }
+
+    private int[] readIntArray(int l) throws IOException {
+        int[] arr = new int[l];
+        for (int i = 0; i < l; i++) {
+            arr[i] = readInt();
+        }
+        return arr;
+    }
+
+    public float[] readFloatArray() throws IOException {
+        int l = readInt();
+        return readFloatArray(l);
+    }
+
+    private float[] readFloatArray(int l) throws IOException {
+        float[] arr = new float[l];
+        for (int i = 0; i < l; i++) {
+            arr[i] = readFloat();
+        }
+        return arr;
+    }
+
+    public double[] readDoubleArray() throws IOException {
+        int l = readInt();
+        return readDoubleArray(l);
+    }
+
+    private double[] readDoubleArray(int l) throws IOException {
+        double[] arr = new double[l];
+        for (int i = 0; i < l; i++) {
+            arr[i] = readDouble();
+        }
+        return arr;
+    }
+
+    @Override
+    public int read() throws IOException {
+        return super.read();
+    }
+
+    /**
+     * Need to provide a custom impl of InputStream as DataInputStream's read methods
+     * are final and we need to keep track of the count for padding purposes.
+     */
+    private static final class XdrInputStream extends InputStream {
+
+        // The underlying input stream
+        private final InputStream mIn;
+
+        // The amount of bytes read so far.
+        private int mCount;
+
+        public XdrInputStream(InputStream in) {
+            mIn = in;
+            mCount = 0;
+        }
+
+        @Override
+        public int read() throws IOException {
+            int read = mIn.read();
+            if (read >= 0) {
+                mCount++;
+            }
+            return read;
+        }
+
+        @Override
+        public int read(byte[] b) throws IOException {
+            return read(b, 0, b.length);
+        }
+
+        @Override
+        public int read(byte[] b, int off, int len) throws IOException {
+            int read = mIn.read(b, off, len);
+            mCount += read;
+            pad();
+            return read;
+        }
+
+        public void pad() throws IOException {
+            int pad = 0;
+            int mod = mCount % 4;
+            if (mod > 0) {
+                pad = 4-mod;
+            }
+
+            while (pad-- > 0) {
+                int b = read();
+                if (b != 0) {
+                    throw new IOException("non-zero padding");
+                }
+            }
+        }
+    }
+}

data/lib/xdrgen/generators/java/XdrDataOutputStream.erb

@@ -0,0 +1,96 @@
+package <%= @namespace %>;
+
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.charset.Charset;
+
+public class XdrDataOutputStream extends DataOutputStream {
+
+    private final XdrOutputStream mOut;
+
+    public XdrDataOutputStream(OutputStream out) {
+        super(new XdrOutputStream(out));
+        mOut = (XdrOutputStream) super.out;
+    }
+
+    public void writeIntArray(int[] a) throws IOException {
+        writeInt(a.length);
+        writeIntArray(a, a.length);
+    }
+
+    private void writeIntArray(int[] a, int l) throws IOException {
+        for (int i = 0; i < l; i++) {
+            writeInt(a[i]);
+        }
+    }
+
+    public void writeFloatArray(float[] a) throws IOException {
+        writeInt(a.length);
+        writeFloatArray(a, a.length);
+    }
+
+    private void writeFloatArray(float[] a, int l) throws IOException {
+        for (int i = 0; i < l; i++) {
+            writeFloat(a[i]);
+        }
+    }
+
+    public void writeDoubleArray(double[] a) throws IOException {
+        writeInt(a.length);
+        writeDoubleArray(a, a.length);
+    }
+
+    private void writeDoubleArray(double[] a, int l) throws IOException {
+        for (int i = 0; i < l; i++) {
+            writeDouble(a[i]);
+        }
+    }
+
+    private static final class XdrOutputStream extends OutputStream {
+
+        private final OutputStream mOut;
+
+        // Number of bytes written
+        private int mCount;
+
+        public XdrOutputStream(OutputStream out) {
+            mOut = out;
+            mCount = 0;
+        }
+
+        @Override
+        public void write(int b) throws IOException {
+            mOut.write(b);
+            // https://docs.oracle.com/javase/7/docs/api/java/io/OutputStream.html#write(int):
+            // > The byte to be written is the eight low-order bits of the argument b.
+            // > The 24 high-order bits of b are ignored.
+            mCount++;
+        }
+
+        @Override
+        public void write(byte[] b) throws IOException {
+            // https://docs.oracle.com/javase/7/docs/api/java/io/OutputStream.html#write(byte[]):
+            // > The general contract for write(b) is that it should have exactly the same effect
+            // > as the call write(b, 0, b.length).
+            write(b, 0, b.length);
+        }
+
+        public void write(byte[] b, int offset, int length) throws IOException {
+            mOut.write(b, offset, length);
+            mCount += length;
+            pad();
+        }
+
+        public void pad() throws IOException {
+            int pad = 0;
+            int mod = mCount % 4;
+            if (mod > 0) {
+                pad = 4-mod;
+            }
+            while (pad-- > 0) {
+                write(0);
+            }
+        }
+    }
+}

data/lib/xdrgen/generators/java/XdrElement.erb

@@ -0,0 +1,10 @@
+package <%= @namespace %>;
+
+import java.io.IOException;
+
+/**
+ * Common parent interface for all generated classes. 
+ */
+interface XdrElement {
+    void encode(XdrDataOutputStream stream) throws IOException;
+}

data/lib/xdrgen/generators/java/XdrString.erb

@@ -0,0 +1,58 @@
+package <%= @namespace %>;
+
+import java.io.IOException;
+import java.io.InvalidClassException;
+import java.nio.charset.Charset;
+import java.util.Arrays;
+
+public class XdrString implements XdrElement {
+    private byte[] bytes;
+
+    public XdrString(byte[] bytes) {
+        this.bytes = bytes;
+    }
+
+    public XdrString(String text) {
+        this.bytes = text.getBytes(Charset.forName("UTF-8"));
+    }
+
+    @Override
+    public void encode(XdrDataOutputStream stream) throws IOException {
+        stream.writeInt(this.bytes.length);
+        stream.write(this.bytes, 0, this.bytes.length);
+    }
+
+    public static XdrString decode(XdrDataInputStream stream, int maxSize) throws IOException {
+        int size = stream.readInt();
+        if (size > maxSize) {
+            throw new InvalidClassException("String length "+size+" exceeds max size "+maxSize);
+        }
+        byte[] bytes = new byte[size];
+        stream.read(bytes);
+        return new XdrString(bytes);
+    }
+
+    public byte[] getBytes() {
+        return this.bytes;
+    }
+
+    @Override
+    public int hashCode() {
+        return Arrays.hashCode(this.bytes);
+    }
+
+    @Override
+    public boolean equals(Object object) {
+        if (object == null || !(object instanceof XdrString)) {
+          return false;
+        }
+
+        XdrString other = (XdrString) object;
+        return Arrays.equals(this.bytes, other.bytes);
+    }
+
+    @Override
+    public String toString() {
+        return new String(bytes, Charset.forName("UTF-8"));
+    }
+}

data/lib/xdrgen/generators/javascript.rb

@@ -0,0 +1,248 @@
+module Xdrgen
+  module Generators
+
+    class Javascript < Xdrgen::Generators::Base
+      MAX_INT = (2**31) - 1
+      def generate
+        path = "#{@namespace}_generated.js"
+        out = @output.open(path)
+
+        render_top_matter out
+        render_define_block(out) do
+          render_definitions(out, @top)
+        end
+      end
+
+      private
+      def render_definitions(out, node)
+        node.definitions.each{|n| render_definition out, n }
+        node.namespaces.each{|n| render_definitions out, n }
+      end
+
+      def render_nested_definitions(out, defn)
+        return unless defn.respond_to? :nested_definitions
+        defn.nested_definitions.each{|ndefn| render_definition out, ndefn}
+      end
+
+      def render_definition(out, defn)
+        render_nested_definitions(out, defn)
+        render_source_comment(out, defn)
+
+        case defn
+        when AST::Definitions::Struct ;
+          render_struct out, defn
+        when AST::Definitions::Enum ;
+          render_enum out, defn
+        when AST::Definitions::Union ;
+          render_union out, defn
+        when AST::Definitions::Typedef ;
+          render_typedef out, defn
+        when AST::Definitions::Const ;
+          render_const out, defn
+        end
+
+        out.break
+      end
+
+      def render_source_comment(out, defn)
+        return if defn.is_a?(AST::Definitions::Namespace)
+
+        out.puts <<-EOS.strip_heredoc
+          // === xdr source ============================================================
+          //
+        EOS
+
+        out.puts "//   " + defn.text_value.split("\n").join("\n//   ")
+
+        out.puts <<-EOS.strip_heredoc
+          //
+          // ===========================================================================
+        EOS
+      end
+
+
+      def render_top_matter(out)
+        out.puts <<-EOS.strip_heredoc
+          // Automatically generated on #{Time.now.iso8601}
+          // DO NOT EDIT or your changes may be overwritten
+
+          /* jshint maxstatements:2147483647  */
+          /* jshint esnext:true  */
+
+          import * as XDR from 'js-xdr';
+
+        EOS
+        out.break
+      end
+
+      def render_define_block(out)
+        out.puts "var types = XDR.config(xdr => {"
+        yield
+      ensure
+        out.puts "});"
+        out.puts "export default types;"
+        out.break
+      end
+
+
+      def render_typedef(out, typedef)
+        out.puts "xdr.typedef(\"#{name typedef}\", #{reference typedef.declaration.type});"
+      end
+
+      def render_const(out, const)
+        out.puts "xdr.const(\"#{const_name const}\", #{const.value});"
+      end
+
+      def render_struct(out, struct)
+        out.puts "xdr.struct(\"#{name struct}\", ["
+        out.indent do
+          struct.members.each do |m|
+            out.puts "[\"#{member_name m}\", #{reference m.type}],"
+          end
+        end
+        out.puts "]);"
+      end
+
+      def render_enum(out, enum)
+        out.puts "xdr.enum(\"#{name enum}\", {"
+
+        out.indent do
+          enum.members.each do |m|
+            out.puts "#{member_name m}: #{m.value},"
+          end
+        end
+
+        out.puts "});"
+      end
+
+      def render_union(out, union)
+        out.puts "xdr.union(\"#{name union}\", {"
+        out.indent do
+          out.puts "switchOn: #{reference union.discriminant.type},"
+          out.puts "switchName: \"#{member_name union.discriminant}\","
+          out.puts "switches: ["
+
+          out.indent do
+            union.normal_arms.each do |arm|
+              arm_name = arm.void? ? "xdr.void()" : "\"#{member_name(arm)}\""
+
+              arm.cases.each do |acase|
+                switch = if acase.value.is_a?(AST::Identifier)
+                  if union.discriminant.type.is_a?(AST::Typespecs::Int)
+                    member = union.resolved_case(acase)
+                    "#{member.value}"
+                  else
+                    '"' + member_name(acase.value) + '"'
+                  end
+                else
+                  acase.value.text_value
+                end
+
+                out.puts "[#{switch}, #{arm_name}],"
+              end
+            end
+          end
+
+          out.puts "],"
+          out.puts "arms: {"
+
+          out.indent do
+            union.arms.each do |arm|
+              next if arm.void?
+              out.puts "#{member_name arm}: #{reference arm.type},"
+            end
+          end
+
+          out.puts "},"
+
+          if union.default_arm.present?
+            arm = union.default_arm
+            arm_name = arm.void? ? "xdr.void()" : member_name(arm)
+            out.puts "defaultArm: #{arm_name},"
+          end
+
+        end
+        out.puts "});"
+      end
+
+      private
+      def name(named)
+        parent = name named.parent_defn if named.is_a?(AST::Concerns::NestedDefinition)
+
+        # NOTE: classify will strip plurality, so we restore it if necessary
+        plural = named.name.pluralize == named.name
+        base   = named.name.underscore.classify
+        result = plural ? base.pluralize : base
+
+        "#{parent}#{result}"
+      end
+
+      def const_name(named)
+        # NOTE: classify will strip plurality, so we restore it if necessary
+        plural = named.name.pluralize == named.name
+        base   = named.name.underscore.upcase
+        plural ? base.pluralize : base
+      end
+
+      def member_name(member)
+        name(member).camelize(:lower)
+      end
+
+      def reference(type)
+        baseReference = case type
+        when AST::Typespecs::Bool
+          "xdr.bool()"
+        when AST::Typespecs::Double
+          "xdr.double()"
+        when AST::Typespecs::Float
+          "xdr.float()"
+        when AST::Typespecs::Hyper
+          "xdr.hyper()"
+        when AST::Typespecs::Int
+          "xdr.int()"
+        when AST::Typespecs::Opaque
+          if type.fixed?
+            "xdr.opaque(#{type.size})"
+          else
+            "xdr.varOpaque(#{type.size})"
+          end
+        when AST::Typespecs::Quadruple
+          raise "no quadruple support for javascript"
+        when AST::Typespecs::String
+          "xdr.string(#{type.size})"
+        when AST::Typespecs::UnsignedHyper
+          "xdr.uhyper()"
+        when AST::Typespecs::UnsignedInt
+          "xdr.uint()"
+        when AST::Typespecs::Simple
+          "xdr.lookup(\"#{name type}\")"
+        when AST::Definitions::Base
+          "xdr.lookup(\"#{name type}\")"
+        when AST::Concerns::NestedDefinition
+          "xdr.lookup(\"#{name type}\")"
+        else
+          raise "Unknown reference type: #{type.class.name}, #{type.class.ancestors}"
+        end
+
+        case type.sub_type
+        when :simple
+          baseReference
+        when :optional
+          "xdr.option(#{baseReference})"
+        when :array
+          is_named, size = type.array_size
+          size = is_named ? "xdr.lookup(\"#{size}\")" : size
+          "xdr.array(#{baseReference}, #{size})"
+        when :var_array
+          is_named, size = type.array_size
+          size = is_named ? "xdr.lookup(\"#{size}\")" : (size || MAX_INT)
+          "xdr.varArray(#{baseReference}, #{size})"
+        else
+          raise "Unknown sub_type: #{type.sub_type}"
+        end
+
+      end
+
+    end
+  end
+end