examples/twoway/client.c

+/*
+  client.c -- LabComm example of using stacked readers/writers.
+
+  Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
+
+  This file is part of LabComm.
+
+  LabComm is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  LabComm is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#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>
+#include <stdlib.h>
+#include <strings.h>
+#include <sys/select.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.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"
+
+static void handle_Sum(int32_t *value, void *context)
+{
+  printf("A+B=%d ", *value);
+}
+
+static void handle_Diff(int32_t *value, void *context)
+{
+  printf("A-B=%d ", *value);
+}
+
+static void handle_Product(int32_t *value, void *context)
+{
+  printf("A*B=%d ", *value);
+}
+
+static void *run_decoder(void *context)
+{
+  struct labcomm2014_decoder *decoder = context;
+  int result;
+
+  labcomm2014_decoder_register_types_Sum(decoder, handle_Sum, NULL);
+  labcomm2014_decoder_register_types_Diff(decoder, handle_Diff, NULL);
+  do {
+    result = labcomm2014_decoder_decode_one(decoder);
+  } while (result >= 0);
+  return NULL;
+}
+
+
+int main(int argc, char *argv[])
+{
+  int fd;
+  struct sockaddr_in adr;
+  int err;
+  struct hostent *host;
+  struct sockaddr_in to;
+  int nodelay;
+  struct decimating *decimating;
+  struct introspecting *introspecting;
+  char *hostname;
+  int port;
+  struct labcomm2014_scheduler *scheduler;
+  struct labcomm2014_decoder *decoder;
+  struct labcomm2014_encoder *encoder;
+  struct labcomm2014_time *next;
+  int32_t i, j;
+
+  hostname = argv[1];
+  port = atoi(argv[2]);
+  
+  fd = socket(PF_INET, SOCK_STREAM, 0);
+  if (fd < 0) {
+    fprintf(stderr, "failed to create socket\n");
+    goto out;
+  }
+  
+  adr.sin_family = AF_INET;
+  adr.sin_port = 0;
+  adr.sin_addr.s_addr = INADDR_ANY;
+  err = bind(fd, (struct sockaddr*)&adr, sizeof(adr));
+  if (err != 0) {
+    fprintf(stderr, "failed to bind socket\n");
+    goto out;
+  }
+      
+  host = gethostbyname(hostname);
+  if (!host) {
+    fprintf(stderr, "failed to lookup %s\n", hostname);
+    goto out;
+  }
+      
+  to.sin_family = AF_INET;
+  to.sin_port = htons(port);
+  bcopy((char*)host->h_addr, (char*)&to.sin_addr, host->h_length);
+  err = connect(fd, (struct sockaddr*)&to, sizeof(to));
+  if (err != 0) {
+    fprintf(stderr, "failed to connect %d@%s\n", port, hostname);
+    goto out;
+  }
+  
+  nodelay = 1;
+  setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &nodelay, sizeof(nodelay));
+  scheduler = labcomm2014_pthread_scheduler_new(labcomm2014_default_memory);
+  decimating = decimating_new(labcomm2014_fd_reader_new(labcomm2014_default_memory, 
+						    fd, 1),
+			      labcomm2014_fd_writer_new(labcomm2014_default_memory, 
+						    fd, 0),
+			      labcomm2014_default_error_handler,
+			      labcomm2014_default_memory,
+			      scheduler);
+  if (decimating == NULL) {
+    /* Warning: might leak reader and writer at this point */
+    goto out;
+  }
+  introspecting = introspecting_new(decimating->reader,
+				    decimating->writer,
+				    labcomm2014_default_error_handler,
+				    labcomm2014_default_memory,
+				    scheduler);
+  if (introspecting == NULL) {
+    /* Warning: might leak reader and writer at this point */
+    goto out;
+  }
+  decoder = labcomm2014_decoder_new(introspecting->reader, 
+				labcomm2014_default_error_handler,
+				labcomm2014_default_memory,
+				scheduler);
+  encoder = labcomm2014_encoder_new(introspecting->writer, 
+				labcomm2014_default_error_handler,
+				labcomm2014_default_memory,
+				scheduler);
+  pthread_t rdt;
+  pthread_create(&rdt, NULL, run_decoder, decoder);  
+  labcomm2014_encoder_register_types_A(encoder);
+  labcomm2014_encoder_register_types_B(encoder);
+  labcomm2014_encoder_register_types_Terminate(encoder);
+
+  err = labcomm2014_decoder_ioctl_types_Sum(decoder, SET_DECIMATION, 2);
+  err = labcomm2014_decoder_ioctl_types_Diff(decoder, SET_DECIMATION, 4);
+
+  next = labcomm2014_scheduler_now(scheduler);
+  for (i = 0 ; i < 4 ; i++) {
+    if (i == 2) {
+      labcomm2014_decoder_register_types_Product(decoder, handle_Product, NULL);
+    }
+    for (j = 0 ; j < 4 ; j++) {
+      printf("\nA=%d B=%d: ", i, j);
+      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");
+  labcomm2014_encode_types_Terminate(encoder);
+out:
+  return 0;
+  
+}
+

examples/twoway/decimating.c

+/*
+  decimating.c -- LabComm example of a twoway stacked decimation 
+                  reader/writer.
+
+  Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
+
+  This file is part of LabComm.
+
+  LabComm is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  LabComm is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "labcomm2014_private.h"
+#include "decimating.h"
+#include "gen/decimating_messages.h"
+
+struct decimating_private {
+  struct decimating decimating;
+  struct labcomm2014_error_handler *error;
+  struct labcomm2014_memory *memory;
+  struct labcomm2014_scheduler *scheduler;
+  int encoder_initialized;
+  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;
+				int current;
+			      });
+  LABCOMM_SIGNATURE_ARRAY_DEF(reader_decimation, int);
+};
+
+static void set_decimation(
+  decimating_messages_set_decimation *value,
+  void * context)
+{
+  struct decimating_private *decimating = context;
+  struct decimation *decimation;
+
+  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;
+  labcomm2014_scheduler_data_unlock(decimating->scheduler);
+}
+
+static int wrap_reader_alloc(
+  struct labcomm2014_reader *r, 
+  struct labcomm2014_reader_action_context *action_context)
+{
+  struct decimating_private *decimating = action_context->context;
+  
+  labcomm2014_decoder_register_decimating_messages_set_decimation(
+    r->decoder, set_decimation, decimating);
+  return labcomm2014_reader_alloc(r, action_context->next);
+}
+
+struct send_set_decimation {
+  struct decimating_private *decimating;
+  decimating_messages_set_decimation set_decimation;
+
+};
+
+static void send_set_decimation(void *arg)
+{
+  struct send_set_decimation *msg = arg;
+  struct labcomm2014_memory *memory = msg->decimating->memory;
+
+  labcomm2014_encode_decimating_messages_set_decimation(
+    msg->decimating->decimating.writer->encoder, &msg->set_decimation);
+  labcomm2014_memory_free(memory, 1, msg);
+}
+
+static void enqueue_decimation(struct decimating_private *decimating,
+			       int remote_index, 
+			       int amount) 
+{
+  struct send_set_decimation *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;
+    
+    labcomm2014_scheduler_enqueue(decimating->scheduler, 0, 
+			      send_set_decimation, msg);
+  }
+}
+
+static int wrap_reader_start(
+  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;
+
+  if (value == NULL) {
+    int *decimation, amount;
+    
+    labcomm2014_scheduler_data_lock(decimating->scheduler);
+    decimation = LABCOMM_SIGNATURE_ARRAY_REF(decimating->memory,
+					     decimating->reader_decimation, 
+					     int,
+					     local_index);
+    amount = *decimation;
+    labcomm2014_scheduler_data_unlock(decimating->scheduler);
+    if (remote_index != 0 && amount != 0) {
+      enqueue_decimation(decimating, remote_index, amount);
+    }
+  }
+  return labcomm2014_reader_start(r, action_context->next, 
+                              local_index, remote_index, signature, value);
+}
+
+static int wrap_reader_ioctl(
+  struct labcomm2014_reader *r,   
+  struct labcomm2014_reader_action_context *action_context,
+  int local_index, int remote_index,
+  const struct labcomm2014_signature *signature, 
+  uint32_t action, va_list args)
+{
+  struct decimating_private *decimating = action_context->context;
+
+  if (action == SET_DECIMATION) {
+    va_list va;
+    int amount;
+    int *decimation;
+
+    va_copy(va, args);
+    amount = va_arg(va, int);
+    va_end(va);
+   
+    labcomm2014_scheduler_data_lock(decimating->scheduler);
+    decimation = LABCOMM_SIGNATURE_ARRAY_REF(decimating->memory,
+					     decimating->reader_decimation, 
+					     int,
+					     local_index);
+    *decimation = amount;
+    labcomm2014_scheduler_data_unlock(decimating->scheduler);
+    if (remote_index) {
+      enqueue_decimation(decimating, remote_index, amount);
+    }
+    
+  } else {
+    return labcomm2014_reader_ioctl(r, action_context->next,
+				local_index, remote_index, signature, 
+				action, args);
+  }
+  return 0;
+}
+
+struct labcomm2014_reader_action decimating_reader_action = {
+  .alloc = wrap_reader_alloc,
+  .free = NULL,
+  .start = wrap_reader_start,
+  .end = NULL,
+  .fill = NULL,
+  .ioctl = wrap_reader_ioctl
+};
+
+static void register_signatures(void *context)
+{
+  struct decimating_private *decimating = context;
+
+  labcomm2014_encoder_register_decimating_messages_set_decimation(
+    decimating->decimating.writer->encoder);
+}
+
+static int wrap_writer_alloc(
+  struct labcomm2014_writer *w, 
+  struct labcomm2014_writer_action_context *action_context)
+{
+  struct decimating_private *decimating = action_context->context;
+
+  labcomm2014_scheduler_enqueue(decimating->scheduler, 
+			    0, register_signatures, decimating);
+  return labcomm2014_writer_alloc(w, action_context->next);
+}
+
+static int wrap_writer_start(
+  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;
+
+  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);
+  }
+  if (result == 0) {
+    result = labcomm2014_writer_start(w, action_context->next,
+				 index, signature, value);
+  }
+  return result;
+}
+
+struct labcomm2014_writer_action decimating_writer_action = {
+  .alloc = wrap_writer_alloc,
+  .free = NULL, 
+  .start = wrap_writer_start,
+  .end = NULL,
+  .flush = NULL,
+  .ioctl = NULL
+};
+
+struct decimating *decimating_new(
+  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;
+
+  result = malloc(sizeof(*result));
+  if (result == NULL) {
+    goto out_fail;
+  }
+
+  /* Wrap reader and writer */
+  result->reader_action_context.next = reader->action_context;
+  result->reader_action_context.action = &decimating_reader_action;
+  result->reader_action_context.context = result;
+  reader->action_context = &result->reader_action_context;
+
+  result->writer_action_context.next = writer->action_context;
+  result->writer_action_context.action = &decimating_writer_action;
+  result->writer_action_context.context = result;
+  writer->action_context = &result->writer_action_context;
+
+  /* Init visible result struct */
+  result->decimating.reader = reader;
+  result->decimating.writer = writer;
+
+  /* Init other fields */
+  result->error = error;
+  result->memory = memory;
+  result->scheduler = scheduler;
+  LABCOMM_SIGNATURE_ARRAY_INIT(result->writer_decimation, struct decimation);
+  LABCOMM_SIGNATURE_ARRAY_INIT(result->reader_decimation, int);
+
+  goto out_ok;
+
+out_fail:
+  return NULL;
+
+out_ok:
+  return &result->decimating;
+}
+
+

