aaronp-zomg 1.0.2.20080827232412

data/lib/zomg/idl/visitors/sexp.rb

@@ -0,0 +1,274 @@
+module ZOMG
+  module IDL
+    module Visitors
+      class Sexp
+        def visit_Specification(o)
+          [:spec, o.children.map { |c| c.accept(self) }]
+        end
+
+        def visit_Struct(o)
+          [:struct, o.name, o.children.map { |c| c.accept(self) }]
+        end
+
+        def visit_Member(o)
+          [:member, o.type.accept(self), o.children.map { |c| c.accept(self) }]
+        end
+
+        def visit_Enum(o)
+          [:enum, o.name, o.children]
+        end
+
+        def visit_Union(o)
+          [:union, o.name, o.switch_type.accept(self), o.children.map { |c| c.accept(self) }]
+        end
+
+        def visit_Case(o)
+          [:case, o.children.map { |c| c.accept(self) }]
+        end
+
+        def visit_CaseLabel(o)
+          [:label, o.children.accept(self)]
+        end
+
+        def visit_ElementSpec(o)
+          [:element_spec, o.children.map { |c| c.accept(self) }]
+        end
+
+        def visit_Typedef(o)
+          [ :typedef,
+            o.type_spec.accept(self),
+            o.children.map { |c| c.accept(self) }
+          ]
+        end
+
+        def visit_ArrayDeclarator(o)
+          [:array_decl, o.name, o.children.map { |c| c.accept(self) }]
+        end
+
+        def visit_Sequence(o)
+          [:sequence, o.children.map { |c| c.accept(self) }]
+        end
+
+        def visit_Constant(o)
+          [ :const,
+            o.type.accept(self),
+            o.name,
+            o.value.accept(self) ]
+        end
+
+        def visit_Interface(o)
+          [ :interface,
+            o.header.accept(self),
+            o.children.map { |c| c.accept(self) }
+          ]
+        end
+
+        def visit_Operation(o)
+          [:op,
+            o.attribute && :oneway,
+            o.returns.accept(self),
+            o.name,
+            o.children.map { |c| c.accept(self) },
+            o.raises && o.raises.map { |c| c.accept(self) },
+            o.context && o.context.accept(self)
+          ]
+        end
+
+        def visit_Parameter(o)
+          [ :param,
+            o.attribute.accept(self),
+            o.type.accept(self),
+            o.declarator.accept(self),
+          ]
+        end
+
+        def visit_ScopedName(o)
+          [ :scoped_name,
+            o.name,
+            o.children.map { |c| c.accept(self) }
+          ]
+        end
+
+        def visit_Attribute(o)
+          [ :attribute,
+            o.readonly && :readonly,
+            o.type.accept(self),
+            o.children.map { |c| c.accept(self) }
+          ]
+        end
+
+        def visit_Module(o)
+          [:module, o.name, o.children.map { |c| c.accept(self) }]
+        end
+
+        def visit_Exception(o)
+          [:exception, o.name, o.children.map { |c| c.accept(self) }]
+        end
+
+        def visit_Context(o)
+          [:context, o.children.map { |c| c.accept(self) }]
+        end
+
+        def visit_ValueBoxDcl(o)
+          [:valuebox, o.name, o.children.accept(self)]
+        end
+
+        def visit_UnaryMinus(o)
+          [:uminus, o.children.accept(self)]
+        end
+
+        def visit_UnaryPlus(o)
+          [:uplus, o.children.accept(self)]
+        end
+
+        {
+          'MultiplyExpr'  => :multiply,
+          'ModulusExpr'   => :modulus,
+          'PlusExpr'      => :plus,
+          'ShiftLeftExpr' => :lshift,
+          'MinusExpr'     => :minus,
+          'DivideExpr'    => :divide,
+          'AmpersandExpr' => :ampersand,
+          'OrExpr'        => :or,
+        }.each do |type,sym|
+          define_method(:"visit_#{type}") do |o|
+            [sym, o.left.accept(self), o.right.accept(self)]
+          end
+        end
+
+        # Terminal nodes
+        def visit_Object(o)
+          :object
+        end
+
+        def visit_WideStringLiteral(o)
+          [:wstring_lit, o.children]
+        end
+
+        def visit_WideCharacterLiteral(o)
+          [:wstring_lit, o.children]
+        end
+
+        def visit_StringLiteral(o)
+          [:string_lit, o.children]
+        end
+
+        def visit_ForwardDeclaration(o)
+          [:forward_decl, o.children]
+        end
+
+        def visit_FloatingPointLiteral(o)
+          [:float, o.children]
+        end
+
+        def visit_BooleanLiteral(o)
+          [:boolean, o.children]
+        end
+
+        def visit_In(o)
+          :in
+        end
+
+        def visit_Out(o)
+          :out
+        end
+
+        def visit_Any(o)
+          :any
+        end
+
+        def visit_InOut(o)
+          :in_out
+        end
+
+        def visit_InterfaceHeader(o)
+          [:header, o.abstract, o.name, o.children.map { |c| c.accept(self) }]
+        end
+
+        def visit_DefaultLabel(o)
+          [:default]
+        end
+
+        def visit_ArraySize(o)
+          [:size, o.children.accept(self)]
+        end
+
+        def visit_Char(o)
+          :char
+        end
+
+        def visit_WChar(o)
+          :wchar
+        end
+
+        def visit_String(o)
+          [:string, o.children.map { |c| c.accept(self)}]
+        end
+
+        def visit_WString(o)
+          [:wstring, o.children.map { |c| c.accept(self)}]
+        end
+
+        def visit_Short(o)
+          :short
+        end
+
+        def visit_Long(o)
+          :long
+        end
+
+        def visit_LongLong(o)
+          :long_long
+        end
+
+        def visit_UnsignedLongLong(o)
+          :ulong_long
+        end
+
+        def visit_Float(o)
+          :float
+        end
+
+        def visit_UnsignedShort(o)
+          :ushort
+        end
+
+        def visit_UnsignedLong(o)
+          :ulong
+        end
+
+        def visit_Double(o)
+          :double
+        end
+
+        def visit_Boolean(o)
+          :boolean
+        end
+
+        def visit_Void(o)
+          :void
+        end
+
+        def visit_Octet(o)
+          :octet
+        end
+
+        def visit_SimpleDeclarator(o)
+          [:decl, o.name]
+        end
+
+        def visit_IntegerLiteral(o)
+          [:int, o.to_i]
+        end
+
+        def visit_CharacterLiteral(o)
+          [:charlit, o.children]
+        end
+
+        def accept(target)
+          target.accept(self)
+        end
+      end
+    end
+  end
+end

