lib/python/labcomm/StreamWriter.py → lib/python/labcomm2014/StreamWriter.py

-import labcomm
-
 class StreamWriter:
     
     def __init__(self, stream):
@@ -10,7 +8,10 @@ class StreamWriter:
         self.stream.write(data)
         pass
 
-    def mark(self):
+    def mark_begin(self, decl, value):
+        pass
+
+    def mark_end(self, decl, value):
         self.stream.flush()
         pass
 

lib/python/labcomm2014/__init__.py

+__all__ = [ 'LabComm' ]
+
+import LabComm
+
+from StreamReader import StreamReader
+from StreamWriter import StreamWriter
+
+Decoder = LabComm.Decoder
+Encoder = LabComm.Encoder
+
+sample = LabComm.sample_def
+sample_def = LabComm.sample_def
+sample_ref = LabComm.sample_ref
+typedef = LabComm.typedef
+
+array = LabComm.array
+struct = LabComm.struct
+primitive = LabComm.primitive
+
+BOOLEAN = LabComm.BOOLEAN
+BYTE = LabComm.BYTE
+SHORT = LabComm.SHORT
+INTEGER = LabComm.INTEGER
+LONG = LabComm.LONG
+FLOAT = LabComm.FLOAT
+DOUBLE = LabComm.DOUBLE
+STRING = LabComm.STRING
+SAMPLE = LabComm.SAMPLE
+
+decl_from_signature = LabComm.decl_from_signature
+

packaging/.gitignore

+labcomm2014-*.src.rpm
+rpmbuild

packaging/Makefile

+.PHONY: all
+all:
+
+.PHONY: test
+test:
+
+.PHONY: clean
+clean:
+	rm -rf rpmbuild
+	rm -f *~
+
+.PHONY: distclean
+distclean: clean
+	rm -f labcomm-*.src.rpm
+
+.PHONY: srpm
+srpm:
+	./make_srpm

packaging/make_srpm