examples/twoway/decimating.h

+#ifndef __DECIMATING_H__
+#define __DECIMATING_H__
+
+#include <labcomm2014.h>
+#include <labcomm2014_ioctl.h>
+
+struct decimating {
+  struct labcomm2014_reader *reader;
+  struct labcomm2014_writer *writer;
+};
+
+extern struct decimating *decimating_new(
+  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)
+
+#endif

examples/twoway/decimating_messages.lc

+sample struct {
+  int decimation;
+  int signature_index;
+} set_decimation;

examples/twoway/introspecting.c

+/*
+  introspecting.c -- LabComm example of a twoway stacked introspection 
+                     reader/writer.
+
+  Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
+
+  This file is part of LabComm.
+
+  LabComm is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  LabComm is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "labcomm2014_private.h"
+#include "introspecting.h"
+#include "gen/introspecting_messages.h"
+
+struct introspecting_private {
+  struct introspecting introspecting;
+  struct labcomm2014_error_handler *error;
+  struct labcomm2014_memory *memory;
+  struct labcomm2014_scheduler *scheduler;
+
+  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;
+				int size;
+				uint8_t *signature;
+			      });
+  LABCOMM_SIGNATURE_ARRAY_DEF(local, 
+			      struct local {
+				enum introspecting_status status;
+				const struct labcomm2014_signature *signature;
+			      });
+};
+
+static struct local *get_local(struct introspecting_private *introspecting,
+			       int index,
+			       const struct labcomm2014_signature *signature)
+{
+  /* Called with data_lock held */
+  struct local *local;
+  
+  local = LABCOMM_SIGNATURE_ARRAY_REF(introspecting->memory,
+				      introspecting->local, 
+				      struct local, 
+				      index);
+  if (local->signature == NULL) {
+    local->signature = signature;
+    local->status = introspecting_unknown;
+  }  
+  if (local->status == introspecting_unknown) {
+    int i;
+
+    local->status = introspecting_unhandled;
+    LABCOMM_SIGNATURE_ARRAY_FOREACH(introspecting->remote, struct remote, i) {
+      struct remote *r;
+      
+      r = LABCOMM_SIGNATURE_ARRAY_REF(introspecting->memory,
+				      introspecting->remote, struct remote, i);
+      if (r->name && 
+	  strcmp(signature->name, r->name) == 0 &&
+	  r->size == signature->size &&
+	  memcmp(signature->signature, r->signature, signature->size) == 0) {
+	local->status = introspecting_unregistered;
+	break;
+      }
+    }
+  }
+  return local;
+}
+
+static void handles_signature(
+  introspecting_messages_handles_signature *value,
+  void * context)
+{
+  struct introspecting_private *introspecting = context;
+  struct remote *remote;
+
+  labcomm2014_scheduler_data_lock(introspecting->scheduler);
+  remote = LABCOMM_SIGNATURE_ARRAY_REF(introspecting->memory,
+				       introspecting->remote, 
+				       struct remote, 
+				       value->index);
+  remote->name = strdup(value->name);
+  remote->signature = malloc(value->signature.n_0);
+  if (remote->signature) {
+    int i;
+
+    memcpy(remote->signature, value->signature.a, value->signature.n_0);
+    remote->size = value->signature.n_0;
+    LABCOMM_SIGNATURE_ARRAY_FOREACH(introspecting->local, struct local, i) {
+      struct local *l;
+      
+      l = LABCOMM_SIGNATURE_ARRAY_REF(introspecting->memory,
+				      introspecting->local, struct local, i);
+      if (l->signature && 
+	  l->status == introspecting_unhandled &&
+	  l->signature->name && 
+	  strcmp(remote->name, l->signature->name) == 0 &&
+	  remote->size == l->signature->size &&
+	  memcmp(l->signature->signature, remote->signature, 
+		 l->signature->size) == 0) {
+	l->status = introspecting_unregistered;
+      }
+    }
+  }
+  labcomm2014_scheduler_data_unlock(introspecting->scheduler);
+}
+
+static int wrap_reader_alloc(
+  struct labcomm2014_reader *r, 
+  struct labcomm2014_reader_action_context *action_context)
+{
+  struct introspecting_private *introspecting = action_context->context;
+
+  labcomm2014_decoder_register_introspecting_messages_handles_signature(
+    introspecting->introspecting.reader->decoder, 
+    handles_signature, introspecting);
+  return labcomm2014_reader_alloc(r, action_context->next);
+}
+
+struct handles_signature {
+  struct introspecting_private *introspecting;
+  int index;
+  const struct labcomm2014_signature *signature;
+};
+
+static void send_handles_signature(void *arg)
+{
+  struct handles_signature *h = arg;
+
+  introspecting_messages_handles_signature handles_signature;
+  handles_signature.index = h->index;
+  handles_signature.name = h->signature->name;
+  handles_signature.signature.n_0 = h->signature->size;
+  handles_signature.signature.a = h->signature->signature;
+  labcomm2014_encode_introspecting_messages_handles_signature(
+    h->introspecting->introspecting.writer->encoder, &handles_signature);
+}
+
+static int wrap_reader_start(
+  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;
+  
+  if (value == NULL) {
+    struct handles_signature *handles_signature;
+
+    handles_signature = labcomm2014_memory_alloc(introspecting->memory, 1,
+					     sizeof(*handles_signature));
+    handles_signature->introspecting = introspecting;
+    handles_signature->index = local_index;
+    handles_signature->signature = signature;
+    labcomm2014_scheduler_enqueue(introspecting->scheduler, 
+			      0, send_handles_signature, handles_signature);
+  }
+  return labcomm2014_reader_start(r, action_context->next, 
+			      local_index, remote_index, signature, value);
+}
+
+ void encode_handles_signature(
+  struct labcomm2014_encoder *encoder,
+  void *context)
+{
+  const struct labcomm2014_signature *signature = context;
+  introspecting_messages_handles_signature handles_signature;
+  int index = 0;
+
+  handles_signature.index = index;
+  handles_signature.name = signature->name;
+  handles_signature.signature.n_0 = signature->size;
+  handles_signature.signature.a = signature->signature;
+
+  labcomm2014_encode_introspecting_messages_handles_signature(
+    NULL, &handles_signature);
+}
+
+struct labcomm2014_reader_action introspecting_reader_action = {
+  .alloc = wrap_reader_alloc,
+  .free = NULL,
+  .start = wrap_reader_start,
+  .end = NULL,
+  .fill = NULL,
+  .ioctl = NULL
+};
+
+static void register_encoder_signatures(void *context)
+{
+  struct introspecting_private *introspecting = context;
+
+  labcomm2014_encoder_register_introspecting_messages_handles_signature(
+    introspecting->introspecting.writer->encoder);
+}
+
+static int wrap_writer_alloc(
+  struct labcomm2014_writer *w, 
+  struct labcomm2014_writer_action_context *action_context)
+{
+  struct introspecting_private *introspecting = action_context->context;
+
+  labcomm2014_scheduler_enqueue(introspecting->scheduler, 
+			    0, register_encoder_signatures, introspecting);
+  return labcomm2014_writer_alloc(w, action_context->next);
+}
+
+static int wrap_writer_start(
+  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 (index >= LABCOMM_USER && value == NULL) {
+    struct local *local;
+
+    labcomm2014_scheduler_data_lock(introspecting->scheduler);
+    local = get_local(introspecting, index, signature);
+    local->status = introspecting_registered;
+    labcomm2014_scheduler_data_unlock(introspecting->scheduler);
+  }
+  return labcomm2014_writer_start(w, action_context->next, index, signature, value);
+}
+
+static int wrap_writer_ioctl(
+  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;
+
+  switch (ioctl_action) {
+    case HAS_SIGNATURE: {
+      struct local *local;
+      int result;
+
+      labcomm2014_scheduler_data_lock(introspecting->scheduler);
+      local = get_local(introspecting, index, signature);
+      result = local->status;
+      labcomm2014_scheduler_data_unlock(introspecting->scheduler);
+      return result;
+    }
+    default: {
+      return labcomm2014_writer_ioctl(w, action_context->next, index, signature, 
+				  ioctl_action, args);  
+    } break;
+  }
+}
+
+struct labcomm2014_writer_action introspecting_writer_action = {
+  .alloc = wrap_writer_alloc,
+  .free = NULL, 
+  .start = wrap_writer_start,
+  .end = NULL,
+  .flush = NULL,
+  .ioctl = wrap_writer_ioctl
+};
+
+extern struct introspecting *introspecting_new(
+  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;
+
+  result = malloc(sizeof(*result));
+  if (result == NULL) {
+    goto out_fail;
+  }
+
+  /* Wrap reader and writer */
+  result->reader_action_context.next = reader->action_context;
+  result->reader_action_context.action = &introspecting_reader_action;
+  result->reader_action_context.context = result;
+  reader->action_context = &result->reader_action_context;
+
+  result->writer_action_context.next = writer->action_context;
+  result->writer_action_context.action = &introspecting_writer_action;
+  result->writer_action_context.context = result;
+  writer->action_context = &result->writer_action_context;
+
+  /* Init visible result struct */
+  result->introspecting.reader = reader;
+  result->introspecting.writer = writer;
+
+  /* Init other fields */
+  result->error = error;
+  result->memory = memory;
+  result->scheduler = scheduler;
+  LABCOMM_SIGNATURE_ARRAY_INIT(result->remote, struct remote);
+  LABCOMM_SIGNATURE_ARRAY_INIT(result->local, struct local);
+
+  goto out_ok;
+
+out_fail:
+  return NULL;
+
+out_ok:
+  return &result->introspecting;
+}
+
+