data/lib/zomg/version.rb

@@ -0,0 +1,3 @@
+module ZOMG
+  VERSION = '1.0.2'
+end

data/test/assets/array/array1.idl

@@ -0,0 +1,60 @@
+
+/*
+ *  Test various combinations of Arrays in IDL
+ */
+
+
+typedef char VectorChar[5];
+typedef octet VectorOctet[5];
+
+struct S0 {
+  char c[5];
+  octet o[5];
+};
+
+typedef short Vector[10];
+typedef Vector Matrix[10];
+typedef Vector VB;
+typedef VB MB[10];
+
+typedef short arr[1][2];
+typedef sequence<arr,2> arrseq;
+
+struct S1 {
+  long x;
+  char b[ 3 ];
+  long c[ 5 ][ 4 ];
+  string s[6];
+};
+
+typedef S1 S1_arr[ 3 ][ 4 ];
+
+// Note: long_arr is an array of fixed length data
+typedef long long_arr[ 10 ];
+
+interface foo;
+typedef foo foo_arr[6];
+
+// Note: SS is an array of variable data
+typedef string SS[ 5 ][ 4 ];
+
+struct S2 {
+  long x;
+  SS ss_obj;
+};
+
+
+struct S3 {
+  long a[1];
+  long b[1][2];
+  long c[1][2][3];
+};
+
+typedef sequence<S1_arr> S1_seq;
+
+
+interface foo {
+  SS bar( in SS x, inout SS y, out SS z, out long_arr w );
+  long_arr baz();
+};
+

data/test/assets/array/array2.idl

@@ -0,0 +1,38 @@
+typedef sequence<long,10> vec10;
+typedef char str22[22][2];
+typedef boolean boolarray[3][40];
+
+
+struct A {
+    long    a1;
+    char    a2[17];
+    char    a3[10][2];
+//  vec10   a3;
+};
+
+struct B {
+    long    b1;
+    A       b2;
+};
+
+struct C {
+    long    c1;
+    long    c2;
+};
+
+typedef A A_matrix[2][3][4];
+typedef B B_matrix[2][3][4];
+typedef C C_matrix[2][3][4];
+
+typedef A_matrix A_rmatrix[2][3][4][5];
+
+interface A_i {
+    A       op(in A a1, inout A a2, out A a3);
+    str22   op2(in str22 a1, inout str22 a2, out str22 a3);
+// THIS IS NOT A LEGAL OPERATION!!! You can't have [] on params
+//  str22       op3(in short a1[3][4], inout short a2[3][4], out short a3[4][4]);
+    A_matrix    op4(in A a1, inout A a2, out A a3);
+    attribute str22 attribute_array;
+//  void foo(in any x[3], out any y[4], inout any z[3]);
+};
+

data/test/assets/array/array3.idl

@@ -0,0 +1,8 @@
+typedef sequence<long,10> vec10;
+typedef char str22[22][2];
+typedef boolean boolarray[3][40];
+typedef sequence<long> vec;
+typedef unsigned short A_matrix[2][3][4];
+typedef A_matrix A_rmatrix[2][3][4][5];
+typedef string<15> a;
+

data/test/assets/array/array4.idl

@@ -0,0 +1,7 @@
+interface arrayez {
+    typedef long arr8k[2048];
+    long test_in8k(in arr8k a);
+    long test_out8k(out arr8k a);
+    long test_io8k(in arr8k a, out arr8k b);
+};
+

data/test/assets/array/array5.idl

@@ -0,0 +1,80 @@
+/* This should test for alignment constraints on arrays */
+
+// This is a data structure that ends in unconstrained alignment
+struct end {
+    long elem1;
+    char elem2;
+};
+// This is a data structure that begins in unconstrained alignment
+struct begin {
+    char elem1;
+    long elem2;
+};
+
+struct cLd {
+    char first;
+    long data[50];
+    double last;
+};
+
+struct dLc {
+    double first;
+    long data[50];
+    char last;
+};
+
+struct sLs {
+    short first;
+    long data[50];
+    short last;
+};
+
+struct cLCd {
+    char first;
+    end data[50];
+    double last;
+};
+
+struct dLCc {
+    double first;
+    end data[50];
+    char last;
+};
+
+struct sLCs {
+    short first;
+    end data[50];
+    short last;
+};
+
+struct cCLd {
+    char first;
+    begin data[50];
+    double last;
+};
+
+struct dCLc {
+    double first;
+    begin data[50];
+    char last;
+};
+
+struct sCLs {
+    short first;
+    begin data[50];
+    short last;
+};
+
+#define test(t) t test_##t (in t inp, inout t iop, out t outp)
+
+interface arrays {
+    test(cLd);
+    test(dLc);
+    test(sLs);
+    test(cLCd);
+    test(dLCc);
+    test(sLCs);
+    test(cCLd);
+    test(dCLc);
+    test(sCLs);
+};