lib/c/2014/labcomm2014.c

+/*
+  labcomm2014.c -- runtime for handling encoding and decoding of
+               labcomm2014 samples.
+
+  Copyright 2006-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/>.
+*/
+
+#ifdef LABCOMM_COMPAT
+  #include LABCOMM_COMPAT
+#else
+  #include <stdio.h>
+  #include <strings.h>
+#endif
+
+#include <errno.h>
+#include <string.h>
+#include <stdarg.h>
+#include <stddef.h>
+
+#include "labcomm2014.h"
+#include "labcomm2014_private.h"
+#include "labcomm2014_ioctl.h"
+#include "labcomm2014_dynamic_buffer_writer.h"
+
+/* Unwrapping reader/writer functions */
+#define UNWRAP_ac(rw, ac, ...) ac
+#define UNWRAP(func, ...)	     \
+  while (1) {								\
+    if (UNWRAP_ac(__VA_ARGS__)->action->func) {				\
+      return UNWRAP_ac(__VA_ARGS__)->action->func(__VA_ARGS__); }	\
+    if (UNWRAP_ac(__VA_ARGS__)->next == NULL) { return -ENOSYS; }	\
+    UNWRAP_ac( __VA_ARGS__) = UNWRAP_ac(__VA_ARGS__)->next;		\
+  }
+
+int labcomm2014_reader_alloc(struct labcomm2014_reader *r,
+                         struct labcomm2014_reader_action_context *action_context)
+{
+  UNWRAP(alloc, r, action_context);
+}
+
+int labcomm2014_reader_free(struct labcomm2014_reader *r,
+                        struct labcomm2014_reader_action_context *action_context)
+{
+  UNWRAP(free, r, action_context);
+}
+
+int labcomm2014_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)
+{
+  UNWRAP(start, r, action_context, local_index, remote_index, signature, value);
+}
+
+int labcomm2014_reader_end(struct labcomm2014_reader *r,
+                       struct labcomm2014_reader_action_context *action_context)
+{
+  UNWRAP(end, r, action_context);
+}
+
+int labcomm2014_reader_fill(struct labcomm2014_reader *r,
+                        struct labcomm2014_reader_action_context *action_context)
+{
+  UNWRAP(fill, r, action_context);
+}
+
+int labcomm2014_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 ioctl_action, va_list args)
+{
+  UNWRAP(ioctl, r, action_context,
+	 local_index, remote_index, signature, ioctl_action, args);
+}
+
+int labcomm2014_writer_alloc(struct labcomm2014_writer *w,
+                         struct labcomm2014_writer_action_context *action_context)
+{
+  UNWRAP(alloc, w, action_context);
+}
+
+int labcomm2014_writer_free(struct labcomm2014_writer *w,
+                        struct labcomm2014_writer_action_context *action_context)
+{
+  UNWRAP(free, w, action_context);
+}
+
+int labcomm2014_writer_start(struct labcomm2014_writer *w,
+                         struct labcomm2014_writer_action_context *action_context,
+                         int index, const struct labcomm2014_signature *signature,
+                         void *value)
+{
+  UNWRAP(start, w, action_context, index, signature, value);
+}
+
+int labcomm2014_writer_end(struct labcomm2014_writer *w,
+                       struct labcomm2014_writer_action_context *action_context)
+{
+  UNWRAP(end, w, action_context);
+}
+
+int labcomm2014_writer_flush(struct labcomm2014_writer *w,
+                         struct labcomm2014_writer_action_context *action_context)
+{
+  UNWRAP(flush, w, action_context);
+}
+
+int labcomm2014_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)
+{
+  UNWRAP(ioctl, w, action_context, index, signature, ioctl_action, args);
+}
+
+#undef UNWRAP
+#undef UNWRAP_ac
+
+
+
+
+static const char *labcomm2014_error_string[] = {
+#define LABCOMM2014_ERROR(name, description) description ,
+#include "labcomm2014_error.h"
+#undef LABCOMM2014_ERROR
+};
+static const int labcomm2014_error_string_count = (sizeof(labcomm2014_error_string) /
+					       sizeof(labcomm2014_error_string[0]));
+
+
+const char *labcomm2014_error_get_str(enum labcomm2014_error error_id)
+{
+  const char *error_str = NULL;
+  // Check if this is a known error ID.
+  if (error_id < labcomm2014_error_string_count) {
+    error_str = labcomm2014_error_string[error_id];
+  }
+  return error_str;
+}
+
+void labcomm20142014_on_error_fprintf(enum labcomm2014_error error_id, size_t nbr_va_args, ...)
+{
+#ifndef LABCOMM_NO_STDIO
+  const char *err_msg = labcomm2014_error_get_str(error_id); // The final string to print.
+  if (err_msg == NULL) {
+    err_msg = "Error with an unknown error ID occured.";
+  }
+  fprintf(stderr, "%s\n", err_msg);
+
+ if (nbr_va_args > 0) {
+   va_list arg_pointer;
+   va_start(arg_pointer, nbr_va_args);
+
+   fprintf(stderr, "%s\n", "Extra info {");
+   char *print_format = va_arg(arg_pointer, char *);
+   vfprintf(stderr, print_format, arg_pointer);
+   fprintf(stderr, "}\n");
+
+   va_end(arg_pointer);
+ }
+#else
+ ; // If labcomm2014 can't be compiled with stdio the user will have to make an own error callback functionif he/she needs error reporting.
+#endif
+}
+
+
+
+#if 0
+static void dump(void *p, int size, int first, int last)
+{
+  int i, j;
+
+  printf("%d %d (%p): ", first, last, p);
+  for (i = first ; i < last ; i++) {
+    for (j = 0 ; j < size ; j++) {
+      printf("%2.2d", ((char*)p)[(i-first)*size + j]);
+    }
+    printf(" ");
+  }
+  printf("\n");
+}
+#endif
+
+void *labcomm2014_signature_array_ref(struct labcomm2014_memory *memory,
+				  int *first, int *last, void **data,
+				  int size, int index)
+{
+  if (*first == 0 && *last == 0) {
+    *first = index;
+    *last = index + 1;
+    *data = labcomm2014_memory_alloc(memory, 0, size);
+    if (*data) {
+      memset(*data, 0, size);
+    }
+  } else if (index < *first || *last <= index) {
+    void *old_data = *data;
+    int old_first = *first;
+    int old_last = *last;
+    int n;
+    *first = (index<old_first)?index:old_first;
+    *last = (old_last<=index)?index+1:old_last;
+    n = (*last - *first);
+    *data = labcomm2014_memory_alloc(memory, 0, n * size);
+    if (*data) {
+      memset(*data, 0, n * size);
+      memcpy(*data + (old_first - *first) * size,
+	     old_data,
+	     (old_last - old_first) * size);
+    }
+//    dump(old_data, size, old_first, old_last);
+    labcomm2014_memory_free(memory, 0, old_data);
+  }
+  if (*data) {
+//    dump(*data, size, *first, *last);
+    return *data + (index - *first) * size;
+  } else {
+    return NULL;
+  }
+}
+
+static int local_index = LABCOMM_USER;
+
+void labcomm2014_set_local_index(struct labcomm2014_signature *signature)
+{
+  if (signature->index != 0) {
+    labcomm2014_error_fatal_global(LABCOMM2014_ERROR_SIGNATURE_ALREADY_SET,
+			       "Signature already set: %s\n", signature->name);
+  }
+  signature->index = local_index;
+  local_index++;
+}
+
+int labcomm2014_get_local_index(const struct labcomm2014_signature *signature)
+{
+  int result;
+  if (! signature) {
+    result = 0;
+  } else {
+    if (signature->index == 0) {
+      labcomm2014_error_fatal_global(LABCOMM2014_ERROR_SIGNATURE_NOT_SET,
+                                     "Signature not set: %s\n",
+                                     signature->name);
+    }
+    result = signature->index;
+  }
+  return result;
+}
+
+int labcomm2014_get_local_type_index(const struct labcomm2014_signature *signature)
+{
+    return labcomm2014_get_local_index(signature);
+}
+
+int labcomm2014_internal_sizeof(const struct labcomm2014_signature *signature,
+                            void *v)
+{
+  int length = signature->encoded_size(signature, v);
+  return (labcomm2014_size_packed32(signature->index) +
+          labcomm2014_size_packed32(length) +
+          length);
+}
+

lib/c/2014/labcomm2014.h