examples/twoway/introspecting.h

+/*
+  introspecting.h -- LabComm example of a twoway stacked introspection 
+                     reader/writer.
+
+  Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
+
+  This file is part of LabComm.
+
+  LabComm is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  LabComm is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __INTROSPECTING_H__
+#define __INTROSPECTING_H__
+
+#include <labcomm2014.h>
+#include <labcomm2014_ioctl.h>
+#include <labcomm2014_fd_reader.h>
+#include <labcomm2014_fd_writer.h>
+
+struct introspecting {
+  struct labcomm2014_reader *reader;
+  struct labcomm2014_writer *writer;
+};
+
+extern struct introspecting *introspecting_new(
+  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, 
+			    introspecting_unhandled, 
+			    introspecting_unregistered, 
+			    introspecting_registered };
+#endif

examples/twoway/introspecting_messages.lc

+sample struct {
+  int index;
+  string name;
+  byte signature[_];
+} handles_signature;

examples/twoway/server.c

+/*
+  server.c -- LabComm example of using stacked readers/writers.
+
+  Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
+
+  This file is part of LabComm.
+
+  LabComm is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  LabComm is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#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>
+#include <stdio.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.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"
+
+struct client {
+  int fd;
+  pthread_t main_thread;
+  pthread_t decoder_thread;
+  struct sockaddr_in adr;
+  unsigned int adrlen;
+  int32_t A, B, Sum, Diff, Product;
+  struct labcomm2014_decoder *decoder;
+  struct labcomm2014_encoder *encoder;
+  struct labcomm2014_scheduler *scheduler;
+};
+
+static void handle_A(int32_t *value, void *context)
+{
+  struct client *client = context;
+
+  client->A = *value;
+}
+
+static void handle_B(int32_t *value, void *context)
+{
+  struct client *client = context;
+  int status;
+
+  client->B = *value;
+  status = labcomm2014_encoder_ioctl_types_Product(client->encoder, HAS_SIGNATURE);
+  switch (status) {
+    case introspecting_unregistered:
+      labcomm2014_encoder_register_types_Product(client->encoder);
+      /* fall through */
+    case introspecting_registered:
+      client->Product = client->A * client->B;
+      labcomm2014_encode_types_Product(client->encoder, &client->Product);
+      break;
+    default:
+      break;
+  }
+  client->Sum = client->A + client->B;
+  client->Diff = client->A - client->B;
+  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)
+{
+  exit(0);
+}
+
+static void *run_decoder(void *arg)
+{
+  struct client *client = arg;
+  int result;
+
+  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 = labcomm2014_decoder_decode_one(client->decoder);
+  } while (result >= 0);
+  labcomm2014_scheduler_wakeup(client->scheduler);
+  return NULL;
+}
+
+static void *run_client(void *arg) 
+{
+  struct client *client = arg;
+  struct decimating *decimating;
+  struct introspecting *introspecting;
+
+  printf("Client start\n");
+  client->A = 0;
+  client->B = 0;
+  client->scheduler = labcomm2014_pthread_scheduler_new(labcomm2014_default_memory);
+  decimating = decimating_new(labcomm2014_fd_reader_new(labcomm2014_default_memory,
+						    client->fd, 1),
+			      labcomm2014_fd_writer_new(labcomm2014_default_memory,
+						    client->fd, 0),
+			      labcomm2014_default_error_handler,
+			      labcomm2014_default_memory,
+			      client->scheduler);
+  if (decimating == NULL) {
+    /* Warning: might leak reader and writer at this point */
+    goto out;
+  }
+  introspecting = introspecting_new(decimating->reader,
+				    decimating->writer,
+				    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 = labcomm2014_decoder_new(introspecting->reader,
+				    labcomm2014_default_error_handler,
+				    labcomm2014_default_memory,
+				    client->scheduler);
+  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);  
+  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:
+  printf("Client end\n");
+  shutdown(client->fd, SHUT_RDWR);
+  close(client->fd);
+  free(client);
+  return NULL;
+}
+
+int main(int argc, char *argv[])
+{
+  int fd;
+  int result = 0;
+  int reuse;
+  int port;
+  struct sockaddr_in adr;
+  
+  port = atoi(argv[1]);
+  fd = socket(PF_INET, SOCK_STREAM, 0);
+  if (fd < 0) {
+    result = errno;
+    goto no_server_socket;
+  }
+  reuse = 1;
+  setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));
+
+  adr.sin_family = AF_INET;
+  adr.sin_port = htons(port);
+  adr.sin_addr.s_addr = INADDR_ANY;
+  if (bind(fd, (struct sockaddr*)&adr, sizeof(adr)) != 0) {
+    result = errno;
+    goto failed_to_bind;
+  }
+  if (listen(fd, 5) != 0) {
+    result = errno;
+    goto failed_to_listen;
+  }
+  while (1) {
+    struct client *client;
+    int nodelay;
+
+    client = malloc(sizeof(*client));
+    if (client == NULL) {
+      result = errno;
+      goto failed_to_alloc_client;
+    }
+    client->adr.sin_family = AF_INET;
+    client->adr.sin_port = 0;
+    client->adr.sin_addr.s_addr = INADDR_ANY;
+    client->adrlen = sizeof(client->adr);
+    client->fd = accept(fd,  (struct sockaddr*)&client->adr, &client->adrlen); 
+    if (client->fd < 0) {
+      result = errno;
+      goto failed_to_accept;
+    }
+    nodelay = 1;
+    setsockopt(client->fd, IPPROTO_TCP, TCP_NODELAY, &nodelay, sizeof(nodelay));
+    pthread_create(&client->main_thread, NULL, run_client, client);
+  } 
+
+failed_to_alloc_client:
+failed_to_accept:
+failed_to_listen: 
+failed_to_bind:
+  close(fd);
+no_server_socket:
+  return result;
+  
+}
+