+#!/bin/sh
+
+spec() {
+cat << 'EOF'
+Name:      labcomm__SUFFIX__
+Version:   __VERSION__
+Release:   1
+Summary:   LabComm communication protocol
+License:   GPLv3
+
+# https://gitlab.control.lth.se/anders_blomdell/labcomm/repository/archive.tar.gz?__COMMIT__
+Source0:  labcomm.__DESCRIBE__.tar.gz
+
+BuildRequires: gcc
+BuildRequires: ant
+BuildRequires: java
+BuildRequires: mono-core
+
+%description
+LabComm communication protocol
+
+%package devel
+Summary: LabComm communication protocol
+Requires: %{name} = %{version}-%{release}
+
+%description devel
+LabComm communication protocol
+
+%
+%prep
+%setup -q -c -a 0
+
+%build
+pwd
+make
+
+%install
+
+# 
+# C 
+#
+install -d ${RPM_BUILD_ROOT}/%{_libdir}
+install lib/c/liblabcomm2014.a ${RPM_BUILD_ROOT}/%{_libdir}/
+install lib/c/liblabcomm2014.so.1 ${RPM_BUILD_ROOT}/%{_libdir}/liblabcomm2014.so.__VERSION__
+ln -s liblabcomm2014.so.__VERSION__ ${RPM_BUILD_ROOT}/%{_libdir}/liblabcomm2014.so
+install -d ${RPM_BUILD_ROOT}/%{_includedir}/labcomm
+install lib/c/2014/*h ${RPM_BUILD_ROOT}/%{_includedir}/labcomm
+
+#
+# java 
+#
+install -d ${RPM_BUILD_ROOT}/usr/lib
+install -m u=r,g=r,o=r compiler/labcomm2014_compiler.jar ${RPM_BUILD_ROOT}/usr/lib
+install -m u=r,g=r,o=r lib/java/labcomm2014.jar ${RPM_BUILD_ROOT}/usr/lib
+
+install -d ${RPM_BUILD_ROOT}/%{_bindir}
+install -m u=rx,g=rx,o=rx \
+        compiler/labcomm2014 ${RPM_BUILD_ROOT}/%{_bindir}/labcomm2014
+ls -l ${RPM_BUILD_ROOT}/%{_bindir}
+
+#
+# C#
+#
+install -d ${RPM_BUILD_ROOT}/usr/lib
+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/labcomm2014/* ${RPM_BUILD_ROOT}/%{python_sitelib}/labcomm2014
+
+%files
+%defattr (-, root, root)
+%exclude /usr/lib/debug
+%exclude /usr/lib/labcomm2014_compiler.jar
+/usr/lib/*
+%{_libdir}/*
+
+%files devel
+%defattr (-, root, root)
+/usr/lib/labcomm2014_compiler.jar
+%{_includedir}/labcomm/*
+%{_bindir}/*
+
+EOF
+}
+
+# Create a suitable directory for rpmbuild
+rm -rf rpmbuild
+mkdir -p rpmbuild/BUILD
+mkdir -p rpmbuild/SPECS
+mkdir -p rpmbuild/RPMS
+mkdir -p rpmbuild/SRPMS
+mkdir -p rpmbuild/SOURCES
+rm -rf rpmbuild/SOURCES/*
+
+# Create spec and .tar.gz
+DESCRIBE=$(git describe | sed -e 's/^v\(.*\)/\1/')
+SUFFIX=$(echo ${DESCRIBE} | sed -e 's/^\([^.]*\)[.].*$/\1/g')
+VERSION=$(echo ${DESCRIBE} | sed -e 's/^[^.]*[.]\(.*\)/\1/g;s/-/./g')
+COMMIT=$(git rev-parse HEAD)
+(
+    spec | \
+        sed -e "s/__SUFFIX__/${SUFFIX}/g" | \
+        sed -e "s/__VERSION__/${VERSION}/g" | \
+        sed -e "s/__DESCRIBE__/${DESCRIBE}/g" | \
+        sed -e "s/__COMMIT__/${COMMIT}/g" \
+) > rpmbuild/SPECS/labcomm.spec
+(
+    cd $(git rev-parse --show-toplevel)
+    git archive --format tar HEAD
+) > rpmbuild/SOURCES/labcomm.${DESCRIBE}.tar.gz
+rpmbuild --define "_topdir $(pwd)/rpmbuild" \
+         -bs rpmbuild/SPECS/labcomm.spec 2>&1 | sed -e 's|rpmbuild/SRPMS/||g'
+mv rpmbuild/SRPMS/* .

test/.gitignore

+gen

test/Makefile

-TESTS=basic simple nested
-LABCOMM_JAR=../compiler/labComm.jar
+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
 
-CFLAGS=-O3 -g -Wall -Werror -Wno-unused-function
+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
@@ -65,8 +87,17 @@ gen/%/c_relay.c: gen/%/typeinfo relay_gen_c.py Makefile
 
 .PRECIOUS: gen/%/c_relay
 gen/%/c_relay: gen/%/c_relay.c gen/%/c_code.c Makefile
-	$(CC) $(CFLAGS) -o $@ $< -I../lib/c -I. -L..//lib/c \
-		gen/$*/c_code.c -llabcomm
+	$(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
@@ -77,14 +108,18 @@ 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/%/labcomm.dll:
-	ln -s ../../../lib/csharp/labcomm.dll $@
-
 .PRECIOUS: gen/%/cs_relay.exe
-gen/%/cs_relay.exe: gen/%/cs_relay.cs gen/%/cs_code.cs \
-		    gen/%/labcomm.dll Makefile
-	mcs -out:$@ $(filter %.cs, $^) -lib:../lib/csharp/ -r:labcomm
+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
 .PRECIOUS: gen/%/java_code
@@ -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/ref.lc

+sample sample s1;
+sample sample s2;
+sample sample s3;
+sample sample sample_list[4];

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,58 +34,117 @@ if __name__ == '__main__':
       |#include <sys/types.h>
       |#include <sys/stat.h>
       |#include <fcntl.h>
-      |#include <labcomm.h>
-      |#include <labcomm_default_error_handler.h>
-      |#include <labcomm_default_memory.h>
-      |#include <labcomm_default_scheduler.h>
-      |#include <labcomm_fd_reader.h>
-      |#include <labcomm_fd_writer.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:
         result.extend(split_match('^[^|]*\|(.*)$', """
           |void handle_%(func)s(%(arg)s *v, void *context)
           |{
-          |  struct labcomm_encoder *e = context;
-          |  labcomm_encode_%(func)s(e%(valargstr)s);
+          |  struct labcomm2014_encoder *e = context;
+          |  labcomm2014_encode_%(func)s(e%(valargstr)s);
           |}""" % { 'func': func, 'arg': arg, 'valargstr': '' if stype == "void" else', v' }))
-#        result.extend(split_match('^[^|]*\|(.*)$', """
-#          |void handle_%(func)s(%(arg)s *v, void *context)
-#          |{
-#          |  struct labcomm_encoder *e = context;
-#          |  labcomm_encode_%(func)s(e, v);
-#          |}""" % { 'func': func, 'arg': arg }))
         pass
     result.extend(split_match('^[^|]*\|(.*)$', """
       |int main(int argc, char *argv[]) {
-      |  struct labcomm_encoder *e;
-      |  struct labcomm_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 = labcomm_encoder_new(labcomm_fd_writer_new(
-      |                              labcomm_default_memory, out, 1), 
-      |                           labcomm_default_error_handler,
-      |                           labcomm_default_memory,
-      |                           labcomm_default_scheduler);
-      |  d = labcomm_decoder_new(labcomm_fd_reader_new(
-      |                              labcomm_default_memory, in, 1), 
-      |                           labcomm_default_error_handler,
-      |                           labcomm_default_memory,
-      |                           labcomm_default_scheduler);
+      |  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_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('^[^|]*\|(.*)$', """
-          |  labcomm_encoder_register_%(func)s(e);
-          |  labcomm_decoder_register_%(func)s(d, handle_%(func)s, e);
+          |  labcomm2014_encoder_register_%(func)s(e);
+          |  labcomm2014_encoder_sample_ref_register(e, labcomm2014_signature_%(func)s);
+          |  labcomm2014_decoder_register_%(func)s(d, handle_%(func)s, e);
+          |  labcomm2014_decoder_sample_ref_register(d, labcomm2014_signature_%(func)s);
        """ % { 'func': func, 'arg': arg }))
     result.extend(split_match('^[^|]*\|(.*)$', """
-      |  labcomm_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
 
 def split_match(pattern, multiline):
     def match(s):
@@ -11,9 +13,19 @@ def split_match(pattern, multiline):
         pass
     return filter(lambda s: s != None, map(match, multiline.split('\n')))
    
+def shuffle(l):
+    result = list(l)
+    random.shuffle(result)
+    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])
@@ -25,7 +37,7 @@ if __name__ == '__main__':
     result.extend(split_match('^[^|]*\|(.*)$', """
       |using System;
       |using System.IO;
-      |using se.lth.control.labcomm;
+      |using se.lth.control.labcomm2014;
       |
       |public class cs_relay :
     """))
@@ -35,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':
@@ -58,22 +72,38 @@ if __name__ == '__main__':
       |    FileStream InFile = new FileStream(InName,
       |                                       FileMode.Open,
       |                                       FileAccess.Read);
-      |    DecoderChannel d = new DecoderChannel(InFile);
+      |    decoder = new DecoderChannel(InFile);
       |    FileStream OutFile = new FileStream(OutName,
       |                                        FileMode.OpenOrCreate,
       |                                        FileAccess.Write);
       |    encoder = new EncoderChannel(OutFile);
-      |
     """))
-    for func,arg in sample:
-        result.append('    %s.register(d, this);' % func)
+    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
-    for func,arg in sample:
+    for func,arg in shuffle(sample):
+        result.append('    %s.registerSampleRef(decoder);' % func)
+        pass
+    for func,arg in shuffle(sample):
         result.append('    %s.register(encoder);' % func)
         pass
+    for func,arg in shuffle(sample):
+        result.append('    %s.registerSampleRef(encoder);' % func)
+        pass
+    
     result.extend(split_match('^[^|]*\|(.*)$', """
       |    try {
-      |      d.run();
+      |      decoder.run();
       |    } catch (EndOfStreamException) {
       |    }
       |  }

test/relay_gen_java.py

@@ -2,6 +2,7 @@
 
 import re
 import sys
+import random
 
 def split_match(pattern, multiline):
     def match(s):
@@ -11,6 +12,10 @@ def split_match(pattern, multiline):
         pass
     return filter(lambda s: s != None, map(match, multiline.split('\n')))
    
+def shuffle(l):
+    result = list(l)
+    random.shuffle(result)
+    return result
 
 if __name__ == '__main__':
     f = open(sys.argv[1])
@@ -26,8 +31,9 @@ if __name__ == '__main__':
       |import java.io.FileInputStream;
       |import java.io.FileOutputStream;
       |import java.io.IOException;
-      |import se.lth.control.labcomm.DecoderChannel;
-      |import se.lth.control.labcomm.EncoderChannel;
+      |import se.lth.control.labcomm2014.DecoderChannel;
+      |import se.lth.control.labcomm2014.EncoderChannel;
+      |import se.lth.control.labcomm2014.Sample;
       |
       |public class java_relay implements
     """))
@@ -58,20 +64,26 @@ if __name__ == '__main__':
     result.extend(split_match('^[^|]*\|(.*)$', """
       |  public java_relay(String InName, String OutName) throws Exception {
       |    FileInputStream InFile = new FileInputStream(InName);
-      |    DecoderChannel d = new DecoderChannel(InFile);
+      |    DecoderChannel decoder = new DecoderChannel(InFile);
       |    FileOutputStream OutFile = new FileOutputStream(OutName);
       |    encoder = new EncoderChannel(OutFile);
       |
     """))
-    for func,arg in sample:
-        result.append('    %s.register(d, this);' % func)
+    for func,arg in shuffle(sample):
+        result.append('    %s.register(decoder, this);' % func)
         pass
-    for func,arg in sample:
+    for func,arg in shuffle(sample):
+        result.append('    %s.registerSampleRef(decoder);' % func)
+        pass
+    for func,arg in shuffle(sample):
         result.append('    %s.register(encoder);' % func)
         pass
+    for func,arg in shuffle(sample):
+        result.append('    %s.registerSampleRef(encoder);' % func)
+        pass
     result.extend(split_match('^[^|]*\|(.*)$', """
       |    try {
-      |      d.run();
+      |      decoder.run();
       |    } catch (java.io.EOFException e) {
       |    }
       |  }

test/test_encoder_decoder.py

@@ -3,7 +3,7 @@
 
 import argparse
 import imp
-import labcomm
+import labcomm2014
 import math
 import os
 import re
@@ -12,20 +12,60 @@ import subprocess
 import sys
 import threading
 
-def generate(decl):
-    if decl.__class__ == labcomm.sample:
+
+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 = signatures
+        pass
+
+    def generate(self, decl):
+        if decl.__class__ == labcomm2014.sample:
             result = []
-        for values in generate(decl.decl):
+            for values in self.generate(decl.decl):
                 result.append((decl, values))
             return result
     
-    elif decl.__class__ == labcomm.struct:
+        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 = generate(decl.field[0][1])
-            values2 = generate(labcomm.struct(decl.field[1:]))
+                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)
@@ -33,15 +73,16 @@ def generate(decl):
                         result.append(v)
             return result
         