+/*
+  labcomm2014.h -- user interface for handling encoding and decoding of
+               labcomm2014 samples.
+
+  Copyright 2006-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 __LABCOMM2014_H__
+#define __LABCOMM2014_H__
+
+#include <stdarg.h>
+
+#ifdef LABCOMM_COMPAT
+  #include LABCOMM_COMPAT
+#else
+  #include <stdint.h>
+  #include <unistd.h>
+#endif
+
+#include "labcomm2014_error.h"
+#include "labcomm2014_scheduler.h"
+
+/* Forward declaration */
+struct labcomm2014_encoder;
+struct labcomm2014_decoder;
+
+#include "labcomm2014_type_signature.h"
+/*
+ * Error handling.
+ */
+
+/* The callback prototype for error handling.
+ * First parameter is the error ID.
+ * The second paramters is the number of va_args that comes after this 
+ * one. If none it should be 0.
+ * Optionaly other paramters can be supplied depending on what is needed 
+ * for this error ID.
+ */
+typedef void (*labcomm2014_error_handler_callback)(enum labcomm2014_error error_id, 
+					       size_t nbr_va_args, ...); 
+
+/* Default error handler, prints message to stderr. 
+ * Extra info about the error can be supplied as char* as VA-args. Especially user defined errors should supply a describing string. if nbr_va_args > 1 the first variable argument must be a printf format string and the possibly following arguments are passed as va_args to vprintf. 
+ */
+void labcomm20142014_on_error_fprintf(enum labcomm2014_error error_id, size_t nbr_va_args, ...);
+
+/* Register a callback for the error handler for this encoder. */
+void labcomm2014_register_error_handler_encoder(struct labcomm2014_encoder *encoder, labcomm2014_error_handler_callback callback);
+
+/* Register a callback for the error handler for this decoder. */
+void labcomm2014_register_error_handler_decoder(struct labcomm2014_decoder *decoder, labcomm2014_error_handler_callback callback);
+
+/* Get a string describing the supplied standrad labcomm2014 error. */
+const char *labcomm2014_error_get_str(enum labcomm2014_error error_id);
+
+typedef int (*labcomm2014_handle_new_datatype_callback)(
+  struct labcomm2014_decoder *decoder,
+  struct labcomm2014_signature *sig);
+
+/*
+ * Dynamic memory handling
+ *   lifetime == 0     memory that will live for as long as the 
+ *                     encoder/decoder or that are allocated/deallocated 
+ *                     during the communication setup phase
+ *   otherwise         memory will live for approximately this number of
+ *                     sent/received samples
+ */
+struct labcomm2014_memory;
+
+void *labcomm2014_memory_alloc(struct labcomm2014_memory *m, int lifetime, size_t size);
+void *labcomm2014_memory_realloc(struct labcomm2014_memory *m, int lifetime, 
+			     void *ptr, size_t size);
+void labcomm2014_memory_free(struct labcomm2014_memory *m, int lifetime, void *ptr);
+
+/*
+ * Decoder
+ */
+struct labcomm2014_reader;
+
+struct labcomm2014_decoder *labcomm2014_decoder_new(
+  struct labcomm2014_reader *reader,
+  struct labcomm2014_error_handler *error,
+  struct labcomm2014_memory *memory,
+  struct labcomm2014_scheduler *scheduler);
+void labcomm2014_decoder_free(
+  struct labcomm2014_decoder *decoder);
+int labcomm2014_decoder_decode_one(
+  struct labcomm2014_decoder *decoder);
+void labcomm2014_decoder_run(
+  struct labcomm2014_decoder *decoder);
+int labcomm2014_decoder_sample_ref_register(
+  struct labcomm2014_decoder *decoder,
+  const struct labcomm2014_signature *signature);
+
+/* See labcomm2014_ioctl.h for predefined ioctl_action values */
+int labcomm2014_decoder_ioctl(struct labcomm2014_decoder *decoder, 
+                              uint32_t ioctl_action,
+                              ...);
+
+const struct labcomm2014_sample_ref *labcomm2014_decoder_get_sample_ref(
+  struct labcomm2014_decoder *decoder,
+  const struct labcomm2014_signature *signature);
+
+/*
+ * Encoder
+ */
+struct labcomm2014_writer;
+
+struct labcomm2014_encoder *labcomm2014_encoder_new(
+  struct labcomm2014_writer *writer,
+  struct labcomm2014_error_handler *error,
+  struct labcomm2014_memory *memory,
+  struct labcomm2014_scheduler *scheduler);
+void labcomm2014_encoder_free(
+  struct labcomm2014_encoder *encoder);
+int labcomm2014_encoder_sample_ref_register(
+  struct labcomm2014_encoder *encoder,
+  const struct labcomm2014_signature *signature);
+
+/* See labcomm2014_ioctl.h for predefined ioctl_action values */
+int labcomm2014_encoder_ioctl(struct labcomm2014_encoder *encoder, 
+                              uint32_t ioctl_action,
+                              ...);
+
+const struct labcomm2014_sample_ref *labcomm2014_encoder_get_sample_ref(
+  struct labcomm2014_encoder *encoder,
+  const struct labcomm2014_signature *signature);
+
+#endif

lib/c/2014/labcomm2014_compat_arm_cortexm3.h

+#ifndef ARM_CORTEXM3_CODESOURCERY
+#error "ARM_CORTEXM3_CODESOURCERY" not defined
+#endif
+
+#include <machine/endian.h>

lib/c/2014/labcomm2014_compat_osx.h

+#ifndef __APPLE__
+#error "__APPLE__" not defined
+#endif
+
+#ifndef LABCOMM_COMPAT_OSX
+#define LABCOMM_COMPAT_OSX
+
+#include <machine/endian.h>
+#include <stdio.h>
+#include <time.h>
+
+#include <mach/clock.h>
+#include <mach/mach.h>
+
+#define CLOCK_REALTIME 0
+static inline void clock_gettime(int garbage, struct timespec *ts)
+{
+  (void) garbage;
+  clock_serv_t cclock;
+  mach_timespec_t mts;
+  host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
+  clock_get_time(cclock, &mts);
+  mach_port_deallocate(mach_task_self(), cclock);
+  ts->tv_sec = mts.tv_sec;
+  ts->tv_nsec = mts.tv_nsec;
+}
+
+#endif

lib/c/2014/labcomm2014_compat_vxworks.h

+#ifndef _LABCOMM_COMPAT_VXWORKS_H_
+#define _LABCOMM_COMPAT_VXWORKS_H_
+
+#ifndef  __VXWORKS__
+#error "__VXWORKS__" not defined
+#endif
+
+#include <types/vxTypes.h>
+#include <selectLib.h>
+#include <types.h>
+#include <timers.h>
+#include <stdio.h>
+#include <private/stdioP.h>
+
+#ifdef __INT64_MAX__
+#undef INT64_MAX
+#define INT64_MAX __INT64_MAX__
+#endif
+
+#if (CPU == PPC603)
+  #undef _LITTLE_ENDIAN
+#endif
+
+#if (CPU == PENTIUM4)
+  #undef _BIG_ENDIAN
+#endif
+
+extern unsigned int cpuFrequency;
+
+#endif

lib/c/2014/labcomm2014_decoder.c

