examples/tcp/labcommTCPtest/server/TestServer.java

+package labcommTCPtest.server;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.net.ServerSocket;
+import java.net.Socket;
+
+import se.lth.control.labcomm2014.DecoderChannel;
+import se.lth.control.labcomm2014.EncoderChannel;
+import labcommTCPtest.gen.FooSample;
+import labcommTCPtest.gen.FooSample.Handler;
+
+public class TestServer implements Handler {
+
+	private OutputStream out;
+	private InputStream in;
+
+	public static void main(String a[]) {
+		try {
+			ServerSocket ss = new ServerSocket(9999);
+			Socket s = ss.accept();
+			
+			TestServer ts = new TestServer(s);
+			ts.runOne();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	public TestServer(Socket s) throws IOException {
+		out = s.getOutputStream();
+		in = s.getInputStream();
+	}
+	
+	public void runOne() {
+		
+		try {
+			DecoderChannel c = new DecoderChannel(in);
+			FooSample.register(c,this);
+			c.runOne();
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	public void handle_FooSample(FooSample sample) throws Exception {
+		EncoderChannel e = new EncoderChannel(out );
+		FooSample.register(e);
+		System.out.println("TestServer.handle_FooSample: "+sample.s);
+		int tmp[] = new int[2*sample.a.length];
+		for (int i = 0; i < sample.a.length;i++) {
+			tmp[2*i] = tmp[2*i+1] = sample.a[i];
+		}
+		
+		sample.s = "double!";
+		sample.x *= 2;
+		sample.y *= 2;
+		sample.a = tmp;
+		sample.t *= 2;
+		sample.d *= 2;
+		FooSample.encode(e, sample);
+	}
+}

examples/tcp/runpy

+#!/bin/sh
+
+PYTHONPATH=../../lib/python ./example_tcp_client_decoder.py $@

examples/tcp/rwsocket.py

+import socket
+import types
+
+def flush(self):
+    pass
+
+socket.socket.write = socket.socket.send
+socket.socket.read = socket.socket.recv
+socket.socket.flush = flush
+
+# class rwsocket(socket.socket):
+#     write=socket.socket.send
+#     read=socket.socket.recv
+
+#     def flush(self):
+#         pass
+
+#     def accept(self):
+#         sock, addr = super(rwsocket, self).accept()
+#         # sock.write = types.MethodType(self.write, sock, sock.__class__)
+#         # sock.read = types.MethodType(self.write, sock, sock.__class__)
+#         sock.__class__ = rwsocket
+
+#         return (sock, addr)

examples/tcp/test.lc

+sample struct {
+    string s;
+    int x;
+    int y;
+    int a[_];
+    long t;
+    double d;
+} FooSample;

examples/twoway/.gitignore

+gen

examples/twoway/Makefile

+UNAME_S=$(shell uname -s)
+
 TARGETS=client server
-LABCOMM_JAR=../../compiler/labComm.jar
-LABCOMM=java -jar $(LABCOMM_JAR) 
+LABCOMM_JAR=../../compiler/labcomm2014_compiler.jar
+LABCOMM=java -jar $(LABCOMM_JAR)
+
+#include ../../lib/c/os_compat.mk
+
+CFLAGS=-O3 -g -Wall -Werror -I../../lib/c/2014 -I. -Wno-unused-function
 
-CFLAGS=-O3 -g -Wall -Werror -I../../lib/c -I. -lpthread
+ifeq ($(UNAME_S),Darwin)
+    CFLAGS+=-DLABCOMM_COMPAT=\"labcomm2014_compat_osx.h\" -DLABCOMM_OS_DARWIN=1
+else
+    CFLAGS+=-Wno-tautological-compare
+endif
 
 all: $(TARGETS:%=gen/%)
 
 test: all
 	LD_LIBRARY_PATH=../../lib/c ./gen/server 2000 &
-	LD_LIBRARY_PATH=../../lib/c ./gen/client localhost 2000 
+	LD_LIBRARY_PATH=../../lib/c ./gen/client localhost 2000
 
 gen/.dir:
 	mkdir -p $@
 
 .PRECIOUS: gen/%.o
 gen/%.o: gen/%.c | gen/.dir
-	$(CC) $(CFLAGS) -c -o $@ $< 
+	$(CC) $(CFLAGS) -c -o $@ $<
 
 gen/%.o: %.c | gen/.dir
-	$(CC) $(CFLAGS) -c -o $@ $< 
+	$(CC) $(CFLAGS) -c -o $@ $<
 
 .PRECIOUS: gen/%.c gen/%.h
 gen/%.c gen/%.h: %.lc | gen/.dir
 	$(LABCOMM) --c=gen/$*.c --h=gen/$*.h $<
 
-gen/client: client.c 
+gen/client: client.c
 	$(CC) -o $@ $(CFLAGS) $^ -lpthread \
-		-L../../lib/c -llabcomm -Tlabcomm.linkscript
+		-L../../lib/c -llabcomm2014
 
-gen/server: server.c 
+gen/server: server.c
 	$(CC) -o $@ $(CFLAGS) $^ -lpthread \
-		-L../../lib/c -llabcomm -Tlabcomm.linkscript
+		-L../../lib/c -llabcomm2014
 
-.PHONY: clean
-clean:
+.PHONY: clean distclean
+clean distclean:
 	rm -rf gen
 
 gen/decimating.o: decimating.h
@@ -42,7 +52,7 @@ gen/introspecting.o: introspecting.h
 gen/introspecting.o: gen/introspecting_messages.h
 gen/client.o: decimating.h
 gen/client.o: gen/types.h
-gen/client: gen/decimating.o 
+gen/client: gen/decimating.o
 gen/client: gen/decimating_messages.o
 gen/client: gen/introspecting.o
 gen/client: gen/introspecting_messages.o

examples/twoway/client.c

@@ -21,7 +21,12 @@
 
 #include <errno.h>
 #include <arpa/inet.h>
+#ifndef LABCOMM_OS_DARWIN
 #include <linux/tcp.h>
+#else
+#include <netinet/in.h>
+#include <netinet/tcp.h> 
+#endif
 #include <netdb.h>
 #include <pthread.h>
 #include <stdio.h>
@@ -31,12 +36,12 @@
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <unistd.h>
-#include <labcomm.h>
-#include <labcomm_fd_reader.h>
-#include <labcomm_fd_writer.h>
-#include <labcomm_default_error_handler.h>
-#include <labcomm_default_memory.h>
-#include <labcomm_pthread_scheduler.h>
+#include <labcomm2014.h>
+#include <labcomm2014_fd_reader.h>
+#include <labcomm2014_fd_writer.h>
+#include <labcomm2014_default_error_handler.h>
+#include <labcomm2014_default_memory.h>
+#include <labcomm2014_pthread_scheduler.h>
 #include "decimating.h"
 #include "introspecting.h"
 #include "gen/types.h"
@@ -58,13 +63,13 @@ static void handle_Product(int32_t *value, void *context)
 
 static void *run_decoder(void *context)
 {
-  struct labcomm_decoder *decoder = context;
+  struct labcomm2014_decoder *decoder = context;
   int result;
 
-  labcomm_decoder_register_types_Sum(decoder, handle_Sum, NULL);
-  labcomm_decoder_register_types_Diff(decoder, handle_Diff, NULL);
+  labcomm2014_decoder_register_types_Sum(decoder, handle_Sum, NULL);
+  labcomm2014_decoder_register_types_Diff(decoder, handle_Diff, NULL);
   do {
-    result = labcomm_decoder_decode_one(decoder);
+    result = labcomm2014_decoder_decode_one(decoder);
   } while (result >= 0);
   return NULL;
 }
@@ -82,10 +87,10 @@ int main(int argc, char *argv[])
   struct introspecting *introspecting;
   char *hostname;
   int port;
-  struct labcomm_scheduler *scheduler;
-  struct labcomm_decoder *decoder;
-  struct labcomm_encoder *encoder;
-  struct labcomm_time *next;
+  struct labcomm2014_scheduler *scheduler;
+  struct labcomm2014_decoder *decoder;
+  struct labcomm2014_encoder *encoder;
+  struct labcomm2014_time *next;
   int32_t i, j;
 
   hostname = argv[1];
@@ -123,13 +128,13 @@ int main(int argc, char *argv[])
   
   nodelay = 1;
   setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &nodelay, sizeof(nodelay));
-  scheduler = labcomm_pthread_scheduler_new(labcomm_default_memory);
-  decimating = decimating_new(labcomm_fd_reader_new(labcomm_default_memory, 
+  scheduler = labcomm2014_pthread_scheduler_new(labcomm2014_default_memory);
+  decimating = decimating_new(labcomm2014_fd_reader_new(labcomm2014_default_memory, 
 						    fd, 1),
-			      labcomm_fd_writer_new(labcomm_default_memory, 
+			      labcomm2014_fd_writer_new(labcomm2014_default_memory, 
 						    fd, 0),
-			      labcomm_default_error_handler,
-			      labcomm_default_memory,
+			      labcomm2014_default_error_handler,
+			      labcomm2014_default_memory,
 			      scheduler);
   if (decimating == NULL) {
     /* Warning: might leak reader and writer at this point */
@@ -137,45 +142,45 @@ int main(int argc, char *argv[])
   }
   introspecting = introspecting_new(decimating->reader,
 				    decimating->writer,
-				    labcomm_default_error_handler,
-				    labcomm_default_memory,
+				    labcomm2014_default_error_handler,
+				    labcomm2014_default_memory,
 				    scheduler);
   if (introspecting == NULL) {
     /* Warning: might leak reader and writer at this point */
     goto out;
   }
-  decoder = labcomm_decoder_new(introspecting->reader, 
-				labcomm_default_error_handler,
-				labcomm_default_memory,
+  decoder = labcomm2014_decoder_new(introspecting->reader, 
+				labcomm2014_default_error_handler,
+				labcomm2014_default_memory,
 				scheduler);
-  encoder = labcomm_encoder_new(introspecting->writer, 
-				labcomm_default_error_handler,
-				labcomm_default_memory,
+  encoder = labcomm2014_encoder_new(introspecting->writer, 
+				labcomm2014_default_error_handler,
+				labcomm2014_default_memory,
 				scheduler);
   pthread_t rdt;
   pthread_create(&rdt, NULL, run_decoder, decoder);  
-  labcomm_encoder_register_types_A(encoder);
-  labcomm_encoder_register_types_B(encoder);
-  labcomm_encoder_register_types_Terminate(encoder);
+  labcomm2014_encoder_register_types_A(encoder);
+  labcomm2014_encoder_register_types_B(encoder);
+  labcomm2014_encoder_register_types_Terminate(encoder);
 
-  err = labcomm_decoder_ioctl_types_Sum(decoder, SET_DECIMATION, 2);
-  err = labcomm_decoder_ioctl_types_Diff(decoder, SET_DECIMATION, 4);
+  err = labcomm2014_decoder_ioctl_types_Sum(decoder, SET_DECIMATION, 2);
+  err = labcomm2014_decoder_ioctl_types_Diff(decoder, SET_DECIMATION, 4);
 
-  next = labcomm_scheduler_now(scheduler);
+  next = labcomm2014_scheduler_now(scheduler);
   for (i = 0 ; i < 4 ; i++) {
     if (i == 2) {
-      labcomm_decoder_register_types_Product(decoder, handle_Product, NULL);
+      labcomm2014_decoder_register_types_Product(decoder, handle_Product, NULL);
     }
     for (j = 0 ; j < 4 ; j++) {
       printf("\nA=%d B=%d: ", i, j);
-      labcomm_encode_types_A(encoder, &i);
-      labcomm_encode_types_B(encoder, &j);
-      labcomm_time_add_usec(next, 100000);
-      labcomm_scheduler_sleep(scheduler, next);
+      labcomm2014_encode_types_A(encoder, &i);
+      labcomm2014_encode_types_B(encoder, &j);
+      labcomm2014_time_add_usec(next, 100000);
+      labcomm2014_scheduler_sleep(scheduler, next);
     }
   }
   printf("\n");
-  labcomm_encode_types_Terminate(encoder, LABCOMM_VOID);
+  labcomm2014_encode_types_Terminate(encoder);
 out:
   return 0;
   

examples/twoway/decimating.c

@@ -23,18 +23,18 @@
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include "labcomm_private.h"
+#include "labcomm2014_private.h"
 #include "decimating.h"
 #include "gen/decimating_messages.h"
 
 struct decimating_private {
   struct decimating decimating;
-  struct labcomm_error_handler *error;
-  struct labcomm_memory *memory;
-  struct labcomm_scheduler *scheduler;
+  struct labcomm2014_error_handler *error;
+  struct labcomm2014_memory *memory;
+  struct labcomm2014_scheduler *scheduler;
   int encoder_initialized;
-  struct labcomm_reader_action_context reader_action_context;
-  struct labcomm_writer_action_context writer_action_context;
+  struct labcomm2014_reader_action_context reader_action_context;
+  struct labcomm2014_writer_action_context writer_action_context;
   LABCOMM_SIGNATURE_ARRAY_DEF(writer_decimation, 
 			      struct decimation {
 				int n;
@@ -50,26 +50,25 @@ static void set_decimation(
   struct decimating_private *decimating = context;
   struct decimation *decimation;
 
-  labcomm_scheduler_data_lock(decimating->scheduler);
+  labcomm2014_scheduler_data_lock(decimating->scheduler);
   decimation = LABCOMM_SIGNATURE_ARRAY_REF(decimating->memory,
 					   decimating->writer_decimation, 
 					   struct decimation, 
 					   value->signature_index);
   decimation->n = value->decimation;
   decimation->current = 0;
-  labcomm_scheduler_data_unlock(decimating->scheduler);
+  labcomm2014_scheduler_data_unlock(decimating->scheduler);
 }
 
 static int wrap_reader_alloc(
-  struct labcomm_reader *r, 
-  struct labcomm_reader_action_context *action_context, 
-  char *labcomm_version)
+  struct labcomm2014_reader *r, 
+  struct labcomm2014_reader_action_context *action_context)
 {
   struct decimating_private *decimating = action_context->context;
   
-  labcomm_decoder_register_decimating_messages_set_decimation(
+  labcomm2014_decoder_register_decimating_messages_set_decimation(
     r->decoder, set_decimation, decimating);
-  return labcomm_reader_alloc(r, action_context->next, labcomm_version);
+  return labcomm2014_reader_alloc(r, action_context->next);
 }
 
 struct send_set_decimation {
@@ -81,11 +80,11 @@ struct send_set_decimation {
 static void send_set_decimation(void *arg)
 {
   struct send_set_decimation *msg = arg;
-  struct labcomm_memory *memory = msg->decimating->memory;
+  struct labcomm2014_memory *memory = msg->decimating->memory;
 
-  labcomm_encode_decimating_messages_set_decimation(
+  labcomm2014_encode_decimating_messages_set_decimation(
     msg->decimating->decimating.writer->encoder, &msg->set_decimation);
-  labcomm_memory_free(memory, 1, msg);
+  labcomm2014_memory_free(memory, 1, msg);
 }
 
 static void enqueue_decimation(struct decimating_private *decimating,
@@ -93,21 +92,21 @@ static void enqueue_decimation(struct decimating_private *decimating,
 			       int amount) 
 {
   struct send_set_decimation *msg;
-  msg = labcomm_memory_alloc(decimating->memory, 1, sizeof(*msg));
+  msg = labcomm2014_memory_alloc(decimating->memory, 1, sizeof(*msg));
   if (msg) {
     msg->decimating = decimating;
     msg->set_decimation.decimation = amount;
     msg->set_decimation.signature_index = remote_index;
     
-    labcomm_scheduler_enqueue(decimating->scheduler, 0, 
+    labcomm2014_scheduler_enqueue(decimating->scheduler, 0, 
 			      send_set_decimation, msg);
   }
 }
 
 static int wrap_reader_start(
-  struct labcomm_reader *r, 
-  struct labcomm_reader_action_context *action_context,
-  int local_index, int remote_index, struct labcomm_signature *signature,
+  struct labcomm2014_reader *r, 
+  struct labcomm2014_reader_action_context *action_context,
+  int local_index, int remote_index, const struct labcomm2014_signature *signature,
   void *value)
 {
   struct decimating_private *decimating = action_context->context;
@@ -115,26 +114,26 @@ static int wrap_reader_start(
   if (value == NULL) {
     int *decimation, amount;
     
-    labcomm_scheduler_data_lock(decimating->scheduler);
+    labcomm2014_scheduler_data_lock(decimating->scheduler);
     decimation = LABCOMM_SIGNATURE_ARRAY_REF(decimating->memory,
 					     decimating->reader_decimation, 
 					     int,
 					     local_index);
     amount = *decimation;
-    labcomm_scheduler_data_unlock(decimating->scheduler);
+    labcomm2014_scheduler_data_unlock(decimating->scheduler);
     if (remote_index != 0 && amount != 0) {
       enqueue_decimation(decimating, remote_index, amount);
     }
   }
-  return labcomm_reader_start(r, action_context->next, 
+  return labcomm2014_reader_start(r, action_context->next, 
                               local_index, remote_index, signature, value);
 }
 
 static int wrap_reader_ioctl(
-  struct labcomm_reader *r,   
-  struct labcomm_reader_action_context *action_context,
+  struct labcomm2014_reader *r,   
+  struct labcomm2014_reader_action_context *action_context,
   int local_index, int remote_index,
-  struct labcomm_signature *signature, 
+  const struct labcomm2014_signature *signature, 
   uint32_t action, va_list args)
 {
   struct decimating_private *decimating = action_context->context;
@@ -148,26 +147,26 @@ static int wrap_reader_ioctl(
     amount = va_arg(va, int);
     va_end(va);
    
-    labcomm_scheduler_data_lock(decimating->scheduler);
+    labcomm2014_scheduler_data_lock(decimating->scheduler);
     decimation = LABCOMM_SIGNATURE_ARRAY_REF(decimating->memory,
 					     decimating->reader_decimation, 
 					     int,
 					     local_index);
     *decimation = amount;
-    labcomm_scheduler_data_unlock(decimating->scheduler);
+    labcomm2014_scheduler_data_unlock(decimating->scheduler);
     if (remote_index) {
       enqueue_decimation(decimating, remote_index, amount);
     }
     
   } else {
-    return labcomm_reader_ioctl(r, action_context->next,
+    return labcomm2014_reader_ioctl(r, action_context->next,
 				local_index, remote_index, signature, 
 				action, args);
   }
   return 0;
 }
 
-struct labcomm_reader_action decimating_reader_action = {
+struct labcomm2014_reader_action decimating_reader_action = {
   .alloc = wrap_reader_alloc,
   .free = NULL,
   .start = wrap_reader_start,
@@ -180,54 +179,55 @@ static void register_signatures(void *context)
 {
   struct decimating_private *decimating = context;
 
-  labcomm_encoder_register_decimating_messages_set_decimation(
+  labcomm2014_encoder_register_decimating_messages_set_decimation(
     decimating->decimating.writer->encoder);
 }
 
 static int wrap_writer_alloc(
-  struct labcomm_writer *w, 
-  struct labcomm_writer_action_context *action_context, 
-  char *labcomm_version)
+  struct labcomm2014_writer *w, 
+  struct labcomm2014_writer_action_context *action_context)
 {
   struct decimating_private *decimating = action_context->context;
 
-  labcomm_scheduler_enqueue(decimating->scheduler, 
+  labcomm2014_scheduler_enqueue(decimating->scheduler, 
 			    0, register_signatures, decimating);
-  return labcomm_writer_alloc(w, action_context->next, labcomm_version);
+  return labcomm2014_writer_alloc(w, action_context->next);
 }
 
 static int wrap_writer_start(
-  struct labcomm_writer *w, 
-  struct labcomm_writer_action_context *action_context, 
-  int index, struct labcomm_signature *signature,
+  struct labcomm2014_writer *w, 
+  struct labcomm2014_writer_action_context *action_context, 
+  int index, const struct labcomm2014_signature *signature,
   void *value)
 {
   struct decimating_private *decimating = action_context->context;
   struct decimation *decimation;
   int result;
 
-  labcomm_scheduler_data_lock(decimating->scheduler);
-
-  decimation = LABCOMM_SIGNATURE_ARRAY_REF(decimating->memory, 
-					   decimating->writer_decimation, 
-					   struct decimation, index);
-  decimation->current++;
-  if (decimation->current < decimation->n) {
-    result = -EALREADY;
-  } else {
-    decimation->current = 0;
+  if (index < LABCOMM_USER) {
     result = 0;
+  } else {
+    labcomm2014_scheduler_data_lock(decimating->scheduler);
+    decimation = LABCOMM_SIGNATURE_ARRAY_REF(decimating->memory, 
+                                             decimating->writer_decimation, 
+                                             struct decimation, index);
+    decimation->current++;
+    if (decimation->current < decimation->n) {
+      result = -EALREADY;
+    } else {
+      decimation->current = 0;
+      result = 0;
+    }
+    labcomm2014_scheduler_data_unlock(decimating->scheduler);
   }
-  labcomm_scheduler_data_unlock(decimating->scheduler);
-
   if (result == 0) {
-    result = labcomm_writer_start(w, action_context->next,
+    result = labcomm2014_writer_start(w, action_context->next,
 				 index, signature, value);
   }
   return result;
 }
 
-struct labcomm_writer_action decimating_writer_action = {
+struct labcomm2014_writer_action decimating_writer_action = {
   .alloc = wrap_writer_alloc,
   .free = NULL, 
   .start = wrap_writer_start,
@@ -237,11 +237,11 @@ struct labcomm_writer_action decimating_writer_action = {
 };
 
 struct decimating *decimating_new(
-  struct labcomm_reader *reader,
-  struct labcomm_writer *writer,
-  struct labcomm_error_handler *error,
-  struct labcomm_memory *memory,
-  struct labcomm_scheduler *scheduler)
+  struct labcomm2014_reader *reader,
+  struct labcomm2014_writer *writer,
+  struct labcomm2014_error_handler *error,
+  struct labcomm2014_memory *memory,
+  struct labcomm2014_scheduler *scheduler)
 {
   struct decimating_private *result;
 

examples/twoway/decimating.h

 #ifndef __DECIMATING_H__
 #define __DECIMATING_H__
 
-#include <labcomm.h>
-#include <labcomm_ioctl.h>
+#include <labcomm2014.h>
+#include <labcomm2014_ioctl.h>
 
 struct decimating {
-  struct labcomm_reader *reader;
-  struct labcomm_writer *writer;
+  struct labcomm2014_reader *reader;
+  struct labcomm2014_writer *writer;
 };
 
 extern struct decimating *decimating_new(
-  struct labcomm_reader *reader,
-  struct labcomm_writer *writer,
-  struct labcomm_error_handler *error,
-  struct labcomm_memory *memory,
-  struct labcomm_scheduler *scheduler);
+  struct labcomm2014_reader *reader,
+  struct labcomm2014_writer *writer,
+  struct labcomm2014_error_handler *error,
+  struct labcomm2014_memory *memory,
+  struct labcomm2014_scheduler *scheduler);
 
 #define SET_DECIMATION LABCOMM_IOSW('d',0,int)
 

examples/twoway/decimating_messages.lc

 sample struct {
   int decimation;
   int signature_index;
-} set_decimation;
\ No newline at end of file
+} set_decimation;

examples/twoway/introspecting.c

@@ -23,18 +23,18 @@
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include "labcomm_private.h"
+#include "labcomm2014_private.h"
 #include "introspecting.h"
 #include "gen/introspecting_messages.h"
 
 struct introspecting_private {
   struct introspecting introspecting;
-  struct labcomm_error_handler *error;
-  struct labcomm_memory *memory;
-  struct labcomm_scheduler *scheduler;
+  struct labcomm2014_error_handler *error;
+  struct labcomm2014_memory *memory;
+  struct labcomm2014_scheduler *scheduler;
 
-  struct labcomm_reader_action_context reader_action_context;
-  struct labcomm_writer_action_context writer_action_context;
+  struct labcomm2014_reader_action_context reader_action_context;
+  struct labcomm2014_writer_action_context writer_action_context;
   LABCOMM_SIGNATURE_ARRAY_DEF(remote, 
 			      struct remote {
 				char *name;
@@ -44,13 +44,13 @@ struct introspecting_private {
   LABCOMM_SIGNATURE_ARRAY_DEF(local, 
 			      struct local {
 				enum introspecting_status status;
-				struct labcomm_signature *signature;
+				const struct labcomm2014_signature *signature;
 			      });
 };
 
 static struct local *get_local(struct introspecting_private *introspecting,
 			       int index,
-			       struct labcomm_signature *signature)
+			       const struct labcomm2014_signature *signature)
 {
   /* Called with data_lock held */
   struct local *local;
@@ -91,7 +91,7 @@ static void handles_signature(
   struct introspecting_private *introspecting = context;
   struct remote *remote;
 
-  labcomm_scheduler_data_lock(introspecting->scheduler);
+  labcomm2014_scheduler_data_lock(introspecting->scheduler);
   remote = LABCOMM_SIGNATURE_ARRAY_REF(introspecting->memory,
 				       introspecting->remote, 
 				       struct remote, 
@@ -119,26 +119,25 @@ static void handles_signature(
       }
     }
   }
-  labcomm_scheduler_data_unlock(introspecting->scheduler);
+  labcomm2014_scheduler_data_unlock(introspecting->scheduler);
 }
 
 static int wrap_reader_alloc(
-  struct labcomm_reader *r, 
-  struct labcomm_reader_action_context *action_context, 
-  char *labcomm_version)
+  struct labcomm2014_reader *r, 
+  struct labcomm2014_reader_action_context *action_context)
 {
   struct introspecting_private *introspecting = action_context->context;
 
-  labcomm_decoder_register_introspecting_messages_handles_signature(
+  labcomm2014_decoder_register_introspecting_messages_handles_signature(
     introspecting->introspecting.reader->decoder, 
     handles_signature, introspecting);
-  return labcomm_reader_alloc(r, action_context->next, labcomm_version);
+  return labcomm2014_reader_alloc(r, action_context->next);
 }
 
 struct handles_signature {
   struct introspecting_private *introspecting;
   int index;
-  struct labcomm_signature *signature;
+  const struct labcomm2014_signature *signature;
 };
 
 static void send_handles_signature(void *arg)
@@ -150,14 +149,14 @@ static void send_handles_signature(void *arg)
   handles_signature.name = h->signature->name;
   handles_signature.signature.n_0 = h->signature->size;
   handles_signature.signature.a = h->signature->signature;
-  labcomm_encode_introspecting_messages_handles_signature(
+  labcomm2014_encode_introspecting_messages_handles_signature(
     h->introspecting->introspecting.writer->encoder, &handles_signature);
 }
 
 static int wrap_reader_start(
-  struct labcomm_reader *r, 
-  struct labcomm_reader_action_context *action_context,
-  int local_index, int remote_index, struct labcomm_signature *signature,
+  struct labcomm2014_reader *r, 
+  struct labcomm2014_reader_action_context *action_context,
+  int local_index, int remote_index, const struct labcomm2014_signature *signature,
   void *value)
 {
   struct introspecting_private *introspecting = action_context->context;
@@ -165,23 +164,23 @@ static int wrap_reader_start(
   if (value == NULL) {
     struct handles_signature *handles_signature;
 
-    handles_signature = labcomm_memory_alloc(introspecting->memory, 1,
+    handles_signature = labcomm2014_memory_alloc(introspecting->memory, 1,
 					     sizeof(*handles_signature));
     handles_signature->introspecting = introspecting;
     handles_signature->index = local_index;
     handles_signature->signature = signature;
-    labcomm_scheduler_enqueue(introspecting->scheduler, 
+    labcomm2014_scheduler_enqueue(introspecting->scheduler, 
 			      0, send_handles_signature, handles_signature);
   }
-  return labcomm_reader_start(r, action_context->next, 
+  return labcomm2014_reader_start(r, action_context->next, 
 			      local_index, remote_index, signature, value);
 }
 
  void encode_handles_signature(
-  struct labcomm_encoder *encoder,
+  struct labcomm2014_encoder *encoder,
   void *context)
 {
-  struct labcomm_signature *signature = context;
+  const struct labcomm2014_signature *signature = context;
   introspecting_messages_handles_signature handles_signature;
   int index = 0;
 
@@ -190,11 +189,11 @@ static int wrap_reader_start(
   handles_signature.signature.n_0 = signature->size;
   handles_signature.signature.a = signature->signature;
 
-  labcomm_encode_introspecting_messages_handles_signature(
+  labcomm2014_encode_introspecting_messages_handles_signature(
     NULL, &handles_signature);
 }
 
-struct labcomm_reader_action introspecting_reader_action = {
+struct labcomm2014_reader_action introspecting_reader_action = {
   .alloc = wrap_reader_alloc,
   .free = NULL,
   .start = wrap_reader_start,
@@ -207,45 +206,44 @@ static void register_encoder_signatures(void *context)
 {
   struct introspecting_private *introspecting = context;
 
-  labcomm_encoder_register_introspecting_messages_handles_signature(
+  labcomm2014_encoder_register_introspecting_messages_handles_signature(
     introspecting->introspecting.writer->encoder);
 }
 
 static int wrap_writer_alloc(
-  struct labcomm_writer *w, 
-  struct labcomm_writer_action_context *action_context, 
-  char *labcomm_version)
+  struct labcomm2014_writer *w, 
+  struct labcomm2014_writer_action_context *action_context)
 {
   struct introspecting_private *introspecting = action_context->context;
 
-  labcomm_scheduler_enqueue(introspecting->scheduler, 
+  labcomm2014_scheduler_enqueue(introspecting->scheduler, 
 			    0, register_encoder_signatures, introspecting);
-  return labcomm_writer_alloc(w, action_context->next, labcomm_version);
+  return labcomm2014_writer_alloc(w, action_context->next);
 }
 
 static int wrap_writer_start(
-  struct labcomm_writer *w, 
-  struct labcomm_writer_action_context *action_context, 
-  int index, struct labcomm_signature *signature,
+  struct labcomm2014_writer *w, 
+  struct labcomm2014_writer_action_context *action_context, 
+  int index, const struct labcomm2014_signature *signature,
   void *value)
 {
   struct introspecting_private *introspecting = action_context->context;
 
-  if (value == NULL) {
+  if (index >= LABCOMM_USER && value == NULL) {
     struct local *local;
 
-    labcomm_scheduler_data_lock(introspecting->scheduler);
+    labcomm2014_scheduler_data_lock(introspecting->scheduler);
     local = get_local(introspecting, index, signature);
     local->status = introspecting_registered;
-    labcomm_scheduler_data_unlock(introspecting->scheduler);
+    labcomm2014_scheduler_data_unlock(introspecting->scheduler);
   }
-  return labcomm_writer_start(w, action_context->next, index, signature, value);
+  return labcomm2014_writer_start(w, action_context->next, index, signature, value);
 }
 
 static int wrap_writer_ioctl(
-  struct labcomm_writer *w, 
-  struct labcomm_writer_action_context *action_context, 
-  int index, struct labcomm_signature *signature, 
+  struct labcomm2014_writer *w, 
+  struct labcomm2014_writer_action_context *action_context, 
+  int index, const struct labcomm2014_signature *signature, 
   uint32_t ioctl_action, va_list args)
 {
   struct introspecting_private *introspecting = action_context->context;
@@ -255,20 +253,20 @@ static int wrap_writer_ioctl(
       struct local *local;
       int result;
 
-      labcomm_scheduler_data_lock(introspecting->scheduler);
+      labcomm2014_scheduler_data_lock(introspecting->scheduler);
       local = get_local(introspecting, index, signature);
       result = local->status;
-      labcomm_scheduler_data_unlock(introspecting->scheduler);
+      labcomm2014_scheduler_data_unlock(introspecting->scheduler);
       return result;
     }
     default: {
-      return labcomm_writer_ioctl(w, action_context->next, index, signature, 
+      return labcomm2014_writer_ioctl(w, action_context->next, index, signature, 
 				  ioctl_action, args);  
     } break;
   }
 }
 
-struct labcomm_writer_action introspecting_writer_action = {
+struct labcomm2014_writer_action introspecting_writer_action = {
   .alloc = wrap_writer_alloc,
   .free = NULL, 
   .start = wrap_writer_start,
@@ -278,11 +276,11 @@ struct labcomm_writer_action introspecting_writer_action = {
 };
 
 extern struct introspecting *introspecting_new(
-  struct labcomm_reader *reader,
-  struct labcomm_writer *writer,
-  struct labcomm_error_handler *error,
-  struct labcomm_memory *memory,
-  struct labcomm_scheduler *scheduler)
+  struct labcomm2014_reader *reader,
+  struct labcomm2014_writer *writer,
+  struct labcomm2014_error_handler *error,
+  struct labcomm2014_memory *memory,
+  struct labcomm2014_scheduler *scheduler)
 {
   struct introspecting_private *result;
 

examples/twoway/introspecting.h

@@ -23,22 +23,22 @@
 #ifndef __INTROSPECTING_H__
 #define __INTROSPECTING_H__
 
-#include <labcomm.h>
-#include <labcomm_ioctl.h>
-#include <labcomm_fd_reader.h>
-#include <labcomm_fd_writer.h>
+#include <labcomm2014.h>
+#include <labcomm2014_ioctl.h>
+#include <labcomm2014_fd_reader.h>
+#include <labcomm2014_fd_writer.h>
 
 struct introspecting {
-  struct labcomm_reader *reader;
-  struct labcomm_writer *writer;
+  struct labcomm2014_reader *reader;
+  struct labcomm2014_writer *writer;
 };
 
 extern struct introspecting *introspecting_new(
-  struct labcomm_reader *reader,
-  struct labcomm_writer *writer,
-  struct labcomm_error_handler *error,
-  struct labcomm_memory *memory,
-  struct labcomm_scheduler *scheduler);
+  struct labcomm2014_reader *reader,
+  struct labcomm2014_writer *writer,
+  struct labcomm2014_error_handler *error,
+  struct labcomm2014_memory *memory,
+  struct labcomm2014_scheduler *scheduler);
 
 #define HAS_SIGNATURE LABCOMM_IOS('i',2)
 enum introspecting_status { introspecting_unknown, 

examples/twoway/server.c

@@ -20,7 +20,12 @@
 */
 
 #include <arpa/inet.h>
+#ifndef LABCOMM_OS_DARWIN
 #include <linux/tcp.h>
+#else
+#include <netinet/in.h>
+#include <netinet/tcp.h> 
+#endif
 #include <errno.h>
 #include <pthread.h>
 #include <stdlib.h>
@@ -28,11 +33,11 @@
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <unistd.h>
-#include <labcomm_default_error_handler.h>
-#include <labcomm_default_memory.h>
-#include <labcomm_pthread_scheduler.h>
-#include <labcomm_fd_reader.h>
-#include <labcomm_fd_writer.h>
+#include <labcomm2014_default_error_handler.h>
+#include <labcomm2014_default_memory.h>
+#include <labcomm2014_pthread_scheduler.h>
+#include <labcomm2014_fd_reader.h>
+#include <labcomm2014_fd_writer.h>
 #include "decimating.h"
 #include "introspecting.h"
 #include "gen/types.h"
@@ -44,9 +49,9 @@ struct client {
   struct sockaddr_in adr;
   unsigned int adrlen;
   int32_t A, B, Sum, Diff, Product;
-  struct labcomm_decoder *decoder;
-  struct labcomm_encoder *encoder;
-  struct labcomm_scheduler *scheduler;
+  struct labcomm2014_decoder *decoder;
+  struct labcomm2014_encoder *encoder;
+  struct labcomm2014_scheduler *scheduler;
 };
 
 static void handle_A(int32_t *value, void *context)
@@ -62,22 +67,22 @@ static void handle_B(int32_t *value, void *context)
   int status;
 
   client->B = *value;
-  status = labcomm_encoder_ioctl_types_Product(client->encoder, HAS_SIGNATURE);
+  status = labcomm2014_encoder_ioctl_types_Product(client->encoder, HAS_SIGNATURE);
   switch (status) {
     case introspecting_unregistered:
-      labcomm_encoder_register_types_Product(client->encoder);
+      labcomm2014_encoder_register_types_Product(client->encoder);
       /* fall through */
     case introspecting_registered:
       client->Product = client->A * client->B;
-      labcomm_encode_types_Product(client->encoder, &client->Product);
+      labcomm2014_encode_types_Product(client->encoder, &client->Product);
       break;
     default:
       break;
   }
   client->Sum = client->A + client->B;
   client->Diff = client->A - client->B;
-  labcomm_encode_types_Sum(client->encoder, &client->Sum);
-  labcomm_encode_types_Diff(client->encoder, &client->Diff);
+  labcomm2014_encode_types_Sum(client->encoder, &client->Sum);
+  labcomm2014_encode_types_Diff(client->encoder, &client->Diff);
 }
 
 static void handle_Terminate(types_Terminate *value, void *context)
@@ -90,14 +95,14 @@ static void *run_decoder(void *arg)
   struct client *client = arg;
   int result;
 
-  labcomm_decoder_register_types_A(client->decoder, handle_A, client);
-  labcomm_decoder_register_types_B(client->decoder, handle_B, client);
-  labcomm_decoder_register_types_Terminate(client->decoder, handle_Terminate, 
+  labcomm2014_decoder_register_types_A(client->decoder, handle_A, client);
+  labcomm2014_decoder_register_types_B(client->decoder, handle_B, client);
+  labcomm2014_decoder_register_types_Terminate(client->decoder, handle_Terminate, 
 					   NULL);
   do {
-    result = labcomm_decoder_decode_one(client->decoder);
+    result = labcomm2014_decoder_decode_one(client->decoder);
   } while (result >= 0);
-  labcomm_scheduler_wakeup(client->scheduler);
+  labcomm2014_scheduler_wakeup(client->scheduler);
   return NULL;
 }
 
@@ -110,13 +115,13 @@ static void *run_client(void *arg)
   printf("Client start\n");
   client->A = 0;
   client->B = 0;
-  client->scheduler = labcomm_pthread_scheduler_new(labcomm_default_memory);
-  decimating = decimating_new(labcomm_fd_reader_new(labcomm_default_memory,
+  client->scheduler = labcomm2014_pthread_scheduler_new(labcomm2014_default_memory);
+  decimating = decimating_new(labcomm2014_fd_reader_new(labcomm2014_default_memory,
 						    client->fd, 1),
-			      labcomm_fd_writer_new(labcomm_default_memory,
+			      labcomm2014_fd_writer_new(labcomm2014_default_memory,
 						    client->fd, 0),
-			      labcomm_default_error_handler,
-			      labcomm_default_memory,
+			      labcomm2014_default_error_handler,
+			      labcomm2014_default_memory,
 			      client->scheduler);
   if (decimating == NULL) {
     /* Warning: might leak reader and writer at this point */
@@ -124,26 +129,26 @@ static void *run_client(void *arg)
   }
   introspecting = introspecting_new(decimating->reader,
 				    decimating->writer,
-				    labcomm_default_error_handler,
-				    labcomm_default_memory,
+				    labcomm2014_default_error_handler,
+				    labcomm2014_default_memory,
 				    client->scheduler);
   if (introspecting == NULL) {
     /* Warning: might leak reader and writer at this point */
     goto out;
   }
-  client->decoder = labcomm_decoder_new(introspecting->reader,
-				    labcomm_default_error_handler,
-				    labcomm_default_memory,
+  client->decoder = labcomm2014_decoder_new(introspecting->reader,
+				    labcomm2014_default_error_handler,
+				    labcomm2014_default_memory,
 				    client->scheduler);
-  client->encoder = labcomm_encoder_new(introspecting->writer,
-				    labcomm_default_error_handler,
-				    labcomm_default_memory,
+  client->encoder = labcomm2014_encoder_new(introspecting->writer,
+				    labcomm2014_default_error_handler,
+				    labcomm2014_default_memory,
 				    client->scheduler);
   pthread_t rdt;
   pthread_create(&rdt, NULL, run_decoder, client);  
-  labcomm_encoder_register_types_Sum(client->encoder);
-  labcomm_encoder_register_types_Diff(client->encoder);
-  labcomm_scheduler_sleep(client->scheduler, NULL);
+  labcomm2014_encoder_register_types_Sum(client->encoder);
+  labcomm2014_encoder_register_types_Diff(client->encoder);
+  labcomm2014_scheduler_sleep(client->scheduler, NULL);
   printf("Awoken\n");
   pthread_join(rdt, NULL);
 out:

examples/twoway/types.lc

@@ -3,4 +3,4 @@ sample int B;
 sample int Sum;
 sample int Diff;
 sample int Product;
-sample void Terminate;
\ No newline at end of file
+sample void Terminate;

examples/user_types/.gitignore

+gen
+labcomm2014.dll
+ExampleDecoder.exe
+ExampleEncoder.exe
+encoded_data_c
+encoded_data_cs
+encoded_data_j
+encoded_data_p
+example_decoder
+example_encoder

examples/user_types/Decoder.java

+import java.io.File;
+import java.io.FileInputStream;
+import java.io.InputStream;
+import java.io.IOException;
+
+import se.lth.control.labcomm2014.DecoderChannel;
+import se.lth.control.labcomm2014.TypeDef;
+import se.lth.control.labcomm2014.TypeDefParser;
+import se.lth.control.labcomm2014.SigTypeDef;
+//import se.lth.control.labcomm2014.TypeBinding;
+
+public class Decoder
+  implements twoLines.Handler,
+//             TypeDef.Handler,
+//             TypeBinding.Handler,
+             TypeDefParser.TypeDefListener,
+             twoInts.Handler,
+             theFirstInt.Handler,
+             theSecondInt.Handler,
+             doavoid.Handler,
+             intAndRef.Handler
+{
+
+  private DecoderChannel decoder;
+  private TypeDefParser tdp;
+
+  public Decoder(InputStream in) 
+    throws Exception 
+  {
+    decoder = new DecoderChannel(in);
+    doavoid.register(decoder, this);
+    twoInts.register(decoder, this);
+    twoLines.register(decoder, this);
+    theFirstInt.register(decoder, this);
+    theSecondInt.register(decoder, this);
+    intAndRef.register(decoder, this);
+    doavoid.registerSampleRef(decoder);
+    this.tdp = TypeDefParser.registerTypeDefParser(decoder); 
+ //   TypeDef.register(decoder, this);
+ //   TypeBinding.register(decoder, this);
+
+        
+    tdp.addListener(this);
+    
+    try {
+      System.out.println("Running decoder.");
+      decoder.run();
+    } catch (java.io.EOFException e) {
+	System.out.println("Decoder reached end of file.");
+    }
+  }
+
+  private String genPoint(point p) {
+    return "("+p.x.val+", "+p.y.val+")";
+  }
+
+  private String genLine(line l) {
+    return "Line from "+genPoint(l.start)+" to "+genPoint(l.end);
+  }
+
+//  public void handle_TypeDef(TypeDef d) throws java.io.IOException {
+//    System.out.println("Got TypeDef: "+d.getName()+"("+d.getIndex()+")");
+//  }
+//
+//  public void handle_TypeBinding(TypeBinding d) throws java.io.IOException {
+//    System.out.println("Got TypeBinding: "+d.getSampleIndex()+" --> "+d.getTypeIndex()+"");
+//  }
+
+  public void onTypeDef(SigTypeDef d) {
+    System.out.println("ontype_def: ");
+    if(d != null) {
+        System.out.print((d.isSampleDef()?"sample ":"typedef ")+d);
+        System.out.println(" "+d.getName()+";");
+    } else {
+        System.out.println(" null???");
+    }
+    //for(byte b: d.getSignature()) {
+    //   System.out.print(Integer.toHexString(b)+" ");
+    //}
+    //System.out.println(); 
+    //try {
+    //   tdp.parseSignature(d.getIndex());
+    //} catch(IOException ex) { ex.printStackTrace();}   
+  }
+
+  public void handle_doavoid() throws java.io.IOException {
+    System.out.println("Got a void.");
+  }
+
+  public void handle_twoInts(twoInts d) throws java.io.IOException {
+    System.out.print("Got twoInts: ");
+    System.out.println(d.a +", "+d.b);
+  }
+
+  public void handle_theFirstInt(int d) throws java.io.IOException {
+    System.out.println("Got theFirstInt: "+d);
+  }
+
+  public void handle_theSecondInt(int d) throws java.io.IOException {
+    System.out.println("Got theSecondInt: "+d);
+  }
+
+  public void handle_intAndRef(intAndRef d) throws java.io.IOException {
+    System.out.println("Got intAndRef: "+d.x+", "+d.reference);
+  }
+
+  public void handle_twoLines(twoLines d) throws java.io.IOException {
+    System.out.print("Got twoLines: ");
+    System.out.println("Line l1: "+genLine(d.l1));
+    System.out.println("              Line l2: "+genLine(d.l2));
+  }
+
+
+  public static void main(String[] arg) throws Exception {
+    Decoder example = new Decoder(
+      new FileInputStream(new File(arg[0]))
+    );
+  }
+}
+

examples/user_types/Encoder.java

+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.OutputStream;
+
+import se.lth.control.labcomm2014.EncoderChannel;
+
+/**
+ * Simple encoder 
+ */
+public class Encoder 
+{
+
+  EncoderChannel encoder;
+
+  public Encoder(OutputStream out) 
+    throws Exception 
+  {
+    encoder = new EncoderChannel(out);
+    doavoid.register(encoder);
+    twoInts.register(encoder);
+    twoLines.register(encoder);
+    theFirstInt.register(encoder);
+    theSecondInt.register(encoder);
+    intAndRef.register(encoder);
+    doavoid.registerSampleRef(encoder);
+  }
+
+  public void doEncode() throws java.io.IOException {
+    System.out.println("Encoding doavoid");
+    doavoid.encode(encoder);
+      
+    intAndRef iar = new intAndRef();
+    iar.x = 17;
+    iar.reference = doavoid.class;
+
+    System.out.println("Encoding intAndRef");
+    intAndRef.encode(encoder, iar);
+
+    twoInts ti = new twoInts();
+    ti.a = 12;
+    ti.b = 21;
+
+    System.out.println("Encoding twoInts");
+    twoInts.encode(encoder, ti);
+      
+    System.out.println("Encoding the Ints");
+    theFirstInt.encode(encoder, 71);
+    theSecondInt.encode(encoder, 24);
+
+    twoLines x = new twoLines();
+    line l1 = new line();
+    point p11 = new point();
+    coord c11x = new coord();
+    coord c11y = new coord();
+    c11x.val = 11;
+    c11y.val = 99;
+    p11.x = c11x;
+    p11.y = c11y;
+
+    l1.start = p11;
+    
+    point p12 = new point();
+    coord c12x = new coord();
+    coord c12y = new coord();
+    c12x.val = 22;
+    c12y.val = 88;
+    p12.x = c12x;
+    p12.y = c12y;
+
+    l1.end = p12;
+
+    line l2 = new line();
+    point p21 = new point();
+    coord c21x = new coord();
+    coord c21y = new coord();
+    c21x.val = 17;
+    c21y.val = 42;
+    p21.x = c21x;
+    p21.y = c21y;
+
+    l2.start = p21;
+    
+    point p22 = new point();
+    coord c22x = new coord();
+    coord c22y = new coord();
+    c22x.val = 13;
+    c22y.val = 37;
+    p22.x = c22x;
+    p22.y = c22y;
+
+    l2.end = p22;
+
+    foo f = new foo();
+    f.a = 10;
+    f.b = 20;
+    f.c = false;
+
+    x.l1 = l1;
+    x.l2 = l2;
+    x.f  = f;
+
+    System.out.println("Encoding theTwoLines");
+    twoLines.encode(encoder, x);
+  }
+
+
+  public static void main(String[] arg) throws Exception {
+    FileOutputStream fos = new FileOutputStream(arg[0]);
+    Encoder example = new Encoder(fos);
+    example.doEncode();
+    fos.close();
+  }
+
+}
+

examples/user_types/ExampleDecoder.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.IO;
+using se.lth.control.labcomm2014;
+
+namespace user_types
+{
+    class Decoder : twoLines.Handler, 
+                    twoInts.Handler, 
+                    theFirstInt.Handler, 
+                    theSecondInt.Handler,
+                    doavoid.Handler,
+                    intAndRef.Handler
+    {
+        DecoderChannel dec;
+
+        public Decoder(Stream stream)
+        {
+            dec = new DecoderChannel(stream);
+            twoLines.register(dec, this);
+            twoInts.register(dec, this);
+            theFirstInt.register(dec, this);
+            theSecondInt.register(dec, this);
+            doavoid.register(dec, this);
+            intAndRef.register(dec, this);
+            doavoid.registerSampleRef(dec);
+            try
+            {
+                Console.WriteLine("Running decoder.");
+                dec.run();
+            }
+            catch (EndOfStreamException)
+            {
+                Console.WriteLine("EOF reached");
+            }
+        }
+
+        private string genPoint(point p)
+        {
+            return "(" + p.x.val + ", " + p.y.val + ")";
+        }
+        private String genLine(line l)
+        {
+            return "Line from " + genPoint(l.start) + " to " + genPoint(l.end);
+        }
+        public void handle(twoLines d)
+        {
+            Console.WriteLine("Got twoLines: ");
+            Console.WriteLine("Line l1: "+genLine(d.l1));
+            Console.WriteLine("Line l2: " + genLine(d.l2));
+        }
+
+        public void handle(twoInts d)
+        {
+            Console.WriteLine("Got twoInts: ");
+            Console.WriteLine("a: "+d.a);
+            Console.WriteLine("b: "+d.b);
+        }
+
+        void theFirstInt.Handler.handle(int d)
+        {
+            Console.WriteLine("Got theFirstInt: "+d);
+        }
+
+        void theSecondInt.Handler.handle(int d)
+        {
+            Console.WriteLine("Got theSecondInt: "+d);
+        }
+
+        void doavoid.Handler.handle()
+        {
+            Console.WriteLine("Got a void.");
+        }
+
+        void intAndRef.Handler.handle(intAndRef d)
+        {
+            Console.WriteLine("Got intAndRef: "+d.x+" : "+d.reference);
+        }
+
+        static void Main(string[] args)
+        {
+            new Decoder(new FileStream(args[0], FileMode.Open));
+        }
+    }
+}

examples/user_types/ExampleEncoder.cs

+using System;
+using System.IO;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using se.lth.control.labcomm2014;
+
+namespace user_types
+{
+    public class Encoder
+    {
+        private EncoderChannel enc;
+        public Encoder(Stream stream)
+        {
+            enc = new EncoderChannel(stream);
+            twoLines.register(enc);
+        }
+
+        public void doEncode()
+        {
+            twoLines x = new twoLines();
+            line l1 = new line();
+            point p11 = new point();
+            coord c11x = new coord();
+            coord c11y = new coord();
+            c11x.val = 11;
+            c11y.val = 99;
+            p11.x = c11x;
+            p11.y = c11y;
+
+            l1.start = p11;
+
+            point p12 = new point();
+            coord c12x = new coord();
+            coord c12y = new coord();
+            c12x.val = 22;
+            c12y.val = 88;
+            p12.x = c12x;
+            p12.y = c12y;
+
+            l1.end = p12;
+
+            line l2 = new line();
+            point p21 = new point();
+            coord c21x = new coord();
+            coord c21y = new coord();
+            c21x.val = 17;
+            c21y.val = 42;
+            p21.x = c21x;
+            p21.y = c21y;
+
+            l2.start = p21;
+
+            point p22 = new point();
+            coord c22x = new coord();
+            coord c22y = new coord();
+            c22x.val = 13;
+            c22y.val = 37;
+            p22.x = c22x;
+            p22.y = c22y;
+
+            l2.end = p22;
+
+            foo f = new foo();
+            f.a = 10;
+            f.b = 20;
+            f.c = false;
+
+            x.l1 = l1;
+            x.l2 = l2;
+            x.f = f;
+
+            Console.WriteLine("Encoding theTwoLines");
+            twoLines.encode(enc, x);
+        }
+
+        static void Main(string[] args)
+        {
+            FileStream stream = new FileStream(args[0],FileMode.Create);
+            Encoder example = new Encoder(stream);
+            example.doEncode();
+            stream.Close();
+        }
+    }
+}

examples/user_types/Makefile

+LCDIR=../..
+LCCJAR=${LCDIR}/compiler/labcomm2014_compiler.jar# the LabComm compiler
+LCLJAR=${LCDIR}/lib/java/labcomm2014.jar# the LabComm library
+
+EXECUTABLES=example_encoder example_decoder \
+	    Encoder.class Decoder.class TDDecoder.class \
+	    TestDataType.class \
+	    ExampleEncoder.exe ExampleDecoder.exe
+
+include ${LCDIR}/lib/c/os_compat.mk
+
+GENDIR=gen
+
+.PHONY: all cleanbuild clean distclean build run allall buildcs runwcs runjastadd
+
+all: cleanbuild run
+
+allall: clean build buildcs runwcs
+
+test: allall
+
+###############################################
+### dependencies and parts ####################
+###############################################
+
+LCC=java -jar ${LCCJAR}
+CLASSPATH=.:${LCLJAR}
+
+${LCCJAR} :
+	$MAKE -C ${LCDIR} make-compiler
+
+${LCLJAR} :
+	$MAKE -C ${LCDIR} labcomm2014.jar
+
+
+cleanbuild: clean build
+
+labcomm2014.dll:
+	ln -sf ../../lib/csharp/labcomm2014.dll $@
+
+ExampleEncoder.exe: ExampleEncoder.cs gen/test.cs labcomm2014.dll Makefile
+	mcs -out:$@ $(filter %.cs, $^) -lib:../../lib/csharp/ -r:labcomm2014
+	chmod a+x $@
+
+ExampleDecoder.exe: ExampleDecoder.cs gen/test.cs labcomm2014.dll Makefile
+	mcs -out:$@ $(filter %.cs, $^) -lib:../../lib/csharp/ -r:labcomm2014
+	chmod a+x $@
+
+build : 
+	mkdir -p ${GENDIR}
+	java -jar ${LCDIR}/compiler/labcomm2014_compiler.jar --java=${GENDIR} --c=${GENDIR}/test.c --h=${GENDIR}/test.h  --python=${GENDIR}/test.py --cs=${GENDIR}/test.cs test.lc 
+
+	javac -cp ${LCDIR}/lib/java/labcomm2014.jar:. ${GENDIR}/*.java Encoder.java Decoder.java
+	javac -cp ${LCDIR}/lib/java/labcomm2014.jar:${LCCJAR}:${GENDIR}:. TDDecoder.java
+	javac -cp ${LCDIR}/lib/java/labcomm2014.jar:${LCCJAR}:${GENDIR}:. TestDataType.java
+
+	${CC} ${CFLAGS} ${LDFLAGS} -Wall -Werror -Wno-unused-function \
+	    -I. -I${LCDIR}/lib/c/2014 -L${LCDIR}/lib/c \
+	    -o example_encoder example_encoder.c ${GENDIR}/test.c \
+	    -llabcomm2014 
+
+	${CC} ${CFLAGS} ${LDFLAGS} -Wall -Werror -I . -I ${LCDIR}/lib/c/2014 -L${LCDIR}/lib/c \
+	    -o example_decoder example_decoder.c ${GENDIR}/test.c \
+	    -llabcomm2014 
+
+buildcs: ExampleEncoder.exe ExampleDecoder.exe
+
+run:
+	@echo
+	@echo "********************************************"
+	@echo "***   ************ running example for version 2014   ***"
+	@echo "********************************************"
+	@echo
+
+	@java -cp .:${LCDIR}/lib/java/labcomm2014.jar:${GENDIR} Encoder encoded_data_j
+
+	@echo "************ running Java  decoder: *****************"
+	@java -cp .:${LCDIR}/lib/java/labcomm2014.jar:${GENDIR} Decoder encoded_data_j
+
+	@echo "************ running C decoder: *****************"
+	@${LD_LIBRARY_PATH_NAME}=${LCDIR}/lib/c/ ./example_decoder encoded_data_j
+
+	@echo "************ running python decoder (from wiki_example):"
+	@PYTHONPATH=${LCDIR}/lib/python ../wiki_example/example_decoder.py encoded_data_j LabComm2014
+
+	@echo "************ running python decoder (with handlers):"
+	@PYTHONPATH=${LCDIR}/lib/python:gen:. ./example_handlers.py encoded_data_j LabComm2014
+
+	@echo "************ running C encoder: *****************"
+	@${LD_LIBRARY_PATH_NAME}=${LCDIR}/lib/c/ ./example_encoder encoded_data_c
+
+	@echo "************ running Java  decoder: *****************"
+	@java -cp .:${LCDIR}/lib/java/labcomm2014.jar:${GENDIR} Decoder encoded_data_c
+
+	@echo "************ running C decoder: *****************"
+	@${LD_LIBRARY_PATH_NAME}=${LCDIR}/lib/c/ ./example_decoder encoded_data_c
+
+	@echo "************ running python decoder (from wiki_example):"
+	@PYTHONPATH=${LCDIR}/lib/python ../wiki_example/example_decoder.py encoded_data_c LabComm2014
+
+	@echo "************ running python decoder (with handlers):"
+	@PYTHONPATH=${LCDIR}/lib/python:gen:. ./example_handlers.py encoded_data_j LabComm2014
+
+	@echo "************ running python encoder: *****************"
+	@PYTHONPATH=${LCDIR}/lib/python:${GENDIR} ./example_encoder.py encoded_data_p LabComm2014
+
+	@echo "************ running Java  decoder: *****************"
+	@java -cp .:${LCDIR}/lib/java/labcomm2014.jar:${GENDIR} Decoder encoded_data_p
+
+	@echo "************ running C decoder: *****************"
+	@${LD_LIBRARY_PATH_NAME}=${LCDIR}/lib/c/ ./example_decoder encoded_data_p
+
+	@echo "************ running python decoder (from wiki_example):"
+	PYTHONPATH=${LCDIR}/lib/python ../wiki_example/example_decoder.py encoded_data_p LabComm2014
+
+	@echo "************ running python decoder (with handlers):"
+	@PYTHONPATH=${LCDIR}/lib/python:gen:. ./example_handlers.py encoded_data_j LabComm2014
+
+
+runwcs: build ExampleEncoder.exe ExampleDecoder.exe
+	@echo
+	@echo "********************************************"
+	@echo "***   ************ running example for version 2014   ***"
+	@echo "********************************************"
+	@echo
+
+	@java -cp .:${LCDIR}/lib/java/labcomm2014.jar:${GENDIR} Encoder encoded_data_j
+
+	@echo "************ running Java  decoder: *****************"
+	@java -cp .:${LCDIR}/lib/java/labcomm2014.jar:${GENDIR} Decoder encoded_data_j
+
+	@echo "************ running C decoder: *****************"
+	@${LD_LIBRARY_PATH_NAME}=${LCDIR}/lib/c/ ./example_decoder encoded_data_j
+
+	@echo "************ running python decoder (from wiki_example):"
+	@PYTHONPATH=${LCDIR}/lib/python ../wiki_example/example_decoder.py encoded_data_j LabComm2014
+
+	@echo "************ running C# decoder: *****************"
+	@${LD_LIBRARY_PATH_NAME}=${LCDIR}/lib/c/ mono ./ExampleDecoder.exe encoded_data_j
+
+	@echo "************ running C encoder: *****************"
+	@${LD_LIBRARY_PATH_NAME}=${LCDIR}/lib/c/ ./example_encoder encoded_data_c
+
+	@echo "************ running Java  decoder: *****************"
+	@java -cp .:${LCDIR}/lib/java/labcomm2014.jar:${GENDIR} Decoder encoded_data_c
+
+	@echo "************ running C decoder: *****************"
+	@${LD_LIBRARY_PATH_NAME}=${LCDIR}/lib/c/ ./example_decoder encoded_data_c
+
+	@echo "************ running python decoder (from wiki_example):"
+	@PYTHONPATH=${LCDIR}/lib/python ../wiki_example/example_decoder.py encoded_data_c LabComm2014
+
+	@echo "************ running C# decoder: *****************"
+	@mono ./ExampleDecoder.exe encoded_data_c
+
+	@echo "************ running python encoder: *****************"
+	@PYTHONPATH=${LCDIR}/lib/python:${GENDIR} ./example_encoder.py encoded_data_p LabComm2014
+
+	@echo "************ running Java  decoder: *****************"
+	@java -cp .:${LCDIR}/lib/java/labcomm2014.jar:${GENDIR} Decoder encoded_data_p
+
+	@echo "************ running C decoder: *****************"
+	@${LD_LIBRARY_PATH_NAME}=${LCDIR}/lib/c/ ./example_decoder encoded_data_p
+
+	@echo "************ running C# decoder: *****************"
+	@mono ./ExampleDecoder.exe encoded_data_p
+
+	@echo "************ running python decoder (from wiki_example):"
+	PYTHONPATH=${LCDIR}/lib/python ../wiki_example/example_decoder.py encoded_data_p LabComm2014
+
+	@echo "************ running C# encoder: *****************"
+	@mono ./ExampleEncoder.exe encoded_data_cs
+
+	@echo "************ running Java  decoder: *****************"
+	@java -cp .:${LCDIR}/lib/java/labcomm2014.jar:${GENDIR} Decoder encoded_data_cs
+
+	@echo "************ running C decoder: *****************"
+	@LD_LIBRARY_PATH=${LCDIR}/lib/c/ ./example_decoder encoded_data_cs
+
+	@echo "************ running python decoder (from wiki_example):"
+	@PYTHONPATH=${LCDIR}/lib/python ../wiki_example/example_decoder.py encoded_data_cs LabComm2014
+
+	@echo "************ running C# decoder: *****************"
+	@mono ./ExampleDecoder.exe encoded_data_cs
+
+runjastadd: cleanbuild
+	@echo
+	@echo "********************************************"
+	@echo "***   ************ running example with JastAdd unparsing  ***"
+	@echo "********************************************"
+	@echo
+
+	@java -cp .:${LCDIR}/lib/java/labcomm2014.jar:${GENDIR} Encoder encoded_data_j
+
+	@echo "************ running Java  TypeDefdecoder: *****************"
+	java -cp .:${LCDIR}/lib/java/labcomm2014.jar:${LCCJAR}:${GENDIR} TDDecoder encoded_data_j
+
+rundatatype: cleanbuild
+	@echo
+	@echo "********************************************"
+	@echo "*************** running datatype example ***"
+	@echo "********************************************"
+	@echo
+
+	@java -cp .:${LCDIR}/lib/java/labcomm2014.jar:${GENDIR} TestDataType 
+
+
+clean:
+	rm -rf ${GENDIR}
+
+distclean: clean
+	rm -f ${EXECUTABLES}
+	rm -f encoded_data_c
+	rm -f encoded_data_cs
+	rm -f encoded_data_j
+	rm -f encoded_data_p
+	rm -f labcomm.dll