-    elif decl.__class__ == labcomm.array:
+        elif decl.__class__ == labcomm2014.array:
             if len(decl.indices) == 1:
-            values = generate(decl.decl)
+                values = self.generate(decl.decl)
                 if decl.indices[0] == 0:
                     lengths = [0, 1, 2]
                 else:
                     lengths = [ decl.indices[0] ]
             else:
-            values = generate(labcomm.array(decl.indices[1:],decl.decl))
+                values = self.generate(labcomm2014.array(decl.indices[1:],
+                                                     decl.decl))
                 if decl.indices[0] == 0:
                     lengths = [1, 2]
                 else:
@@ -55,91 +96,100 @@ def generate(decl):
                     result.append(element)
             return result
     
-    elif decl.__class__ == labcomm.BOOLEAN:
+        elif decl.__class__ == labcomm2014.BOOLEAN:
             return [False, True]
     
-    elif decl.__class__ == labcomm.BYTE:
+        elif decl.__class__ == labcomm2014.BYTE:
             return [0, 127, 128, 255]
     
-    elif decl.__class__ == labcomm.SHORT:
+        elif decl.__class__ == labcomm2014.SHORT:
             return [-32768, 0, 32767]
     
-    elif decl.__class__ == labcomm.INTEGER:
+        elif decl.__class__ == labcomm2014.INTEGER:
             return [-2147483648, 0, 2147483647]
     