+/*
+  labcomm2014_decoder.c -- runtime for handling decoding of labcomm2014 samples.
+
+  Copyright 2006-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/>.
+*/
+#define CURRENT_VERSION "LabComm2014"
+
+#include <errno.h>
+#include "labcomm2014.h"
+#include "labcomm2014_private.h"
+#include "labcomm2014_ioctl.h"
+#include "labcomm2014_dynamic_buffer_writer.h"
+
+#ifdef DEBUG
+#define DEBUG_FPRINTF(str, ...) fprintf(str, ##__VA_ARGS__)
+#else
+#define DEBUG_FPRINTF(str, ...)
+#endif
+
+#ifdef DECODER_DEBUG
+#define DECODER_DEBUG_FPRINTF(str, ...) fprintf(str, ##__VA_ARGS__) 
+#else
+#define DECODER_DEBUG_FPRINTF(str, ...)
+#endif
+
+struct sample_entry {
+  int remote_index;
+  const struct labcomm2014_signature *signature;
+  labcomm2014_decoder_function decode;
+  labcomm2014_handler_function handler;
+  void *context;
+};
+
+struct decoder {
+  struct labcomm2014_decoder decoder;
+  LABCOMM_SIGNATURE_ARRAY_DEF(local, struct sample_entry);
+  LABCOMM_SIGNATURE_ARRAY_DEF(remote_to_local, int);
+  LABCOMM_SIGNATURE_ARRAY_DEF(local_ref, const struct labcomm2014_signature *);
+  LABCOMM_SIGNATURE_ARRAY_DEF(remote_to_local_ref, int);
+};
+
+static int handle_sample_def(struct labcomm2014_decoder *d, int remote_index,
+                             const struct labcomm2014_signature *signature)
+{
+  struct decoder *id = d->context;
+  int result;
+  int i;
+  const struct labcomm2014_signature *local_signature = NULL;
+  int local_index = 0;
+
+  labcomm2014_scheduler_data_lock(d->scheduler);
+  LABCOMM_SIGNATURE_ARRAY_FOREACH(id->local, struct sample_entry, i) {
+    struct sample_entry *s;
+    int *remote_to_local;
+
+    result = -ENOENT;
+    s = LABCOMM_SIGNATURE_ARRAY_REF(d->memory, 
+                                    id->local, struct sample_entry, i);
+    if (s->signature &&
+        s->signature->size == signature->size &&
+        strcmp(s->signature->name, signature->name) == 0 &&
+        memcmp((void*)s->signature->signature, (void*)signature->signature,
+	       signature->size) == 0) {
+      s->remote_index = remote_index;
+      local_signature = s->signature;
+      local_index = i;
+      remote_to_local = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
+                                                    id->remote_to_local, int,
+                                                    remote_index);
+      *remote_to_local = i;
+      result = remote_index;
+      break;
+    }
+  }
+  labcomm2014_scheduler_data_unlock(d->scheduler);
+  if (local_signature) {
+    labcomm2014_reader_start(d->reader, d->reader->action_context,
+                         local_index, remote_index, local_signature,
+                         NULL);
+    labcomm2014_reader_end(d->reader, d->reader->action_context);
+  }
+  return result;
+}
+
+static int handle_sample_ref(struct labcomm2014_decoder *d, int remote_index,
+                             const struct labcomm2014_signature *signature)
+{
+  struct decoder *id = d->context;
+  int result;
+  int i;
+
+  labcomm2014_scheduler_data_lock(d->scheduler);
+  LABCOMM_SIGNATURE_ARRAY_FOREACH(id->local_ref,
+                                  const struct labcomm2014_signature *, i) {
+    const struct labcomm2014_signature *s;
+    int *remote_to_local_ref;
+
+    result = -ENOENT;
+    s = LABCOMM_SIGNATURE_ARRAY_GET(id->local_ref, const struct labcomm2014_signature *, i, 0);
+    if (s &&
+        s->signature &&
+        s->size == signature->size &&
+        strcmp(s->name, signature->name) == 0 &&
+        memcmp((void*)s->signature, (void*)signature->signature, signature->size) == 0) {
+      remote_to_local_ref = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
+                                                        id->remote_to_local_ref,
+                                                        int,
+                                                        remote_index);
+      *remote_to_local_ref = i;
+      result = remote_index;
+      break;
+    }
+  }
+  labcomm2014_scheduler_data_unlock(d->scheduler);
+  return result;
+}
+
+static int reader_skip(struct labcomm2014_reader *r, int len, int tag)
+{
+  int i;
+  DECODER_DEBUG_FPRINTF(stdout, "got tag 0x%x, skipping %d bytes\n", tag, len);
+  for(i = 0; i <len; i++){
+    DECODER_DEBUG_FPRINTF(stderr, ".");
+    labcomm2014_read_byte(r);
+    if (r->error < 0) {
+      DECODER_DEBUG_FPRINTF(stderr, "\nerror while skipping: %d\n",  r->error);
+      return r->error;
+    }
+  }
+  DECODER_DEBUG_FPRINTF(stderr, "\n");
+  return tag;
+}
+
+static char* TODO_read_intentions(struct labcomm2014_reader *r)
+{
+
+    int numInts = labcomm2014_read_byte(r);
+    int i;
+    char *name=NULL;
+
+    printf("TODO_read_intentions: numInts=%d\n", numInts);
+    for(i=0; i <numInts; i++){
+        int klen = labcomm2014_read_packed32(r);
+        printf("TODO_read_intentions: klen=%d\n", klen);
+        if(klen == 0) {
+            name = labcomm2014_read_string(r);
+            printf("TODO_read_intentions: name=%s\n", name);
+        }else{
+            int vlen;
+            reader_skip(r, klen, 1);
+            vlen = labcomm2014_read_packed32(r);
+            reader_skip(r, vlen, 1);
+            printf("TODO_read_intentions: skipping value, %d bytes\n", vlen);
+        }
+    }
+    return name;
+}
+
+static int decode_sample_def_or_ref(struct labcomm2014_decoder *d, int kind)
+{
+  int result;
+  struct labcomm2014_signature signature;
+  int i, remote_index;
+
+  remote_index = labcomm2014_read_packed32(d->reader);
+  if (d->reader->error < 0) {
+    result = d->reader->error;
+    goto out;
+  }
+
+  signature.name = TODO_read_intentions(d->reader);
+  if (d->reader->error < 0) {
+    result = d->reader->error;
+    goto free_signature_name;
+  }
+  signature.size = labcomm2014_read_packed32(d->reader);
+  if (d->reader->error < 0) {
+    result = d->reader->error;
+    goto free_signature_name;
+  }
+  signature.signature = labcomm2014_memory_alloc(d->memory, 1,  signature.size);
+  if (d->reader->error < 0) {
+    result = d->reader->error;
+    goto free_signature_name;
+  }
+  for (i = 0 ; i < signature.size ; i++) {
+    signature.signature[i] = labcomm2014_read_byte(d->reader);
+    if (d->reader->error < 0) {
+      result = d->reader->error;
+      goto free_signature_signature;
+    }
+  }
+  switch (kind) {
+    case LABCOMM_SAMPLE_DEF: {
+      result = handle_sample_def(d, remote_index, &signature);
+      break;
+    } 
+    case LABCOMM_SAMPLE_REF: {
+      result = handle_sample_ref(d, remote_index, &signature);
+      if (result == -ENOENT) {
+        /* Dummy value to silently continue */
+        result = LABCOMM_SAMPLE_REF;
+      }
+      break;
+    } 
+    default:
+      result = -EINVAL;
+  }
+free_signature_signature:
+  labcomm2014_memory_free(d->memory, 1,  signature.signature);
+free_signature_name:
+  if (signature.name) {
+    if (result == -ENOENT) {
+      labcomm2014_error_warning(d->error,
+                                LABCOMM2014_ERROR_DEC_NO_REG_SIGNATURE,
+                                "Signature not found: %s\n",
+                                signature.name);
+    }
+    labcomm2014_memory_free(d->memory, 0, signature.name);
+  }
+out:
+  return result;
+}
+
+struct call_handler_context {
+  struct labcomm2014_reader *reader;
+  int local_index;
+  int remote_index;
+  const struct labcomm2014_signature *signature;
+  labcomm2014_handler_function handler;
+  void *context;
+};
+
+static void call_handler(void *value, void *context)
+{
+  struct call_handler_context *wrap = context;
+
+  if (wrap->reader->error >= 0) {
+    labcomm2014_reader_start(wrap->reader, wrap->reader->action_context,
+			 wrap->local_index, wrap->remote_index, wrap->signature,
+			 value);
+    wrap->handler(value, wrap->context);
+    labcomm2014_reader_end(wrap->reader, wrap->reader->action_context);
+  }
+}
+
+static void reader_alloc(struct labcomm2014_decoder *d)
+{
+  if (!d->reader_allocated) {
+    d->reader_allocated = 1;
+    labcomm2014_reader_alloc(d->reader, d->reader->action_context);
+  }
+}
+
+/* d        - decoder to read from
+   registry - decoder to lookup signatures (registry != d only if
+                nesting decoders, e.g., when decoding pragma)
+   len      - length of the labcomm2014 packet )
+*/
+static int decode_pragma(struct labcomm2014_decoder *d,
+		         struct labcomm2014_decoder *registry,
+		         int len)
+{
+  char *pragma_type;
+  int result;
+  pragma_type = labcomm2014_read_string(d->reader);
+  if (d->reader->error < 0) {
+    result = d->reader->error;
+    goto out;
+  }
+  int bytes = labcomm2014_size_string(pragma_type);
+  int psize = len-bytes;
+  result = reader_skip(d->reader, psize, LABCOMM_PRAGMA);
+out:
+  return result;
+}
+
+static labcomm2014_decoder_function lookup_h(struct labcomm2014_decoder *d,
+                                             struct call_handler_context *wrap,
+                                             int remote_index,
+                                             int *r_local_index)
+{
+  struct decoder *id = d->context;
+  labcomm2014_decoder_function do_decode = NULL;
+  int *local_index;
+
+  labcomm2014_scheduler_data_lock(d->scheduler);
+  local_index = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
+                                            id->remote_to_local, int,
+                                            remote_index);
+  *r_local_index = *local_index;
+  if (*local_index != 0) {
+    struct sample_entry *entry;
+
+    entry = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
+                                        id->local, struct sample_entry,
+                                        *local_index);
+    wrap->local_index = *local_index;
+    wrap->signature = entry->signature;
+    wrap->handler = entry->handler;
+    wrap->context = entry->context;
+    do_decode = entry->decode;
+  }
+  labcomm2014_scheduler_data_unlock(d->scheduler);
+  return do_decode;
+}
+/* d            - decoder to read from
+   registry     - decoder to lookup signatures (registry != d only if
+                    nesting decoders, e.g., when decoding pragma)
+   remote_index -  received type index )
+*/
+static int decode_and_handle(struct labcomm2014_decoder *d,
+		             struct labcomm2014_decoder *registry,
+		             int remote_index)
+{
+  int result;
+  int local_index;
+  struct call_handler_context wrap = {
+    .reader = d->reader,
+    .remote_index = remote_index,
+    .signature = NULL,
+    .handler = NULL,
+    .context = NULL,
+  };
+  labcomm2014_decoder_function do_decode = lookup_h(registry, &wrap, remote_index, &local_index);
+  result = local_index;
+  if (do_decode) {
+    do_decode(d->reader, call_handler, &wrap);
+    if (d->reader->error < 0) {
+      result = d->reader->error;
+    }
+  } else {
+    result = -ENOENT;
+  }
+  return result;
+}
+
+int labcomm2014_decoder_decode_one(struct labcomm2014_decoder *d)
+{
+  return d->decode_one(d);
+}
+
+static int do_decode_one(struct labcomm2014_decoder *d)
+{
+  int result, remote_index, length;
+
+  reader_alloc(d);
+  remote_index = labcomm2014_read_packed32(d->reader);
+  if (d->reader->error < 0) {
+    result = d->reader->error;
+    goto out;
+  }
+  length = labcomm2014_read_packed32(d->reader);
+  if (d->reader->error < 0) {
+    result = d->reader->error;
+    goto out;
+  }
+  if (remote_index == LABCOMM_VERSION) {
+    char *version = labcomm2014_read_string(d->reader);
+    if (d->reader->error < 0) {
+      result = d->reader->error;
+    } else if (strcmp(version, CURRENT_VERSION) == 0) {
+      result = LABCOMM_VERSION;
+      d->version_ok = 1;
+    } else {
+      result = -ECONNRESET;
+    }  
+    labcomm2014_memory_free(d->memory, 1,  version);
+    if (result < 0) {
+      goto out;
+    }
+  } else if (! d->version_ok) {
+    DEBUG_FPRINTF(stderr, "No VERSION %d %d\n", remote_index, length);
+    result = -ECONNRESET;
+  } else if (remote_index == LABCOMM_SAMPLE_DEF) {
+    result = decode_sample_def_or_ref(d, LABCOMM_SAMPLE_DEF); 
+  } else if (remote_index == LABCOMM_SAMPLE_REF) {
+    result = decode_sample_def_or_ref(d, LABCOMM_SAMPLE_REF); 
+  } else if (remote_index == LABCOMM_TYPE_DEF) {
+    result = decode_and_handle(d, d, remote_index);
+    if(result == -ENOENT) { 
+        //No handler for type_defs, skip
+        result = reader_skip(d->reader, length, remote_index);
+    }
+  } else if (remote_index == LABCOMM_TYPE_BINDING) {
+    result = decode_and_handle(d, d, remote_index);
+    if(result == -ENOENT) { 
+        //No handler for type_bindings, skip
+        result = reader_skip(d->reader, length, remote_index);
+    }
+  } else if (remote_index == LABCOMM_PRAGMA) {
+    result = decode_pragma(d, d, length);
+  } else if (remote_index < LABCOMM_USER) {
+    DECODER_DEBUG_FPRINTF(stderr, "SKIP %d %d\n", remote_index, length);
+    result = reader_skip(d->reader, length, remote_index);
+  } else {
+    result = decode_and_handle(d, d, remote_index);
+  }
+out:   
+  return result;
+}
+
+void labcomm2014_decoder_run(struct labcomm2014_decoder *d)
+{
+  while (labcomm2014_decoder_decode_one(d) > 0) {
+  }
+}
+
+int labcomm2014_decoder_ioctl(struct labcomm2014_decoder *d, 
+                              uint32_t action,
+                              ...)
+{
+  int result;  
+  va_list va;
+    
+  va_start(va, action);
+  result = d->ioctl(d, NULL, action, va);
+  va_end(va);
+  return result;
+}
+
+int labcomm2014_decoder_sample_ref_register(
+  struct labcomm2014_decoder *d,
+  const struct labcomm2014_signature *signature)
+{
+  return d->ref_register(d, signature);
+}
+
+static int do_ref_register(
+  struct labcomm2014_decoder *d,
+  const struct labcomm2014_signature *signature)
+{
+  struct decoder *id = d->context;
+  int local_index, *remote_to_local_ref;
+  const struct labcomm2014_signature **s;
+
+  local_index = labcomm2014_get_local_index(signature);
+  if (local_index <= 0) { goto out; }
+  labcomm2014_scheduler_data_lock(d->scheduler);
+  s = LABCOMM_SIGNATURE_ARRAY_REF(d->memory, 
+                                  id->local_ref, 
+                                  const struct labcomm2014_signature*, local_index);
+  if (s == NULL) { local_index = -ENOMEM; goto unlock; };
+  if (*s) { goto unlock; }
+  *s = signature;	
+  remote_to_local_ref = LABCOMM_SIGNATURE_ARRAY_REF(d->memory, 
+                                                    id->remote_to_local_ref, 
+                                                    int, local_index);
+  *remote_to_local_ref = 0;
+unlock:
+  labcomm2014_scheduler_data_unlock(d->scheduler);
+out:
+  return local_index;
+}
+
+static int do_ioctl(struct labcomm2014_decoder *d, 
+                    const struct labcomm2014_signature *signature,
+                    uint32_t action, va_list va)
+{
+  struct decoder *id = d->context;
+  int result;
+  int local_index, remote_index;
+
+  local_index = labcomm2014_get_local_index(signature);
+  if (local_index == 0) {
+    remote_index = 0;
+  } else {
+    labcomm2014_scheduler_data_lock(d->scheduler);
+    remote_index = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
+                                               id->local,
+                                               struct sample_entry,
+                                               local_index)->remote_index;
+    labcomm2014_scheduler_data_unlock(d->scheduler);
+  }
+  result = labcomm2014_reader_ioctl(d->reader, d->reader->action_context,
+                                    local_index, remote_index, 
+                                    signature, action, va);
+  return result;
+}
+
+#ifndef LABCOMM_NO_TYPEDECL
+//// Code for allowing user code to handle type_defs 
+//// (should perhaps be moved to another file)
+
+static void decode_raw_type_def(
+  struct labcomm2014_reader *r,
+  void (*handle)(
+    struct labcomm2014_raw_type_def *v,
+    void *context
+  ),
+  void *context
+)
+{
+  struct labcomm2014_raw_type_def v;
+  v.index = labcomm2014_read_packed32(r);
+  if (r->error < 0) { goto out; }
+  v.name  = TODO_read_intentions(r);
+  if (r->error < 0) { goto free_name; }
+  v.length = labcomm2014_read_packed32(r);
+  if (r->error < 0) { goto free_name; }
+  int i;
+  v.signature_data = labcomm2014_memory_alloc(r->memory, 1, v.length);
+  if(v.signature_data) {
+    for(i=0; i<v.length; i++) {
+      v.signature_data[i] = labcomm2014_read_byte(r);
+      if (r->error < 0) { goto free_sig; }
+    }  
+    handle(&v, context);
+    }
+free_sig:
+  labcomm2014_memory_free(r->memory, 1, v.signature_data);
+free_name:
+  labcomm2014_memory_free(r->memory, 1, v.name);
+out:
+  return;
+}
+int labcomm2014_decoder_register_labcomm2014_type_def(
+  struct labcomm2014_decoder *d,
+  void (*handler)(
+    struct labcomm2014_raw_type_def *v,
+    void *context
+  ),
+  void *context
+)
+{
+  struct decoder *id = d->context;
+  int tag = LABCOMM_TYPE_DEF;
+  struct sample_entry *entry;
+  int *remote_to_local;
+ 
+  labcomm2014_scheduler_data_lock(d->scheduler);
+  entry = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
+				      id->local, struct sample_entry,
+				      tag);
+  if (entry == NULL) { tag = -ENOMEM; goto unlock; }
+  entry->remote_index = tag;
+  entry->signature = NULL;
+  entry->decode = (labcomm2014_decoder_function) decode_raw_type_def;
+  entry->handler =(labcomm2014_handler_function) handler;
+  entry->context = context;
+
+  remote_to_local = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
+                                                id->remote_to_local, int,
+                                                tag);
+  *remote_to_local = tag;
+unlock:
+  labcomm2014_scheduler_data_unlock(d->scheduler);
+
+  return tag;
+}
+
+
+static void decode_type_binding(
+  struct labcomm2014_reader *r,
+  void (*handle)(
+    struct labcomm2014_type_binding *v,
+    void *context
+  ),
+  void *context
+)
+{
+  struct labcomm2014_type_binding v;
+  v.sample_index = labcomm2014_read_packed32(r);
+  if (r->error < 0) { goto out; }
+  v.type_index = labcomm2014_read_packed32(r);
+  if (r->error < 0) { goto out; }
+  handle(&v, context);
+out:
+  return;
+}
+
+int labcomm2014_decoder_register_labcomm2014_type_binding(
+  struct labcomm2014_decoder *d,
+  void (*handler)(
+    struct labcomm2014_type_binding *v,
+    void *context
+  ),
+  void *context
+)
+{
+  struct decoder *id = d->context;
+  int tag = LABCOMM_TYPE_BINDING;
+  struct sample_entry *entry;
+  int *remote_to_local;
+ 
+  labcomm2014_scheduler_data_lock(d->scheduler);
+  entry = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
+				      id->local, struct sample_entry,
+				      tag);
+  if (entry == NULL) { tag = -ENOMEM; goto unlock; }
+  entry->remote_index = tag;
+  entry->signature = NULL;
+  entry->decode = (labcomm2014_decoder_function) decode_type_binding;
+  entry->handler =(labcomm2014_handler_function) handler;
+  entry->context = context;
+
+  remote_to_local = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
+                                                id->remote_to_local, int,
+                                                tag);
+  *remote_to_local = tag;
+unlock:
+  labcomm2014_scheduler_data_unlock(d->scheduler);
+
+  return tag;
+}
+
+//// End type_def handling
+#endif
+
+static int do_register_sample(
+  struct labcomm2014_decoder *d,
+  const struct labcomm2014_signature *signature,
+  labcomm2014_decoder_function decode, 
+  labcomm2014_handler_function handler,
+  void *context)
+{
+  struct decoder *id = d->context;
+  int local_index;
+  struct sample_entry *entry;
+ 
+  reader_alloc(d);
+  local_index = labcomm2014_get_local_index(signature);
+  if (local_index <= 0) { goto out; }
+  labcomm2014_reader_start(d->reader, d->reader->action_context,
+		       local_index, 0, signature,
+		       NULL);
+  labcomm2014_reader_end(d->reader, d->reader->action_context);
+
+  labcomm2014_scheduler_data_lock(d->scheduler);
+  entry = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
+				      id->local, struct sample_entry,
+				      local_index);
+  if (entry == NULL) { local_index = -ENOMEM; goto unlock; }
+  entry->remote_index = 0;
+  entry->signature = signature;
+  entry->decode = decode;
+  entry->handler = handler;
+  entry->context = context;
+unlock:
+  labcomm2014_scheduler_data_unlock(d->scheduler);
+out:
+  return local_index;
+}
+
+static const struct labcomm2014_sample_ref *do_index_to_sample_ref(
+  struct labcomm2014_decoder *d, int index)
+{
+  const struct labcomm2014_signature *result = 0;
+  struct decoder *id = d->context;
+  int local_index;
+
+  labcomm2014_scheduler_data_lock(d->scheduler);
+  local_index = LABCOMM_SIGNATURE_ARRAY_GET(id->remote_to_local_ref, 
+                                            int, index, 0);
+  if (local_index) {
+    result = LABCOMM_SIGNATURE_ARRAY_GET(id->local_ref, 
+                                         const struct labcomm2014_signature*, 
+                                         local_index, 0);
+  }
+  labcomm2014_scheduler_data_unlock(d->scheduler);
+  return labcomm2014_signature_to_sample_ref(result);
+}
+
+static const struct labcomm2014_sample_ref *do_ref_get(
+  struct labcomm2014_decoder *d,
+  const struct labcomm2014_signature *signature)
+{
+  return (const struct labcomm2014_sample_ref *) signature;
+}
+
+static void do_free(struct labcomm2014_decoder* d)
+{
+  struct decoder *id = d->context;
+  struct labcomm2014_memory *memory = d->memory;
+
+  labcomm2014_reader_free(d->reader, d->reader->action_context);
+  LABCOMM_SIGNATURE_ARRAY_FREE(memory, id->local, struct sample_entry);
+  LABCOMM_SIGNATURE_ARRAY_FREE(memory, id->remote_to_local, int);
+  LABCOMM_SIGNATURE_ARRAY_FREE(memory, id->local_ref, 
+                               const struct labcomm2014_signature*);
+  LABCOMM_SIGNATURE_ARRAY_FREE(memory, id->remote_to_local_ref, int);
+  labcomm2014_memory_free(memory, 0, id);
+}
+
+void labcomm2014_decoder_free(struct labcomm2014_decoder* d)
+{
+  d->free(d);
+}
+
+struct labcomm2014_decoder *labcomm2014_decoder_new(
+  struct labcomm2014_reader *reader,
+  struct labcomm2014_error_handler *error,
+  struct labcomm2014_memory *memory,
+  struct labcomm2014_scheduler *scheduler)
+{
+  struct decoder *result;
+
+  result = labcomm2014_memory_alloc(memory, 0, sizeof(*result));
+  if (result) {
+    result->decoder.context = result;
+    result->decoder.reader = reader;
+    result->decoder.reader->decoder = &result->decoder;
+    result->decoder.reader->data = 0;
+    result->decoder.reader->data_size = 0;
+    result->decoder.reader->count = 0;
+    result->decoder.reader->pos = 0;
+    result->decoder.reader->error = 0;
+    result->decoder.reader_allocated = 0;
+    result->decoder.version_ok = 0;
+    result->decoder.error = error;
+    result->decoder.memory = memory;
+    result->decoder.scheduler = scheduler;
+    result->decoder.on_error = labcomm20142014_on_error_fprintf;
+    result->decoder.free = do_free;
+    result->decoder.decode_one = do_decode_one;
+    result->decoder.ref_register = do_ref_register;
+    result->decoder.sample_register = do_register_sample;
+    result->decoder.ioctl = do_ioctl;
+    result->decoder.index_to_sample_ref = do_index_to_sample_ref;
+    result->decoder.ref_get = do_ref_get;
+    LABCOMM_SIGNATURE_ARRAY_INIT(result->local, struct sample_entry);
+    LABCOMM_SIGNATURE_ARRAY_INIT(result->remote_to_local, int);
+    LABCOMM_SIGNATURE_ARRAY_INIT(result->local_ref, 
+                                 const struct labcomm2014_signature*);
+    LABCOMM_SIGNATURE_ARRAY_INIT(result->remote_to_local_ref, int);
+  }
+  return &(result->decoder);
+}
+
+
+const struct labcomm2014_sample_ref *labcomm2014_decoder_get_sample_ref(
+  struct labcomm2014_decoder *decoder,
+  const struct labcomm2014_signature *signature)
+{
+  return decoder->ref_get(decoder, signature);
+}
+

