lib/c/experimental/test_sig_parser.c → lib/c/2014/experimental/test_sig_parser.c

-/* labcomm_sig_parser.c:
+/* labcomm2014_sig_parser.c:
  * a main program for the example labcomm signatures parser
  */
 
 #include <stdio.h>
+#include <stdlib.h>
 
-#include "labcomm_sig_parser.h"
+#include "experimental/labcomm2014_sig_parser.h"
 
-#undef DEBUG_READ
+#define DEBUG_READ
 
 #define BUF_SIZE 1024
 #define STACK_SIZE 16
 #define MAX_NUM_SIGNATURES 10
-#define MAX_SIGNATURES 16
-#define MAX_NAME_LEN 32
-#define MAX_SIG_LEN 128
+#define MAX_SIGNATURES 100
+#define MAX_NAME_LEN 64
+#define MAX_SIG_LEN 512
 
-void test_read(labcomm_sig_parser_t *p) {
-	int r = labcomm_sig_parser_read_file(p, stdin);
+void test_read(labcomm2014_sig_parser_t *p) {
+	int r = labcomm2014_sig_parser_read_file(p, stdin);
 #ifdef DEBUG_READ
 	printf("read %d bytes:\n\n", r);
 	int i;
@@ -28,9 +29,9 @@ void test_read(labcomm_sig_parser_t *p) {
 #endif
 }
 int main() {
-	labcomm_sig_parser_t p;
+	labcomm2014_sig_parser_t p;
 
-	if(labcomm_sig_parser_init(&p, BUF_SIZE, STACK_SIZE, 
+	if(labcomm2014_sig_parser_init(&p, BUF_SIZE, STACK_SIZE, 
                                    MAX_NUM_SIGNATURES, MAX_NAME_LEN, MAX_SIG_LEN) ) {
 		printf("failed to init buffer\n");
 		exit(1);
@@ -40,5 +41,6 @@ int main() {
 		printf("--------------------------------------------- new packet: \n");
 	} while(more(&p) && accept_packet(&p)); 
 	printf("EOF\n");
+    labcomm2014_sig_parser_free(&p);
 }
 

lib/c/labcomm.c → lib/c/2014/labcomm2014.c

 /*
-  labcomm.c -- runtime for handling encoding and decoding of
-               labcomm samples.
+  labcomm2014.c -- runtime for handling encoding and decoding of
+               labcomm2014 samples.
 
   Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
 
@@ -32,12 +32,10 @@
 #include <stdarg.h>
 #include <stddef.h>
 
-#include "labcomm.h"
-#include "labcomm_private.h"
-#include "labcomm_ioctl.h"
-#include "labcomm_dynamic_buffer_writer.h"
-
-#define LABCOMM_VERSION "LabComm2013"
+#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
@@ -49,91 +47,89 @@
     UNWRAP_ac( __VA_ARGS__) = UNWRAP_ac(__VA_ARGS__)->next;		\
   }
 
-int labcomm_reader_alloc(struct labcomm_reader *r, 
-                         struct labcomm_reader_action_context *action_context, 
-                         char *labcomm_version)
+int labcomm2014_reader_alloc(struct labcomm2014_reader *r,
+                         struct labcomm2014_reader_action_context *action_context)
 {
-  UNWRAP(alloc, r, action_context, labcomm_version);
+  UNWRAP(alloc, r, action_context);
 }
 
-int labcomm_reader_free(struct labcomm_reader *r, 
-                        struct labcomm_reader_action_context *action_context)
+int labcomm2014_reader_free(struct labcomm2014_reader *r,
+                        struct labcomm2014_reader_action_context *action_context)
 {
   UNWRAP(free, r, action_context);
 }
 
-int labcomm_reader_start(struct labcomm_reader *r, 
-                         struct labcomm_reader_action_context *action_context,
+int labcomm2014_reader_start(struct labcomm2014_reader *r,
+                         struct labcomm2014_reader_action_context *action_context,
 			 int local_index, int remote_index,
-			 struct labcomm_signature *signature,
+			 const struct labcomm2014_signature *signature,
 			 void *value)
 {
   UNWRAP(start, r, action_context, local_index, remote_index, signature, value);
 }
 
-int labcomm_reader_end(struct labcomm_reader *r, 
-                       struct labcomm_reader_action_context *action_context)
+int labcomm2014_reader_end(struct labcomm2014_reader *r,
+                       struct labcomm2014_reader_action_context *action_context)
 {
   UNWRAP(end, r, action_context);
 }
 
-int labcomm_reader_fill(struct labcomm_reader *r, 
-                        struct labcomm_reader_action_context *action_context)
+int labcomm2014_reader_fill(struct labcomm2014_reader *r,
+                        struct labcomm2014_reader_action_context *action_context)
 {
   UNWRAP(fill, r, action_context);
 }
 
-int labcomm_reader_ioctl(struct labcomm_reader *r, 
-                         struct labcomm_reader_action_context *action_context,
+int labcomm2014_reader_ioctl(struct labcomm2014_reader *r,
+                         struct labcomm2014_reader_action_context *action_context,
                          int local_index, int remote_index,
-                         struct labcomm_signature *signature, 
+                         const struct labcomm2014_signature *signature,
                          uint32_t ioctl_action, va_list args)
 {
-  UNWRAP(ioctl, r, action_context, 
+  UNWRAP(ioctl, r, action_context,
 	 local_index, remote_index, signature, ioctl_action, args);
 }
 
-int labcomm_writer_alloc(struct labcomm_writer *w, 
-                         struct labcomm_writer_action_context *action_context, 
-                         char *labcomm_version)
+int labcomm2014_writer_alloc(struct labcomm2014_writer *w,
+                         struct labcomm2014_writer_action_context *action_context)
 {
-  UNWRAP(alloc, w, action_context, labcomm_version);
+  UNWRAP(alloc, w, action_context);
 }
 
-int labcomm_writer_free(struct labcomm_writer *w, 
-                        struct labcomm_writer_action_context *action_context)
+int labcomm2014_writer_free(struct labcomm2014_writer *w,
+                        struct labcomm2014_writer_action_context *action_context)
 {
   UNWRAP(free, w, action_context);
 }
 
-int labcomm_writer_start(struct labcomm_writer *w, 
-                         struct labcomm_writer_action_context *action_context,
-                         int index, struct labcomm_signature *signature,
+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 labcomm_writer_end(struct labcomm_writer *w, 
-                       struct labcomm_writer_action_context *action_context)
+int labcomm2014_writer_end(struct labcomm2014_writer *w,
+                       struct labcomm2014_writer_action_context *action_context)
 {
   UNWRAP(end, w, action_context);
-} 
+}
 
-int labcomm_writer_flush(struct labcomm_writer *w, 
-                         struct labcomm_writer_action_context *action_context)
+int labcomm2014_writer_flush(struct labcomm2014_writer *w,
+                         struct labcomm2014_writer_action_context *action_context)
 {
   UNWRAP(flush, w, action_context);
-} 
+}
 
-int labcomm_writer_ioctl(struct labcomm_writer *w, 
-                         struct labcomm_writer_action_context *action_context, 
-                         int index, 
-                         struct labcomm_signature *signature, 
+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
@@ -141,29 +137,29 @@ int labcomm_writer_ioctl(struct labcomm_writer *w,
 
 
 
-static const char *labcomm_error_string[] = { 
-#define LABCOMM_ERROR(name, description) description ,
-#include "labcomm_error.h"
-#undef LABCOMM_ERROR
+static const char *labcomm2014_error_string[] = {
+#define LABCOMM2014_ERROR(name, description) description ,
+#include "labcomm2014_error.h"
+#undef LABCOMM2014_ERROR
 };
-static const int labcomm_error_string_count = (sizeof(labcomm_error_string) / 
-					       sizeof(labcomm_error_string[0]));
+static const int labcomm2014_error_string_count = (sizeof(labcomm2014_error_string) /
+					       sizeof(labcomm2014_error_string[0]));
 
 
-const char *labcomm_error_get_str(enum labcomm_error error_id)
+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 < labcomm_error_string_count) {
-    error_str = labcomm_error_string[error_id];
+  if (error_id < labcomm2014_error_string_count) {
+    error_str = labcomm2014_error_string[error_id];
   }
   return error_str;
 }
 
-void on_error_fprintf(enum labcomm_error error_id, size_t nbr_va_args, ...)
+void labcomm20142014_on_error_fprintf(enum labcomm2014_error error_id, size_t nbr_va_args, ...)
 {
 #ifndef LABCOMM_NO_STDIO
-  const char *err_msg = labcomm_error_get_str(error_id); // The final string to print.
+  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.";
   }
@@ -179,9 +175,9 @@ void on_error_fprintf(enum labcomm_error error_id, size_t nbr_va_args, ...)
    fprintf(stderr, "}\n");
 
    va_end(arg_pointer);
- } 
+ }
 #else
- ; // If labcomm can't be compiled with stdio the user will have to make an own error callback functionif he/she needs error reporting.
+ ; // 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
 }
 
@@ -203,16 +199,16 @@ static void dump(void *p, int size, int first, int last)
 }
 #endif
 
-void *labcomm_signature_array_ref(struct labcomm_memory *memory,
+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 = labcomm_memory_alloc(memory, 0, size);
-    if (*data) { 
-      memset(*data, 0, size); 
+    *data = labcomm2014_memory_alloc(memory, 0, size);
+    if (*data) {
+      memset(*data, 0, size);
     }
   } else if (index < *first || *last <= index) {
     void *old_data = *data;
@@ -222,15 +218,15 @@ void *labcomm_signature_array_ref(struct labcomm_memory *memory,
     *first = (index<old_first)?index:old_first;
     *last = (old_last<=index)?index+1:old_last;
     n = (*last - *first);
-    *data = labcomm_memory_alloc(memory, 0, n * size);
+    *data = labcomm2014_memory_alloc(memory, 0, n * size);
     if (*data) {
       memset(*data, 0, n * size);
-      memcpy(*data + (old_first - *first) * size, 
-	     old_data, 
+      memcpy(*data + (old_first - *first) * size,
+	     old_data,
 	     (old_last - old_first) * size);
     }
 //    dump(old_data, size, old_first, old_last);
-    labcomm_memory_free(memory, 0, old_data);
+    labcomm2014_memory_free(memory, 0, old_data);
   }
   if (*data) {
 //    dump(*data, size, *first, *last);
@@ -240,23 +236,45 @@ void *labcomm_signature_array_ref(struct labcomm_memory *memory,
   }
 }
 
-static int local_index = 0x40;
+static int local_index = LABCOMM_USER;
 
-void labcomm_set_local_index(struct labcomm_signature *signature)
+void labcomm2014_set_local_index(struct labcomm2014_signature *signature)
 {
   if (signature->index != 0) {
-    labcomm_error_fatal_global(LABCOMM_ERROR_SIGNATURE_ALREADY_SET,
-			       "%s", signature->name);
+    labcomm2014_error_fatal_global(LABCOMM2014_ERROR_SIGNATURE_ALREADY_SET,
+			       "Signature already set: %s\n", signature->name);
   }
   signature->index = local_index;
   local_index++;
 }
 
-int labcomm_get_local_index(struct labcomm_signature *signature)
+int labcomm2014_get_local_index(const struct labcomm2014_signature *signature)
 {
-  if (signature->index == 0) {
-    labcomm_error_fatal_global(LABCOMM_ERROR_SIGNATURE_NOT_SET,
-			       "%s", signature->name);
+  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 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/labcomm.h → lib/c/2014/labcomm2014.h

 /*
-  labcomm.h -- user interface for handling encoding and decoding of
-               labcomm samples.
+  labcomm2014.h -- user interface for handling encoding and decoding of
+               labcomm2014 samples.
 
   Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
 
@@ -20,32 +20,26 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef _LABCOMM_H_
-#define _LABCOMM_H_
+#ifndef __LABCOMM2014_H__
+#define __LABCOMM2014_H__
 
 #include <stdarg.h>
-#include <stdint.h>
-#include <unistd.h>
-#include "labcomm_error.h"
-#include "labcomm_scheduler.h"
 
-/* Forward declaration */
-struct labcomm_encoder;
-struct labcomm_decoder;
+#ifdef LABCOMM_COMPAT
+  #include LABCOMM_COMPAT
+#else
+  #include <stdint.h>
+  #include <unistd.h>
+#endif
 
-/*
- * Signature entry
- */
-struct labcomm_signature {
-  int type;
-  char *name;
-  int (*encoded_size)(struct labcomm_signature *, void *); // void * == encoded_sample *
-  int size;
-  unsigned char *signature; 
-  int index;
-  int cached_encoded_size; // -1 if not initialized or type is variable size
-};
+#include "labcomm2014_error.h"
+#include "labcomm2014_scheduler.h"
 
+/* Forward declaration */
+struct labcomm2014_encoder;
+struct labcomm2014_decoder;
+
+#include "labcomm2014_type_signature.h"
 /*
  * Error handling.
  */
@@ -57,29 +51,26 @@ struct labcomm_signature {
  * Optionaly other paramters can be supplied depending on what is needed 
  * for this error ID.
  */
-typedef void (*labcomm_error_handler_callback)(enum labcomm_error 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 on_error_fprintf(enum labcomm_error error_id, size_t nbr_va_args, ...);
+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 labcomm_register_error_handler_encoder(struct labcomm_encoder *encoder, labcomm_error_handler_callback callback);
+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 labcomm_register_error_handler_decoder(struct labcomm_decoder *decoder, labcomm_error_handler_callback callback);
-
-/* Get a string describing the supplied standrad labcomm error. */
-const char *labcomm_error_get_str(enum labcomm_error error_id);
+void labcomm2014_register_error_handler_decoder(struct labcomm2014_decoder *decoder, labcomm2014_error_handler_callback callback);
 
-typedef int (*labcomm_handle_new_datatype_callback)(
-  struct labcomm_decoder *decoder,
-  struct labcomm_signature *sig);
+/* Get a string describing the supplied standrad labcomm2014 error. */
+const char *labcomm2014_error_get_str(enum labcomm2014_error error_id);
 
-void labcomm_decoder_register_new_datatype_handler(struct labcomm_decoder *d,
-		labcomm_handle_new_datatype_callback on_new_datatype);
+typedef int (*labcomm2014_handle_new_datatype_callback)(
+  struct labcomm2014_decoder *decoder,
+  struct labcomm2014_signature *sig);
 
 /*
  * Dynamic memory handling
@@ -89,53 +80,65 @@ void labcomm_decoder_register_new_datatype_handler(struct labcomm_decoder *d,
  *   otherwise         memory will live for approximately this number of
  *                     sent/received samples
  */
-struct labcomm_memory;
+struct labcomm2014_memory;
 
-void *labcomm_memory_alloc(struct labcomm_memory *m, int lifetime, size_t size);
-void *labcomm_memory_realloc(struct labcomm_memory *m, int lifetime, 
+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 labcomm_memory_free(struct labcomm_memory *m, int lifetime, void *ptr);
+void labcomm2014_memory_free(struct labcomm2014_memory *m, int lifetime, void *ptr);
 
 /*
  * Decoder
  */
-struct labcomm_reader;
-
-struct labcomm_decoder *labcomm_decoder_new(
-  struct labcomm_reader *reader,
-  struct labcomm_error_handler *error,
-  struct labcomm_memory *memory,
-  struct labcomm_scheduler *scheduler);
-void labcomm_decoder_free(
-  struct labcomm_decoder *decoder);
-int labcomm_decoder_decode_one(
-  struct labcomm_decoder *decoder);
-void labcomm_decoder_run(
-  struct labcomm_decoder *decoder);
-
-/* See labcomm_ioctl.h for predefined ioctl_action values */
-int labcomm_decoder_ioctl(struct labcomm_decoder *decoder, 
-			  uint32_t ioctl_action,
-			  ...);
+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 labcomm_writer;
-
-struct labcomm_encoder *labcomm_encoder_new(
-  struct labcomm_writer *writer,
-  struct labcomm_error_handler *error,
-  struct labcomm_memory *memory,
-  struct labcomm_scheduler *scheduler);
-void labcomm_encoder_free(
-  struct labcomm_encoder *encoder);
-
-/* See labcomm_ioctl.h for predefined ioctl_action values */
-int labcomm_encoder_ioctl(struct labcomm_encoder *encoder, 
-			  uint32_t ioctl_action,
-			  ...);
-
-#define LABCOMM_VOID ((void*)1)
+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/labcomm_compat_vxworks.h → 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
@@ -10,3 +25,6 @@
   #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/labcomm_default_error_handler.c → lib/c/2014/labcomm2014_default_error_handler.c

@@ -19,6 +19,6 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include "labcomm.h"
+#include "labcomm2014.h"
 
-struct labcomm_error_handler *labcomm_default_error_handler = NULL;
+struct labcomm2014_error_handler *labcomm2014_default_error_handler = NULL;

lib/c/labcomm_default_error_handler.h → lib/c/2014/labcomm2014_default_error_handler.h

@@ -18,7 +18,11 @@
   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 "labcomm.h"
+#include "labcomm2014.h"
 
-extern struct labcomm_error_handler *labcomm_default_error_handler;
+extern struct labcomm2014_error_handler *labcomm2014_default_error_handler;
+
+#endif

lib/c/labcomm_default_memory.c → lib/c/2014/labcomm2014_default_memory.c

@@ -20,30 +20,30 @@
 */
 
 #include <stdlib.h>
-#include "labcomm.h"
-#include "labcomm_private.h"
+#include "labcomm2014.h"
+#include "labcomm2014_private.h"
 
-void *default_alloc(struct labcomm_memory *m, int lifetime, size_t size)
+void *default_alloc(struct labcomm2014_memory *m, int lifetime, size_t size)
 {
   return malloc(size);
 }
 
-void *default_realloc(struct labcomm_memory *m, int lifetime, 
+void *default_realloc(struct labcomm2014_memory *m, int lifetime, 
 		      void *ptr, size_t size)
 {
   return realloc(ptr, size);
 }
 
-void default_free(struct labcomm_memory *m, int lifetime, void *ptr)
+void default_free(struct labcomm2014_memory *m, int lifetime, void *ptr)
 {
   free(ptr);
 }
 
-struct labcomm_memory memory = {
+struct labcomm2014_memory memory = {
   .alloc = default_alloc,
   .realloc = default_realloc,
   .free = default_free,
   .context = NULL
 };
 
-struct labcomm_memory *labcomm_default_memory = &memory;
+struct labcomm2014_memory *labcomm2014_default_memory = &memory;

lib/c/labcomm_default_memory.h → lib/c/2014/labcomm2014_default_memory.h

@@ -18,10 +18,12 @@
   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 "labcomm.h"
-#include "labcomm_private.h"
+#include "labcomm2014.h"
 
-extern struct labcomm_memory *labcomm_default_memory;
+extern struct labcomm2014_memory *labcomm2014_default_memory;
 
+#endif

lib/c/labcomm_default_scheduler.c → lib/c/2014/labcomm2014_default_scheduler.c

@@ -21,11 +21,11 @@
 
 #include <stdio.h>
 #include <stdlib.h>
-#include "labcomm_default_scheduler.h"
-#include "labcomm_scheduler.h"
-#include "labcomm_scheduler_private.h"
+#include "labcomm2014_default_scheduler.h"
+#include "labcomm2014_scheduler.h"
+#include "labcomm2014_scheduler_private.h"
 
-static int scheduler_free(struct labcomm_scheduler *s)
+static int scheduler_free(struct labcomm2014_scheduler *s)
 {
   fprintf(stderr, "%s:%d %s %s", __FILE__, __LINE__, __FUNCTION__,
 	  "not implemented");
@@ -33,27 +33,27 @@ static int scheduler_free(struct labcomm_scheduler *s)
   return 0;
 }
  
-static int scheduler_writer_lock(struct labcomm_scheduler *s)
+static int scheduler_writer_lock(struct labcomm2014_scheduler *s)
 {
   return 0;
 }
  
-static int scheduler_writer_unlock(struct labcomm_scheduler *s)
+static int scheduler_writer_unlock(struct labcomm2014_scheduler *s)
 {
   return 0;
 }
 
-static int scheduler_data_lock(struct labcomm_scheduler *s)
+static int scheduler_data_lock(struct labcomm2014_scheduler *s)
 {
   return 0;
 }
  
-static int scheduler_data_unlock(struct labcomm_scheduler *s)
+static int scheduler_data_unlock(struct labcomm2014_scheduler *s)
 {
   return 0;
 }
 
-static struct labcomm_time *scheduler_now(struct labcomm_scheduler *s)
+static struct labcomm2014_time *scheduler_now(struct labcomm2014_scheduler *s)
 {
   fprintf(stderr, "%s:%d %s %s", __FILE__, __LINE__, __FUNCTION__,
 	  "not implemented");
@@ -61,8 +61,8 @@ static struct labcomm_time *scheduler_now(struct labcomm_scheduler *s)
   return NULL;
 }
  
-static int scheduler_sleep(struct labcomm_scheduler *s,
-			   struct labcomm_time *t)
+static int scheduler_sleep(struct labcomm2014_scheduler *s,
+			   struct labcomm2014_time *t)
 {
   fprintf(stderr, "%s:%d %s %s", __FILE__, __LINE__, __FUNCTION__,
 	  "not implemented");
@@ -70,7 +70,7 @@ static int scheduler_sleep(struct labcomm_scheduler *s,
   return 0;
 }
 
-static int scheduler_wakeup(struct labcomm_scheduler *s)
+static int scheduler_wakeup(struct labcomm2014_scheduler *s)
 {
   fprintf(stderr, "%s:%d %s %s", __FILE__, __LINE__, __FUNCTION__,
 	  "not implemented");
@@ -78,8 +78,8 @@ static int scheduler_wakeup(struct labcomm_scheduler *s)
   return 0;
 }
 
-static int scheduler_enqueue(struct labcomm_scheduler *s,
-			     useconds_t delay,
+static int scheduler_enqueue(struct labcomm2014_scheduler *s,
+			     uint32_t delay,
 			     void (*deferred)(void *context),
 			     void *context)
 {
@@ -89,7 +89,7 @@ static int scheduler_enqueue(struct labcomm_scheduler *s,
   return 0;
 }
 
-static const struct labcomm_scheduler_action scheduler_action = {
+static const struct labcomm2014_scheduler_action scheduler_action = {
   .free = scheduler_free,
   .writer_lock = scheduler_writer_lock,
   .writer_unlock = scheduler_writer_unlock,
@@ -101,9 +101,9 @@ static const struct labcomm_scheduler_action scheduler_action = {
   .enqueue = scheduler_enqueue  
 };
 
-static struct labcomm_scheduler scheduler = {
+static struct labcomm2014_scheduler scheduler = {
   .action = &scheduler_action,
   .context = NULL
 };
 
-struct labcomm_scheduler *labcomm_default_scheduler = &scheduler;
+struct labcomm2014_scheduler *labcomm2014_default_scheduler = &scheduler;

lib/c/labcomm_default_scheduler.h → lib/c/2014/labcomm2014_default_scheduler.h

@@ -18,7 +18,11 @@
   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 "labcomm.h"
+#include "labcomm2014.h"
 
-extern struct labcomm_scheduler *labcomm_default_scheduler;
+extern struct labcomm2014_scheduler *labcomm2014_default_scheduler;
+
+#endif