lib/java/se/lth/control/labcomm2014/SignatureSymbol.java

+package se.lth.control.labcomm2014;
+
+public interface SignatureSymbol{
+    public void accept(SignatureSymbolVisitor v);
+}
+

lib/java/se/lth/control/labcomm2014/SignatureSymbolVisitor.java

+package se.lth.control.labcomm2014;
+    /* An interface for using Visitor pattern to traverse
+     * the type tree
+     */
+    public interface SignatureSymbolVisitor {
+        void visit(TypeSymbol s);
+        void visit(SampleSymbol s);
+        void visit(NameSymbol s);
+        void visit(SigPrimitiveType t);
+        //sampleRefs are sent as primitive types
+        //Put this back if that is changed to SampleRefType
+        //void visit(SampleRefType t);
+        void visit(SigStructType t);
+        void visit(SigField t);
+        void visit(SigArrayType t);
+        void visit(SigUserType t);
+    }

lib/java/se/lth/control/labcomm2014/TypeBinding.java

@@ -3,6 +3,8 @@ package se.lth.control.labcomm2014;
 import java.io.IOException;
 import java.io.ByteArrayOutputStream;
 import java.io.ByteArrayInputStream;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
 import se.lth.control.labcomm2014.Decoder;
 import se.lth.control.labcomm2014.DecoderChannel;
 import se.lth.control.labcomm2014.SampleDispatcher;
@@ -77,10 +79,22 @@ public class TypeBinding implements BuiltinType {
       return null; // not used for matching
     }
 
+  public int getNumIntentions() {
+      return 0;
+  }
+
+  public byte[] getIntentionBytes() {
+     return null; // not used for matching
+  }
+
     public void encodeTypeDef(Encoder e, int index) throws IOException{
       throw new Error("Should not be called");
     }
 