examples/twoway/types.lc

+sample int A;
+sample int B;
+sample int Sum;
+sample int Diff;
+sample int Product;
+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

examples/user_types/TDDecoder.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.ParsedSampleDef;
+import se.lth.control.labcomm2014.ASTbuilder;
+//import se.lth.control.labcomm2014.TypeBinding;
+import se.lth.control.labcomm2014.DataType;
+
+import se.lth.control.labcomm2014.compiler.Specification;
+import java.io.FileOutputStream;
+import java.io.PrintStream;
+
+import java.util.Vector;
+import java.util.LinkedList;
+import java.util.Iterator;
+
+
+public class TDDecoder
+  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 TDDecoder(InputStream in) 
+    throws Exception 
+  {
+    decoder = new DecoderChannel(in);
+    twoInts.register(decoder, this);
+    twoLines.register(decoder, this);
+    theFirstInt.register(decoder, this);
+    theSecondInt.register(decoder, this);
+    doavoid.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) {
+    if(d != null && d.isSampleDef()){
+        System.out.println("onTypeDef (sample): ");
+        //------------
+        try {
+            System.out.println("==================== DataType ======");
+            DataType.printDataType(System.out, d);
+            System.out.println();
+            System.out.println("==================== end ======");
+        } catch (IOException ioe) {
+            ioe.printStackTrace();
+        }
+        ASTbuilder v = new ASTbuilder();
+        Specification p = v.makeSpecification((ParsedSampleDef) d);
+        try {
+                FileOutputStream f = new FileOutputStream("/tmp/foopp"+d.getName()+".txt");
+                PrintStream out = new PrintStream(f);
+                p.pp(System.out);
+                //p.C_genC(System.out, new Vector(), "lcname", "prefix", 2014);
+                p.J_gen(out, "testpackage", 2014);
+                out.close();
+
+
+        } catch (Throwable e) {
+                System.err.println("Exception: " + e);
+                e.printStackTrace();
+        }
+    }
+    //System.out.println(" "+d.getName()+";");
+    //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_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_doavoid() throws java.io.IOException {
+    System.out.println("Got a void.");
+  }
+
+  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 {
+    TDDecoder example = new TDDecoder(
+      new FileInputStream(new File(arg[0]))
+    );
+  }
+}
+