lib/c/2014/labcomm2014_default_error_handler.c

+/*
+  test_default_error_handler.c -- LabComm default error handler
+
+  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 "labcomm2014.h"
+
+struct labcomm2014_error_handler *labcomm2014_default_error_handler = NULL;

lib/c/2014/labcomm2014_default_error_handler.h

+/*
+  test_default_error_handler.h -- LabComm default error handler
+
+  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 __LABCOMM2014_DEFAULT_ERROR_HANDLER_H__
+#define __LABCOMM2014_DEFAULT_ERROR_HANDLER_H__
+
+#include "labcomm2014.h"
+
+extern struct labcomm2014_error_handler *labcomm2014_default_error_handler;
+
+#endif

lib/c/2014/labcomm2014_default_memory.c

+/*
+  test_default_memory.c -- LabComm default memory allocator
+
+  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 <stdlib.h>
+#include "labcomm2014.h"
+#include "labcomm2014_private.h"
+
+void *default_alloc(struct labcomm2014_memory *m, int lifetime, size_t size)
+{
+  return malloc(size);
+}
+
+void *default_realloc(struct labcomm2014_memory *m, int lifetime, 
+		      void *ptr, size_t size)
+{
+  return realloc(ptr, size);
+}
+
+void default_free(struct labcomm2014_memory *m, int lifetime, void *ptr)
+{
+  free(ptr);
+}
+
+struct labcomm2014_memory memory = {
+  .alloc = default_alloc,
+  .realloc = default_realloc,
+  .free = default_free,
+  .context = NULL
+};
+
+struct labcomm2014_memory *labcomm2014_default_memory = &memory;

lib/c/2014/labcomm2014_default_memory.h

+/*
+  test_default_memory.h -- LabComm default memory allocator
+
+  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 __LABCOMM2014_DEFAULT_MEMORY_H__
+#define __LABCOMM2014_DEFAULT_MEMORY_H__
+
+#include <stdlib.h>
+#include "labcomm2014.h"
+
+extern struct labcomm2014_memory *labcomm2014_default_memory;
+
+#endif

lib/c/2014/labcomm2014_default_scheduler.c

+/*
+  test_default_scheduler.c -- LabComm default scheduler
+
+  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 <stdio.h>
+#include <stdlib.h>
+#include "labcomm2014_default_scheduler.h"
+#include "labcomm2014_scheduler.h"
+#include "labcomm2014_scheduler_private.h"
+
+static int scheduler_free(struct labcomm2014_scheduler *s)
+{
+  fprintf(stderr, "%s:%d %s %s", __FILE__, __LINE__, __FUNCTION__,
+	  "not implemented");
+  exit(1);
+  return 0;
+}
+ 
+static int scheduler_writer_lock(struct labcomm2014_scheduler *s)
+{
+  return 0;
+}
+ 
+static int scheduler_writer_unlock(struct labcomm2014_scheduler *s)
+{
+  return 0;
+}
+
+static int scheduler_data_lock(struct labcomm2014_scheduler *s)
+{
+  return 0;
+}
+ 
+static int scheduler_data_unlock(struct labcomm2014_scheduler *s)
+{
+  return 0;
+}
+
+static struct labcomm2014_time *scheduler_now(struct labcomm2014_scheduler *s)
+{
+  fprintf(stderr, "%s:%d %s %s", __FILE__, __LINE__, __FUNCTION__,
+	  "not implemented");
+  exit(1);
+  return NULL;
+}
+ 
+static int scheduler_sleep(struct labcomm2014_scheduler *s,
+			   struct labcomm2014_time *t)
+{
+  fprintf(stderr, "%s:%d %s %s", __FILE__, __LINE__, __FUNCTION__,
+	  "not implemented");
+  exit(1);
+  return 0;
+}
+
+static int scheduler_wakeup(struct labcomm2014_scheduler *s)
+{
+  fprintf(stderr, "%s:%d %s %s", __FILE__, __LINE__, __FUNCTION__,
+	  "not implemented");
+  exit(1);
+  return 0;
+}
+
+static int scheduler_enqueue(struct labcomm2014_scheduler *s,
+			     uint32_t delay,
+			     void (*deferred)(void *context),
+			     void *context)
+{
+  fprintf(stderr, "%s:%d %s %s", __FILE__, __LINE__, __FUNCTION__,
+	  "not implemented");
+  exit(1);
+  return 0;
+}
+
+static const struct labcomm2014_scheduler_action scheduler_action = {
+  .free = scheduler_free,
+  .writer_lock = scheduler_writer_lock,
+  .writer_unlock = scheduler_writer_unlock,
+  .data_lock = scheduler_data_lock,
+  .data_unlock = scheduler_data_unlock,
+  .now = scheduler_now,
+  .sleep = scheduler_sleep,
+  .wakeup = scheduler_wakeup,
+  .enqueue = scheduler_enqueue  
+};
+
+static struct labcomm2014_scheduler scheduler = {
+  .action = &scheduler_action,
+  .context = NULL
+};
+
+struct labcomm2014_scheduler *labcomm2014_default_scheduler = &scheduler;

lib/c/2014/labcomm2014_default_scheduler.h

+/*
+  test_default_scheduler.h -- LabComm default scheduler
+
+  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 __LABCOMM2014_DEFAULT_SCHEDULER_H__
+#define __LABCOMM2014_DEFAULT_SCHEDULER_H__
+
+#include "labcomm2014.h"
+
+extern struct labcomm2014_scheduler *labcomm2014_default_scheduler;
+
+#endif

lib/c/2014/labcomm2014_dynamic_buffer_writer.c

+/*
+  labcomm2014_dynamic_buffer_writer.c -- LabComm dynamic memory writer.
+
+  Copyright 2006-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 <stdlib.h>
+#include <stdarg.h>
+#include "labcomm2014.h"
+#include "labcomm2014_private.h"
+#include "labcomm2014_ioctl.h"
+#include "labcomm2014_dynamic_buffer_writer.h"
+
+static int dyn_alloc(struct labcomm2014_writer *w, 
+		     struct labcomm2014_writer_action_context *action_context)
+{
+  w->data_size = 1000;
+  w->count = w->data_size;
+  w->data = labcomm2014_memory_alloc(w->memory, 1, w->data_size);
+  if (w->data == NULL) {
+    w->error = -ENOMEM;
+  }
+  w->pos = 0;
+
+  return w->error;
+}
+
+static int dyn_free(struct labcomm2014_writer *w, 
+		    struct labcomm2014_writer_action_context *action_context)
+{
+  labcomm2014_memory_free(w->memory, 1, w->data);
+  w->data = 0;
+  w->data_size = 0;
+  w->count = 0;
+  w->pos = 0;
+  labcomm2014_memory_free(w->memory, 0, action_context->context);
+  return 0;
+}
+
+static int dyn_start(struct labcomm2014_writer *w, 
+		     struct labcomm2014_writer_action_context *action_context,
+		     int index,
+		     const struct labcomm2014_signature *signature,
+		     void *value)
+{
+  void *tmp;
+
+  w->data_size = 1000;
+  w->count = w->data_size;
+  tmp = labcomm2014_memory_realloc(w->memory, 1, w->data, w->data_size);
+  if (tmp != NULL) {
+    w->data = tmp;
+    w->error = 0;
+  } else {
+    w->error = -ENOMEM;
+  }
+  w->pos = 0;
+
+  return w->error;
+}
+
+static int dyn_end(struct labcomm2014_writer *w, 
+		   struct labcomm2014_writer_action_context *action_context)
+{
+  return 0;
+}
+
+static int dyn_flush(struct labcomm2014_writer *w, 
+		     struct labcomm2014_writer_action_context *action_context)
+{
+  void *tmp;
+
+  w->data_size += 1000;
+  w->count = w->data_size;
+  tmp = labcomm2014_memory_realloc(w->memory, 1, w->data, w->data_size);
+  if (tmp != NULL) {
+    w->data = tmp;
+    w->error = 0;
+  } else {
+    /* Old pointer in w->data still valid */
+    w->error = -ENOMEM;
+  }
+
+  return w->error; 
+}
+
+static int dyn_ioctl(struct labcomm2014_writer *w, 
+		     struct labcomm2014_writer_action_context *action_context, 
+		     int signature_index,
+		     const struct labcomm2014_signature *signature,
+		     uint32_t action, va_list arg)
+{
+  int result = -ENOTSUP;
+  switch (action) {
+    case LABCOMM_IOCTL_WRITER_GET_BYTES_WRITTEN: {
+      int *value = va_arg(arg, int*);
+      *value = w->pos;
+      result = 0;
+    } break;
+    case LABCOMM_IOCTL_WRITER_GET_BYTE_POINTER: {
+      void **value = va_arg(arg, void**);
+      *value = w->data;
+      result = 0;
+    } break;
+  }
+  return result;
+}
+
+static const struct labcomm2014_writer_action action = {
+  .alloc = dyn_alloc,
+  .free = dyn_free,
+  .start = dyn_start,
+  .end = dyn_end,
+  .flush = dyn_flush,
+  .ioctl = dyn_ioctl
+};
+const struct labcomm2014_writer_action *labcomm2014_dynamic_buffer_writer_action = 
+  &action;
+
+struct labcomm2014_writer *labcomm2014_dynamic_buffer_writer_new(
+  struct labcomm2014_memory *memory)
+{
+  struct result {
+    struct labcomm2014_writer writer;
+    struct labcomm2014_writer_action_context action_context;
+  } *result;
+
+  result = labcomm2014_memory_alloc(memory, 0, sizeof(*result));
+  if (result != NULL) {
+    result->action_context.next = NULL;
+    result->action_context.context = result;
+    result->action_context.action = &action;
+    result->writer.action_context = &result->action_context;
+    result->writer.memory = memory;
+    return &result->writer;
+  }
+  return NULL;
+}
+