-    elif decl.__class__ == labcomm.LONG:
+        elif decl.__class__ == labcomm2014.LONG:
             return [-9223372036854775808, 0, 9223372036854775807]
     
-    elif decl.__class__ == labcomm.FLOAT:
+        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__ == labcomm.DOUBLE:
+        elif decl.__class__ == labcomm2014.DOUBLE:
             return [-math.pi, 0.0, math.pi]
     
-    elif decl.__class__ == labcomm.STRING:
+        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 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 uses_refs(self, decls):
+        for decl in decls:
+            if decl.__class__ == labcomm2014.sample:
+                if self.uses_refs([ decl.decl ]):
+                    return True
     
-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 m.sample
+            elif decl.__class__ == labcomm2014.struct:
+                if self.uses_refs([ d for n,d in decl.field ]):
+                    return True
         
-class Test:
+            elif decl.__class__ == labcomm2014.array:
+                if self.uses_refs([ decl.decl ]):
+                    return True
+
+            elif decl.__class__ == labcomm2014.SAMPLE:
+                return True
+
+        return False
         
-    def __init__(self, program, signatures):
-        self.program = program
-        self.signatures = signatures
-        pass
 
     def run(self):
         print>>sys.stderr, 'Testing', self.program
         p = subprocess.Popen(self.program, 
                              stdin=subprocess.PIPE,
-                             stdout=subprocess.PIPE)
+                             stdout=subprocess.PIPE,
+                             stderr=sys.stderr)
         self.expected = None
         self.failed = False