examples/user_types/TestDataType.java

+import java.io.PrintStream;
+
+import se.lth.control.labcomm2014.*;
+
+/**
+ * Test data type tree
+ */
+public class TestDataType
+{
+
+  private PrintStream out;
+  public TestDataType(PrintStream out)
+    throws Exception
+  {
+      this.out = out;
+  }
+
+  public void doTest() throws java.io.IOException {
+    twoLines x = new twoLines();
+    DataType.printDataType(out, x.getDispatcher());
+
+    twoStructsAndInt y = new twoStructsAndInt();
+    DataType.printDataType(out, y.getDispatcher());
+
+    theFirstInt z = new theFirstInt();
+    DataType.printDataType(out, z.getDispatcher());
+
+    doavoid a = new doavoid();
+    DataType.printDataType(out, a.getDispatcher());
+
+  }
+
+  public static void main(String[] arg) throws Exception {
+    TestDataType example = new TestDataType(System.out);
+    example.doTest();
+  }
+
+}
+

examples/user_types/example_decoder.c

+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <labcomm2014_fd_reader.h>
+#include <labcomm2014_default_error_handler.h>
+#include <labcomm2014_default_memory.h>
+#include <labcomm2014_default_scheduler.h>
+#include "gen/test.h"
+#include <stdio.h>
+
+static void handle_test_doavoid(test_doavoid *v,void *context) {
+  printf("Got a void.\n"); 
+}
+
+static void handle_test_intAndRef(test_intAndRef *v,void *context) {
+  printf("Got intAndRef. (%d : %p) \n", v->x, v->reference); 
+}
+
+static void handle_test_twoInts(test_twoInts *v,void *context) {
+  printf("Got twoInts. (%d,%d) \n", v->a, v->b); 
+}
+
+static void handle_test_theFirstInt(int *v,void *context) {
+  printf("Got theFirstInt. (%d) \n", *v); 
+}
+
+static void handle_test_theSecondInt(int *v,void *context) {
+  printf("Got theSecondInt. (%d) \n", *v); 
+}
+
+static void handle_type_def(struct labcomm2014_raw_type_def *v,void *context) {
+  printf("Got type_def. (0x%x) %s\n", v->index, v->name); 
+}
+
+static void handle_type_binding(struct labcomm2014_type_binding *v,void *context) {
+  printf("Got type binding. 0x%x --> 0x%x\n", v->sample_index, v->type_index); 
+}
+
+static void handle_test_twoLines(test_twoLines *v,void *context) {
+  printf("Got twoLines. (%d,%d) -> (%d,%d), (%d,%d) -> (%d,%d)\n", v->l1.start.x.val, v->l1.start.y.val, 
+                                                                     v->l1.end.x.val, v->l1.end.y.val,    
+                                                                     v->l2.start.x.val, v->l2.start.y.val,
+                                                                     v->l2.end.x.val, v->l2.end.y.val);    
+}
+
+int main(int argc, char *argv[]) {
+  int fd;
+  struct labcomm2014_decoder *decoder;
+  void  *context = NULL;
+
+  char *filename = argv[1];
+  printf("C decoder reading from %s\n", filename);
+  fd = open(filename, O_RDONLY);
+  decoder = labcomm2014_decoder_new(labcomm2014_fd_reader_new(
+				  labcomm2014_default_memory, fd, 1), 
+				labcomm2014_default_error_handler, 
+				labcomm2014_default_memory,
+				labcomm2014_default_scheduler);
+  if (!decoder) { 
+    printf("Failed to allocate decoder %s:%d\n", __FUNCTION__, __LINE__);
+    return 1;
+  }
+
+  labcomm2014_decoder_register_test_doavoid(decoder, handle_test_doavoid, context);
+  labcomm2014_decoder_register_test_intAndRef(decoder, handle_test_intAndRef, context);
+  labcomm2014_decoder_sample_ref_register(decoder,labcomm2014_signature_test_doavoid );
+
+  labcomm2014_decoder_register_test_twoInts(decoder, handle_test_twoInts, context);
+  labcomm2014_decoder_register_test_theFirstInt(decoder, handle_test_theFirstInt, context);
+  labcomm2014_decoder_register_test_theSecondInt(decoder, handle_test_theSecondInt, context);
+  labcomm2014_decoder_register_test_twoLines(decoder, handle_test_twoLines, context);
+  labcomm2014_decoder_register_labcomm2014_type_def(decoder, handle_type_def, context);
+  labcomm2014_decoder_register_labcomm2014_type_binding(decoder, handle_type_binding, context);
+
+  printf("Decoding:\n");
+  labcomm2014_decoder_run(decoder);
+  printf("--- End Of File ---:\n");
+  labcomm2014_decoder_free(decoder);
+
+  return 0;
+}