lib/c/2014/labcomm2014_dynamic_buffer_writer.h

+/*
+  labcomm2014_dynamic_buffer_writer.h -- LabComm dynamic memory writer.
+
+  Copyright 2006-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 __LABCOMM2014_DYNAMIC_BUFFER_READER_WRITER_H__
+#define __LABCOMM2014_DYNAMIC_BUFFER_READER_WRITER_H__
+
+#include "labcomm2014.h"
+
+extern const struct labcomm2014_writer_action *labcomm2014_dynamic_buffer_writer_action;
+
+struct labcomm2014_writer *labcomm2014_dynamic_buffer_writer_new(
+  struct labcomm2014_memory *memory);
+
+#endif

lib/c/2014/labcomm2014_encoder.c

+/*
+  labcomm2014_encoder.c -- handling encoding of labcomm2014 samples.
+
+  Copyright 2006-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/>.
+*/
+#define CURRENT_VERSION "LabComm2014"
+
+#include <errno.h>
+#include "labcomm2014.h"
+#include "labcomm2014_private.h"
+#include "labcomm2014_ioctl.h"
+#include "labcomm2014_dynamic_buffer_writer.h"
+
+//define the following to disable encoding of typedefs
+#undef LABCOMM_WITHOUT_TYPE_DEFS
+
+#undef LABCOMM2014_WITH_SANITY_CHECKS
+
+struct encoder {
+  struct labcomm2014_encoder encoder;
+  LABCOMM_SIGNATURE_ARRAY_DEF(registered, int);
+  LABCOMM_SIGNATURE_ARRAY_DEF(sample_ref, int);
+  LABCOMM_SIGNATURE_ARRAY_DEF(typedefs, int);
+};
+
+#ifdef LABCOMM2014_WITH_SANITY_CHECKS
+static int expectedByteCount;
+static void encoder_check_write_start(struct labcomm2014_encoder *e, int numBytes)
+{
+    int previouslyWritten = 0;
+    int err = labcomm2014_encoder_ioctl(e, LABCOMM_IOCTL_WRITER_GET_BYTES_WRITTEN, &previouslyWritten);
+    if(err) {
+      printf("ERROR: get_bytes_written returned %d (%s)\n", err, strerror(err));
+    }
+    expectedByteCount = numBytes + previouslyWritten;
+#ifdef LABCOMM2014_ENCODER_DEBUG
+    printf("previously written: %d bytes, length = %d bytes, expected = %d bytes\n",
+            previouslyWritten, numBytes, expectedByteCount);
+#endif
+}
+
+static int encoder_check_write_end(struct labcomm2014_encoder *e)
+{
+    int written = 0;
+    int err = labcomm2014_encoder_ioctl(e, LABCOMM_IOCTL_WRITER_GET_BYTES_WRITTEN, &written);
+    if(err) {
+      printf("ERROR: get_bytes_written returned %d (%s)\n", err, strerror(err));
+    }
+    int result = 0;
+#ifdef LABCOMM2014_ENCODER_DEBUG
+    printf("DEBUG: encoder_check_write_end: expected: %d, was: %d\n",
+        expectedByteCount, written);
+#endif
+    if(written != expectedByteCount) {
+        printf("WARNING! encoder_check_write_end: expected: %d, was: %d\n",
+            expectedByteCount, written);
+        result = -EINVAL;
+    }
+    return result;
+}
+#endif
+/* XXX: TEMPORARY PLACEHOLDERS FOR INTENTIONS */
+
+static int TODO_sizeof_intentions(const struct labcomm2014_signature *signature) {
+    int res = labcomm2014_size_string(signature->name) + 2;
+    return res;
+}
+
+static int TODO_encode_intentions(
+  struct labcomm2014_encoder *e,
+  const struct labcomm2014_signature *signature)
+{
+  int result = -EINVAL;
+
+  labcomm2014_write_packed32(e->writer, 1); // one intention: the name
+  labcomm2014_write_packed32(e->writer, 0); // key: the empty string
+  labcomm2014_write_string(e->writer, signature->name);
+
+  result = e->writer->error;
+  return result;
+}
+static int do_sample_register(
+  struct labcomm2014_encoder *e,
+  const struct labcomm2014_signature *signature,
+  labcomm2014_encoder_function encode)
+{
+  int result = -EINVAL;
+  struct encoder *ie = e->context;
+  int index, *done, err, i, length;
+
+  index = labcomm2014_get_local_index(signature);
+  labcomm2014_scheduler_writer_lock(e->scheduler);
+  if (index <= 0) { goto out; }
+  done = LABCOMM_SIGNATURE_ARRAY_REF(e->memory, ie->registered, int, index);
+  if (*done) {
+      goto out; }
+  *done = 1;
+  err = labcomm2014_writer_start(e->writer, e->writer->action_context,
+                index, signature, NULL);
+  if (err == -EALREADY) { result = 0; goto out; }
+  if (err != 0) { result = err; goto out; }
+  labcomm2014_write_packed32(e->writer, LABCOMM_SAMPLE_DEF);
+  length = (labcomm2014_size_packed32(index) +
+            TODO_sizeof_intentions(signature) +
+            labcomm2014_size_packed32(signature->size) +
+            signature->size);
+  labcomm2014_write_packed32(e->writer, length);
+  labcomm2014_write_packed32(e->writer, index);
+  TODO_encode_intentions(e, signature);
+  labcomm2014_write_packed32(e->writer, signature->size);
+  for (i = 0 ; i < signature->size ; i++) {
+    if (e->writer->pos >= e->writer->count) {
+      labcomm2014_writer_flush(e->writer, e->writer->action_context);
+    }
+    e->writer->data[e->writer->pos] = signature->signature[i];
+    e->writer->pos++;
+  }
+  labcomm2014_writer_end(e->writer, e->writer->action_context);
+  result = e->writer->error;
+out:
+  labcomm2014_scheduler_writer_unlock(e->scheduler);
+  return result;
+}
+
+static int do_encode(
+  struct labcomm2014_encoder *e,
+  const struct labcomm2014_signature *signature,
+  labcomm2014_encoder_function encode,
+  void *value)
+{
+  int result, index, length;
+  struct encoder *ie = e->context;
+
+  index = labcomm2014_get_local_index(signature);
+  length = (signature->encoded_size(signature, value));
+  labcomm2014_scheduler_writer_lock(e->scheduler);
+  if (! LABCOMM_SIGNATURE_ARRAY_GET(ie->registered, int, index, 0)) {
+    result = -EINVAL;
+    goto no_end;
+  }
+  result = labcomm2014_writer_start(e->writer, e->writer->action_context,
+                                    index, signature, value);
+  if (result == -EALREADY) { result = 0; goto no_end; }
+  if (result != 0) { goto out; }
+  result = labcomm2014_write_packed32(e->writer, index);
+  result = labcomm2014_write_packed32(e->writer, length);
+  if (result != 0) { goto out; }
+  result = encode(e->writer, value);
+out:
+  labcomm2014_writer_end(e->writer, e->writer->action_context);
+no_end:
+  labcomm2014_scheduler_writer_unlock(e->scheduler);
+  return result;
+}
+
+int labcomm2014_encoder_sample_ref_register(
+  struct labcomm2014_encoder *e,
+  const struct labcomm2014_signature *signature)
+{
+  return e->ref_register(e, signature);
+}
+
+static int do_ref_register(
+  struct labcomm2014_encoder *e,
+  const struct labcomm2014_signature *signature)
+{
+  int result = -EINVAL;
+  struct encoder *ie = e->context;
+  int index, *done, err, i, length;
+
+  index = labcomm2014_get_local_index(signature);
+  labcomm2014_scheduler_writer_lock(e->scheduler);
+  if (index <= 0) { goto out; }
+
+  done = LABCOMM_SIGNATURE_ARRAY_REF(e->memory, ie->sample_ref, int, index);
+  if (*done) { goto out; }
+  *done = 1;
+  err = labcomm2014_writer_start(e->writer, e->writer->action_context,
+                index, signature, NULL);
+  if (err == -EALREADY) { result = 0; goto out; }
+  if (err != 0) { result = err; goto out; }
+  labcomm2014_write_packed32(e->writer, LABCOMM_SAMPLE_REF);
+  length = (labcomm2014_size_packed32(index) +
+            TODO_sizeof_intentions(signature) +
+            labcomm2014_size_packed32(signature->size) +
+            signature->size);
+  labcomm2014_write_packed32(e->writer, length);
+  labcomm2014_write_packed32(e->writer, index);
+  TODO_encode_intentions(e, signature);
+  labcomm2014_write_packed32(e->writer, signature->size);
+  for (i = 0 ; i < signature->size ; i++) {
+    if (e->writer->pos >= e->writer->count) {
+      labcomm2014_writer_flush(e->writer, e->writer->action_context);
+    }
+    e->writer->data[e->writer->pos] = signature->signature[i];
+    e->writer->pos++;
+  }
+  labcomm2014_writer_end(e->writer, e->writer->action_context);
+  result = e->writer->error;
+out:
+  labcomm2014_scheduler_writer_unlock(e->scheduler);
+  return result;
+}
+
+int labcomm2014_encoder_ioctl(struct labcomm2014_encoder *encoder,
+                              uint32_t action,
+                              ...)
+{
+  int result;
+  va_list va;
+
+  if (LABCOMM_IOC_SIG(action) != LABCOMM_IOC_NOSIG) {
+    result = -EINVAL;
+    goto out;
+  }
+
+  va_start(va, action);
+  result = encoder->ioctl(encoder, NULL, action, va);
+  va_end(va);
+
+out:
+  return result;
+}
+
+static int do_ioctl(
+  struct labcomm2014_encoder *encoder,
+  const struct labcomm2014_signature *signature,
+  uint32_t action, va_list va)
+{
+  int result = -ENOTSUP;
+  int index;
+
+  index = labcomm2014_get_local_index(signature);
+  result = labcomm2014_writer_ioctl(encoder->writer,
+        encoder->writer->action_context,
+        index, signature, action, va);
+  return result;
+}
+
+static int do_sample_ref_to_index(
+  struct labcomm2014_encoder *e,
+  const struct labcomm2014_sample_ref *sample_ref)
+{
+  /* writer_lock should be held at this point */
+  struct encoder *ie = e->context;
+  int index = 0;
+  if (sample_ref != NULL) {
+    index = labcomm2014_get_local_index(
+      (struct labcomm2014_signature *)sample_ref);
+    if (! LABCOMM_SIGNATURE_ARRAY_GET(ie->sample_ref, int, index, 0)) {
+      index = 0;
+    }
+  }
+  return index;
+}
+
+
+/**********************************************************
+ * Start of code related to sending (hierarchical)
+ * typedefs. Define LABCOMM_WITHOUT_TYPEDEFS to disable
+ **********************************************************/
+#ifndef LABCOMM_WITHOUT_TYPE_DEFS
+
+static void write_sig_tree_byte(char b, const struct labcomm2014_signature *signature,
+                           void *context)
+{
+  struct labcomm2014_encoder *e = context;
+  if(signature) {
+    labcomm2014_write_packed32(e->writer, labcomm2014_get_local_index(signature));
+  }else {
+    if (e->writer->pos >= e->writer->count) {
+     labcomm2014_writer_flush(e->writer, e->writer->action_context);
+    }
+    e->writer->data[e->writer->pos] = b;
+    e->writer->pos++;
+  }
+}
+
+static void do_write_signature(struct labcomm2014_encoder * e,
+                               const struct labcomm2014_signature *signature,
+                               unsigned char flatten)
+{
+  map_signature(write_sig_tree_byte, e, signature, flatten);
+}
+
+static void sig_size(char b, const struct labcomm2014_signature *signature,
+                     void *context)
+{
+  int *result = context;
+  int diff;
+  if(signature) {
+    int idx = labcomm2014_get_local_index(signature);
+    diff = labcomm2014_size_packed32(idx);
+  }else {
+    diff = 1;
+  }
+    (*result)+=diff;
+}
+
+static int calc_sig_encoded_size(struct labcomm2014_encoder *e,
+                                 const struct labcomm2014_signature *sig)
+{
+  int result=0;
+  map_signature(sig_size, &result, sig, LABCOMM2014_FALSE);
+  return result;
+}
+
+static int internal_reg_type(
+  struct labcomm2014_encoder *e,
+  const struct labcomm2014_signature *signature,
+  labcomm2014_bool flatten)
+{
+  int result = -EINVAL;
+  int index, *done, err;
+  struct encoder *ie = e->context;
+
+  index = labcomm2014_get_local_index(signature);
+  labcomm2014_scheduler_writer_lock(e->scheduler);
+  if (index <= 0) { goto out; }
+  done = LABCOMM_SIGNATURE_ARRAY_REF(e->memory, ie->typedefs, int, index);
+  if (*done) { goto out; }
+  *done = 1;
+  err = labcomm2014_writer_start(e->writer, e->writer->action_context,
+                                 index, signature, NULL);
+  if (err == -EALREADY) { result = 0; goto out; }
+  if (err != 0) { result = err; goto out; }
+
+  printf("internal_reg_type: %s\n", signature->name);
+  int sig_size = calc_sig_encoded_size(e, signature);
+  int len_idx= labcomm2014_size_packed32(index);
+  int len_ints =TODO_sizeof_intentions(signature);
+  int len_sigsize =labcomm2014_size_packed32(sig_size);
+  int len_sig =sig_size;
+
+  int len = len_idx + len_ints + len_sigsize + len_sig;
+
+  labcomm2014_write_packed32(e->writer, LABCOMM_TYPE_DEF);
+  labcomm2014_write_packed32(e->writer, len);
+#ifdef LABCOMM2014_WITH_SANITY_CHECKS
+  encoder_check_write_start(e, len);
+#endif
+  labcomm2014_write_packed32(e->writer, index);
+  TODO_encode_intentions(e, signature);
+  labcomm2014_write_packed32(e->writer, sig_size);
+  do_write_signature(e, signature, LABCOMM2014_FALSE);
+#ifdef LABCOMM2014_WITH_SANITY_CHECKS
+  encoder_check_write_end(e);
+#endif
+  labcomm2014_writer_end(e->writer, e->writer->action_context);
+  result = e->writer->error;
+out:
+  labcomm2014_scheduler_writer_unlock(e->scheduler);
+  return result;
+}
+#endif
+
+static int do_type_register(
+  struct labcomm2014_encoder *e,
+  const struct labcomm2014_signature *signature)
+{
+#ifndef LABCOMM_WITHOUT_TYPE_DEFS
+  return internal_reg_type(e, signature, LABCOMM2014_FALSE);
+#else
+  return 0;
+#endif
+}
+
+static int do_type_bind(
+  struct labcomm2014_encoder *e,
+  const struct labcomm2014_signature *signature,
+  char has_deps)
+{
+#ifndef LABCOMM_WITHOUT_TYPE_DEFS
+  int result = -EINVAL;
+  int err;
+  int sindex = labcomm2014_get_local_index(signature);
+  int tindex = has_deps ? labcomm2014_get_local_type_index(signature) : LABCOMM_BIND_SELF;
+  labcomm2014_scheduler_writer_lock(e->scheduler);
+  if(sindex <= 0 || (has_deps && tindex <= 0)) {goto out;}
+  err = labcomm2014_writer_start(e->writer, e->writer->action_context,
+                LABCOMM_TYPE_BINDING, signature, NULL);
+  if (err == -EALREADY) { result = 0; goto out; }
+  if (err != 0) { result = err; goto out; }
+  int length = (labcomm2014_size_packed32(sindex) +
+                labcomm2014_size_packed32(tindex));
+  labcomm2014_write_packed32(e->writer, LABCOMM_TYPE_BINDING);
+  labcomm2014_write_packed32(e->writer, length);
+  labcomm2014_write_packed32(e->writer, sindex);
+  labcomm2014_write_packed32(e->writer, tindex);
+  labcomm2014_writer_end(e->writer, e->writer->action_context);
+  result = e->writer->error;
+
+out:
+  labcomm2014_scheduler_writer_unlock(e->scheduler);
+  return result;
+#else
+  return 0;
+#endif
+}
+
+static const struct labcomm2014_sample_ref *do_ref_get(
+  struct labcomm2014_encoder *e,
+  const struct labcomm2014_signature *signature)
+{
+  return (const struct labcomm2014_sample_ref *) signature;
+}
+
+void labcomm2014_encoder_free(struct labcomm2014_encoder* e)
+{
+  e->free(e);
+}
+
+static void do_free(struct labcomm2014_encoder* e)
+{
+  struct encoder *ie = e->context;
+  struct labcomm2014_memory *memory = e->memory;
+
+  labcomm2014_writer_free(e->writer, e->writer->action_context);
+  LABCOMM_SIGNATURE_ARRAY_FREE(e->memory, ie->registered, int);
+  LABCOMM_SIGNATURE_ARRAY_FREE(e->memory, ie->sample_ref, int);
+  LABCOMM_SIGNATURE_ARRAY_FREE(e->memory, ie->typedefs, int);
+  labcomm2014_memory_free(memory, 0, ie);
+}
+
+static struct labcomm2014_encoder *internal_encoder_new(
+  struct labcomm2014_writer *writer,
+  struct labcomm2014_error_handler *error,
+  struct labcomm2014_memory *memory,
+  struct labcomm2014_scheduler *scheduler,
+  labcomm2014_bool outputVer)
+{
+  struct encoder *result;
+
+  result = labcomm2014_memory_alloc(memory, 0, sizeof(*result));
+  if (result) {
+    int length;
+
+    result->encoder.context = result;
+    result->encoder.writer = writer;
+    result->encoder.writer->encoder = &result->encoder;
+    result->encoder.writer->data = NULL;
+    result->encoder.writer->data_size = 0;
+    result->encoder.writer->count = 0;
+    result->encoder.writer->pos = 0;
+    result->encoder.writer->error = 0;
+    result->encoder.error = error;
+    result->encoder.memory = memory;
+    result->encoder.scheduler = scheduler;
+    result->encoder.free = do_free;
+    result->encoder.type_register = do_type_register;
+    result->encoder.type_bind = do_type_bind;
+    result->encoder.sample_register = do_sample_register;
+    result->encoder.ref_register = do_ref_register;
+    result->encoder.encode = do_encode;
+    result->encoder.ioctl = do_ioctl;
+    result->encoder.sample_ref_to_index = do_sample_ref_to_index;
+    result->encoder.ref_get = do_ref_get;
+    LABCOMM_SIGNATURE_ARRAY_INIT(result->registered, int);
+    LABCOMM_SIGNATURE_ARRAY_INIT(result->sample_ref, int);
+    LABCOMM_SIGNATURE_ARRAY_INIT(result->typedefs, int);
+    labcomm2014_writer_alloc(result->encoder.writer,
+                             result->encoder.writer->action_context);
+    if(outputVer) {
+        labcomm2014_writer_start(result->encoder.writer,
+                                 result->encoder.writer->action_context,
+                                 LABCOMM_VERSION, NULL, CURRENT_VERSION);
+        labcomm2014_write_packed32(result->encoder.writer, LABCOMM_VERSION);
+        length = labcomm2014_size_string(CURRENT_VERSION);
+        labcomm2014_write_packed32(result->encoder.writer, length);
+        labcomm2014_write_string(result->encoder.writer, CURRENT_VERSION);
+        labcomm2014_writer_end(result->encoder.writer,
+                               result->encoder.writer->action_context);
+    }
+  }
+  return &(result->encoder);
+}
+
+struct labcomm2014_encoder *labcomm2014_encoder_new(
+  struct labcomm2014_writer *writer,
+  struct labcomm2014_error_handler *error,
+  struct labcomm2014_memory *memory,
+  struct labcomm2014_scheduler *scheduler)
+{
+    return internal_encoder_new(writer,error,memory,scheduler,LABCOMM2014_TRUE);
+}
+
+
+const struct labcomm2014_sample_ref *labcomm2014_encoder_get_sample_ref(
+  struct labcomm2014_encoder *encoder,
+  const struct labcomm2014_signature *signature)
+{
+  return encoder->ref_get(encoder, signature);
+}
+  