-        self.next = threading.Semaphore(0)
+        self.next = threading.Condition()
         decoder = threading.Thread(target=self.decode, args=(p.stdout,))
         decoder.start()
-        encoder = labcomm.Encoder(labcomm.StreamWriter(p.stdin))
-        for name,signature in self.signatures:
+        encoder = labcomm2014.Encoder(labcomm2014.StreamWriter(p.stdin))
+        for signature in self.signatures:
             encoder.add_decl(signature)
             pass
-        for name,signature in self.signatures:
-            print>>sys.stderr, "Checking", name,
-            for decl,value in generate(signature):
-                sys.stdout.write('.')
-                #print name,decl,value,value.__class__
-                self.expected = value
-                encoder.encode(value, decl)
+        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
@@ -152,14 +202,16 @@ class Test:
         pass
 
     def decode(self, f):
-        decoder = labcomm.Decoder(labcomm.StreamReader(f))
+        decoder = labcomm2014.Decoder(labcomm2014.StreamReader(f))
         try:
             while True:
                 value,decl = decoder.decode()
                 if value != None:
-                    if value != self.expected:
-                        print>>sys.stderr, "Coding error", value, self.expected, decl
-                        self.failed = True
+                    self.next.acquire()
+                    self.received_value = value
+                    self.received_decl = decl
+                    self.expected = None
+                    self.next.notify_all()
                     self.next.release()
                 pass
             pass

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

