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

@@ -4,13 +4,6 @@ class StreamReader:
         self.stream = stream
         pass
 
-    def start(self, decoder, version):
-        other_version = decoder.decode_string()
-        if version != other_version:
-            raise Exception("LabComm version mismatch %s != %s" %
-                            (version, other_version))
-        pass
-
     def read(self, count):
         result = self.stream.read(count)
         if len(result) == 0:

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

@@ -4,15 +4,14 @@ class StreamWriter:
         self.stream = stream
         pass
             
-    def start(self, encoder, version):
-        encoder.encode_string(version)
-        pass
-    
     def write(self, data):
         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
-LABCOMM=java -jar $(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
+include ../lib/c/os_compat.mk
 
-all:	
+all:
 
-test: $(TESTS:%=test_%)
+test: $(TESTS:%=test_%) $(TESTS:%=test_renaming_%) compiler_errors
 #	PYTHONPATH=../lib/python \
 #		./test_encoder_decoder.py --labcomm="$(LABCOMM)" basic.lc
 
@@ -14,19 +16,53 @@ test: $(TESTS:%=test_%)
 clean distclean:
 	rm -rf gen
 
-.PHONY: test_%
+.PHONY: test_% 
 test_%: gen/%/signatures.py \
 	gen/%/c_relay \
 	gen/%/cs_relay.exe \
 	gen/%/java_relay.class \
-	gen/%/java_code 
-	PYTHONPATH=../lib/python ./test_encoder_decoder.py \
+	gen/%/java_code
+	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 \
-			    /dev/stdin /dev/stdout
+		--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
+
+compiler_errors: testErrorsOK testErrorsNOK
+
+# tests that should succeed
+testErrorsOK: $(wildcard errors/correct/*.lc)
+	./test_errors.py --labcomm="$(LABCOMM)" --testOK $^
+
+# tests that should fail
+testErrorsNOK: $(wildcard errors/incorrect/*.lc)
+	./test_errors.py --labcomm="$(LABCOMM)" --testNOK $^
+
 .PRECIOUS: gen/%/.dir
 gen/%/.dir:
 	mkdir -p gen/$*
@@ -51,9 +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 -Tlabcomm.linkscript
+	$(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
@@ -64,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
@@ -85,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/basic.lc

@@ -6,4 +6,4 @@ sample long s_long;
 sample float s_float;
 sample double s_double;
 sample boolean s_boolean;
-sample string s_string;
\ No newline at end of file
+sample string s_string;

test/errors/correct/structtype.lc

+typedef struct {
+	string topic;
+} pubsub;
+
+sample pubsub subscribe;
+sample pubsub unsubscribe;
+
+sample pubsub publish;
+sample pubsub unpublish;

test/errors/correct/void.lc

+typedef void avoid;
+
+sample avoid doavoid;
+
+// examples of errors: void may not be used
+// in structs or arrays
+//
+// sample struct {
+//  int a;
+//  avoid error;
+//} foo;
+//
+//sample void error2[2] ;
+//sample avoid error3[_];

test/errors/incorrect/void.lc

+typedef void avoid;
+
+// examples of errors: void may not be used
+// in structs or arrays
+//
+sample struct {
+  int a;
+  avoid error_1;
+} foo;
+
+sample void error_2[2] ;
+sample avoid error_3[_];

test/nested.lc

@@ -21,3 +21,5 @@ sample struct_t struct_t_s;
 sample struct_array_t struct_array_t_s;
 sample struct_struct_t struct_struct_t_s;
 
+sample string string_array[_];
+sample struct { string s[_]; } string_struct_array;

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,54 +14,137 @@ 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 = l[1:].split(l[0])
+        lang,kind,func,arg,stype = l[1:].split(l[0])
         if lang == 'C' and kind == 'sample':
-            sample.append((func, arg))
+            sample.append((func, arg, stype))
             pass
         pass
     result = []
     result.extend(split_match('^[^|]*\|(.*)$', """
+      |// generated by relay_gen_c.py
       |#include <sys/types.h>
       |#include <sys/stat.h>
       |#include <fcntl.h>
-      |#include <labcomm.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 in sample:
+    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, v);
-          |}""" % { 'func': func, 'arg': arg }))
+          |  struct labcomm2014_encoder *e = context;
+          |  labcomm2014_encode_%(func)s(e%(valargstr)s);
+          |}""" % { 'func': func, 'arg': arg, 'valargstr': '' if stype == "void" else', v' }))
         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(out, 1), NULL);
-      |  d = labcomm_decoder_new(labcomm_fd_reader_new(in, 1), NULL);
+      |  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('^[^|]*\|(.*)$', """
+          |  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('^[^|]*\|(.*)$', """
+      |  while ((result = labcomm2014_decoder_decode_one(d)) > 0) {};
     """))
-    for func,arg in sample:
+    if options.renaming:
         result.extend(split_match('^[^|]*\|(.*)$', """
-          |  labcomm_encoder_register_%(func)s(e);
-          |  labcomm_decoder_register_%(func)s(d, handle_%(func)s, e);
-        """ % { 'func': func, 'arg': arg }))
+        |  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('^[^|]*\|(.*)$', """
-      |  labcomm_decoder_run(d);
-      |  return 0;
+      |  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,12 +13,22 @@ 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 = l[1:].split(l[0])
+        lang,kind,func,arg,dummy = l[1:].split(l[0])
         if lang == 'C#' and kind == 'sample':
             sample.append((func, arg))
             pass
@@ -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('^[^|]*\|(.*)$', """
       |{
-      |  LabCommEncoderChannel 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);
-      |    LabCommDecoderChannel d = new LabCommDecoderChannel(InFile);
+      |    decoder = new DecoderChannel(InFile);
       |    FileStream OutFile = new FileStream(OutName,
       |                                        FileMode.OpenOrCreate,
       |                                        FileAccess.Write);
-      |    encoder = new LabCommEncoderChannel(OutFile);
-      |
+      |    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,12 +12,16 @@ 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])
     sample = []
     for l in map(lambda s: s.strip(), f):
-        lang,kind,func,arg = l[1:].split(l[0])
+        lang,kind,func,arg,dummy = l[1:].split(l[0])
         if lang == 'Java' and kind == 'sample':
             sample.append((func, arg))
             pass
@@ -26,8 +31,9 @@ if __name__ == '__main__':
       |import java.io.FileInputStream;
       |import java.io.FileOutputStream;
       |import java.io.IOException;
-      |import se.lth.control.labcomm.LabCommDecoderChannel;
-      |import se.lth.control.labcomm.LabCommEncoderChannel;
+      |import se.lth.control.labcomm2014.DecoderChannel;
+      |import se.lth.control.labcomm2014.EncoderChannel;
+      |import se.lth.control.labcomm2014.Sample;
       |
       |public class java_relay implements
     """))
@@ -37,7 +43,7 @@ if __name__ == '__main__':
     result.append('  %s.Handler' % sample[-1][0])
     result.extend(split_match('^[^|]*\|(.*)$', """
       |{
-      |  LabCommEncoderChannel encoder;
+      |  EncoderChannel encoder;
     """))
     for func,arg in sample:
         if arg == 'void':
@@ -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);
-      |    LabCommDecoderChannel d = new LabCommDecoderChannel(InFile);
+      |    DecoderChannel decoder = new DecoderChannel(InFile);
       |    FileOutputStream OutFile = new FileOutputStream(OutName);
-      |    encoder = new LabCommEncoderChannel(OutFile);
+      |    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/simple.lc

@@ -9,4 +9,4 @@ sample struct {
   int a;
   int b;
 } an_int_struct;
-sample void a_void;
\ No newline at end of file
+sample void a_void;

test/test_encoder_decoder.py

@@ -3,7 +3,7 @@
 
 import argparse
 import imp
-import labcomm
+import labcomm2014
 import math
 import os
 import re
@@ -12,77 +12,6 @@ import subprocess
 import sys
 import threading
 
-def generate(decl):
-    if decl.__class__ == labcomm.sample:
-        result = []
-        for values in generate(decl.decl):
-            result.append((decl, values))
-        return result
-
-    elif decl.__class__ == labcomm.struct:
-        result = []
-        if len(decl.field) == 0:
-            result.append({})
-        else:
-            values1 = generate(decl.field[0][1])
-            values2 = generate(labcomm.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__ == labcomm.array:
-        if len(decl.indices) == 1:
-            values = 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))
-            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__ == labcomm.BOOLEAN:
-        return [False, True]
-
-    elif decl.__class__ == labcomm.BYTE:
-        return [-128, 0, 127]
-
-    elif decl.__class__ == labcomm.SHORT:
-        return [-32768, 0, 32767]
-
-    elif decl.__class__ == labcomm.INTEGER:
-        return [-2147483648, 0, 2147483647]
-
-    elif decl.__class__ == labcomm.LONG:
-        return [-9223372036854775808, 0, 9223372036854775807]
-
-    elif decl.__class__ == labcomm.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:
-        return [-math.pi, 0.0, math.pi]
-
-    elif decl.__class__ == labcomm.STRING:
-        return ['string', u'sträng' ]
-
-    print decl
-    raise Exception("unhandled decl %s" % decl.__class__)
 
 def labcomm_compile(lc, name, args):
     for lang in [ 'c', 'csharp', 'java', 'python']:
@@ -108,7 +37,7 @@ def get_signatures(path):
     with fp as fp:
         m = imp.load_module('signatures', fp, pathname, description)
         pass
-    return m.sample
+    return map(lambda s: s.signature, m.sample)
 
 class Test:
     
@@ -117,34 +46,154 @@ class Test:
         self.signatures = 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 'Testing', self.program
+        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 "Checking", name,
-            sys.stdout.flush()
-            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()
-                if self.failed:
-                    p.terminate()
+                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
+            print>>sys.stderr
             pass
         p.stdin.close()
         if p.wait() != 0:
@@ -153,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 "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_errors.py

+#!/usr/bin/python
+
+import sys
+import argparse
+import subprocess
+
+# returns true if test fails
+def test_labcomm_compile_OK(lc, args):
+    cmd = args.labcomm.split() + [lc]
+    try:
+        res = subprocess.check_call(cmd)
+        print "sucess!"
+        return False
+    except subprocess.CalledProcessError as ex:
+        print ex.output
+        print ex.returncode
+        return True
+
+def test_labcomm_compile_fail(lc, args):
+    cmd = args.labcomm.split() + [lc]
+    try:
+        res = subprocess.check_call(cmd)
+        print "failed! (should have produced an error)"
+        return True
+    except subprocess.CalledProcessError as ex:
+        print "sucess!"
+        print ex.output
+        print ex.returncode
+        return False;
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Run test of error messages.')
+
+    parser.add_argument('--labcomm');
+    parser.add_argument('--testOK', nargs='*', default=[])
+    parser.add_argument('--testNOK', nargs='*', default=[])
+    args = parser.parse_args()
+
+    fail = False;
+    for test in args.testOK:
+        fail = fail or test_labcomm_compile_OK(test, args)
+        pass
+    for test in args.testNOK:
+        fail = fail or test_labcomm_compile_fail(test, args)
+        pass
+    if fail:
+        print "*** fail ***"
+    else:
+        print "*** success ***"