lib/c/2014/labcomm2014_error.c

+/*
+  labcomm2014_error.c -- labcomm2014 error handling
+
+  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 <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include "labcomm2014_error.h"
+
+static char *description[] = {
+#define LABCOMM2014_ERROR(name, description) description ,
+#include "labcomm2014_error.h"
+#undef LABCOMM2014_ERROR
+};
+
+void labcomm2014_error_fatal_global(enum labcomm2014_error error,
+                                    char *format,
+                                    ...)
+{
+  va_list args;
+
+  fprintf(stderr, "Fatal error %d (%s)\n", error, description[error]);
+  va_start(args, format);
+  vfprintf(stderr, format, args);
+  va_end(args);
+
+  exit(1);
+}
+
+void labcomm2014_error_warning(struct labcomm2014_error_handler *e,
+                               enum labcomm2014_error error,
+                               char *format,
+                               ...)
+{
+  va_list args;
+
+  fprintf(stderr, "Fatal warning %d (%s)\n", error, description[error]);
+  va_start(args, format);
+  vfprintf(stderr, format, args);
+  va_end(args);
+
+  exit(1);
+}
+                         

lib/c/2014/labcomm2014_error.h

+/*
+  labcomm2014_error.h -- labcomm2014 error declarations
+
+  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 __LABCOMM2014_ERROR_H___
+#define __LABCOMM2014_ERROR_H___
+
+enum labcomm2014_error {
+#define LABCOMM2014_ERROR(name, description) name ,
+#include "labcomm2014_error.h"
+#undef LABCOMM2014_ERROR
+};
+
+struct labcomm2014_error_handler;
+
+void labcomm2014_error_warning(struct labcomm2014_error_handler *e,
+			   enum labcomm2014_error,
+			   char *format,
+			   ...);
+			 
+void labcomm2014_error_fatal_global(enum labcomm2014_error error,
+				char *format,
+				...);
+			 
+#endif
+
+#ifdef LABCOMM2014_ERROR
+
+LABCOMM2014_ERROR(LABCOMM2014_ERROR_SIGNATURE_ALREADY_SET,
+                  "Signature has already been set")
+LABCOMM2014_ERROR(LABCOMM2014_ERROR_SIGNATURE_NOT_SET,
+                  "Signature has not been set")
+
+LABCOMM2014_ERROR(LABCOMM2014_ERROR_ENC_NO_REG_SIGNATURE,
+                  "Encoder has no registration for this signature")
+LABCOMM2014_ERROR(LABCOMM2014_ERROR_ENC_BUF_FULL,
+                  "The labcomm2014 buffer is full")
+
+LABCOMM2014_ERROR(LABCOMM2014_ERROR_DEC_NO_REG_SIGNATURE,
+                  "Decoder has no registration for this signature")
+LABCOMM2014_ERROR(LABCOMM2014_ERROR_DEC_UNKNOWN_DATATYPE,
+                  "Decoder: Unknown datatype")
+LABCOMM2014_ERROR(LABCOMM2014_ERROR_DEC_INDEX_MISMATCH,
+                  "Decoder: index mismatch")
+LABCOMM2014_ERROR(LABCOMM2014_ERROR_DEC_TYPE_NOT_FOUND,
+                  "Decoder: type not found")
+LABCOMM2014_ERROR(LABCOMM2014_ERROR_UNIMPLEMENTED_FUNC,
+                  "This function is not yet implemented")
+LABCOMM2014_ERROR(LABCOMM2014_ERROR_MEMORY,
+                  "Could not allocate memory")
+LABCOMM2014_ERROR(LABCOMM2014_ERROR_USER_DEF,
+                  "User defined error")
+LABCOMM2014_ERROR(LABCOMM2014_ERROR_BAD_WRITER,
+                  "Decoder: writer_ioctl() failed")
+
+#endif