tools/lc2csv.py

+#!/usr/bin/env python
+
+import argparse
+import labcomm2014
+import sys
+import time
+
+
+class Reader(object):
+    def __init__(self, file_):
+        self._file = file_
+
+    def read(self, count):
+        data = self._file.read(count)
+        if len(data) == 0:
+            raise EOFError()
+        return data
+
+    def mark(self, value, decl):
+        pass
+
+
+class FollowingReader(Reader):
+    def __init__(self, file_, interval, timeout):
+        super(FollowingReader, self).__init__(file_)
+        self._interval = interval
+        self._timeout = timeout
+
+    def read(self, count):
+        data = ''
+        t_start = time.time()
+        while len(data) < count:
+            tmp = self._file.read(count - len(data))
+            if tmp:
+                data += tmp
+            else:
+                time.sleep(self._interval)
+                if self._timeout and time.time() - t_start > self._timeout:
+                    raise EOFError()
+        return data
+
+
+def flatten(sample, _type):
+    if isinstance(_type, labcomm2014.sample):
+        flatten(sample, _type.decl)
+    elif isinstance(_type, labcomm2014.array):
+        for e in sample:
+            flatten(e, _type.decl)
+    elif isinstance(_type, labcomm2014.struct):
+        for name, decl in _type.field:
+            flatten(sample[name], decl)
+    elif isinstance(_type, labcomm2014.BOOLEAN):
+        print "%d," % sample,
+    elif isinstance(_type, labcomm2014.STRING):
+        print "\"%s\"," % sample,
+    elif isinstance(_type, labcomm2014.primitive):
+        print "%s," % sample,
+    else:
+        raise Exception("Unhandled type. " + str(type(type_)) + " " + str(type_))
+
+
+def flatten_labels(_type, prefix=""):
+    if isinstance(_type, labcomm2014.sample):
+        flatten_labels(_type.decl, _type.name)
+    elif isinstance(_type, labcomm2014.array):
+        if len(_type.indices) != 1:
+            raise Exception("Fix multidimensional arrays")
+        if len(_type.indices) == 0:
+            raise Exception("We dont't handle dynamical sizes yet %s" % _type)
+        for i in range(0, _type.indices[0]):
+            flatten_labels(_type.decl, prefix + "[%d]" % i)
+    elif isinstance(_type, labcomm2014.struct):
+        for name, decl in _type.field:
+            flatten_labels(decl,
+                           prefix + "." + name)
+    elif isinstance(_type, labcomm2014.primitive):
+        print '"%s",' % prefix,
+    else:
+        raise Exception("Unhandled type. " + str(type(type_)) + " " + str(type_))
+
+
+def default(type_):
+    if isinstance(type_, labcomm2014.sample):
+        return default(type_.decl)
+    elif isinstance(type_, labcomm2014.array):
+        if len(type_.indices) != 1:
+            raise Exception("Fix multidimensional arrays")
+        if len(type_.indices) == 0:
+            raise Exception("We dont't handle dynamical sizes yet %s" % type_)
+        for i in range(0, type_.indices[0]):
+            return [default(type_.decl) for _ in range(type_.indices[0])]
+    elif isinstance(type_, labcomm2014.struct):
+        return {name: default(decl) for name, decl in type_.field}
+    elif isinstance(type_, labcomm2014.STRING):
+        return ''
+    elif isinstance(type_, labcomm2014.BOOLEAN):
+        return False
+    elif (isinstance(type_, labcomm2014.FLOAT) or
+          isinstance(type_, labcomm2014.DOUBLE)):
+        return float('NaN')
+    elif (isinstance(type_, labcomm2014.BYTE) or
+          isinstance(type_, labcomm2014.SHORT) or
+          isinstance(type_, labcomm2014.INTEGER) or
+          isinstance(type_, labcomm2014.LONG)):
+        return 0
+    else:
+        raise Exception("Unhandled type. " + str(type(type_)) + " " + str(type_))
+
+
+def dump(sample, _type):
+    for k in sorted(_type.keys()):
+        flatten(sample[k], _type[k])
+    print
+
+
+def dump_labels(type_):
+    for k in sorted(type_.keys()):
+        flatten_labels(type_[k])
+    print
+
+
+def defaults(current, type_):
+    for k in sorted(type_.keys()):
+        if k not in current:
+            current[k] = default(type_[k])
+
+
+def main(main_args):
+    parser = argparse.ArgumentParser()
+    parser.add_argument('elc', type=str, help="The log file.")
+    parser.add_argument('-f', '--follow', action='store_true',
+                        help="find all registrations that already "
+                        "exist, then watch the file for changes. All "
+                        "future registrations are ignored (because "
+                        "the header has already been written).")
+    parser.add_argument('-s', '--interval', action="store", type=float,
+                        default=0.040,
+                        help="time to sleep between failed reads. Requires -f.")
+    parser.add_argument('-t', '--timeout', action="store", type=float,
+                        help="timeout to terminate when no changes are detected. "
+                        "Requires -f.")
+    parser.add_argument('-w', '--no-default-columns', action="store_true",
+                        help="Do not fill columns for which there is no "
+                        "data with default values. Wait instead until at least "
+                        "one sample has arrived for each registration.")
+    parser.add_argument('-a', '--trigger-all', action="store_true",
+                        help="Output one line for each sample instead of for "
+                        "each sample of the registration that has arrived with "
+                        "the highest frequency.")
+    args = parser.parse_args(main_args)
+    n_samples = {}         # The number of received samples for each sample reg.
+    current = {}           # The most recent sample for each sample reg.
+    type_ = {}             # The type (declaration) of each sample reg.
+    file_ = open(args.elc)
+    if args.follow:
+        reader = FollowingReader(file_, args.interval, args.timeout)
+    else:
+        reader = Reader(file_)
+    d = labcomm2014.Decoder(reader)
+    while True:
+        try:
+            o, t = d.decode()
+            if o is None:
+                n_samples[t.name] = 0
+                type_[t.name] = t
+            else:
+                n_samples[t.name] += 1
+                current[t.name] = o
+                break
+        except EOFError:
+            break
+    dump_labels(type_)
+    if not args.no_default_columns:
+        defaults(current, type_)
+    n_rows = 0
+    while True:
+        try:
+            o, t = d.decode()
+            if o is None:
+                continue
+            current[t.name] = o
+            n_samples[t.name] += 1
+            if len(current) < len(type_):
+                continue
+            if args.trigger_all:
+                dump(current, type_)
+            else:
+                if n_samples[t.name] > n_rows:
+                    n_rows = n_samples[t.name]
+                    dump(current, type_)
+        except EOFError:
+            break
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