examples/user_types/example_encoder.c

+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <labcomm2014_fd_writer.h>
+#include <labcomm2014_default_error_handler.h>
+#include <labcomm2014_default_memory.h>
+#include <labcomm2014_default_scheduler.h>
+#include "gen/test.h"
+#include <stdio.h>
+
+int main(int argc, char *argv[]) {
+  int fd;
+  struct labcomm2014_encoder *encoder;
+
+  char *filename = argv[1];
+  printf("C encoder writing to %s\n", filename);
+  fd = open(filename, O_WRONLY|O_CREAT|O_TRUNC, 0644);
+  encoder = labcomm2014_encoder_new(labcomm2014_fd_writer_new(
+				  labcomm2014_default_memory, fd, 1), 
+				labcomm2014_default_error_handler, 
+				labcomm2014_default_memory,
+				labcomm2014_default_scheduler);
+  labcomm2014_encoder_register_test_twoLines(encoder);
+
+  test_twoLines tl;
+
+  tl.l1.start.x.val = 11;
+  tl.l1.start.y.val = 13;
+  tl.l1.end.x.val = 21;
+  tl.l1.end.y.val = 23;
+  tl.l2.start.x.val = 11;
+  tl.l2.start.y.val = 13;
+  tl.l2.end.x.val = 21;
+  tl.l2.end.y.val = 23;
+ 
+  printf("Encoding twoLines...\n");
+  labcomm2014_encode_test_twoLines(encoder, &tl);
+
+  return 0;
+}

examples/user_types/example_encoder.py

+#!/usr/bin/python
+
+import labcomm2014
+import sys
+import test
+
+if __name__ == '__main__':
+    version = sys.argv[2] if len(sys.argv) == 3 else "LabComm2014"
+    encoder = labcomm2014.Encoder(labcomm2014.StreamWriter(open(sys.argv[1], 'w')), version)
+    encoder.add_decl(test.twoLines.signature)
+    tl = {
+        (('','l1'),):{
+            (('','start'),):{
+                (('','x'),):{(('','val'),):1},
+                (('','y'),):{(('','val'),):11}
+            },
+            (('','end'),):{
+                (('','x'),):{(('','val'),):2},
+                (('','y'),):{(('','val'),):22}
+            }
+        },
+        (('','l2'),):{
+            (('','start'),):{
+                (('','x'),):{(('','val'),):3},
+                (('','y'),):{(('','val'),):33}
+            },
+            (('','end'),):{
+                (('','x'),):{(('','val'),):4},
+                (('','y'),):{(('','val'),):44}
+            }
+        },
+        (('','f'),):{
+            (('','a'),):10,
+            (('','b'),):20,
+            (('','c'),):False
+        }
+    }
+    encoder.encode(tl, test.twoLines.signature)