+    public void registerTypeDeps(Encoder e) throws IOException{
+      throw new Error("Should not be called");
+    }
+
     public void decodeAndHandle(Decoder d,
                                 SampleHandler h) throws Exception {
       ((Handler)h).handle_TypeBinding(TypeBinding.decode(d));
@@ -89,6 +103,25 @@ public class TypeBinding implements BuiltinType {
     public boolean hasDependencies() {
         return false;
     }
+
+    public Iterator<SampleDispatcher> getDependencyIterator() {
+        return new Iterator<SampleDispatcher>() {
+            public boolean hasNext() {
+                return false;
+            }
+
+            public SampleDispatcher next() throws NoSuchElementException {
+                throw new NoSuchElementException();
+            }
+            public void remove() throws UnsupportedOperationException {
+                throw new UnsupportedOperationException();
+            }
+        };
+    }
+
+    public DataType getDataType() {
+        throw new Error("not implemented");
+    }
   }
 
   public static void encode(Encoder e, TypeBinding value) throws IOException {

lib/java/se/lth/control/labcomm2014/TypeDef.java

@@ -3,6 +3,8 @@ package se.lth.control.labcomm2014;
 import java.io.IOException;
 import java.io.ByteArrayOutputStream;
 import java.io.ByteArrayInputStream;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
 import se.lth.control.labcomm2014.Decoder;
 import se.lth.control.labcomm2014.DecoderChannel;
 import se.lth.control.labcomm2014.SampleDispatcher;
@@ -85,10 +87,22 @@ public class TypeDef implements BuiltinType {
       return null; // not used for matching
     }
 
+    public int getNumIntentions() {
+        return 0;
+    }
+
+    public byte[] getIntentionBytes() {
+        return new byte[0];
+    }
+
     public void encodeTypeDef(Encoder e, int index) throws IOException{
       throw new Error("Should not be called");
     }
 
+    public void registerTypeDeps(Encoder e) throws IOException{
+      throw new Error("Should not be called");
+    }
+
 //    public boolean canDecodeAndHandle() {
 //      return true;
 //    }
@@ -101,6 +115,25 @@ public class TypeDef implements BuiltinType {
     public boolean hasDependencies() {
         return false;
     }
+
+    public Iterator<SampleDispatcher> getDependencyIterator() {
+        return new Iterator<SampleDispatcher>() {
+            public boolean hasNext() {
+                return false;
+            }
+
+            public SampleDispatcher next() throws NoSuchElementException {
+                throw new NoSuchElementException();
+            }
+            public void remove() throws UnsupportedOperationException {
+                throw new UnsupportedOperationException();
+            }
+        };
+    }
+
+    public DataType getDataType() {
+        throw new Error("not implemented");
+    }
   }
 
   public static void encode(Encoder e, TypeDef value) throws IOException {
@@ -119,6 +152,14 @@ public class TypeDef implements BuiltinType {
   public static TypeDef decode(Decoder d) throws IOException {
     TypeDef result;
     int index = d.decodePacked32();
+    int numIntentions = d.decodePacked32();
+    if(numIntentions != 1) {
+        System.out.println("WARNING: #intentions == "+numIntentions);
+    }
+    int keylen = d.decodePacked32();
+    if(keylen != 0) {
+        System.out.println("WARNING: keylen == "+keylen);
+    }
     String name = d.decodeString();
     int siglen= d.decodePacked32();
     byte sig[] = new byte[siglen];

lib/java/se/lth/control/labcomm2014/TypeDefParser.java

@@ -49,13 +49,14 @@ public class TypeDefParser implements TypeDef.Handler, TypeBinding.Handler {
     }
 
     public interface TypeDefListener {
-        void onTypeDef(ParsedTypeDef d);
+        void onTypeDef(SigTypeDef d);
     }
 
     private HashMap<Integer,TypeDef> typeDefs;
     private HashMap<Integer,Integer> typeBindings;
     private HashSet<TypeDefListener> listeners;
     private LinkedList<ParsedSampleDef> sampleDefs;
+    private HashMap<Integer,ParsedTypeDef> pts;
     private Decoder decoder;
 
     protected TypeDefParser(Decoder d) {
@@ -64,6 +65,7 @@ public class TypeDefParser implements TypeDef.Handler, TypeBinding.Handler {
         typeBindings = new HashMap<Integer,Integer>();
         listeners = new HashSet<TypeDefListener>();
         sampleDefs = new LinkedList<ParsedSampleDef>();
+        pts = new HashMap<Integer,ParsedTypeDef>();
     }
 
     public void addListener(TypeDefListener l) {
@@ -76,7 +78,10 @@ public class TypeDefParser implements TypeDef.Handler, TypeBinding.Handler {
     }
 
     public void handle_TypeDef(TypeDef d) throws java.io.IOException {
+        System.out.println("handle_TypeDef: "+d.getIndex());
         typeDefs.put(d.getIndex(), d);
+        ParsedTypeDef td = parseSignatureTD(d);
+        pts.put(d.getIndex(), td);
     }
 
     public void handle_TypeBinding(TypeBinding d) throws java.io.IOException {
@@ -87,6 +92,7 @@ public class TypeDefParser implements TypeDef.Handler, TypeBinding.Handler {
             typeBindings.put(d.getSampleIndex(), d.getTypeIndex());
             td = getTypeDefForIndex(d.getSampleIndex());
         }
+        System.out.println("handle_TypeBinding: "+d.getSampleIndex());
         ParsedSampleDef result = parseSignature(td);
 
         sampleDefs.add(result);
@@ -100,7 +106,7 @@ public class TypeDefParser implements TypeDef.Handler, TypeBinding.Handler {
     private void notifyListener(TypeDefListener l, ParsedTypeDef d) {
         l.onTypeDef(d);
         if(d instanceof ParsedSampleDef) {
-            for(ParsedTypeDef dep : ((ParsedSampleDef)d).getDependencies()) {
+            for(SigTypeDef dep : ((ParsedSampleDef)d).getDependencies()) {
                 //do we want to change ParseTypeDef to have dependencies,
                 //and do recursion here?
                 //if so, do notifyListener(l, dep);
@@ -130,21 +136,21 @@ public class TypeDefParser implements TypeDef.Handler, TypeBinding.Handler {
         return res;
     }
 
-    public LinkedList<ParsedSymbol> symbolify() {
+    public LinkedList<SignatureSymbol> symbolify() {
 
-        LinkedList<ParsedSymbol> result = new LinkedList<ParsedSymbol>();
+        LinkedList<SignatureSymbol> result = new LinkedList<SignatureSymbol>();
 
         Iterator<ParsedSampleDef> sdi = sampleDefIterator();
 
         while(sdi.hasNext()) {
-            ParsedSampleDef sd = sdi.next();
+            SigTypeDef sd = sdi.next();
             result.add(new SampleSymbol());
             result.add(sd.getType());
             result.add(new NameSymbol(sd.getName()));
 
-            Iterator<ParsedTypeDef> di = sd.getDepIterator();        
+            Iterator<SigTypeDef> di = sd.getDepIterator();
             while(di.hasNext()) {
-                ParsedTypeDef d = di.next();
+                SigTypeDef d = di.next();
                 result.add(new TypeSymbol());
                 result.add(d.getType());
                 result.add(new NameSymbol(d.getName()));
@@ -154,7 +160,7 @@ public class TypeDefParser implements TypeDef.Handler, TypeBinding.Handler {
     }
 
     public String symbolString() {
-        Iterator<ParsedSymbol> i = symbolify().iterator();
+        Iterator<SignatureSymbol> i = symbolify().iterator();
 
         StringBuilder sb = new StringBuilder();
 
@@ -164,65 +170,9 @@ public class TypeDefParser implements TypeDef.Handler, TypeBinding.Handler {
         return sb.toString();
     }
 
-    /* An interface for using Visitor pattern to traverse 
-     * ParsedTypeDefs
-     */
-    public interface ParsedSymbolVisitor {
-        void visit(TypeSymbol s);
-        void visit(SampleSymbol s);
-        void visit(NameSymbol s);
-        void visit(PrimitiveType t);
-        //sampleRefs are sent as primitive types
-        //Put this back if that is changed to SampleRefType
-        //void visit(SampleRefType t);
-        void visit(ParsedStructType t);
-        void visit(ParsedField t);
-        void visit(ArrayType t);
-        void visit(ParsedUserType t);
-    }
-    public abstract class ParsedSymbol{
-        public abstract void accept(ParsedSymbolVisitor v);
-    }
-
-    public class TypeSymbol extends ParsedSymbol {
-        public String toString() {
-            return "typedef ";
-        }
-        public void accept(ParsedSymbolVisitor v){
-            v.visit(this);
-        }
-    }
-
-    public class SampleSymbol extends ParsedSymbol {
-        public String toString() {
-            return "sample ";
-        }
-        public void accept(ParsedSymbolVisitor v){
-            v.visit(this);
-        }
-    }
-
-    public class NameSymbol extends ParsedSymbol {
-        private String name;
-
-        public NameSymbol(String name) {
-            this.name = name;
-        }
-
-        public String toString() { 
-            return name;
-        }
-        public void accept(ParsedSymbolVisitor v){
-            v.visit(this);
-        }
-    }
-
-    public abstract class ParsedType extends ParsedSymbol{
-    }
-
 // SampleRefType currently not sent, se above
-//    public class SampleRefType extends ParsedType {
-//        public void accept(ParsedSymbolVisitor v) {
+//    public class SampleRefType extends DataType {
+//        public void accept(SignatureSymbolVisitor v) {
 //            v.visit(this);
 //        }
 //
@@ -230,259 +180,6 @@ public class TypeDefParser implements TypeDef.Handler, TypeBinding.Handler {
 //            return "sample";}
 //    }
 
-    public class PrimitiveType extends ParsedType {
-        private final String name;
-        private int tag;
-
-        String getName() {
-            return name;
-        }
-
-        int getTag() {
-            return tag;
-        }
-        PrimitiveType(int tag) {
-            this.tag = tag;
-            switch(tag) {
-                case Constant.BOOLEAN:
-                    this.name = "boolean";
-                    break;
-                case Constant.BYTE:
-                    this.name = "byte";
-                    break;
-                case Constant.SHORT:
-                    this.name = "short";
-                    break;
-                case Constant.INT:
-                    this.name = "int";
-                    break;
-                case Constant.LONG:
-                    this.name = "long";
-                    break;
-                case Constant.FLOAT:
-                    this.name = "float";
-                    break;
-                case Constant.DOUBLE:
-                    this.name = "double";
-                    break;
-                case Constant.STRING:
-                    this.name = "string";
-                    break;
-                case Constant.SAMPLE:
-                    this.name = "sample";
-                    break;
-                default:
-                    this.name = "??? unknown tag 0x"+Integer.toHexString(tag);    
-            }
-        }
-
-        public void accept(ParsedSymbolVisitor v) {
-            v.visit(this);
-        }
-
-        public String toString() { 
-            return name;}
-    }
-
-    public class ParsedStructType extends ParsedType {
-        private ParsedField fields[];
-
-        ParsedStructType(int nParsedFields) {
-            this.fields = new ParsedField[nParsedFields];
-        }
-
-        public ParsedField[] getFields() {
-            return fields;
-        }
-
-        void setParsedField(int idx, ParsedField f) {
-            fields[idx] = f;
-        }
-
-        public boolean isVoid() {
-            return fields.length == 0;
-        }
-
-        public String toString() {
-            if(isVoid()) { //void type is empty struct
-                return "void";
-            } else {
-                StringBuilder sb = new StringBuilder();
-                sb.append("struct {\n");
-                for(ParsedField f : fields) {
-                    sb.append(f.toString());
-                    sb.append(";\n");        
-                }
-                sb.append("}");
-                return sb.toString();
-            }
-        }
-
-        public void accept(ParsedSymbolVisitor v) {
-            v.visit(this);
-        }
-    }
-
-    public class ParsedField extends ParsedSymbol{
-        private ParsedType type;
-        private String name;
-
-        ParsedField(String name, ParsedType type) {
-            this.name = name;
-            this.type = type;
-        }
-
-        public ParsedType getType() {
-            return type;
-        }
-
-        public String getName() {
-            return name;
-        }
-
-        public String toString() {
-            return type.toString() + " " + name;
-        }
-
-        public void accept(ParsedSymbolVisitor v) {
-            v.visit(this);
-        }
-    }
-
-    public class ArrayType extends ParsedType {
-        private int idx[];
-        private ParsedType type;
-
-        ArrayType(int idx[], ParsedType elementType) {
-            this.idx = idx;
-            this.type = elementType;
-        }
-
-        public ParsedType getType() {
-            return type;
-        }
-
-        public int[] getIdx() {
-            return idx;
-        }
-
-        public String toString() {
-            StringBuilder sb = new StringBuilder();
-            sb.append(type.toString());
-            for(int i : idx) {
-                sb.append("["+(i>0 ? i : "_")+"]");
-            }
-            return sb.toString();
-        }
-
-        public void accept(ParsedSymbolVisitor v) {
-            v.visit(this);
-        }
-    }
-
-    public class ParsedUserType extends ParsedType {
-        private String name;
-        public String getName() {
-            return name;
-        }
-
-        public String toString() {
-            return name;
-        }
-
-        ParsedUserType(String name) {
-            this.name = name;
-        }
-
-        public void accept(ParsedSymbolVisitor v) {
-            v.visit(this);
-        }
-    }
-
-    public class ParsedTypeDef{
-       private int idx;
-       private String name;
-       private ParsedType type;
-
-       ParsedTypeDef(int idx, String name){
-            this.idx = idx;
-            this.name = name;
-       }
-
-       ParsedTypeDef(int idx, String name, ParsedType type) {
-           this(idx, name);
-           this.type = type;
-       }
-
-       /** To be overridden in ParsedSampleDef
-        */
-       public boolean isSampleDef() {
-           return false;
-       }
-
-       void setType(ParsedType type) {
-           this.type = type;
-       }
-
-       ParsedType getType() {
-           return type;
-       }
-
-       int getIndex() {
-           return idx;
-       }
-
-       public String getName() {
-            return name;
-       }
-
-       public String toString() {
-          return type.toString();
-       }
-
-       public int hashCode() {
-           return name.hashCode();
-       }
-
-       public boolean equals(Object o) {
-            if(! (o instanceof ParsedTypeDef)){
-                return false;
-            } else {
-                ParsedTypeDef other = (ParsedTypeDef) o;
-                return other.idx == idx && other.name.equals(name);
-            }
-       }
-
-       public void accept(ParsedSymbolVisitor v) {
-            type.accept(v);
-       }
-    }
-   
-    public class ParsedSampleDef extends ParsedTypeDef{
-
-        private HashSet<ParsedTypeDef> deps;
-        ParsedSampleDef(ParsedTypeDef td) {
-            super(td.getIndex(), td.getName(), td.getType());
-            this.deps = new HashSet<ParsedTypeDef>();
-        }
-
-        void addDependency(ParsedTypeDef d) {
-            deps.add(d);
-        }
-
-        @Override
-        public boolean isSampleDef() {
-            return true;
-        }
-        private HashSet<ParsedTypeDef> getDependencies() {
-            return deps;
-        }
-
-        Iterator<ParsedTypeDef> getDepIterator() {
-            return deps.iterator();
-        }        
-    }
-
     private class ParserState {
         private ByteArrayInputStream bis;
         private DataInputStream in;
@@ -546,6 +243,40 @@ public class TypeDefParser implements TypeDef.Handler, TypeBinding.Handler {
             return current.getName();
         }
 
+        void addTypeUse(int tag) {
+            SigTypeDef td = pts.get(tag);
+            if(td != null) {
+                currentParsed.addDependency(td);
+            } else {
+                System.out.println("******* WARNING: TypeDefParser:addTypeUse ("+tag+"): null???");
+            }
+        }
+        /** return name, (if any, or "") for now */
+        String decodeIntentions() throws IOException {
+            int n = decodePacked32() & 0xffffffff;
+            if(n==0) return "";
+
+            String name = "";
+
+            for(int i=0; i<n;i++) {
+                int klen = decodePacked32() & 0xffffffff;
+                byte[] kchars = new byte[klen];
+                for(int k=0; k<klen; k++) {
+                    kchars[k] = in.readByte();
+                }
+
+                int vlen = decodePacked32() & 0xffffffff;
+                byte[] vchars = new byte[vlen];
+                for(int j=0; j<vlen; j++) {
+                    vchars[j] = in.readByte();
+                }
+                if(klen==0) {
+                  name = new String(vchars);
+                }
+            }
+            return name;
+        }
+
         String decodeString() throws IOException {
             int len = decodePacked32() & 0xffffffff;
             byte[] chars = new byte[len];
@@ -569,6 +300,24 @@ public class TypeDefParser implements TypeDef.Handler, TypeBinding.Handler {
 
             return (int) (res & 0xffffffff);
         }
+
+        void skipBytes(int len) throws IOException {
+            for(int i=0; i<len; i++) {
+                in.readByte();
+            }
+        }
+    }
+
+    private ParsedTypeDef parseSignatureTD(TypeDef td) throws IOException{
+        return parseSignatureTD(td, new ParserState(td));
+    }
+
+    private ParsedTypeDef parseSignatureTD(TypeDef td, ParserState s) throws IOException{
+
+        ParsedTypeDef result=null;
+        s.popType();
+        result = parseTypeDef(s);
+        return result;
     }
 
     public ParsedSampleDef parseSignature(TypeDef td) throws IOException{
@@ -576,74 +325,99 @@ public class TypeDefParser implements TypeDef.Handler, TypeBinding.Handler {
 
         ParsedSampleDef result=null;
         try {
-            s.popType();
-            result = parseSampleTypeDef(s);
-            while(s.moreTypes()) {
-                s.popType();
-                result.addDependency(parseTypeDef(s));
-            }
+            result = new ParsedSampleDef(parseSignatureTD(td,s));
+
+//            while(s.moreTypes()) {
+//                s.popType();
+//                result.addDependency(parseTypeDef(s));
+//            }
         } catch(java.io.EOFException ex) {
             System.out.println("EOF: self_binding");
         }
         return result;
     }
 
-    private ArrayType  parseArray(ParserState in) throws IOException {
+    private SigArrayType  parseArray(ParserState in) throws IOException {
         int numIdx = in.decodePacked32();
         int idx[] = new int[numIdx];
         for(int i=0; i<numIdx; i++){
             idx[i] = in.decodePacked32();
         }
         int type = in.decodePacked32();
-        ParsedType elementType = lookupType(type, in); 
-        ArrayType result = new ArrayType(idx, elementType);
+        DataType elementType = lookupType(type, in);
+        SigArrayType result = new SigArrayType(elementType, idx);
         for(int i=0; i<numIdx; i++){
             idx[i] = in.decodePacked32();
         }
         return result;
     }
 
-    private ParsedStructType parseStruct(ParserState in) throws IOException {
-        int numParsedFields = in.decodePacked32();
-        ParsedStructType result = new ParsedStructType(numParsedFields);
-        for(int i=0; i<numParsedFields; i++) {
-            result.setParsedField(i, parseParsedField(in));
+    private SigStructType parseStruct(ParserState in) throws IOException {
+        int numSigFields = in.decodePacked32();
+        SigStructType result = new SigStructType(numSigFields);
+        for(int i=0; i<numSigFields; i++) {
+            result.addField(parseSigField(in));
         }
         return result;
     }
 
-    private ParsedField parseParsedField(ParserState in) throws IOException {
-        String name = in.decodeString();
-        return new ParsedField(name, parseType(in));
+    private SigField parseSigField(ParserState in) throws IOException {
+        String name = in.decodeIntentions();
+        return new SigField(name, parseType(in, false));
     }
 
-    private ParsedType lookupType(int tag, ParserState in) {
-        ParsedType result;
+    private DataType lookupType(int tag, ParserState in) {
+        DataType result;
         if(tag >= Constant.FIRST_USER_INDEX) {
                 TypeDef td = typeDefs.get(tag);
-                result = new ParsedUserType(td.getName());
+                result = new SigUserType(td.getName());
+                in.addTypeUse(tag);
                 in.pushType(tag);
 // sampleRefs are sent as primitive types, see above
 //        } else if(tag == Constant.SAMPLE) {
 //                result = new SampleRefType();
         } else {
-                result = new PrimitiveType(tag);
+                result = new SigPrimitiveType(tag);
         }
         return result;
     }
 
     private ParsedSampleDef parseSampleTypeDef(ParserState in) throws IOException {
-        ParsedTypeDef td = parseTypeDef(in);
+        ParsedTypeDef td = parseTypeDef(in, true);
         return new ParsedSampleDef(td);
     }
     private ParsedTypeDef parseTypeDef(ParserState in) throws IOException {
+        return parseTypeDef(in, false);
+    }
+
+    private void addParsedTypeDef(ParsedTypeDef td) {
+        int idx = td.getIndex();
+        if(idx>=0x40) {
+            pts.put(idx, td);
+        }
+    }
+
+    private ParsedTypeDef parseTypeDef(ParserState in, boolean parseIntentions) throws IOException {
         ParsedTypeDef result = in.newTypeDef();
-        result.setType(parseType(in));
+        result.setType(parseType(in, false));
+        addParsedTypeDef(result);
         return result;
     }
-    private ParsedType parseType(ParserState in) throws IOException {
+
+    private DataType parseType(ParserState in, boolean parseIntentions) throws IOException {
+        if(parseIntentions) {
+            String intentions = in.decodeIntentions();
+            if(intentions.length()>0) {
+                System.out.println("parseType intentions ("+intentions);
+            } else {
+                System.out.println("no intentions");
+            }
+        } else {
+//            System.out.println("not parsing intentions");
+        }
+
         int tag = in.decodePacked32();
-        ParsedType result = null;
+        DataType result = null;
         switch(tag) {
             case 0:
                 System.out.println("SELF");

lib/java/se/lth/control/labcomm2014/TypeSymbol.java

+package se.lth.control.labcomm2014;
+
+public class TypeSymbol implements SignatureSymbol {
+    public String toString() {
+        return "typedef ";
+    }
+    public void accept(SignatureSymbolVisitor v){
+        v.visit(this);
+    }
+}
+

lib/java/se/lth/control/labcomm2014/VoidType.java

+package se.lth.control.labcomm2014;
+import java.io.PrintStream;
+
+public class VoidType extends SigStructType{
+    public VoidType() {
+        super("void");
+    }
+
+    public void print(PrintStream out, String indent) {
+        out.print("void");
+    }
+}

lib/python/labcomm2014/LabComm.py

@@ -375,6 +375,9 @@ class SAMPLE(primitive):
         return encoder.encode_type(i_SAMPLE)
 
     def encode(self, encoder, value):
+        if not isinstance(value, type_decl):
+            # Probably trying to encode a sample class, grab signature
+            value = value.signature
         return encoder.encode_int(encoder.ref_to_index.get(value, 0))
 
     def decode(self, decoder, obj=None):
@@ -386,19 +389,29 @@ class SAMPLE(primitive):
     def __repr__(self):
         return "labcomm.SAMPLE()"
 
+# helper function
+
+def dict_to_sorted_tuple(d):
+    tmpL = zip(d.keys(), d.values())
+    tmpL.sort()
+    return tuple(tmpL)
+
 #
 # Aggregate types
 #
 class sampledef_or_sampleref_or_typedef(type_decl):
-    def __init__(self, name=None, decl=None):
-        self.name = name
+    def __init__(self, intentions={}, decl=None):
+        self.intentionDict = dict(intentions)
+        self.name = self.intentionDict.get('', None)
+        self.intentions = tuple(sorted(self.intentionDict.iteritems()))
         self.decl = decl
 
     def encode_decl(self, encoder):
         encoder.encode_type(self.type_index)
         with length_encoder(encoder) as e1:
             e1.encode_type(self.get_index(encoder))
-            e1.encode_string(self.name)
+            # XXX: temporary hack for intentions
+            e1.encode_intentions(self.intentions)
             with length_encoder(e1) as e2:
                 self.decl.encode_decl(e2)
 
@@ -407,12 +420,14 @@ class sampledef_or_sampleref_or_typedef(type_decl):
 
     def decode_decl(self, decoder):
         index = decoder.decode_type_number()
-        name = decoder.decode_string()
+         # XXX: temporary hack for intentions
+         #      assume the name is the only intention
+        ints = decoder.decode_intentions()
         if usePacketLength(decoder.version):
             length = decoder.decode_packed32()
         decl = decoder.decode_decl()
         result = self.__class__.__new__(self.__class__)
-        result.__init__(name=name, decl=decl)
+        result.__init__(intentions=ints, decl=decl)
         self.add_index(decoder, index, result)
         return result
 
@@ -448,15 +463,22 @@ class sample_def(sampledef_or_sampleref_or_typedef):
     def add_index(self, decoder, index, decl):
         decoder.add_decl(decl, index)
 
+    def rename(self, name):
+        newIntentions = dict(self.intentionDict)
+        newIntentions['']=name
+        return sample_def(newIntentions, decl=self.decl)
+
 class sample_ref(sampledef_or_sampleref_or_typedef):
     type_index = i_SAMPLE_REF
     type_name = 'sample_ref'
 
-    def __init__(self, name=None, decl=None, sample=None):
-        self.name = name
+    def __init__(self, intentions={}, decl=None, sample=None):
+        self.intentionDict = dict(intentions)
+        self.name = self.intentionDict.get('', None) # XXX should we allow  nameless?
         self.decl = decl
-        if sample == None and name != None and decl != None:
-            self.sample = sample_def(name, decl)
+        self.intentions=tuple(sorted(self.intentionDict.iteritems()))
+        if sample == None and self.name != None and decl != None:
+            self.sample = sample_def(intentions, decl)
         else:
             self.sample = sample
 
@@ -620,44 +642,59 @@ class struct(type_decl):
     def encode_decl(self, encoder):
         encoder.encode_type(i_STRUCT)
         encoder.encode_packed32(len(self.field))
-        for (name, decl) in self.field:
-            encoder.encode_string(name)
+        for (intentions, decl) in self.field:
+                encoder.encode_intentions(intentions)
                 encoder.encode_type_number(decl)
 
     def encode(self, encoder, obj):
-        if isinstance(obj, dict):
-            for (name, decl) in self.field:
-                decl.encode(encoder, obj[name])
-        else:
-            for (name, decl) in self.field:
+        try:
+            # hack to get names as keys in the obj:
+            tmp_foo = zip (map(lambda x:dict(x)[''],obj.keys()), obj.values())
+            tmp_obj = dict(tmp_foo)
+            for (intentions, decl) in self.field:
+                tmp = dict(intentions)
+                name = tmp['']
+                decl.encode(encoder, tmp_obj[name])
+        except AttributeError:
+            print "HERE BE DRAGONS! hack to get duck-typing example to work"
+            for (intentions, decl) in self.field:
+                tmp = dict(intentions)
+                name = tmp['']
+                print "trying to encode [%s] " % (name)
                 decl.encode(encoder, getattr(obj, name))
 
     def decode_decl(self, decoder):
         n_field = decoder.decode_packed32()
         field = []
         for i in range(n_field):
-            name = decoder.decode_string()
+            ints = decoder.decode_intentions()
             decl = decoder.decode_decl()
-            field.append((name, decl))
+            field.append((ints, decl))
         return struct(field)
 
     def decode(self, decoder, obj=None):
         if obj == None:
             obj = decoder.create_object()
-        for (name, decl) in self.field:
-            obj.__setattr__(name, decl.decode(decoder))
+        for (intentions, decl) in self.field:
+            #name = dict(intentions)['']
+            obj.__setattr__(intentions, decl.decode(decoder))
         return obj
 
     def new_instance(self):
         result = anonymous_object()
-        for (name, decl) in self.field:
+        for (intentions, decl) in self.field:
+            name = dict(intentions)['']
             result.__setattr__(name, decl.new_instance())
         return result
 
     def __repr__(self):
         delim = ""
         result = "labcomm.struct(["
-        for (name, decl) in self.field:
+        for (intentions, decl) in self.field:
+            try:
+                name = dict(intentions)['']
+            except:
+                name = '(no name)'
             result += "%s\n  ('%s', %s)" % (delim, name, decl)
             delim = ","
         result += "\n])"
@@ -671,7 +708,8 @@ STRUCT = struct([])
 
 class anonymous_object(dict):
     def __setattr__(self, name, value):
-        if name.startswith("_"):
+# XXX HERE BE DRAGONS! Is this OK:
+        if (str(name)).startswith("_"):
             super(anonymous_object, self).__setattr__(name, value)
         else:
             self[name] = value
@@ -729,6 +767,9 @@ class Codec(object):
         return True
 
     def add_ref(self, ref, index=0):
+        if not isinstance(ref, type_decl):
+            # Probably trying to register a sample class, grab signature
+            ref = ref.signature
         if index == 0:
             if ref.sample in self.ref_to_index:
                 return False
@@ -783,15 +824,16 @@ class Encoder(Codec):
                 decl.encode_decl(self)
             self.writer.mark_end(decl, None)
 
-    def add_ref(self, decl, index=0):
-        if not isinstance(decl, type_decl):
-            decl = decl.signature
-        ref = sample_ref(name=decl.name, decl=decl.decl, sample=decl)
+    def add_ref(self, ref, index=0):
+        if not isinstance(ref, type_decl):
+            # Trying to register a sample class
+            ref = ref.signature
+        decl = sample_ref(intentions=ref.intentions, decl=ref.decl, sample=ref)
         if index == 0:
-            self.writer.mark_begin(decl, None)
-            if super(Encoder, self).add_ref(ref, index):
-                ref.encode_decl(self)
-            self.writer.mark_end(decl, None)
+            self.writer.mark_begin(ref, None)
+            if super(Encoder, self).add_ref(decl, index):
+                decl.encode_decl(self)
+            self.writer.mark_end(ref, None)
 
     def encode(self, object, decl=None):
         if decl == None:
@@ -859,11 +901,24 @@ class Encoder(Codec):
 	self.encode_packed32(len(s));
 	self.pack("%ds" % len(s),s)
 
+    def encode_intentions(self, intentions):
+        self.encode_packed32(len(intentions))
+        try:
+            for (k,v) in intentions:
+                self.encode_string(k)
+                self.encode_string(v)
+        except:
+             print "WARNING! encode_intentions: don't know what to do with %s" % intentions
+
 class Decoder(Codec):
     def __init__(self, reader, version=DEFAULT_VERSION):
         super(Decoder, self).__init__()
         self.reader = reader
         self.version = version
+        self.handlers = {}
+
+    def register_handler(self, decl, handler):
+        self.handlers[decl] = handler
 
     def unpack(self, format):
         size = packer.calcsize(format)
@@ -893,6 +948,24 @@ class Decoder(Codec):
         else:
             raise Exception("Invalid type index %d" % index)
 
+    def runOne(self):
+        data,decl = self.decode()
+         # decode any signatures until next sample
+        while data == None:
+             data,decl = self.decode()
+        if decl:
+            if data != None:
+                if decl in self.handlers:
+                    handler = self.handlers[decl]
+                    handler(data)
+                else:
+                    print ("No handler for %s" % decl.name )
+                    for key, value in self.handlers.iteritems():
+                        if key == decl:
+                            print "but value %s == decl %s" % (key,decl)
+                            print "hashes %d : %d" % (hash(key),hash(decl))
+                            raise Exception()
+
     def decode(self):
         while True:
             index = self.decode_type_number()
@@ -990,6 +1063,16 @@ class Decoder(Codec):
         index = self.decode_int()
         return self.index_to_ref.get(index, None)
 
+    def decode_intentions(self):
+        numIntentions = self.decode_packed32()
+        res = {}
+        for i in range(numIntentions):
+            key = self.decode_string()
+            val = self.decode_string()
+            res[key] = val
+        result = dict_to_sorted_tuple(res)
+        return result
+
 class signature_reader:
     def __init__(self, signature):
         self.signature = packer.pack("!%db" % len(signature), *signature)

packaging/.gitignore

-labcomm-*.src.rpm
+labcomm2014-*.src.rpm
 rpmbuild

packaging/make_srpm

@@ -68,7 +68,7 @@ install -m u=r,g=r,o=r lib/csharp/labcomm2014.dll ${RPM_BUILD_ROOT}/usr/lib
 # Python
 #
 install -d ${RPM_BUILD_ROOT}/%{python_sitelib}/labcomm2014
-install lib/python/labcomm/* ${RPM_BUILD_ROOT}/%{python_sitelib}/labcomm2014
+install lib/python/labcomm2014/* ${RPM_BUILD_ROOT}/%{python_sitelib}/labcomm2014
 
 %files
 %defattr (-, root, root)
@@ -112,5 +112,5 @@ COMMIT=$(git rev-parse HEAD)
     git archive --format tar HEAD
 ) > rpmbuild/SOURCES/labcomm.${DESCRIBE}.tar.gz
 rpmbuild --define "_topdir $(pwd)/rpmbuild" \
-         -bs rpmbuild/SPECS/labcomm.spec
+         -bs rpmbuild/SPECS/labcomm.spec 2>&1 | sed -e 's|rpmbuild/SRPMS/||g'
 mv rpmbuild/SRPMS/* .

test/Makefile

 TESTS=basic simple nested ref
 LABCOMM_JAR=../compiler/labcomm2014_compiler.jar
 LABCOMM=java -jar $(LABCOMM_JAR)
+MONO_PATH=$(shell pwd)/../lib/csharp
+PYTHONPATH=$(shell pwd)/../lib/python
 
 include ../lib/c/os_compat.mk
 
 all:
 
-test: $(TESTS:%=test_%) compiler_errors
+test: $(TESTS:%=test_%) $(TESTS:%=test_renaming_%) compiler_errors
 #	PYTHONPATH=../lib/python \
 #		./test_encoder_decoder.py --labcomm="$(LABCOMM)" basic.lc
 
@@ -20,13 +22,33 @@ test_%: gen/%/signatures.py \
 	gen/%/cs_relay.exe \
 	gen/%/java_relay.class \
 	gen/%/java_code
-	PYTHONPATH=../lib/python ./test_encoder_decoder.py \
+	PYTHONPATH=$(PYTHONPATH) MONO_PATH=$(MONO_PATH) \
+		./test_encoder_decoder.py \
 		--signatures=gen/$*/signatures.py \
 		--test tee gen/$*/testdata \
-		--test gen/$*/c_relay /dev/stdin /dev/stdout \
+		--test $(shell echo $(VALGRIND) | sed -e 's/[-][-]/\\\\--/g') \
+		       gen/$*/c_relay /dev/stdin /dev/stdout \
 		--test mono gen/$*/cs_relay.exe /dev/stdin /dev/stdout \
-		--test java \\-cp gen/$*:../lib/java/labcomm.jar java_relay \
+		--test java \\-cp gen/$*:../lib/java/labcomm2014.jar \
+		       java_relay /dev/stdin /dev/stdout
+
+.PHONY: test_renaming_%
+test_renaming_%: gen/%/signatures.py \
+		gen/%/c_renaming_relay \
+		gen/%/cs_renaming_relay.exe \
+		gen/%/java_relay.class \
+		gen/%/java_code
+	PYTHONPATH=$(PYTHONPATH) MONO_PATH=$(MONO_PATH) \
+	    ./test_renaming_encoder_decoder.py \
+		--signatures=gen/$*/signatures.py \
+		--test tee gen/$*/testdata.renamed \
+		--test $(shell echo $(VALGRIND) | sed -e 's/[-][-]/\\\\--/g') \
+		       gen/$*/c_renaming_relay /dev/stdin /dev/stdout \
+		--test mono gen/$*/cs_renaming_relay.exe \
 		       /dev/stdin /dev/stdout
+	echo \
+		--test java \\-cp gen/$*:../lib/java/labcomm2014.jar \
+		       java_relay /dev/stdin /dev/stdout
 
 # test cases for compiler error checking
 .PHONY: compiler_errors testErrorsOK testErrorsNOK
@@ -68,6 +90,15 @@ gen/%/c_relay: gen/%/c_relay.c gen/%/c_code.c Makefile
 	$(CC) $(CFLAGS) -o $@ $< -I../lib/c/2014 -I. -L../lib/c \
 		gen/$*/c_code.c -llabcomm2014
 
+.PRECIOUS: gen/%/c_renaming_relay.c
+gen/%/c_renaming_relay.c: gen/%/typeinfo relay_gen_c.py Makefile
+	./relay_gen_c.py --renaming $< > $@
+
+.PRECIOUS: gen/%/c_renaming_relay
+gen/%/c_renaming_relay: gen/%/c_renaming_relay.c gen/%/c_code.c Makefile
+	$(CC) $(CFLAGS) -o $@ $< -I../lib/c/2014 -I. -L../lib/c \
+		gen/$*/c_code.c -llabcomm2014
+
 # C# relay test rules
 .PRECIOUS: gen/%/cs_code.cs
 gen/%/cs_code.cs: %.lc Makefile | gen/%/.dir
@@ -77,13 +108,17 @@ gen/%/cs_code.cs: %.lc Makefile | gen/%/.dir
 gen/%/cs_relay.cs:  gen/%/typeinfo relay_gen_cs.py Makefile
 	./relay_gen_cs.py $< > $@
 
-.PRECIOUS: gen/%/labcomm.dll
-gen/%/labcomm2014.dll:
-	ln -s ../../../lib/csharp/labcomm2014.dll $@
-
 .PRECIOUS: gen/%/cs_relay.exe
-gen/%/cs_relay.exe: gen/%/cs_relay.cs gen/%/cs_code.cs \
-		    gen/%/labcomm2014.dll Makefile
+gen/%/cs_relay.exe: gen/%/cs_relay.cs gen/%/cs_code.cs Makefile
+	mcs -out:$@ $(filter %.cs, $^) -lib:../lib/csharp/ -r:labcomm2014
+
+.PRECIOUS: gen/%/cs_renaming_relay.cs
+gen/%/cs_renaming_relay.cs:  gen/%/typeinfo relay_gen_cs.py Makefile
+	./relay_gen_cs.py --renaming $< > $@
+
+.PRECIOUS: gen/%/cs_renaming_relay.exe
+gen/%/cs_renaming_relay.exe: gen/%/cs_renaming_relay.cs \
+			     gen/%/cs_code.cs Makefile
 	mcs -out:$@ $(filter %.cs, $^) -lib:../lib/csharp/ -r:labcomm2014
 
 # Java relay test rules
@@ -98,4 +133,4 @@ gen/%/java_relay.java: gen/%/typeinfo relay_gen_java.py Makefile
 
 .PRECIOUS: gen/%/java_relay.class
 gen/%/java_relay.class: gen/%/java_relay.java gen/%/java_code Makefile
-	javac -d gen/$*  -cp ../lib/java/labcomm.jar:gen/$*/java_code $<
+	javac -d gen/$*  -cp ../lib/java/labcomm2014.jar:gen/$*/java_code $<

test/relay_gen_c.py

 #!/usr/bin/python
 
+import argparse
 import re
 import sys
 
@@ -13,7 +14,13 @@ def split_match(pattern, multiline):
    
 
 if __name__ == '__main__':
-    f = open(sys.argv[1])
+    parser = argparse.ArgumentParser(description='Generate C test relay.')
+    parser.add_argument('--renaming', action='store_true')
+    parser.add_argument('typeinfo', help='typeinfo file')
+
+    options = parser.parse_args(sys.argv[1:])
+
+    f = open(options.typeinfo)
     sample = []
     for l in map(lambda s: s.strip(), f):
         lang,kind,func,arg,stype = l[1:].split(l[0])
@@ -27,12 +34,22 @@ if __name__ == '__main__':
       |#include <sys/types.h>
       |#include <sys/stat.h>
       |#include <fcntl.h>
+      |#include <stdio.h>
+      |#include <errno.h>
       |#include <labcomm2014.h>
       |#include <labcomm2014_default_error_handler.h>
       |#include <labcomm2014_default_memory.h>
       |#include <labcomm2014_default_scheduler.h>
       |#include <labcomm2014_fd_reader.h>
       |#include <labcomm2014_fd_writer.h>
+    """))
+    if options.renaming:
+        result.extend(split_match('^[^|]*\|(.*)$', """
+        |#include "labcomm2014_renaming.h"
+        |#include "labcomm2014_renaming_encoder.h"
+        |#include "labcomm2014_renaming_decoder.h"
+        """))
+    result.extend(split_match('^[^|]*\|(.*)$', """
       |#include "c_code.h"
     """))
     for func,arg,stype in sample:
@@ -45,26 +62,64 @@ if __name__ == '__main__':
         pass
     result.extend(split_match('^[^|]*\|(.*)$', """
       |int main(int argc, char *argv[]) {
-      |  struct labcomm2014_encoder *e;
-      |  struct labcomm2014_decoder *d;
-      |  int in, out;
+      |  struct labcomm2014_encoder *e, *e_e;
+      |  struct labcomm2014_decoder *d, *d_d;
+    """))
+    if options.renaming:
+        result.extend(split_match('^[^|]*\|(.*)$', """
+        |  struct labcomm2014_renaming_registry *registry;
+        |  struct labcomm2014_encoder *e_p, *e_s;
+        |  struct labcomm2014_decoder *d_p, *d_s;
+        """))
+    result.extend(split_match('^[^|]*\|(.*)$', """
+      |  int in, out, result;
       |  
       |  if (argc < 3) { return 1; }
       |  in = open(argv[1], O_RDONLY);
       |  if (in < 0) { return 1; }
       |  out = open(argv[2], O_WRONLY);
       |  if (out < 0) { return 1; }
-      |  e = labcomm2014_encoder_new(labcomm2014_fd_writer_new(
+      |  e_e = labcomm2014_encoder_new(labcomm2014_fd_writer_new(
       |                                labcomm2014_default_memory, out, 1),
       |                                labcomm2014_default_error_handler,
       |                                labcomm2014_default_memory,
       |                                labcomm2014_default_scheduler);
-      |  d = labcomm2014_decoder_new(labcomm2014_fd_reader_new(
+      |  d_d = labcomm2014_decoder_new(labcomm2014_fd_reader_new(
       |                                labcomm2014_default_memory, in, 1),
       |                                labcomm2014_default_error_handler,
       |                                labcomm2014_default_memory,
       |                                labcomm2014_default_scheduler);
     """))
+    if not options.renaming:
+        result.extend(split_match('^[^|]*\|(.*)$', """
+        |  e = e_e;
+        |  d = d_d;
+        """))
+    else:
+        result.extend(split_match('^[^|]*\|(.*)$', """
+        |  registry = labcomm2014_renaming_registry_new(
+        |    labcomm2014_default_error_handler,
+        |    labcomm2014_default_memory,
+        |    labcomm2014_default_scheduler);
+        |  e_p = labcomm2014_renaming_encoder_new(e_e,
+        |                                         registry,
+        |                                         labcomm2014_renaming_prefix,
+        |                                         "prefix:");
+        |  e_s = labcomm2014_renaming_encoder_new(e_p,
+        |                                         registry,
+        |                                         labcomm2014_renaming_suffix,
+        |                                         ":suffix");
+        |  e = e_s;
+        |  d_p = labcomm2014_renaming_decoder_new(d_d,
+        |                                         registry,
+        |                                         labcomm2014_renaming_prefix,
+        |                                         "prefix:");
+        |  d_s = labcomm2014_renaming_decoder_new(d_p,
+        |                                         registry,
+        |                                         labcomm2014_renaming_suffix,
+        |                                         ":suffix");
+        |  d = d_s;
+        """))
     for func,arg,stype in sample:
         result.extend(split_match('^[^|]*\|(.*)$', """
           |  labcomm2014_encoder_register_%(func)s(e);
@@ -73,8 +128,23 @@ if __name__ == '__main__':
           |  labcomm2014_decoder_sample_ref_register(d, labcomm2014_signature_%(func)s);
        """ % { 'func': func, 'arg': arg }))
     result.extend(split_match('^[^|]*\|(.*)$', """
-      |  labcomm2014_decoder_run(d);
-      |  return 0;
+      |  while ((result = labcomm2014_decoder_decode_one(d)) > 0) {};
+    """))
+    if options.renaming:
+        result.extend(split_match('^[^|]*\|(.*)$', """
+        |  labcomm2014_decoder_free(d_s);
+        |  labcomm2014_decoder_free(d_p);
+        |  labcomm2014_encoder_free(e_s);
+        |  labcomm2014_encoder_free(e_p);
+        |  labcomm2014_renaming_registry_free(registry);
+        """))
+    result.extend(split_match('^[^|]*\|(.*)$', """
+      |  labcomm2014_decoder_free(d_d);
+      |  labcomm2014_encoder_free(e_e);
+      |  if (result == 0) return 0;
+      |  if (result == -EPIPE) return 0;
+      |  fprintf(stderr, "Failed with %d", result);
+      |  return 1;
       |}
     """))
     print "\n".join(result)

test/relay_gen_cs.py

 #!/usr/bin/python
 
+import argparse
 import re
 import sys
 import random
@@ -18,7 +19,13 @@ def shuffle(l):
     return result
 
 if __name__ == '__main__':
-    f = open(sys.argv[1])
+    parser = argparse.ArgumentParser(description='Generate C test relay.')
+    parser.add_argument('--renaming', action='store_true')
+    parser.add_argument('typeinfo', help='typeinfo file')
+
+    options = parser.parse_args(sys.argv[1:])
+
+    f = open(options.typeinfo)
     sample = []
     for l in map(lambda s: s.strip(), f):
         lang,kind,func,arg,dummy = l[1:].split(l[0])
@@ -40,7 +47,9 @@ if __name__ == '__main__':
     result.append('  %s.Handler' % sample[-1][0])
     result.extend(split_match('^[^|]*\|(.*)$', """
       |{
-      |  EncoderChannel encoder;
+      |  Encoder encoder;
+      |  Decoder decoder;
+      |
     """))
     for func,arg in sample:
         if arg == 'void':
@@ -63,13 +72,22 @@ if __name__ == '__main__':
       |    FileStream InFile = new FileStream(InName,
       |                                       FileMode.Open,
       |                                       FileAccess.Read);
-      |    DecoderChannel decoder = new DecoderChannel(InFile);
+      |    decoder = new DecoderChannel(InFile);
       |    FileStream OutFile = new FileStream(OutName,
       |                                        FileMode.OpenOrCreate,
       |                                        FileAccess.Write);
       |    encoder = new EncoderChannel(OutFile);
-      |
     """))
+    if options.renaming:
+        result.extend(split_match('^[^|]*\|(.*)$', """
+        |    RenamingRegistry registry = new RenamingRegistry();
+        |    decoder = new RenamingDecoder(
+        |        decoder, registry, s => "prefix:" + s + ":suffix");
+        |    encoder = new RenamingEncoder(
+        |        encoder, registry, s => "prefix:" + s + ":suffix");
+        """))
+
+
     for func,arg in shuffle(sample):
         result.append('    %s.register(decoder, this);' % func)
         pass

test/test_encoder_decoder.py

@@ -179,7 +179,7 @@ class Test:
                 if p.poll() != None:
                     print>>sys.stderr, "Failed with:", p.poll()
                     self.failed = True
-                elif value != self.received_value:
+                elif value != self.received_value or decl != self.received_decl:
                     print>>sys.stderr, "Coding error"
                     print>>sys.stderr, value == self.received_value
                     print>>sys.stderr, "Got:     ", self.received_value 

test/test_renaming_encoder_decoder.py

+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+import argparse
+import imp
+import labcomm2014
+import math
+import os
+import re
+import struct
+import subprocess
+import sys
+import threading
+
+
+def labcomm_compile(lc, name, args):
+    for lang in [ 'c', 'csharp', 'java', 'python']:
+        destdir = 'gen/%s/%s' % (name, lang)
+        if not os.path.exists(destdir):
+            os.makedirs(destdir)
+            pass
+        pass
+    cmd = args.labcomm.split() + [ 
+        "--c=gen/%s/c/%s.c" % (name, name),
+        "--h=gen/%s/c/%s.h" % (name, name),
+        "--cs=gen/%s/csharp/%s.cs" % (name, name),
+        "--python=gen/%s/python/%s.py" % (name, name),
+        "--java=gen/%s/java/" % name,
+        "--typeinfo=gen/%s/%s.typeinfo" % (name, name),
+        lc]
+    subprocess.check_call(cmd)
+    pass
+
+def get_signatures(path):
+    fp, pathname, description = imp.find_module(os.path.basename(path)[0:-3], 
+                                                [ os.path.dirname(path) ])
+    with fp as fp:
+        m = imp.load_module('signatures', fp, pathname, description)
+        pass
+    return map(lambda s: s.signature, m.sample)
+
+class Test:
+    
+    def __init__(self, program, signatures):
+        self.program = program
+        self.signatures = map(lambda s: s.rename('prefix:%s:suffix' % s.name),
+                              signatures)
+        pass
+
+    def generate(self, decl):
+        if decl.__class__ == labcomm2014.sample:
+            result = []
+            for values in self.generate(decl.decl):
+                result.append((decl, values))
+            return result
+    
+        elif decl.__class__ == labcomm2014.typedef:
+            result = []
+            for values in self.generate(decl.decl):
+                result.append(values)
+            return result
+
+        elif decl.__class__ == labcomm2014.struct:
+            result = []
+            if len(decl.field) == 0:
+                result.append({})
+            else:
+                values1 = self.generate(decl.field[0][1])
+                values2 = self.generate(labcomm2014.struct(decl.field[1:]))
+                for v1 in values1:
+                    for v2 in values2:
+                        v = dict(v2)
+                        v[decl.field[0][0]] = v1
+                        result.append(v)
+            return result
+        
+        elif decl.__class__ == labcomm2014.array:
+            if len(decl.indices) == 1:
+                values = self.generate(decl.decl)
+                if decl.indices[0] == 0:
+                    lengths = [0, 1, 2]
+                else:
+                    lengths = [ decl.indices[0] ]
+            else:
+                values = self.generate(labcomm2014.array(decl.indices[1:],
+                                                     decl.decl))
+                if decl.indices[0] == 0:
+                    lengths = [1, 2]
+                else:
+                    lengths = [ decl.indices[0] ]
+            result = []
+            for v in values:
+                for i in lengths:
+                    element = []
+                    for j in range(i):
+                        element.append(v)
+                    result.append(element)
+            return result
+    
+        elif decl.__class__ == labcomm2014.BOOLEAN:
+            return [False, True]
+    
+        elif decl.__class__ == labcomm2014.BYTE:
+            return [0, 127, 128, 255]
+    
+        elif decl.__class__ == labcomm2014.SHORT:
+            return [-32768, 0, 32767]
+    
+        elif decl.__class__ == labcomm2014.INTEGER:
+            return [-2147483648, 0, 2147483647]
+    
+        elif decl.__class__ == labcomm2014.LONG:
+            return [-9223372036854775808, 0, 9223372036854775807]
+    
+        elif decl.__class__ == labcomm2014.FLOAT:
+            def tofloat(v):
+                return struct.unpack('f', struct.pack('f', v))[0]
+            return [tofloat(-math.pi), 0.0, tofloat(math.pi)]
+    
+        elif decl.__class__ == labcomm2014.DOUBLE:
+            return [-math.pi, 0.0, math.pi]
+    
+        elif decl.__class__ == labcomm2014.STRING:
+            return ['string', u'sträng' ]
+    
+        elif decl.__class__ == labcomm2014.SAMPLE:
+            return self.signatures
+    
+        print>>sys.stderr, decl
+        raise Exception("unhandled decl %s" % decl.__class__)
+
+    def uses_refs(self, decls):
+        for decl in decls:
+            if decl.__class__ == labcomm2014.sample:
+                if self.uses_refs([ decl.decl ]):
+                    return True
+    
+            elif decl.__class__ == labcomm2014.struct:
+                if self.uses_refs([ d for n,d in decl.field ]):
+                    return True
+        
+            elif decl.__class__ == labcomm2014.array:
+                if self.uses_refs([ decl.decl ]):
+                    return True
+
+            elif decl.__class__ == labcomm2014.SAMPLE:
+                return True
+
+        return False
+        
+
+    def run(self):
+        print>>sys.stderr, 'Testing', self.program
+        p = subprocess.Popen(self.program, 
+                             stdin=subprocess.PIPE,
+                             stdout=subprocess.PIPE,
+                             stderr=sys.stderr)
+        self.expected = None
+        self.failed = False
+        self.next = threading.Condition()
+        decoder = threading.Thread(target=self.decode, args=(p.stdout,))
+        decoder.start()
+        encoder = labcomm2014.Encoder(labcomm2014.StreamWriter(p.stdin))
+        for signature in self.signatures:
+            encoder.add_decl(signature)
+            pass
+        if self.uses_refs(self.signatures):
+            for signature in self.signatures:
+                encoder.add_ref(signature)
+        for signature in self.signatures:
+            print>>sys.stderr, "Checking", signature.name,
+            for decl,value in self.generate(signature):
+                sys.stderr.write('.')
+                self.next.acquire()
+                self.received_value = None
+                self.received_decl = None
+                encoder.encode(value, decl)
+                self.next.wait(2)
+                self.next.release()
+                if p.poll() != None:
+                    print>>sys.stderr, "Failed with:", p.poll()
+                    self.failed = True
+                elif value != self.received_value or decl != self.received_decl:
+                    print>>sys.stderr, "Coding error"
+                    print>>sys.stderr, value == self.received_value
+                    print>>sys.stderr, "Got:     ", self.received_value 
+                    print>>sys.stderr, "         ", self.received_decl 
+                    print>>sys.stderr, "Expected:", value
+                    print>>sys.stderr, "         ", decl
+                    self.failed = True
+                    
+                if self.failed: 
+                    if p.poll() == None:
+                        p.terminate()
+                    exit(1)
+                pass
+            print>>sys.stderr
+            pass
+        p.stdin.close()
+        if p.wait() != 0:
+            exit(1)
+            pass
+        pass
+
+    def decode(self, f):
+        decoder = labcomm2014.Decoder(labcomm2014.StreamReader(f))
+        try:
+            while True:
+                value,decl = decoder.decode()
+                if value != None:
+                    self.next.acquire()
+                    self.received_value = value
+                    self.received_decl = decl
+                    self.expected = None
+                    self.next.notify_all()
+                    self.next.release()
+                pass
+            pass
+        except EOFError:
+            pass
+        pass
+
+    pass
+    
+def run(test, signatures):
+    t = Test(test, signatures)
+    t.run()
+    pass
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Run encoding test.')
+    class test_action(argparse.Action):
+        def __call__(self, parser, namespace, values, option_string=None):
+            old = list(getattr(namespace, self.dest))
+            def strip_slash(s):
+                if s.startswith('\\'):
+                    return s[1:]
+                return s
+            old.append(map(strip_slash, values))
+            setattr(namespace, self.dest, old)
+    parser.add_argument('--signatures')
+    parser.add_argument('--test', nargs='*', action=test_action, default=[])
+
+    args = parser.parse_args()
+    signatures = get_signatures(args.signatures)
+    for test in args.test:
+        run(test, signatures)
+    exit(0)
+    
+    for lc in args.lc:
+        run(lc, args)
+        pass
+    pass