tools/lc_to_matlab_coder.py

+#!/usr/bin/python
+
+import sys
+import imp
+import subprocess
+import os
+import labcomm2014
+
+TRANSLATE={
+    labcomm2014.SHORT() : 'short',
+    labcomm2014.DOUBLE() : 'double'
+}
+
+def compile_lc(lc):
+    p = subprocess.Popen([ 'labcomm2014', '--python=/dev/stdout', lc],
+                         stdout=subprocess.PIPE)
+    src = p.stdout.read()
+    code = compile(src, 'lc_import', 'exec')
+    mod = sys.modules.setdefault('lc_import', imp.new_module('lc_import'))
+    exec code in mod.__dict__
+    import lc_import
+    return (lc_import.typedef, lc_import.sample)
+
+def gen_binding(decl, lc_prefix, prefix, suffix):
+    if isinstance(decl, labcomm2014.sample):
+        if isinstance(decl.decl, labcomm2014.typedef):
+            print "%(n1)s = coder.cstructname(%(n1)s, '%(lc)s_%(n2)s')" % dict(
+                n1=decl.name, n2=decl.decl.name, lc=lc_prefix)
+        else:
+            print "%(n1)s = coder.cstructname(%(n1)s, '%(lc)s_%(n2)s')" % dict(
+                n1=decl.name, n2=decl.name, lc=lc_prefix)
+        gen_binding(decl.decl, lc_prefix, '%s.' % decl.name, suffix)
+    elif isinstance(decl, labcomm2014.typedef):
+        print "%(p)s%(s)s = coder.cstructname(%(p)s%(s)s, '%(lc)s_%(n)s')" % dict(
+            n=decl.name, lc=lc_prefix, p=prefix, s=suffix)
+        gen_binding(decl.decl, lc_prefix, prefix, suffix)
+    elif isinstance(decl, labcomm2014.array):
+         raise Exception("Array unhandled")
+    elif isinstance(decl, labcomm2014.struct):
+        for n, d in decl.field:
+            gen_binding(d, lc_prefix, '%sFields.%s' % (prefix, n), suffix)
+    elif isinstance(decl, labcomm2014.primitive):
+        pass
+    else:
+        raise Exception("Unhandled type. %s", decl)
+    
+def gen_sample(lc_prefix, decl):
+    if isinstance(decl, labcomm2014.sample):
+        print "%s = " % decl.name,
+        gen_sample(lc_prefix, decl.decl)
+        print
+        gen_binding(decl, lc_prefix, '', '')
+    elif isinstance(decl, labcomm2014.typedef):
+        # Expand in place
+        gen_sample(lc_prefix, decl.decl)
+    elif isinstance(decl, labcomm2014.array):
+         raise Exception("Array unhandled")
+    elif isinstance(decl, labcomm2014.struct):
+        print "struct(..."
+        for n, d in decl.field:
+            print "'%s, " % n,
+            gen_sample(lc_prefix, d)
+        print ")..."
+    elif isinstance(decl, labcomm2014.primitive):
+        print "%s(0), ..." % TRANSLATE[decl]
+    else:
+        raise Exception("Unhandled type. %s", decl)  
+
+"""
+robtarget = struct(...
+	'orientation', ...
+	struct(...
+	    'q1', double(0), ...
+	    'q2', double(0), ...
+	    'q3', double(0), ...
+	    'q4', double(0) ...
+	), ...
+	'translation', ...
+	struct(...
+	    'x', double(0), ...
+	    'y', double(0), ...
+	    'z', double(0) ...
+	), ...
+	'configuration', ...
+	struct(...
+	    'cf1', int16(0), ...
+	    'cf4', int16(0), ...
+	    'cf6', int16(0), ...
+	    'cfx', int16(0) ...
+	) ...
+);
+robtarget_types = coder.typeof(robtarget);
+
+act = coder.cstructname(robtarget_types, 'egm_pb2lc_robtarget');
+act.Fields.translation = coder.cstructname(act.Fields.translation, 'egm_pb2lc_cartesian');
+act.Fields.orientation = coder.cstructname(act.Fields.orientation, 'egm_pb2lc_quaternion');
+act.Fields.configuration = coder.cstructname(act.Fields.configuration, 'egm_pb2lc_confdata');
+"""
+
+def gen_matlab(lc):
+    lc_prefix = os.path.basename(lc).split('.')[0]
+    typedef, sample = compile_lc(lc)
+    for s in sample:
+        gen_sample(lc_prefix, s.signature)
+
+if __name__ == '__main__':
+    for lc in sys.argv[1:]:
+        gen_matlab(lc)