From e3c16fdacde72d618cd0a9f36b93fb6121e43dfc Mon Sep 17 00:00:00 2001
From: Anders Blomdell <anders.blomdell@control.lth.se>
Date: Tue, 24 Feb 2015 13:19:32 +0100
Subject: [PATCH] Changed 'labcomm' to 'labcomm2014' for C-code.

---
 compiler/2014/C_CodeGen.jrag                  | 166 ++++----
 examples/simple/example_decoder.c             |  36 +-
 examples/simple/example_encoder.c             |  48 +--
 examples/twoway/client.c                      |  78 ++--
 examples/twoway/decimating.c                  |  94 ++---
 examples/twoway/decimating.h                  |  18 +-
 examples/twoway/introspecting.c               |  98 ++---
 examples/twoway/introspecting.h               |  22 +-
 examples/twoway/server.c                      |  68 +--
 examples/user_types/example_decoder.c         |  46 +-
 examples/user_types/example_encoder.c         |  24 +-
 examples/wiki_example/example_encoder.c       |  26 +-
 lib/c/2014/Makefile                           |   2 +-
 lib/c/2014/labcomm.h                          | 138 ------
 lib/c/2014/{labcomm.c => labcomm2014.c}       | 114 ++---
 lib/c/2014/labcomm2014.h                      | 138 ++++++
 ...m3.h => labcomm2014_compat_arm_cortexm3.h} |   0
 ..._compat_osx.h => labcomm2014_compat_osx.h} |   0
 ...vxworks.h => labcomm2014_compat_vxworks.h} |   0
 ...abcomm_decoder.c => labcomm2014_decoder.c} | 284 ++++++-------
 ....c => labcomm2014_default_error_handler.c} |   4 +-
 ....h => labcomm2014_default_error_handler.h} |   8 +-
 ..._memory.c => labcomm2014_default_memory.c} |  14 +-
 ..._memory.h => labcomm2014_default_memory.h} |   8 +-
 ...uler.c => labcomm2014_default_scheduler.c} |  32 +-
 ...uler.h => labcomm2014_default_scheduler.h} |   8 +-
 ....c => labcomm2014_dynamic_buffer_writer.c} |  62 +--
 ....h => labcomm2014_dynamic_buffer_writer.h} |  14 +-
 lib/c/2014/labcomm2014_encoder.c              | 398 ++++++++++++++++++
 .../{labcomm_error.c => labcomm2014_error.c}  |   6 +-
 .../{labcomm_error.h => labcomm2014_error.h}  |  20 +-
 ...mm_fd_reader.c => labcomm2014_fd_reader.c} |  44 +-
 ...mm_fd_reader.h => labcomm2014_fd_reader.h} |  10 +-
 ...mm_fd_writer.c => labcomm2014_fd_writer.c} |  54 +--
 ...mm_fd_writer.h => labcomm2014_fd_writer.h} |  10 +-
 .../{labcomm_ioctl.h => labcomm2014_ioctl.h}  |  10 +-
 ...{labcomm_memory.c => labcomm2014_memory.c} |  10 +-
 ...abcomm_private.h => labcomm2014_private.h} | 300 ++++++-------
 ...uler.c => labcomm2014_pthread_scheduler.c} |  98 ++---
 ...uler.h => labcomm2014_pthread_scheduler.h} |  12 +-
 ...mm_scheduler.c => labcomm2014_scheduler.c} |  24 +-
 ...mm_scheduler.h => labcomm2014_scheduler.h} |  34 +-
 lib/c/2014/labcomm2014_scheduler_private.h    |  60 +++
 .../{labcomm_time.c => labcomm2014_time.c}    |   8 +-
 ...gnature.c => labcomm2014_type_signature.c} |  32 +-
 ...gnature.h => labcomm2014_type_signature.h} |  46 +-
 lib/c/2014/labcomm_encoder.c                  | 398 ------------------
 lib/c/2014/labcomm_scheduler_private.h        |  60 ---
 lib/c/2014/test/test_labcomm.c                |  88 ++--
 .../test/test_labcomm_basic_type_encoding.c   |  12 +-
 lib/c/2014/test/test_labcomm_copy.c           | 170 ++++----
 .../test/test_labcomm_generated_encoding.c    | 132 +++---
 .../test/test_labcomm_pthread_scheduler.c     |  32 +-
 lib/c/2014/test/test_signature_numbers.c      |  10 +-
 lib/c/version_compare.py                      |   6 +-
 test/relay_gen_c.py                           |  56 ++-
 56 files changed, 1842 insertions(+), 1848 deletions(-)
 delete mode 100644 lib/c/2014/labcomm.h
 rename lib/c/2014/{labcomm.c => labcomm2014.c} (54%)
 create mode 100644 lib/c/2014/labcomm2014.h
 rename lib/c/2014/{labcomm_compat_arm_cortexm3.h => labcomm2014_compat_arm_cortexm3.h} (100%)
 rename lib/c/2014/{labcomm_compat_osx.h => labcomm2014_compat_osx.h} (100%)
 rename lib/c/2014/{labcomm_compat_vxworks.h => labcomm2014_compat_vxworks.h} (100%)
 rename lib/c/2014/{labcomm_decoder.c => labcomm2014_decoder.c} (63%)
 rename lib/c/2014/{labcomm_default_error_handler.c => labcomm2014_default_error_handler.c} (88%)
 rename lib/c/2014/{labcomm_default_error_handler.h => labcomm2014_default_error_handler.h} (80%)
 rename lib/c/2014/{labcomm_default_memory.c => labcomm2014_default_memory.c} (73%)
 rename lib/c/2014/{labcomm_default_memory.h => labcomm2014_default_memory.h} (82%)
 rename lib/c/2014/{labcomm_default_scheduler.c => labcomm2014_default_scheduler.c} (67%)
 rename lib/c/2014/{labcomm_default_scheduler.h => labcomm2014_default_scheduler.h} (81%)
 rename lib/c/2014/{labcomm_dynamic_buffer_writer.c => labcomm2014_dynamic_buffer_writer.c} (57%)
 rename lib/c/2014/{labcomm_dynamic_buffer_writer.h => labcomm2014_dynamic_buffer_writer.h} (65%)
 create mode 100644 lib/c/2014/labcomm2014_encoder.c
 rename lib/c/2014/{labcomm_error.c => labcomm2014_error.c} (86%)
 rename lib/c/2014/{labcomm_error.h => labcomm2014_error.h} (81%)
 rename lib/c/2014/{labcomm_fd_reader.c => labcomm2014_fd_reader.c} (64%)
 rename lib/c/2014/{labcomm_fd_reader.h => labcomm2014_fd_reader.h} (75%)
 rename lib/c/2014/{labcomm_fd_writer.c => labcomm2014_fd_writer.c} (60%)
 rename lib/c/2014/{labcomm_fd_writer.h => labcomm2014_fd_writer.h} (75%)
 rename lib/c/2014/{labcomm_ioctl.h => labcomm2014_ioctl.h} (95%)
 rename lib/c/2014/{labcomm_memory.c => labcomm2014_memory.c} (74%)
 rename lib/c/2014/{labcomm_private.h => labcomm2014_private.h} (52%)
 rename lib/c/2014/{labcomm_pthread_scheduler.c => labcomm2014_pthread_scheduler.c} (75%)
 rename lib/c/2014/{labcomm_pthread_scheduler.h => labcomm2014_pthread_scheduler.h} (71%)
 rename lib/c/2014/{labcomm_scheduler.c => labcomm2014_scheduler.c} (66%)
 rename lib/c/2014/{labcomm_scheduler.h => labcomm2014_scheduler.h} (50%)
 create mode 100644 lib/c/2014/labcomm2014_scheduler_private.h
 rename lib/c/2014/{labcomm_time.c => labcomm2014_time.c} (82%)
 rename lib/c/2014/{labcomm_type_signature.c => labcomm2014_type_signature.c} (70%)
 rename lib/c/2014/{labcomm_type_signature.h => labcomm2014_type_signature.h} (67%)
 delete mode 100644 lib/c/2014/labcomm_encoder.c
 delete mode 100644 lib/c/2014/labcomm_scheduler_private.h

diff --git a/compiler/2014/C_CodeGen.jrag b/compiler/2014/C_CodeGen.jrag
index d0dc920..9b7cac5 100644
--- a/compiler/2014/C_CodeGen.jrag
+++ b/compiler/2014/C_CodeGen.jrag
@@ -192,7 +192,7 @@ aspect C_CodeGen {
     env.println("");
 
     // Include
-    env.println("#include \"labcomm"+env.verStr+".h\"");
+    env.println("#include \"labcomm2014.h\"");
     for (int i = 0 ; i < includes.size() ; i++) {
       env.println("#include \"" + includes.get(i) + "\"");
     }
@@ -208,8 +208,8 @@ aspect C_CodeGen {
     C_env env = new C_env("", lcName, prefix, out, version);
 
     // Include
-    env.println("#include \"labcomm"+env.verStr+".h\"");
-    env.println("#include \"labcomm"+env.verStr+"_private.h\"");
+    env.println("#include \"labcomm2014.h\"");
+    env.println("#include \"labcomm2014_private.h\"");
     for (int i = 0 ; i < includes.size() ; i++) {
       env.println("#include \"" + includes.get(i) + "\"");
     }
@@ -285,8 +285,8 @@ aspect C_Type {
     env.println(";");
     env.println("#define LABCOMM_DEFINED_" + env.prefix + getName());
     env.println("#endif");
-    env.println("extern const struct labcomm"+env.verStr+"_signature " +
-                "*labcomm"+env.verStr+"_signature_" + env.prefix + getName() + 
+    env.println("extern const struct labcomm2014_signature " +
+                "*labcomm2014_signature_" + env.prefix + getName() + 
                 ";");
   }
 
@@ -311,7 +311,7 @@ aspect C_Type {
       case LABCOMM_DOUBLE: { env.print("double"); } break;
       case LABCOMM_STRING: { env.print("char*"); } break;
       case LABCOMM_SAMPLE: { 
-        env.print("const struct labcomm_signature *"); 
+        env.print("const struct labcomm2014_signature *"); 
       } break;
     }
     env.print(" " + name);
@@ -383,10 +383,10 @@ aspect C_Declarations {
   }
 
   public void SampleDecl.C_emitDecoderDeclaration(C_env env) {
-    env.println("int labcomm"+env.verStr+"_decoder_register_" + 
+    env.println("int labcomm2014_decoder_register_" + 
 		env.prefix + getName() + "(");
     env.indent();
-    env.println("struct labcomm"+env.verStr+"_decoder *d,");
+    env.println("struct labcomm2014_decoder *d,");
     env.println("void (*handler)(");
     env.indent();
     env.println(env.prefix + getName() + " *v,");
@@ -397,9 +397,9 @@ aspect C_Declarations {
     env.unindent();
     env.println(");");
 
-    env.println("int labcomm"+env.verStr+"_decoder_ioctl_" + env.prefix + getName() + "(");
+    env.println("int labcomm2014_decoder_ioctl_" + env.prefix + getName() + "(");
     env.indent();
-    env.println("struct labcomm"+env.verStr+"_decoder *d,");
+    env.println("struct labcomm2014_decoder *d,");
     env.println("int ioctl_action,");
     env.println("...");
     env.unindent();
@@ -410,24 +410,24 @@ aspect C_Declarations {
   }
 
   public void SampleDecl.C_emitEncoderDeclaration(C_env env) {
-    env.println("int labcomm"+env.verStr+"_encoder_register_" + 
+    env.println("int labcomm2014_encoder_register_" + 
 		env.prefix + getName() + "(");
     env.indent();
-    env.println("struct labcomm"+env.verStr+"_encoder *e);");
+    env.println("struct labcomm2014_encoder *e);");
     env.unindent();
 
-    env.println("int labcomm"+env.verStr+"_encode_" + env.prefix + getName() + "(");
+    env.println("int labcomm2014_encode_" + env.prefix + getName() + "(");
     env.indent();
-    env.println("struct labcomm"+env.verStr+"_encoder *e");
+    env.println("struct labcomm2014_encoder *e");
     if(!isVoid() ) {
         env.println(", "+env.prefix + getName() + " *v");
     }
     env.unindent();
     env.println(");");
 
-    env.println("int labcomm"+env.verStr+"_encoder_ioctl_" + env.prefix + getName() + "(");
+    env.println("int labcomm2014_encoder_ioctl_" + env.prefix + getName() + "(");
     env.indent();
-    env.println("struct labcomm"+env.verStr+"_encoder *e,");
+    env.println("struct labcomm2014_encoder *e,");
     env.println("int ioctl_action,");
     env.println("...");
     env.unindent();
@@ -489,7 +489,7 @@ aspect C_Decoder {
     env = env.nestStruct("v");
     env.println("static void decode_" + env.prefix + getName() + "(");
     env.indent();
-    env.println("struct labcomm"+env.verStr+"_reader *r,");
+    env.println("struct labcomm2014_reader *r,");
     env.println("void (*handle)(");
     env.indent();
     env.println(env.prefix + getName() + " *v,");
@@ -528,11 +528,11 @@ aspect C_Decoder {
     env.print(env.qualid + " = ");
     switch (getToken()) {
       case LABCOMM_SAMPLE: { 
-        env.println("labcomm_internal_decoder_index_to_signature(" +
-                    "r->decoder, labcomm"+env.verStr+"_read_int(r));");
+        env.println("labcomm2014_internal_decoder_index_to_signature(" +
+                    "r->decoder, labcomm2014_read_int(r));");
       } break;
       default: {
-        env.println("labcomm"+env.verStr+"_read_" + getName() + "(r);");
+        env.println("labcomm2014_read_" + getName() + "(r);");
       }; break;
     }
   }
@@ -580,7 +580,7 @@ aspect C_Decoder {
   }
 
   public void VariableSize.C_emitDecoderDecodeLimit(C_env env, int i) {
-    env.println(env.qualid + ".n_" + i + " = labcomm"+env.verStr+"_read_packed32(r);");
+    env.println(env.qualid + ".n_" + i + " = labcomm2014_read_packed32(r);");
   }
 
   public void ArrayType.C_emitDecoderDecodeLimit(C_env env) {
@@ -594,7 +594,7 @@ aspect C_Decoder {
 
   public void VariableArrayType.C_emitDecoderArrayAllocate(C_env env) {
     env.print(env.qualid + 
-              ".a = labcomm"+env.verStr+"_memory_alloc(r->memory, 1, sizeof(" + 
+              ".a = labcomm2014_memory_alloc(r->memory, 1, sizeof(" + 
 	      env.qualid + ".a[0])");
     for (int i = 0 ; i < getNumExp() ; i++) {
       env.print(" * " + getExp(i).C_getLimit(env, i));
@@ -612,7 +612,7 @@ aspect C_Decoder {
 
   public void PrimType.C_emitDecoderDeallocation(C_env env) {
     if (C_isDynamic()) {
-      env.println("labcomm"+env.verStr+"_memory_free(r->memory, 1, " + 
+      env.println("labcomm2014_memory_free(r->memory, 1, " + 
                   env.qualid + ");");
     }
   }
@@ -658,7 +658,7 @@ aspect C_Decoder {
 
   public void VariableArrayType.C_emitDecoderDeallocation(C_env env) {
     super.C_emitDecoderDeallocation(env);
-    env.println("labcomm"+env.verStr+"_memory_free(r->memory, 1, " + 
+    env.println("labcomm2014_memory_free(r->memory, 1, " + 
                 env.qualid + ".a);");
   }
 
@@ -676,10 +676,10 @@ aspect C_Decoder {
   }
 
   public void SampleDecl.C_emitDecoderRegisterHandler(C_env env) {
-    env.println("int labcomm"+env.verStr+"_decoder_register_" + 
+    env.println("int labcomm2014_decoder_register_" + 
 		env.prefix + getName() + "(");
     env.indent();
-    env.println("struct labcomm"+env.verStr+"_decoder *d,");
+    env.println("struct labcomm2014_decoder *d,");
     env.println("void (*handler)(");
     env.indent();
     env.println(env.prefix + getName() + " *v,");
@@ -691,12 +691,12 @@ aspect C_Decoder {
     env.println(")");
     env.println("{");
     env.indent();
-    env.println("return labcomm"+env.verStr+"_internal_decoder_register(");
+    env.println("return labcomm2014_internal_decoder_register(");
     env.indent();
     env.println("d,");
     env.println("&signature_" + env.prefix + getName() + ",");
-    env.println("(labcomm"+env.verStr+"_decoder_function)decode_" + env.prefix + getName() + ",");
-    env.println("(labcomm"+env.verStr+"_handler_function)handler,");
+    env.println("(labcomm2014_decoder_function)decode_" + env.prefix + getName() + ",");
+    env.println("(labcomm2014_handler_function)handler,");
     env.println("context");
     env.unindent();
     env.println(");");
@@ -711,10 +711,10 @@ aspect C_copy {
   private void SampleDecl.C_emitCopyFunctionParam(C_env env, String src,
 						  String dst)
   {
-    env.println("void labcomm" + env.verStr + "_copy_" +
+    env.println("void labcomm2014_copy_" +
                 env.prefix + getName() + "(");
     env.indent();
-    env.println("struct labcomm" + env.verStr + "_memory *mem,");
+    env.println("struct labcomm2014_memory *mem,");
     env.println(env.prefix + getName() + " *" + dst + ",");
     env.println(env.prefix + getName() + " *" + src);
     env.unindent();
@@ -765,9 +765,8 @@ aspect C_copy {
   public void PrimType.C_emitCopy(C_env env_src, C_env env_dst) {
     if (C_isDynamic()) {
       env_src.println(String.format(
-	  "%s%s = labcomm%s_memory_alloc(mem, 1, strlen(%s%s)+1);",
+	  "%s%s = labcomm2014_memory_alloc(mem, 1, strlen(%s%s)+1);",
 	  env_dst.accessor(), env_dst.qualid,
-          env_src.verStr,
 	  env_src.accessor(), env_src.qualid));
       env_src.println(String.format(
 	  "memcpy(%s%s, %s%s, strlen(%s%s)+1);",
@@ -843,8 +842,7 @@ aspect C_copy {
 							C_env env_dst)
   {
     env_src.print(env_dst.qualid + env_dst.memberAccessor() +
-                  "a = labcomm" + env_src.verStr +
-                  "_memory_alloc(mem, 1, sizeof(" +
+                  "a = labcomm2014_memory_alloc(mem, 1, sizeof(" +
 		  env_src.qualid + env_src.memberAccessor() + "a[0])");
     for (int i = 0 ; i < getNumExp() ; i++) {
       env_src.print(" * " + getExp(i).C_getLimit(env_src, i));
@@ -857,10 +855,10 @@ aspect C_copy {
   private void SampleDecl.C_emitCopyDeallocationFunctionParam(C_env env,
 							      String par)
   {
-    env.println("void labcomm" + env.verStr + "_copy_free_" +
+    env.println("void labcomm2014_copy_free_" +
                 env.prefix + getName() + "(");
     env.indent();
-    env.println("struct labcomm" + env.verStr + "_memory *mem,");
+    env.println("struct labcomm2014_memory *mem,");
     env.println(env.prefix + getName() + " *" + par);
     env.unindent();
     env.print(")");
@@ -907,7 +905,7 @@ aspect C_copy {
 
   public void PrimType.C_emitCopyDeallocation(C_env env) {
     if (C_isDynamic()) {
-      env.println("labcomm" + env.verStr + "_memory_free(mem, 1, " +
+      env.println("labcomm2014_memory_free(mem, 1, " +
                   env.accessor() + env.qualid + ");");
     }
   }
@@ -953,7 +951,7 @@ aspect C_copy {
 
   public void VariableArrayType.C_emitCopyDeallocation(C_env env) {
     super.C_emitCopyDeallocation(env);
-    env.println("labcomm" + env.verStr + "_memory_free(mem, 1, " +
+    env.println("labcomm2014_memory_free(mem, 1, " +
                 env.qualid + env.memberAccessor() + "a);");
   }
 
@@ -975,9 +973,9 @@ aspect C_DecoderIoctl {
   }
 
   public void SampleDecl.C_emitDecoderIoctl(C_env env) {
-    env.println("int labcomm"+env.verStr+"_decoder_ioctl_" + env.prefix + getName() + "(");
+    env.println("int labcomm2014_decoder_ioctl_" + env.prefix + getName() + "(");
     env.indent();
-    env.println("struct labcomm"+env.verStr+"_decoder *d,");
+    env.println("struct labcomm2014_decoder *d,");
     env.println("int ioctl_action,");
     env.println("...");
     env.unindent();
@@ -987,7 +985,7 @@ aspect C_DecoderIoctl {
     env.println("int result;");
     env.println("va_list va;");
     env.println("va_start(va, ioctl_action);");
-    env.println("result = labcomm"+env.verStr+"_internal_decoder_ioctl(");
+    env.println("result = labcomm2014_internal_decoder_ioctl(");
     env.indent();
     env.println("d, &signature_" + env.prefix + getName() + ", ");
     env.println("ioctl_action, va);");
@@ -1016,7 +1014,7 @@ aspect C_Encoder {
     env = env.nestStruct("(*v)");
     env.println("static int encode_" + env.prefix + getName() + "(");
     env.indent();
-    env.println("struct labcomm"+env.verStr+"_writer *w");
+    env.println("struct labcomm2014_writer *w");
     if(!isVoid() ) {
         env.println(", "+env.prefix + getName() + " *v");
     }
@@ -1031,8 +1029,8 @@ aspect C_Encoder {
     env.println("}");
 
     // Typesafe encode wrapper
-    env.println("int labcomm"+env.verStr+"_encode_" + env.prefix + getName() + "(");
-    env.println("struct labcomm"+env.verStr+"_encoder *e");
+    env.println("int labcomm2014_encode_" + env.prefix + getName() + "(");
+    env.println("struct labcomm2014_encoder *e");
     if(!isVoid() ) {
         env.println(", "+env.prefix + getName() + " *v");
     }
@@ -1040,9 +1038,9 @@ aspect C_Encoder {
     env.println(")");
     env.println("{");
     env.indent();
-    env.println("return labcomm"+env.verStr+"_internal_encode(e, &signature_" + 
+    env.println("return labcomm2014_internal_encode(e, &signature_" + 
 		env.prefix + getName() + 
-		", (labcomm"+env.verStr+"_encoder_function)encode_" + 
+		", (labcomm2014_encoder_function)encode_" + 
                 env.prefix + getName() +
 		(!isVoid()?", v":", NULL")+");");
     env.unindent();
@@ -1063,12 +1061,12 @@ aspect C_Encoder {
     env.print("result = ");
     switch (getToken()) {
       case LABCOMM_SAMPLE: { 
-        env.println("labcomm"+env.verStr+"_write_int(w, " + 
-                    "labcomm_internal_encoder_signature_to_index(w->encoder, " +
+        env.println("labcomm2014_write_int(w, " + 
+                    "labcomm2014_internal_encoder_signature_to_index(w->encoder, " +
                     env.qualid + "));");
       } break;
       default: {
-        env.println("labcomm"+env.verStr+"_write_" + getName() + 
+        env.println("labcomm2014_write_" + getName() + 
                     "(w, " + env.qualid + ");");
       } break;
     }
@@ -1117,7 +1115,7 @@ aspect C_Encoder {
   }
 
   public void VariableSize.C_emitEncoderEncodeLimit(C_env env, int i) {
-    env.println("labcomm"+env.verStr+"_write_packed32(w, " + env.qualid + ".n_" + i + ");");
+    env.println("labcomm2014_write_packed32(w, " + env.qualid + ".n_" + i + ");");
   }
 
   public void ArrayType.C_emitEncoderEncodeLimit(C_env env) {
@@ -1133,10 +1131,10 @@ aspect C_Encoder {
   }
   
   protected void Decl.C_emitEncoderTypeRegister(C_env env) {
-    env.println("int labcomm"+env.verStr+"_encoder_type_register_" + 
+    env.println("int labcomm2014_encoder_type_register_" + 
 		env.prefix + getName() + "(");
     env.indent();
-    env.println("struct labcomm"+env.verStr+"_encoder *e");
+    env.println("struct labcomm2014_encoder *e");
     env.unindent();
     env.println(")");
     env.println("{");
@@ -1146,7 +1144,7 @@ aspect C_Encoder {
     C_emitUserTypeDeps(env, null, true); 
 
     if(!isSampleDecl() || hasDependencies()) {
-      env.println("return labcomm"+env.verStr+"_internal_encoder_type_register(");
+      env.println("return labcomm2014_internal_encoder_type_register(");
       env.indent();
       env.println("e,");
       env.println("&signature_" + env.prefix + getName() + "");
@@ -1165,10 +1163,10 @@ aspect C_Encoder {
   
   public void SampleDecl.C_emitEncoderRegisterHandler(C_env env) {
     C_emitEncoderTypeRegister(env);
-    env.println("int labcomm"+env.verStr+"_encoder_register_" + 
+    env.println("int labcomm2014_encoder_register_" + 
 		env.prefix + getName() + "(");
     env.indent();
-    env.println("struct labcomm"+env.verStr+"_encoder *e");
+    env.println("struct labcomm2014_encoder *e");
     env.unindent();
     env.println(")");
     env.println("{");
@@ -1176,17 +1174,17 @@ aspect C_Encoder {
     C_emitUserTypeDeps(env, null, false); //XXX HERE BE DRAGONS
                                           //currently set to false to turn off
                                           //outputting of code
-    env.println("int result = labcomm"+env.verStr+"_internal_encoder_register(");
+    env.println("int result = labcomm2014_internal_encoder_register(");
     env.indent();
     env.println("e,");
     env.println("&signature_" + env.prefix + getName() + ",");
-    env.println("(labcomm"+env.verStr+"_encoder_function)encode_" + env.prefix + getName());
+    env.println("(labcomm2014_encoder_function)encode_" + env.prefix + getName());
     env.unindent();
     env.println(");");
     env.println("if(result >= 0) {\n");
     env.indent();
-    env.println("labcomm"+env.verStr+"_encoder_type_register_" + env.prefix + getName()+"(e);");
-    env.println("labcomm"+env.verStr+"_internal_encoder_type_bind(");
+    env.println("labcomm2014_encoder_type_register_" + env.prefix + getName()+"(e);");
+    env.println("labcomm2014_internal_encoder_type_bind(");
     env.indent();
     env.println("e,");
     env.println("&signature_" + env.prefix + getName() + ",");
@@ -1212,9 +1210,9 @@ aspect C_EncoderIoctl {
   }
 
   public void SampleDecl.C_emitEncoderIoctl(C_env env) {
-    env.println("int labcomm"+env.verStr+"_encoder_ioctl_" + env.prefix + getName() + "(");
+    env.println("int labcomm2014_encoder_ioctl_" + env.prefix + getName() + "(");
     env.indent();
-    env.println("struct labcomm"+env.verStr+"_encoder *e,");
+    env.println("struct labcomm2014_encoder *e,");
     env.println("int ioctl_action,");
     env.println("...");
     env.unindent();
@@ -1224,7 +1222,7 @@ aspect C_EncoderIoctl {
     env.println("int result;");
     env.println("va_list va;");
     env.println("va_start(va, ioctl_action);");
-    env.println("result = labcomm"+env.verStr+"_internal_encoder_ioctl(");
+    env.println("result = labcomm2014_internal_encoder_ioctl(");
     env.indent();
     env.println("e, &signature_" + env.prefix + getName() + ", ");
     env.println("ioctl_action, va);");
@@ -1246,7 +1244,7 @@ aspect C_TypeDependencies {
 
             t.C_emitUserTypeDeps(env, t.getName(), outputCode);
             if(outputCode) {
-               env.println("labcomm"+env.verStr+"_encoder_type_register_"+env.prefix + t.getName()+"(e);");
+               env.println("labcomm2014_encoder_type_register_"+env.prefix + t.getName()+"(e);");
             } else {  // Just output a comment
 	        String refpath = (via == null) ? "directly" : "indirectly via "+via;
 	       env.println(" //Depends ("+refpath+") on "+t.getName() );
@@ -1263,7 +1261,7 @@ aspect C_TypeDependencies {
 
             t.C_emitUserTypeRefs(env, t.getName(), outputCode);
             if(outputCode) {
-               env.println("labcomm"+env.verStr+"_encoder_type_register_"+env.prefix + t.getName()+"(e);");
+               env.println("labcomm2014_encoder_type_register_"+env.prefix + t.getName()+"(e);");
             } else {  // Just output a comment
 	        String refpath = (via == null) ? "directly" : "indirectly via "+via;
 	       env.println(" //Is referenced ("+refpath+")  by "+t.getName() );
@@ -1305,7 +1303,7 @@ aspect C_Signature {
 
   public void TypeDecl.C_emitFlatSignature(C_env env) {
     C_emitSizeofValue(env);
-    env.println("static struct labcomm"+env.verStr+"_signature " +
+    env.println("static struct labcomm2014_signature " +
                 "signature_" + env.prefix + getName() + " = {");
     env.indent();
     env.println("\"" + getName() + "\",");
@@ -1319,8 +1317,8 @@ aspect C_Signature {
     env.println("signature_tree_" + env.prefix + getName() + "");
     env.unindent();
     env.println(" };");
-    env.println("const struct labcomm"+env.verStr+"_signature " +
-                "*labcomm"+env.verStr+"_signature_" + env.prefix + getName() + 
+    env.println("const struct labcomm2014_signature " +
+                "*labcomm2014_signature_" + env.prefix + getName() + 
                 " = &signature_" + env.prefix + getName() + ";");
   }
 
@@ -1345,7 +1343,7 @@ aspect C_Signature {
     env.println("};");
 
     C_emitSizeofValue(env);
-    env.println("static struct labcomm"+env.verStr+"_signature " +
+    env.println("static struct labcomm2014_signature " +
                 "signature_" + env.prefix + getName() + " = {");
     env.indent();
     env.println("\"" + getName() + "\",");
@@ -1357,8 +1355,8 @@ aspect C_Signature {
     env.println("signature_tree_" + env.prefix + getName() + "");
     env.unindent();
     env.println(" };");
-    env.println("const struct labcomm"+env.verStr+"_signature " +
-                "*labcomm"+env.verStr+"_signature_" + env.prefix + getName() + 
+    env.println("const struct labcomm2014_signature " +
+                "*labcomm2014_signature_" + env.prefix + getName() + 
                 " = &signature_" + env.prefix + getName() + ";");
   }
 
@@ -1370,7 +1368,7 @@ aspect C_Signature {
 
     public void TypeRefSignatureLine.C_emitSignature(C_env env, boolean isDecl){ 
       env.print(getIndentString());
-    //  env.println("LABCOMM_SIGDEF_SIGNATURE(labcomm"+env.verStr+"_signature_" + env.prefix + decl.getName() +"),");
+    //  env.println("LABCOMM_SIGDEF_SIGNATURE(labcomm2014_signature_" + env.prefix + decl.getName() +"),");
       env.println("LABCOMM_SIGDEF_SIGNATURE(signature_" + env.prefix + decl.getName() +"),");
     }
 
@@ -1399,8 +1397,8 @@ aspect C_Signature {
 //        if (data != null) {
 //            for (int j = 0 ; j < data.length ; j++) {
 //                env.print(getIndentString());
-//                //env.print("printf(\"labcomm"+env.verStr+"_write_byte( w, (unsigned char)"+ String.format("0x%02X ", data[j]) +")\\n\"); ");
-//                env.print("labcomm"+env.verStr+"_write_byte( w, (unsigned char)"+ String.format("0x%02X ", data[j]) +"); ");
+//                //env.print("printf(\"labcomm2014_write_byte( w, (unsigned char)"+ String.format("0x%02X ", data[j]) +")\\n\"); ");
+//                env.print("labcomm2014_write_byte( w, (unsigned char)"+ String.format("0x%02X ", data[j]) +"); ");
 //                env.println("if (result != 0) { return result; }");
 //            }
 //            env.println();
@@ -1408,7 +1406,7 @@ aspect C_Signature {
 //
 //}
   public void SignatureList.C_emitSignature(C_env env, boolean decl) { 
-  env.println("static struct labcomm_signature_data signature_tree_" + 
+  env.println("static struct labcomm2014_signature_data signature_tree_" + 
   	 env.prefix + parentDecl().getName() + "[] = {");
   env.indent();
   for (int i = 0 ; i < size() ; i++) {
@@ -1443,11 +1441,11 @@ aspect C_Signature {
 //      }
 //    }
 //    env.println("};");
-//    env.println("struct labcomm"+env.verStr+"_signature labcomm"+env.verStr+"_signature_" + 
+//    env.println("struct labcomm2014_signature labcomm2014_signature_" + 
 //		env.prefix + getName() + " = {");
 //    env.indent();
 //    env.println("LABCOMM_SAMPLE, \"" + getName() + "\",");
-//    env.println("(int (*)(struct labcomm"+env.verStr+"_signature *, void *))labcomm"+env.verStr+"_sizeof_" + 
+//    env.println("(int (*)(struct labcomm2014_signature *, void *))labcomm2014_sizeof_" + 
 //		env.prefix + getName() + ",");
 //    env.println("sizeof(signature_bytes_" + env.prefix + getName() + "),");
 //    env.println("signature_bytes_" + env.prefix + getName() + ",");
@@ -1484,13 +1482,13 @@ aspect C_Constructor {
 
   public void TypeDecl.C_emitConstructor(C_env env) {
     if (isReferenced()) {
-      env.println("labcomm"+env.verStr+"_set_local_index(&signature_" +
+      env.println("labcomm2014_set_local_index(&signature_" +
                   env.prefix + getName() + ");");
     }
   }
 
   public void SampleDecl.C_emitConstructor(C_env env) {
-    env.println("labcomm"+env.verStr+"_set_local_index(&signature_" + 
+    env.println("labcomm2014_set_local_index(&signature_" + 
 		env.prefix + getName() + ");");
   }
 
@@ -1513,7 +1511,7 @@ aspect C_Sizeof {
   }
 
   public void SampleDecl.C_emitSizeofDeclaration(C_env env) {
-    env.println("extern int labcomm"+env.verStr+"_sizeof_" + env.prefix + getName() +
+    env.println("extern int labcomm2014_sizeof_" + env.prefix + getName() +
         "(" + env.prefix + getName() + " *v);");
   }
 
@@ -1526,11 +1524,11 @@ aspect C_Sizeof {
 
   public void SampleDecl.C_emitSizeof(C_env env) {
     env = env.nestStruct("(*v)");
-    env.println("int labcomm"+env.verStr+"_sizeof_" + env.prefix + getName() +
+    env.println("int labcomm2014_sizeof_" + env.prefix + getName() +
         "(" + env.prefix + getName() + " *v)");
     env.println("{");
     env.indent();
-    env.println("return labcomm"+env.verStr+"_internal_sizeof(" +
+    env.println("return labcomm2014_internal_sizeof(" +
                 "&signature_" + env.prefix + getName() +
                 ", v);");
     env.unindent();
@@ -1616,7 +1614,7 @@ aspect C_Sizeof {
     switch (getToken()) {
       case LABCOMM_STRING: { 
         env.print("{ int l = strlen(" + env.qualid + "); ");
-    env.println("result += labcomm"+env.verStr+"_size_packed32(l) + l; }"); 
+    env.println("result += labcomm2014_size_packed32(l) + l; }"); 
       } break;
       default: { 
     throw new Error(this.getClass().getName() + 
@@ -1649,7 +1647,7 @@ aspect C_Sizeof {
   }
 
   public void VariableSize.C_emitSizeof(C_env env, int i) {
-    env.println("result += labcomm"+env.verStr+"_size_packed32(" + 
+    env.println("result += labcomm2014_size_packed32(" + 
                 env.qualid + env.memberAccessor() + "n_" + i + ");");
   }
 
diff --git a/examples/simple/example_decoder.c b/examples/simple/example_decoder.c
index 107aada..493ae34 100644
--- a/examples/simple/example_decoder.c
+++ b/examples/simple/example_decoder.c
@@ -1,10 +1,10 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
-#include <labcomm_fd_reader.h>
-#include <labcomm_default_error_handler.h>
-#include <labcomm_default_memory.h>
-#include <labcomm_default_scheduler.h>
+#include <labcomm2014_fd_reader.h>
+#include <labcomm2014_default_error_handler.h>
+#include <labcomm2014_default_memory.h>
+#include <labcomm2014_default_scheduler.h>
 #include "gen/simple.h"
 #include <stdio.h>
 
@@ -57,33 +57,33 @@ static void handle_simple_TwoFixedArrays(simple_TwoFixedArrays *d,void *context)
 
 int main(int argc, char *argv[]) {
   int fd;
-  struct labcomm_decoder *decoder;
+  struct labcomm2014_decoder *decoder;
   void  *context = NULL;
 
   char *filename = argv[1];
   printf("C decoder reading from %s\n", filename);
   fd = open(filename, O_RDONLY);
-  decoder = labcomm_decoder_new(labcomm_fd_reader_new(
-				  labcomm_default_memory, fd, 1), 
-				labcomm_default_error_handler, 
-				labcomm_default_memory,
-				labcomm_default_scheduler);
+  decoder = labcomm2014_decoder_new(labcomm2014_fd_reader_new(
+				  labcomm2014_default_memory, fd, 1), 
+				labcomm2014_default_error_handler, 
+				labcomm2014_default_memory,
+				labcomm2014_default_scheduler);
   if (!decoder) { 
     printf("Failed to allocate decoder %s:%d\n", __FUNCTION__, __LINE__);
     return 1;
   }
 
-  labcomm_decoder_register_simple_doavoid(decoder, handle_simple_doavoid, context);
-  labcomm_decoder_register_simple_theTwoInts(decoder, handle_simple_theTwoInts, context);
-  labcomm_decoder_register_simple_anotherTwoInts(decoder, handle_simple_anotherTwoInts, context);
-  labcomm_decoder_register_simple_IntString(decoder, handle_simple_IntString, context);
-  labcomm_decoder_register_simple_TwoArrays(decoder, handle_simple_TwoArrays, context);
-  labcomm_decoder_register_simple_TwoFixedArrays(decoder, handle_simple_TwoFixedArrays, context);
+  labcomm2014_decoder_register_simple_doavoid(decoder, handle_simple_doavoid, context);
+  labcomm2014_decoder_register_simple_theTwoInts(decoder, handle_simple_theTwoInts, context);
+  labcomm2014_decoder_register_simple_anotherTwoInts(decoder, handle_simple_anotherTwoInts, context);
+  labcomm2014_decoder_register_simple_IntString(decoder, handle_simple_IntString, context);
+  labcomm2014_decoder_register_simple_TwoArrays(decoder, handle_simple_TwoArrays, context);
+  labcomm2014_decoder_register_simple_TwoFixedArrays(decoder, handle_simple_TwoFixedArrays, context);
 
   printf("Decoding:\n");
-  labcomm_decoder_run(decoder);
+  labcomm2014_decoder_run(decoder);
   printf("--- End Of File ---:\n");
-  labcomm_decoder_free(decoder);
+  labcomm2014_decoder_free(decoder);
 
   return 0;
 }
diff --git a/examples/simple/example_encoder.c b/examples/simple/example_encoder.c
index ea77e11..c13e83d 100644
--- a/examples/simple/example_encoder.c
+++ b/examples/simple/example_encoder.c
@@ -1,53 +1,53 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
-#include <labcomm_fd_writer.h>
-#include <labcomm_default_error_handler.h>
-#include <labcomm_default_memory.h>
-#include <labcomm_default_scheduler.h>
+#include <labcomm2014_fd_writer.h>
+#include <labcomm2014_default_error_handler.h>
+#include <labcomm2014_default_memory.h>
+#include <labcomm2014_default_scheduler.h>
 #include "gen/simple.h"
 #include <stdio.h>
 
 int main(int argc, char *argv[]) {
   int fd;
-  struct labcomm_encoder *encoder;
+  struct labcomm2014_encoder *encoder;
 
   char *filename = argv[1];
   printf("C encoder writing to %s\n", filename);
   fd = open(filename, O_WRONLY|O_CREAT|O_TRUNC, 0644);
-  encoder = labcomm_encoder_new(labcomm_fd_writer_new(
-				  labcomm_default_memory, fd, 1), 
-				labcomm_default_error_handler, 
-				labcomm_default_memory,
-				labcomm_default_scheduler);
-  labcomm_encoder_register_simple_doavoid(encoder);
-  labcomm_encoder_register_simple_theTwoInts(encoder);
-  labcomm_encoder_register_simple_anotherTwoInts(encoder);
-  labcomm_encoder_register_simple_IntString(encoder);
-
-  labcomm_encode_simple_doavoid(encoder);
+  encoder = labcomm2014_encoder_new(labcomm2014_fd_writer_new(
+				  labcomm2014_default_memory, fd, 1), 
+				labcomm2014_default_error_handler, 
+				labcomm2014_default_memory,
+				labcomm2014_default_scheduler);
+  labcomm2014_encoder_register_simple_doavoid(encoder);
+  labcomm2014_encoder_register_simple_theTwoInts(encoder);
+  labcomm2014_encoder_register_simple_anotherTwoInts(encoder);
+  labcomm2014_encoder_register_simple_IntString(encoder);
+
+  labcomm2014_encode_simple_doavoid(encoder);
 
   simple_IntString is;
   is.x = 24;
   is.s = "Hello, LabComm!";
   printf("Encoding IntString, x=%d, s=%s\n", is.x, is.s);
-  labcomm_encode_simple_IntString(encoder, &is);
+  labcomm2014_encode_simple_IntString(encoder, &is);
 
   simple_theTwoInts ti;
   ti.a = 13;
   ti.b = 37;
   printf("Encoding theTwoInts, a=%d, b=%d\n", ti.a, ti.b);
-  labcomm_encode_simple_theTwoInts(encoder, &ti);
+  labcomm2014_encode_simple_theTwoInts(encoder, &ti);
 
   simple_anotherTwoInts ati;
   ati.a = 23;
   ati.b = 47;
   printf("Encoding anotherTwoInts, a=%d, b=%d\n", ati.a, ati.b);
-  labcomm_encode_simple_anotherTwoInts(encoder, &ati);
+  labcomm2014_encode_simple_anotherTwoInts(encoder, &ati);
 
   int foo[20];
 
-  labcomm_encoder_register_simple_TwoArrays(encoder);
+  labcomm2014_encoder_register_simple_TwoArrays(encoder);
 
   simple_TwoArrays ta;
   ta.fixed.a[0] = 17;
@@ -61,12 +61,12 @@ int main(int argc, char *argv[]) {
   }
 
   printf("Encoding TwoArrays...\n");
-  labcomm_encode_simple_TwoArrays(encoder, &ta);
+  labcomm2014_encode_simple_TwoArrays(encoder, &ta);
 
   ti.a = 23;
   ti.b = 47;
   printf("Encoding theTwoInts, a=%d, b=%d\n", ti.a, ti.b);
-  labcomm_encode_simple_theTwoInts(encoder, &ti);
+  labcomm2014_encode_simple_theTwoInts(encoder, &ti);
 
 
   simple_TwoFixedArrays tfa;
@@ -82,8 +82,8 @@ int main(int argc, char *argv[]) {
   tfa.b.a[1][2] = 63;
 
   printf("Encoding TwoFixedArrays...\n");
-  labcomm_encoder_register_simple_TwoFixedArrays(encoder);
-  labcomm_encode_simple_TwoFixedArrays(encoder, &tfa);
+  labcomm2014_encoder_register_simple_TwoFixedArrays(encoder);
+  labcomm2014_encode_simple_TwoFixedArrays(encoder, &tfa);
 
   return 0;
 }
diff --git a/examples/twoway/client.c b/examples/twoway/client.c
index 0166a35..f0e5447 100644
--- a/examples/twoway/client.c
+++ b/examples/twoway/client.c
@@ -36,12 +36,12 @@
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <unistd.h>
-#include <labcomm.h>
-#include <labcomm_fd_reader.h>
-#include <labcomm_fd_writer.h>
-#include <labcomm_default_error_handler.h>
-#include <labcomm_default_memory.h>
-#include <labcomm_pthread_scheduler.h>
+#include <labcomm2014.h>
+#include <labcomm2014_fd_reader.h>
+#include <labcomm2014_fd_writer.h>
+#include <labcomm2014_default_error_handler.h>
+#include <labcomm2014_default_memory.h>
+#include <labcomm2014_pthread_scheduler.h>
 #include "decimating.h"
 #include "introspecting.h"
 #include "gen/types.h"
@@ -63,13 +63,13 @@ static void handle_Product(int32_t *value, void *context)
 
 static void *run_decoder(void *context)
 {
-  struct labcomm_decoder *decoder = context;
+  struct labcomm2014_decoder *decoder = context;
   int result;
 
-  labcomm_decoder_register_types_Sum(decoder, handle_Sum, NULL);
-  labcomm_decoder_register_types_Diff(decoder, handle_Diff, NULL);
+  labcomm2014_decoder_register_types_Sum(decoder, handle_Sum, NULL);
+  labcomm2014_decoder_register_types_Diff(decoder, handle_Diff, NULL);
   do {
-    result = labcomm_decoder_decode_one(decoder);
+    result = labcomm2014_decoder_decode_one(decoder);
   } while (result >= 0);
   return NULL;
 }
@@ -87,10 +87,10 @@ int main(int argc, char *argv[])
   struct introspecting *introspecting;
   char *hostname;
   int port;
-  struct labcomm_scheduler *scheduler;
-  struct labcomm_decoder *decoder;
-  struct labcomm_encoder *encoder;
-  struct labcomm_time *next;
+  struct labcomm2014_scheduler *scheduler;
+  struct labcomm2014_decoder *decoder;
+  struct labcomm2014_encoder *encoder;
+  struct labcomm2014_time *next;
   int32_t i, j;
 
   hostname = argv[1];
@@ -128,13 +128,13 @@ int main(int argc, char *argv[])
   
   nodelay = 1;
   setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &nodelay, sizeof(nodelay));
-  scheduler = labcomm_pthread_scheduler_new(labcomm_default_memory);
-  decimating = decimating_new(labcomm_fd_reader_new(labcomm_default_memory, 
+  scheduler = labcomm2014_pthread_scheduler_new(labcomm2014_default_memory);
+  decimating = decimating_new(labcomm2014_fd_reader_new(labcomm2014_default_memory, 
 						    fd, 1),
-			      labcomm_fd_writer_new(labcomm_default_memory, 
+			      labcomm2014_fd_writer_new(labcomm2014_default_memory, 
 						    fd, 0),
-			      labcomm_default_error_handler,
-			      labcomm_default_memory,
+			      labcomm2014_default_error_handler,
+			      labcomm2014_default_memory,
 			      scheduler);
   if (decimating == NULL) {
     /* Warning: might leak reader and writer at this point */
@@ -142,45 +142,45 @@ int main(int argc, char *argv[])
   }
   introspecting = introspecting_new(decimating->reader,
 				    decimating->writer,
-				    labcomm_default_error_handler,
-				    labcomm_default_memory,
+				    labcomm2014_default_error_handler,
+				    labcomm2014_default_memory,
 				    scheduler);
   if (introspecting == NULL) {
     /* Warning: might leak reader and writer at this point */
     goto out;
   }
-  decoder = labcomm_decoder_new(introspecting->reader, 
-				labcomm_default_error_handler,
-				labcomm_default_memory,
+  decoder = labcomm2014_decoder_new(introspecting->reader, 
+				labcomm2014_default_error_handler,
+				labcomm2014_default_memory,
 				scheduler);
-  encoder = labcomm_encoder_new(introspecting->writer, 
-				labcomm_default_error_handler,
-				labcomm_default_memory,
+  encoder = labcomm2014_encoder_new(introspecting->writer, 
+				labcomm2014_default_error_handler,
+				labcomm2014_default_memory,
 				scheduler);
   pthread_t rdt;
   pthread_create(&rdt, NULL, run_decoder, decoder);  
-  labcomm_encoder_register_types_A(encoder);
-  labcomm_encoder_register_types_B(encoder);
-  labcomm_encoder_register_types_Terminate(encoder);
+  labcomm2014_encoder_register_types_A(encoder);
+  labcomm2014_encoder_register_types_B(encoder);
+  labcomm2014_encoder_register_types_Terminate(encoder);
 
-  err = labcomm_decoder_ioctl_types_Sum(decoder, SET_DECIMATION, 2);
-  err = labcomm_decoder_ioctl_types_Diff(decoder, SET_DECIMATION, 4);
+  err = labcomm2014_decoder_ioctl_types_Sum(decoder, SET_DECIMATION, 2);
+  err = labcomm2014_decoder_ioctl_types_Diff(decoder, SET_DECIMATION, 4);
 
-  next = labcomm_scheduler_now(scheduler);
+  next = labcomm2014_scheduler_now(scheduler);
   for (i = 0 ; i < 4 ; i++) {
     if (i == 2) {
-      labcomm_decoder_register_types_Product(decoder, handle_Product, NULL);
+      labcomm2014_decoder_register_types_Product(decoder, handle_Product, NULL);
     }
     for (j = 0 ; j < 4 ; j++) {
       printf("\nA=%d B=%d: ", i, j);
-      labcomm_encode_types_A(encoder, &i);
-      labcomm_encode_types_B(encoder, &j);
-      labcomm_time_add_usec(next, 100000);
-      labcomm_scheduler_sleep(scheduler, next);
+      labcomm2014_encode_types_A(encoder, &i);
+      labcomm2014_encode_types_B(encoder, &j);
+      labcomm2014_time_add_usec(next, 100000);
+      labcomm2014_scheduler_sleep(scheduler, next);
     }
   }
   printf("\n");
-  labcomm_encode_types_Terminate(encoder);
+  labcomm2014_encode_types_Terminate(encoder);
 out:
   return 0;
   
diff --git a/examples/twoway/decimating.c b/examples/twoway/decimating.c
index ea3cfab..705f4ce 100644
--- a/examples/twoway/decimating.c
+++ b/examples/twoway/decimating.c
@@ -23,18 +23,18 @@
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include "labcomm_private.h"
+#include "labcomm2014_private.h"
 #include "decimating.h"
 #include "gen/decimating_messages.h"
 
 struct decimating_private {
   struct decimating decimating;
-  struct labcomm_error_handler *error;
-  struct labcomm_memory *memory;
-  struct labcomm_scheduler *scheduler;
+  struct labcomm2014_error_handler *error;
+  struct labcomm2014_memory *memory;
+  struct labcomm2014_scheduler *scheduler;
   int encoder_initialized;
-  struct labcomm_reader_action_context reader_action_context;
-  struct labcomm_writer_action_context writer_action_context;
+  struct labcomm2014_reader_action_context reader_action_context;
+  struct labcomm2014_writer_action_context writer_action_context;
   LABCOMM_SIGNATURE_ARRAY_DEF(writer_decimation, 
 			      struct decimation {
 				int n;
@@ -50,25 +50,25 @@ static void set_decimation(
   struct decimating_private *decimating = context;
   struct decimation *decimation;
 
-  labcomm_scheduler_data_lock(decimating->scheduler);
+  labcomm2014_scheduler_data_lock(decimating->scheduler);
   decimation = LABCOMM_SIGNATURE_ARRAY_REF(decimating->memory,
 					   decimating->writer_decimation, 
 					   struct decimation, 
 					   value->signature_index);
   decimation->n = value->decimation;
   decimation->current = 0;
-  labcomm_scheduler_data_unlock(decimating->scheduler);
+  labcomm2014_scheduler_data_unlock(decimating->scheduler);
 }
 
 static int wrap_reader_alloc(
-  struct labcomm_reader *r, 
-  struct labcomm_reader_action_context *action_context)
+  struct labcomm2014_reader *r, 
+  struct labcomm2014_reader_action_context *action_context)
 {
   struct decimating_private *decimating = action_context->context;
   
-  labcomm_decoder_register_decimating_messages_set_decimation(
+  labcomm2014_decoder_register_decimating_messages_set_decimation(
     r->decoder, set_decimation, decimating);
-  return labcomm_reader_alloc(r, action_context->next);
+  return labcomm2014_reader_alloc(r, action_context->next);
 }
 
 struct send_set_decimation {
@@ -80,11 +80,11 @@ struct send_set_decimation {
 static void send_set_decimation(void *arg)
 {
   struct send_set_decimation *msg = arg;
-  struct labcomm_memory *memory = msg->decimating->memory;
+  struct labcomm2014_memory *memory = msg->decimating->memory;
 
-  labcomm_encode_decimating_messages_set_decimation(
+  labcomm2014_encode_decimating_messages_set_decimation(
     msg->decimating->decimating.writer->encoder, &msg->set_decimation);
-  labcomm_memory_free(memory, 1, msg);
+  labcomm2014_memory_free(memory, 1, msg);
 }
 
 static void enqueue_decimation(struct decimating_private *decimating,
@@ -92,21 +92,21 @@ static void enqueue_decimation(struct decimating_private *decimating,
 			       int amount) 
 {
   struct send_set_decimation *msg;
-  msg = labcomm_memory_alloc(decimating->memory, 1, sizeof(*msg));
+  msg = labcomm2014_memory_alloc(decimating->memory, 1, sizeof(*msg));
   if (msg) {
     msg->decimating = decimating;
     msg->set_decimation.decimation = amount;
     msg->set_decimation.signature_index = remote_index;
     
-    labcomm_scheduler_enqueue(decimating->scheduler, 0, 
+    labcomm2014_scheduler_enqueue(decimating->scheduler, 0, 
 			      send_set_decimation, msg);
   }
 }
 
 static int wrap_reader_start(
-  struct labcomm_reader *r, 
-  struct labcomm_reader_action_context *action_context,
-  int local_index, int remote_index, const struct labcomm_signature *signature,
+  struct labcomm2014_reader *r, 
+  struct labcomm2014_reader_action_context *action_context,
+  int local_index, int remote_index, const struct labcomm2014_signature *signature,
   void *value)
 {
   struct decimating_private *decimating = action_context->context;
@@ -114,26 +114,26 @@ static int wrap_reader_start(
   if (value == NULL) {
     int *decimation, amount;
     
-    labcomm_scheduler_data_lock(decimating->scheduler);
+    labcomm2014_scheduler_data_lock(decimating->scheduler);
     decimation = LABCOMM_SIGNATURE_ARRAY_REF(decimating->memory,
 					     decimating->reader_decimation, 
 					     int,
 					     local_index);
     amount = *decimation;
-    labcomm_scheduler_data_unlock(decimating->scheduler);
+    labcomm2014_scheduler_data_unlock(decimating->scheduler);
     if (remote_index != 0 && amount != 0) {
       enqueue_decimation(decimating, remote_index, amount);
     }
   }
-  return labcomm_reader_start(r, action_context->next, 
+  return labcomm2014_reader_start(r, action_context->next, 
                               local_index, remote_index, signature, value);
 }
 
 static int wrap_reader_ioctl(
-  struct labcomm_reader *r,   
-  struct labcomm_reader_action_context *action_context,
+  struct labcomm2014_reader *r,   
+  struct labcomm2014_reader_action_context *action_context,
   int local_index, int remote_index,
-  const struct labcomm_signature *signature, 
+  const struct labcomm2014_signature *signature, 
   uint32_t action, va_list args)
 {
   struct decimating_private *decimating = action_context->context;
@@ -147,26 +147,26 @@ static int wrap_reader_ioctl(
     amount = va_arg(va, int);
     va_end(va);
    
-    labcomm_scheduler_data_lock(decimating->scheduler);
+    labcomm2014_scheduler_data_lock(decimating->scheduler);
     decimation = LABCOMM_SIGNATURE_ARRAY_REF(decimating->memory,
 					     decimating->reader_decimation, 
 					     int,
 					     local_index);
     *decimation = amount;
-    labcomm_scheduler_data_unlock(decimating->scheduler);
+    labcomm2014_scheduler_data_unlock(decimating->scheduler);
     if (remote_index) {
       enqueue_decimation(decimating, remote_index, amount);
     }
     
   } else {
-    return labcomm_reader_ioctl(r, action_context->next,
+    return labcomm2014_reader_ioctl(r, action_context->next,
 				local_index, remote_index, signature, 
 				action, args);
   }
   return 0;
 }
 
-struct labcomm_reader_action decimating_reader_action = {
+struct labcomm2014_reader_action decimating_reader_action = {
   .alloc = wrap_reader_alloc,
   .free = NULL,
   .start = wrap_reader_start,
@@ -179,25 +179,25 @@ static void register_signatures(void *context)
 {
   struct decimating_private *decimating = context;
 
-  labcomm_encoder_register_decimating_messages_set_decimation(
+  labcomm2014_encoder_register_decimating_messages_set_decimation(
     decimating->decimating.writer->encoder);
 }
 
 static int wrap_writer_alloc(
-  struct labcomm_writer *w, 
-  struct labcomm_writer_action_context *action_context)
+  struct labcomm2014_writer *w, 
+  struct labcomm2014_writer_action_context *action_context)
 {
   struct decimating_private *decimating = action_context->context;
 
-  labcomm_scheduler_enqueue(decimating->scheduler, 
+  labcomm2014_scheduler_enqueue(decimating->scheduler, 
 			    0, register_signatures, decimating);
-  return labcomm_writer_alloc(w, action_context->next);
+  return labcomm2014_writer_alloc(w, action_context->next);
 }
 
 static int wrap_writer_start(
-  struct labcomm_writer *w, 
-  struct labcomm_writer_action_context *action_context, 
-  int index, const struct labcomm_signature *signature,
+  struct labcomm2014_writer *w, 
+  struct labcomm2014_writer_action_context *action_context, 
+  int index, const struct labcomm2014_signature *signature,
   void *value)
 {
   struct decimating_private *decimating = action_context->context;
@@ -207,7 +207,7 @@ static int wrap_writer_start(
   if (index < LABCOMM_USER) {
     result = 0;
   } else {
-    labcomm_scheduler_data_lock(decimating->scheduler);
+    labcomm2014_scheduler_data_lock(decimating->scheduler);
     decimation = LABCOMM_SIGNATURE_ARRAY_REF(decimating->memory, 
                                              decimating->writer_decimation, 
                                              struct decimation, index);
@@ -218,16 +218,16 @@ static int wrap_writer_start(
       decimation->current = 0;
       result = 0;
     }
-    labcomm_scheduler_data_unlock(decimating->scheduler);
+    labcomm2014_scheduler_data_unlock(decimating->scheduler);
   }
   if (result == 0) {
-    result = labcomm_writer_start(w, action_context->next,
+    result = labcomm2014_writer_start(w, action_context->next,
 				 index, signature, value);
   }
   return result;
 }
 
-struct labcomm_writer_action decimating_writer_action = {
+struct labcomm2014_writer_action decimating_writer_action = {
   .alloc = wrap_writer_alloc,
   .free = NULL, 
   .start = wrap_writer_start,
@@ -237,11 +237,11 @@ struct labcomm_writer_action decimating_writer_action = {
 };
 
 struct decimating *decimating_new(
-  struct labcomm_reader *reader,
-  struct labcomm_writer *writer,
-  struct labcomm_error_handler *error,
-  struct labcomm_memory *memory,
-  struct labcomm_scheduler *scheduler)
+  struct labcomm2014_reader *reader,
+  struct labcomm2014_writer *writer,
+  struct labcomm2014_error_handler *error,
+  struct labcomm2014_memory *memory,
+  struct labcomm2014_scheduler *scheduler)
 {
   struct decimating_private *result;
 
diff --git a/examples/twoway/decimating.h b/examples/twoway/decimating.h
index cdfedd7..3d91c67 100644
--- a/examples/twoway/decimating.h
+++ b/examples/twoway/decimating.h
@@ -1,20 +1,20 @@
 #ifndef __DECIMATING_H__
 #define __DECIMATING_H__
 
-#include <labcomm.h>
-#include <labcomm_ioctl.h>
+#include <labcomm2014.h>
+#include <labcomm2014_ioctl.h>
 
 struct decimating {
-  struct labcomm_reader *reader;
-  struct labcomm_writer *writer;
+  struct labcomm2014_reader *reader;
+  struct labcomm2014_writer *writer;
 };
 
 extern struct decimating *decimating_new(
-  struct labcomm_reader *reader,
-  struct labcomm_writer *writer,
-  struct labcomm_error_handler *error,
-  struct labcomm_memory *memory,
-  struct labcomm_scheduler *scheduler);
+  struct labcomm2014_reader *reader,
+  struct labcomm2014_writer *writer,
+  struct labcomm2014_error_handler *error,
+  struct labcomm2014_memory *memory,
+  struct labcomm2014_scheduler *scheduler);
 
 #define SET_DECIMATION LABCOMM_IOSW('d',0,int)
 
diff --git a/examples/twoway/introspecting.c b/examples/twoway/introspecting.c
index 3c64c19..87bffeb 100644
--- a/examples/twoway/introspecting.c
+++ b/examples/twoway/introspecting.c
@@ -23,18 +23,18 @@
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include "labcomm_private.h"
+#include "labcomm2014_private.h"
 #include "introspecting.h"
 #include "gen/introspecting_messages.h"
 
 struct introspecting_private {
   struct introspecting introspecting;
-  struct labcomm_error_handler *error;
-  struct labcomm_memory *memory;
-  struct labcomm_scheduler *scheduler;
+  struct labcomm2014_error_handler *error;
+  struct labcomm2014_memory *memory;
+  struct labcomm2014_scheduler *scheduler;
 
-  struct labcomm_reader_action_context reader_action_context;
-  struct labcomm_writer_action_context writer_action_context;
+  struct labcomm2014_reader_action_context reader_action_context;
+  struct labcomm2014_writer_action_context writer_action_context;
   LABCOMM_SIGNATURE_ARRAY_DEF(remote, 
 			      struct remote {
 				char *name;
@@ -44,13 +44,13 @@ struct introspecting_private {
   LABCOMM_SIGNATURE_ARRAY_DEF(local, 
 			      struct local {
 				enum introspecting_status status;
-				const struct labcomm_signature *signature;
+				const struct labcomm2014_signature *signature;
 			      });
 };
 
 static struct local *get_local(struct introspecting_private *introspecting,
 			       int index,
-			       const struct labcomm_signature *signature)
+			       const struct labcomm2014_signature *signature)
 {
   /* Called with data_lock held */
   struct local *local;
@@ -91,7 +91,7 @@ static void handles_signature(
   struct introspecting_private *introspecting = context;
   struct remote *remote;
 
-  labcomm_scheduler_data_lock(introspecting->scheduler);
+  labcomm2014_scheduler_data_lock(introspecting->scheduler);
   remote = LABCOMM_SIGNATURE_ARRAY_REF(introspecting->memory,
 				       introspecting->remote, 
 				       struct remote, 
@@ -119,25 +119,25 @@ static void handles_signature(
       }
     }
   }
-  labcomm_scheduler_data_unlock(introspecting->scheduler);
+  labcomm2014_scheduler_data_unlock(introspecting->scheduler);
 }
 
 static int wrap_reader_alloc(
-  struct labcomm_reader *r, 
-  struct labcomm_reader_action_context *action_context)
+  struct labcomm2014_reader *r, 
+  struct labcomm2014_reader_action_context *action_context)
 {
   struct introspecting_private *introspecting = action_context->context;
 
-  labcomm_decoder_register_introspecting_messages_handles_signature(
+  labcomm2014_decoder_register_introspecting_messages_handles_signature(
     introspecting->introspecting.reader->decoder, 
     handles_signature, introspecting);
-  return labcomm_reader_alloc(r, action_context->next);
+  return labcomm2014_reader_alloc(r, action_context->next);
 }
 
 struct handles_signature {
   struct introspecting_private *introspecting;
   int index;
-  const struct labcomm_signature *signature;
+  const struct labcomm2014_signature *signature;
 };
 
 static void send_handles_signature(void *arg)
@@ -149,14 +149,14 @@ static void send_handles_signature(void *arg)
   handles_signature.name = h->signature->name;
   handles_signature.signature.n_0 = h->signature->size;
   handles_signature.signature.a = h->signature->signature;
-  labcomm_encode_introspecting_messages_handles_signature(
+  labcomm2014_encode_introspecting_messages_handles_signature(
     h->introspecting->introspecting.writer->encoder, &handles_signature);
 }
 
 static int wrap_reader_start(
-  struct labcomm_reader *r, 
-  struct labcomm_reader_action_context *action_context,
-  int local_index, int remote_index, const struct labcomm_signature *signature,
+  struct labcomm2014_reader *r, 
+  struct labcomm2014_reader_action_context *action_context,
+  int local_index, int remote_index, const struct labcomm2014_signature *signature,
   void *value)
 {
   struct introspecting_private *introspecting = action_context->context;
@@ -164,23 +164,23 @@ static int wrap_reader_start(
   if (value == NULL) {
     struct handles_signature *handles_signature;
 
-    handles_signature = labcomm_memory_alloc(introspecting->memory, 1,
+    handles_signature = labcomm2014_memory_alloc(introspecting->memory, 1,
 					     sizeof(*handles_signature));
     handles_signature->introspecting = introspecting;
     handles_signature->index = local_index;
     handles_signature->signature = signature;
-    labcomm_scheduler_enqueue(introspecting->scheduler, 
+    labcomm2014_scheduler_enqueue(introspecting->scheduler, 
 			      0, send_handles_signature, handles_signature);
   }
-  return labcomm_reader_start(r, action_context->next, 
+  return labcomm2014_reader_start(r, action_context->next, 
 			      local_index, remote_index, signature, value);
 }
 
  void encode_handles_signature(
-  struct labcomm_encoder *encoder,
+  struct labcomm2014_encoder *encoder,
   void *context)
 {
-  const struct labcomm_signature *signature = context;
+  const struct labcomm2014_signature *signature = context;
   introspecting_messages_handles_signature handles_signature;
   int index = 0;
 
@@ -189,11 +189,11 @@ static int wrap_reader_start(
   handles_signature.signature.n_0 = signature->size;
   handles_signature.signature.a = signature->signature;
 
-  labcomm_encode_introspecting_messages_handles_signature(
+  labcomm2014_encode_introspecting_messages_handles_signature(
     NULL, &handles_signature);
 }
 
-struct labcomm_reader_action introspecting_reader_action = {
+struct labcomm2014_reader_action introspecting_reader_action = {
   .alloc = wrap_reader_alloc,
   .free = NULL,
   .start = wrap_reader_start,
@@ -206,25 +206,25 @@ static void register_encoder_signatures(void *context)
 {
   struct introspecting_private *introspecting = context;
 
-  labcomm_encoder_register_introspecting_messages_handles_signature(
+  labcomm2014_encoder_register_introspecting_messages_handles_signature(
     introspecting->introspecting.writer->encoder);
 }
 
 static int wrap_writer_alloc(
-  struct labcomm_writer *w, 
-  struct labcomm_writer_action_context *action_context)
+  struct labcomm2014_writer *w, 
+  struct labcomm2014_writer_action_context *action_context)
 {
   struct introspecting_private *introspecting = action_context->context;
 
-  labcomm_scheduler_enqueue(introspecting->scheduler, 
+  labcomm2014_scheduler_enqueue(introspecting->scheduler, 
 			    0, register_encoder_signatures, introspecting);
-  return labcomm_writer_alloc(w, action_context->next);
+  return labcomm2014_writer_alloc(w, action_context->next);
 }
 
 static int wrap_writer_start(
-  struct labcomm_writer *w, 
-  struct labcomm_writer_action_context *action_context, 
-  int index, const struct labcomm_signature *signature,
+  struct labcomm2014_writer *w, 
+  struct labcomm2014_writer_action_context *action_context, 
+  int index, const struct labcomm2014_signature *signature,
   void *value)
 {
   struct introspecting_private *introspecting = action_context->context;
@@ -232,18 +232,18 @@ static int wrap_writer_start(
   if (index >= LABCOMM_USER && value == NULL) {
     struct local *local;
 
-    labcomm_scheduler_data_lock(introspecting->scheduler);
+    labcomm2014_scheduler_data_lock(introspecting->scheduler);
     local = get_local(introspecting, index, signature);
     local->status = introspecting_registered;
-    labcomm_scheduler_data_unlock(introspecting->scheduler);
+    labcomm2014_scheduler_data_unlock(introspecting->scheduler);
   }
-  return labcomm_writer_start(w, action_context->next, index, signature, value);
+  return labcomm2014_writer_start(w, action_context->next, index, signature, value);
 }
 
 static int wrap_writer_ioctl(
-  struct labcomm_writer *w, 
-  struct labcomm_writer_action_context *action_context, 
-  int index, const struct labcomm_signature *signature, 
+  struct labcomm2014_writer *w, 
+  struct labcomm2014_writer_action_context *action_context, 
+  int index, const struct labcomm2014_signature *signature, 
   uint32_t ioctl_action, va_list args)
 {
   struct introspecting_private *introspecting = action_context->context;
@@ -253,20 +253,20 @@ static int wrap_writer_ioctl(
       struct local *local;
       int result;
 
-      labcomm_scheduler_data_lock(introspecting->scheduler);
+      labcomm2014_scheduler_data_lock(introspecting->scheduler);
       local = get_local(introspecting, index, signature);
       result = local->status;
-      labcomm_scheduler_data_unlock(introspecting->scheduler);
+      labcomm2014_scheduler_data_unlock(introspecting->scheduler);
       return result;
     }
     default: {
-      return labcomm_writer_ioctl(w, action_context->next, index, signature, 
+      return labcomm2014_writer_ioctl(w, action_context->next, index, signature, 
 				  ioctl_action, args);  
     } break;
   }
 }
 
-struct labcomm_writer_action introspecting_writer_action = {
+struct labcomm2014_writer_action introspecting_writer_action = {
   .alloc = wrap_writer_alloc,
   .free = NULL, 
   .start = wrap_writer_start,
@@ -276,11 +276,11 @@ struct labcomm_writer_action introspecting_writer_action = {
 };
 
 extern struct introspecting *introspecting_new(
-  struct labcomm_reader *reader,
-  struct labcomm_writer *writer,
-  struct labcomm_error_handler *error,
-  struct labcomm_memory *memory,
-  struct labcomm_scheduler *scheduler)
+  struct labcomm2014_reader *reader,
+  struct labcomm2014_writer *writer,
+  struct labcomm2014_error_handler *error,
+  struct labcomm2014_memory *memory,
+  struct labcomm2014_scheduler *scheduler)
 {
   struct introspecting_private *result;
 
diff --git a/examples/twoway/introspecting.h b/examples/twoway/introspecting.h
index 984670d..bcd3be7 100644
--- a/examples/twoway/introspecting.h
+++ b/examples/twoway/introspecting.h
@@ -23,22 +23,22 @@
 #ifndef __INTROSPECTING_H__
 #define __INTROSPECTING_H__
 
-#include <labcomm.h>
-#include <labcomm_ioctl.h>
-#include <labcomm_fd_reader.h>
-#include <labcomm_fd_writer.h>
+#include <labcomm2014.h>
+#include <labcomm2014_ioctl.h>
+#include <labcomm2014_fd_reader.h>
+#include <labcomm2014_fd_writer.h>
 
 struct introspecting {
-  struct labcomm_reader *reader;
-  struct labcomm_writer *writer;
+  struct labcomm2014_reader *reader;
+  struct labcomm2014_writer *writer;
 };
 
 extern struct introspecting *introspecting_new(
-  struct labcomm_reader *reader,
-  struct labcomm_writer *writer,
-  struct labcomm_error_handler *error,
-  struct labcomm_memory *memory,
-  struct labcomm_scheduler *scheduler);
+  struct labcomm2014_reader *reader,
+  struct labcomm2014_writer *writer,
+  struct labcomm2014_error_handler *error,
+  struct labcomm2014_memory *memory,
+  struct labcomm2014_scheduler *scheduler);
 
 #define HAS_SIGNATURE LABCOMM_IOS('i',2)
 enum introspecting_status { introspecting_unknown, 
diff --git a/examples/twoway/server.c b/examples/twoway/server.c
index e6eaac0..152f8a9 100644
--- a/examples/twoway/server.c
+++ b/examples/twoway/server.c
@@ -33,11 +33,11 @@
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <unistd.h>
-#include <labcomm_default_error_handler.h>
-#include <labcomm_default_memory.h>
-#include <labcomm_pthread_scheduler.h>
-#include <labcomm_fd_reader.h>
-#include <labcomm_fd_writer.h>
+#include <labcomm2014_default_error_handler.h>
+#include <labcomm2014_default_memory.h>
+#include <labcomm2014_pthread_scheduler.h>
+#include <labcomm2014_fd_reader.h>
+#include <labcomm2014_fd_writer.h>
 #include "decimating.h"
 #include "introspecting.h"
 #include "gen/types.h"
@@ -49,9 +49,9 @@ struct client {
   struct sockaddr_in adr;
   unsigned int adrlen;
   int32_t A, B, Sum, Diff, Product;
-  struct labcomm_decoder *decoder;
-  struct labcomm_encoder *encoder;
-  struct labcomm_scheduler *scheduler;
+  struct labcomm2014_decoder *decoder;
+  struct labcomm2014_encoder *encoder;
+  struct labcomm2014_scheduler *scheduler;
 };
 
 static void handle_A(int32_t *value, void *context)
@@ -67,22 +67,22 @@ static void handle_B(int32_t *value, void *context)
   int status;
 
   client->B = *value;
-  status = labcomm_encoder_ioctl_types_Product(client->encoder, HAS_SIGNATURE);
+  status = labcomm2014_encoder_ioctl_types_Product(client->encoder, HAS_SIGNATURE);
   switch (status) {
     case introspecting_unregistered:
-      labcomm_encoder_register_types_Product(client->encoder);
+      labcomm2014_encoder_register_types_Product(client->encoder);
       /* fall through */
     case introspecting_registered:
       client->Product = client->A * client->B;
-      labcomm_encode_types_Product(client->encoder, &client->Product);
+      labcomm2014_encode_types_Product(client->encoder, &client->Product);
       break;
     default:
       break;
   }
   client->Sum = client->A + client->B;
   client->Diff = client->A - client->B;
-  labcomm_encode_types_Sum(client->encoder, &client->Sum);
-  labcomm_encode_types_Diff(client->encoder, &client->Diff);
+  labcomm2014_encode_types_Sum(client->encoder, &client->Sum);
+  labcomm2014_encode_types_Diff(client->encoder, &client->Diff);
 }
 
 static void handle_Terminate(types_Terminate *value, void *context)
@@ -95,14 +95,14 @@ static void *run_decoder(void *arg)
   struct client *client = arg;
   int result;
 
-  labcomm_decoder_register_types_A(client->decoder, handle_A, client);
-  labcomm_decoder_register_types_B(client->decoder, handle_B, client);
-  labcomm_decoder_register_types_Terminate(client->decoder, handle_Terminate, 
+  labcomm2014_decoder_register_types_A(client->decoder, handle_A, client);
+  labcomm2014_decoder_register_types_B(client->decoder, handle_B, client);
+  labcomm2014_decoder_register_types_Terminate(client->decoder, handle_Terminate, 
 					   NULL);
   do {
-    result = labcomm_decoder_decode_one(client->decoder);
+    result = labcomm2014_decoder_decode_one(client->decoder);
   } while (result >= 0);
-  labcomm_scheduler_wakeup(client->scheduler);
+  labcomm2014_scheduler_wakeup(client->scheduler);
   return NULL;
 }
 
@@ -115,13 +115,13 @@ static void *run_client(void *arg)
   printf("Client start\n");
   client->A = 0;
   client->B = 0;
-  client->scheduler = labcomm_pthread_scheduler_new(labcomm_default_memory);
-  decimating = decimating_new(labcomm_fd_reader_new(labcomm_default_memory,
+  client->scheduler = labcomm2014_pthread_scheduler_new(labcomm2014_default_memory);
+  decimating = decimating_new(labcomm2014_fd_reader_new(labcomm2014_default_memory,
 						    client->fd, 1),
-			      labcomm_fd_writer_new(labcomm_default_memory,
+			      labcomm2014_fd_writer_new(labcomm2014_default_memory,
 						    client->fd, 0),
-			      labcomm_default_error_handler,
-			      labcomm_default_memory,
+			      labcomm2014_default_error_handler,
+			      labcomm2014_default_memory,
 			      client->scheduler);
   if (decimating == NULL) {
     /* Warning: might leak reader and writer at this point */
@@ -129,26 +129,26 @@ static void *run_client(void *arg)
   }
   introspecting = introspecting_new(decimating->reader,
 				    decimating->writer,
-				    labcomm_default_error_handler,
-				    labcomm_default_memory,
+				    labcomm2014_default_error_handler,
+				    labcomm2014_default_memory,
 				    client->scheduler);
   if (introspecting == NULL) {
     /* Warning: might leak reader and writer at this point */
     goto out;
   }
-  client->decoder = labcomm_decoder_new(introspecting->reader,
-				    labcomm_default_error_handler,
-				    labcomm_default_memory,
+  client->decoder = labcomm2014_decoder_new(introspecting->reader,
+				    labcomm2014_default_error_handler,
+				    labcomm2014_default_memory,
 				    client->scheduler);
-  client->encoder = labcomm_encoder_new(introspecting->writer,
-				    labcomm_default_error_handler,
-				    labcomm_default_memory,
+  client->encoder = labcomm2014_encoder_new(introspecting->writer,
+				    labcomm2014_default_error_handler,
+				    labcomm2014_default_memory,
 				    client->scheduler);
   pthread_t rdt;
   pthread_create(&rdt, NULL, run_decoder, client);  
-  labcomm_encoder_register_types_Sum(client->encoder);
-  labcomm_encoder_register_types_Diff(client->encoder);
-  labcomm_scheduler_sleep(client->scheduler, NULL);
+  labcomm2014_encoder_register_types_Sum(client->encoder);
+  labcomm2014_encoder_register_types_Diff(client->encoder);
+  labcomm2014_scheduler_sleep(client->scheduler, NULL);
   printf("Awoken\n");
   pthread_join(rdt, NULL);
 out:
diff --git a/examples/user_types/example_decoder.c b/examples/user_types/example_decoder.c
index b727f8a..5d6062e 100644
--- a/examples/user_types/example_decoder.c
+++ b/examples/user_types/example_decoder.c
@@ -1,10 +1,10 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
-#include <labcomm_fd_reader.h>
-#include <labcomm_default_error_handler.h>
-#include <labcomm_default_memory.h>
-#include <labcomm_default_scheduler.h>
+#include <labcomm2014_fd_reader.h>
+#include <labcomm2014_default_error_handler.h>
+#include <labcomm2014_default_memory.h>
+#include <labcomm2014_default_scheduler.h>
 #include "gen/test.h"
 #include <stdio.h>
 
@@ -28,11 +28,11 @@ static void handle_test_theSecondInt(int *v,void *context) {
   printf("Got theSecondInt. (%d) \n", *v); 
 }
 
-static void handle_type_def(struct labcomm_raw_type_def *v,void *context) {
+static void handle_type_def(struct labcomm2014_raw_type_def *v,void *context) {
   printf("Got type_def. (0x%x) %s\n", v->index, v->name); 
 }
 
-static void handle_type_binding(struct labcomm_type_binding *v,void *context) {
+static void handle_type_binding(struct labcomm2014_type_binding *v,void *context) {
   printf("Got type binding. 0x%x --> 0x%x\n", v->sample_index, v->type_index); 
 }
 
@@ -45,37 +45,37 @@ static void handle_test_twoLines(test_twoLines *v,void *context) {
 
 int main(int argc, char *argv[]) {
   int fd;
-  struct labcomm_decoder *decoder;
+  struct labcomm2014_decoder *decoder;
   void  *context = NULL;
 
   char *filename = argv[1];
   printf("C decoder reading from %s\n", filename);
   fd = open(filename, O_RDONLY);
-  decoder = labcomm_decoder_new(labcomm_fd_reader_new(
-				  labcomm_default_memory, fd, 1), 
-				labcomm_default_error_handler, 
-				labcomm_default_memory,
-				labcomm_default_scheduler);
+  decoder = labcomm2014_decoder_new(labcomm2014_fd_reader_new(
+				  labcomm2014_default_memory, fd, 1), 
+				labcomm2014_default_error_handler, 
+				labcomm2014_default_memory,
+				labcomm2014_default_scheduler);
   if (!decoder) { 
     printf("Failed to allocate decoder %s:%d\n", __FUNCTION__, __LINE__);
     return 1;
   }
 
-  labcomm_decoder_register_test_doavoid(decoder, handle_test_doavoid, context);
-  labcomm_decoder_register_test_intAndRef(decoder, handle_test_intAndRef, context);
-  labcomm_decoder_sample_ref_register(decoder,labcomm_signature_test_doavoid );
+  labcomm2014_decoder_register_test_doavoid(decoder, handle_test_doavoid, context);
+  labcomm2014_decoder_register_test_intAndRef(decoder, handle_test_intAndRef, context);
+  labcomm2014_decoder_sample_ref_register(decoder,labcomm2014_signature_test_doavoid );
 
-  labcomm_decoder_register_test_twoInts(decoder, handle_test_twoInts, context);
-  labcomm_decoder_register_test_theFirstInt(decoder, handle_test_theFirstInt, context);
-  labcomm_decoder_register_test_theSecondInt(decoder, handle_test_theSecondInt, context);
-  labcomm_decoder_register_test_twoLines(decoder, handle_test_twoLines, context);
-  labcomm_decoder_register_labcomm_type_def(decoder, handle_type_def, context);
-  labcomm_decoder_register_labcomm_type_binding(decoder, handle_type_binding, context);
+  labcomm2014_decoder_register_test_twoInts(decoder, handle_test_twoInts, context);
+  labcomm2014_decoder_register_test_theFirstInt(decoder, handle_test_theFirstInt, context);
+  labcomm2014_decoder_register_test_theSecondInt(decoder, handle_test_theSecondInt, context);
+  labcomm2014_decoder_register_test_twoLines(decoder, handle_test_twoLines, context);
+  labcomm2014_decoder_register_labcomm2014_type_def(decoder, handle_type_def, context);
+  labcomm2014_decoder_register_labcomm2014_type_binding(decoder, handle_type_binding, context);
 
   printf("Decoding:\n");
-  labcomm_decoder_run(decoder);
+  labcomm2014_decoder_run(decoder);
   printf("--- End Of File ---:\n");
-  labcomm_decoder_free(decoder);
+  labcomm2014_decoder_free(decoder);
 
   return 0;
 }
diff --git a/examples/user_types/example_encoder.c b/examples/user_types/example_encoder.c
index 3c76dcd..6c1d1ef 100644
--- a/examples/user_types/example_encoder.c
+++ b/examples/user_types/example_encoder.c
@@ -1,26 +1,26 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
-#include <labcomm_fd_writer.h>
-#include <labcomm_default_error_handler.h>
-#include <labcomm_default_memory.h>
-#include <labcomm_default_scheduler.h>
+#include <labcomm2014_fd_writer.h>
+#include <labcomm2014_default_error_handler.h>
+#include <labcomm2014_default_memory.h>
+#include <labcomm2014_default_scheduler.h>
 #include "gen/test.h"
 #include <stdio.h>
 
 int main(int argc, char *argv[]) {
   int fd;
-  struct labcomm_encoder *encoder;
+  struct labcomm2014_encoder *encoder;
 
   char *filename = argv[1];
   printf("C encoder writing to %s\n", filename);
   fd = open(filename, O_WRONLY|O_CREAT|O_TRUNC, 0644);
-  encoder = labcomm_encoder_new(labcomm_fd_writer_new(
-				  labcomm_default_memory, fd, 1), 
-				labcomm_default_error_handler, 
-				labcomm_default_memory,
-				labcomm_default_scheduler);
-  labcomm_encoder_register_test_twoLines(encoder);
+  encoder = labcomm2014_encoder_new(labcomm2014_fd_writer_new(
+				  labcomm2014_default_memory, fd, 1), 
+				labcomm2014_default_error_handler, 
+				labcomm2014_default_memory,
+				labcomm2014_default_scheduler);
+  labcomm2014_encoder_register_test_twoLines(encoder);
 
   test_twoLines tl;
 
@@ -34,7 +34,7 @@ int main(int argc, char *argv[]) {
   tl.l2.end.y.val = 23;
  
   printf("Encoding twoLines...\n");
-  labcomm_encode_test_twoLines(encoder, &tl);
+  labcomm2014_encode_test_twoLines(encoder, &tl);
 
   return 0;
 }
diff --git a/examples/wiki_example/example_encoder.c b/examples/wiki_example/example_encoder.c
index 3983a13..ee82c7a 100644
--- a/examples/wiki_example/example_encoder.c
+++ b/examples/wiki_example/example_encoder.c
@@ -1,24 +1,24 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
-#include <labcomm.h>
-#include <labcomm_default_memory.h>
-#include <labcomm_fd_reader.h>
-#include <labcomm_fd_writer.h>
+#include <labcomm2014.h>
+#include <labcomm2014_default_memory.h>
+#include <labcomm2014_fd_reader.h>
+#include <labcomm2014_fd_writer.h>
 #include "example.h"
 
 int main(int argc, char *argv[]) {
   int fd;
-  struct labcomm_encoder *encoder;
-  struct labcomm_writer *labcomm_fd_writer;
+  struct labcomm2014_encoder *encoder;
+  struct labcomm2014_writer *labcomm2014_fd_writer;
   int i, j;
 
   fd = open("example.encoded", O_WRONLY|O_CREAT|O_TRUNC, 0644);
-  labcomm_fd_writer = labcomm_fd_writer_new(labcomm_default_memory, fd, 1);
-  encoder = labcomm_encoder_new(labcomm_fd_writer, NULL, 
-                                labcomm_default_memory, NULL);
-  labcomm_encoder_register_example_log_message(encoder);
-  labcomm_encoder_register_example_data(encoder);
+  labcomm2014_fd_writer = labcomm2014_fd_writer_new(labcomm2014_default_memory, fd, 1);
+  encoder = labcomm2014_encoder_new(labcomm2014_fd_writer, NULL, 
+                                labcomm2014_default_memory, NULL);
+  labcomm2014_encoder_register_example_log_message(encoder);
+  labcomm2014_encoder_register_example_data(encoder);
   for (i = 0 ; i < argc ; i++) {
     example_log_message message;
 
@@ -29,12 +29,12 @@ int main(int argc, char *argv[]) {
       message.line.a[j].last = (j == message.line.n_0 - 1);
       message.line.a[j].data = argv[j + 1];
     }
-    labcomm_encode_example_log_message(encoder, &message);
+    labcomm2014_encode_example_log_message(encoder, &message);
     free(message.line.a);
   }
   for (i = 0 ; i < argc ; i++) {
     float f = i;
-    labcomm_encode_example_data(encoder, &f);
+    labcomm2014_encode_example_data(encoder, &f);
   }
   return 0;
 }
diff --git a/lib/c/2014/Makefile b/lib/c/2014/Makefile
index f5a9f10..0e7aca5 100644
--- a/lib/c/2014/Makefile
+++ b/lib/c/2014/Makefile
@@ -1,5 +1,5 @@
 ## Macros
-VERSION=
+VERSION=2014
 LIBVERSION=2014
 
 include ../os_compat.mk
diff --git a/lib/c/2014/labcomm.h b/lib/c/2014/labcomm.h
deleted file mode 100644
index fa62e7d..0000000
--- a/lib/c/2014/labcomm.h
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
-  labcomm.h -- user interface for handling encoding and decoding of
-               labcomm 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 __LABCOMM_H__
-#define __LABCOMM_H__
-
-#include <stdarg.h>
-
-#ifdef LABCOMM_COMPAT
-  #include LABCOMM_COMPAT
-#else
-  #include <stdint.h>
-  #include <unistd.h>
-#endif
-
-#include "labcomm_error.h"
-#include "labcomm_scheduler.h"
-
-/* Forward declaration */
-struct labcomm_encoder;
-struct labcomm_decoder;
-
-#include "labcomm_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 (*labcomm_error_handler_callback)(enum labcomm_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 labcomm2014_on_error_fprintf(enum labcomm_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);
-
-/* 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);
-
-typedef int (*labcomm_handle_new_datatype_callback)(
-  struct labcomm_decoder *decoder,
-  struct labcomm_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 labcomm_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 *ptr, size_t size);
-void labcomm_memory_free(struct labcomm_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);
-int labcomm_decoder_sample_ref_register(
-  struct labcomm_decoder *decoder,
-  const struct labcomm_signature *signature);
-
-/* See labcomm_ioctl.h for predefined ioctl_action values */
-int labcomm_decoder_ioctl(struct labcomm_decoder *decoder, 
-			  uint32_t ioctl_action,
-			  ...);
-
-/*
- * 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);
-int labcomm_encoder_sample_ref_register(
-  struct labcomm_encoder *encoder,
-  const struct labcomm_signature *signature);
-
-/* 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)
-
-#endif
diff --git a/lib/c/2014/labcomm.c b/lib/c/2014/labcomm2014.c
similarity index 54%
rename from lib/c/2014/labcomm.c
rename to lib/c/2014/labcomm2014.c
index a01c96b..41d6f1a 100644
--- a/lib/c/2014/labcomm.c
+++ b/lib/c/2014/labcomm2014.c
@@ -1,6 +1,6 @@
 /*
-  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,10 +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"
+#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
@@ -47,85 +47,85 @@
     UNWRAP_ac( __VA_ARGS__) = UNWRAP_ac(__VA_ARGS__)->next;		\
   }
 
-int labcomm_reader_alloc(struct labcomm_reader *r,
-                         struct labcomm_reader_action_context *action_context)
+int labcomm2014_reader_alloc(struct labcomm2014_reader *r,
+                         struct labcomm2014_reader_action_context *action_context)
 {
   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,
-			 const 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,
-                         const struct labcomm_signature *signature,
+                         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 labcomm_writer_alloc(struct labcomm_writer *w,
-                         struct labcomm_writer_action_context *action_context)
+int labcomm2014_writer_alloc(struct labcomm2014_writer *w,
+                         struct labcomm2014_writer_action_context *action_context)
 {
   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, const 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 labcomm2014_writer_ioctl(struct labcomm2014_writer *w,
+                         struct labcomm2014_writer_action_context *action_context,
                          int index,
-                         const struct labcomm_signature *signature,
+                         const struct labcomm2014_signature *signature,
                          uint32_t ioctl_action, va_list args)
 {
   UNWRAP(ioctl, w, action_context, index, signature, ioctl_action, args);
@@ -137,29 +137,29 @@ int labcomm_writer_ioctl(struct labcomm_writer *w,
 
 
 
-static const char *labcomm_error_string[] = {
+static const char *labcomm2014_error_string[] = {
 #define LABCOMM_ERROR(name, description) description ,
-#include "labcomm_error.h"
+#include "labcomm2014_error.h"
 #undef LABCOMM_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 labcomm2014_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.";
   }
@@ -177,7 +177,7 @@ void labcomm2014_on_error_fprintf(enum labcomm_error error_id, size_t nbr_va_arg
    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
 }
 
@@ -199,14 +199,14 @@ 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);
+    *data = labcomm2014_memory_alloc(memory, 0, size);
     if (*data) {
       memset(*data, 0, size);
     }
@@ -218,7 +218,7 @@ 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,
@@ -226,7 +226,7 @@ void *labcomm_signature_array_ref(struct labcomm_memory *memory,
 	     (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);
@@ -238,36 +238,36 @@ void *labcomm_signature_array_ref(struct labcomm_memory *memory,
 
 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,
+    labcomm2014_error_fatal_global(LABCOMM_ERROR_SIGNATURE_ALREADY_SET,
 			       "Signature already set: %s\n", signature->name);
   }
   signature->index = local_index;
   local_index++;
 }
 
-int labcomm_get_local_index(const 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,
+    labcomm2014_error_fatal_global(LABCOMM_ERROR_SIGNATURE_NOT_SET,
 			       "Signature not set: %s\n", signature->name);
   }
   return signature->index;
 }
 
-int labcomm_get_local_type_index(const struct labcomm_signature *signature)
+int labcomm2014_get_local_type_index(const struct labcomm2014_signature *signature)
 {
-    return labcomm_get_local_index(signature);
+    return labcomm2014_get_local_index(signature);
 }
 
-int labcomm_internal_sizeof(const struct labcomm_signature *signature,
+int labcomm2014_internal_sizeof(const struct labcomm2014_signature *signature,
                             void *v)
 {
   int length = signature->encoded_size(v);
-  return (labcomm_size_packed32(signature->index) +
-          labcomm_size_packed32(length) +
+  return (labcomm2014_size_packed32(signature->index) +
+          labcomm2014_size_packed32(length) +
           length);
 }
 
diff --git a/lib/c/2014/labcomm2014.h b/lib/c/2014/labcomm2014.h
new file mode 100644
index 0000000..5492b1e
--- /dev/null
+++ b/lib/c/2014/labcomm2014.h
@@ -0,0 +1,138 @@
+/*
+  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 __LABCOMM_H__
+#define __LABCOMM_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,
+			  ...);
+
+/*
+ * 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,
+			  ...);
+
+#define LABCOMM_VOID ((void*)1)
+
+#endif
diff --git a/lib/c/2014/labcomm_compat_arm_cortexm3.h b/lib/c/2014/labcomm2014_compat_arm_cortexm3.h
similarity index 100%
rename from lib/c/2014/labcomm_compat_arm_cortexm3.h
rename to lib/c/2014/labcomm2014_compat_arm_cortexm3.h
diff --git a/lib/c/2014/labcomm_compat_osx.h b/lib/c/2014/labcomm2014_compat_osx.h
similarity index 100%
rename from lib/c/2014/labcomm_compat_osx.h
rename to lib/c/2014/labcomm2014_compat_osx.h
diff --git a/lib/c/2014/labcomm_compat_vxworks.h b/lib/c/2014/labcomm2014_compat_vxworks.h
similarity index 100%
rename from lib/c/2014/labcomm_compat_vxworks.h
rename to lib/c/2014/labcomm2014_compat_vxworks.h
diff --git a/lib/c/2014/labcomm_decoder.c b/lib/c/2014/labcomm2014_decoder.c
similarity index 63%
rename from lib/c/2014/labcomm_decoder.c
rename to lib/c/2014/labcomm2014_decoder.c
index cac035f..8d3f79b 100644
--- a/lib/c/2014/labcomm_decoder.c
+++ b/lib/c/2014/labcomm2014_decoder.c
@@ -1,5 +1,5 @@
 /*
-  labcomm_decoder.c -- runtime for handling decoding of labcomm samples.
+  labcomm2014_decoder.c -- runtime for handling decoding of labcomm2014 samples.
 
   Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
 
@@ -21,10 +21,10 @@
 #define CURRENT_VERSION "LabComm2014"
 
 #include <errno.h>
-#include "labcomm.h"
-#include "labcomm_private.h"
-#include "labcomm_ioctl.h"
-#include "labcomm_dynamic_buffer_writer.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__)
@@ -40,36 +40,36 @@
 
 struct sample_entry {
   int remote_index;
-  const struct labcomm_signature *signature;
-  labcomm_decoder_function decode;
-  labcomm_handler_function handler;
+  const struct labcomm2014_signature *signature;
+  labcomm2014_decoder_function decode;
+  labcomm2014_handler_function handler;
   void *context;
 };
 
-struct labcomm_decoder {
-  struct labcomm_reader *reader;
+struct labcomm2014_decoder {
+  struct labcomm2014_reader *reader;
   int reader_allocated;
   int version_ok;
-  struct labcomm_error_handler *error;
-  struct labcomm_memory *memory;
-  struct labcomm_scheduler *scheduler;
-  labcomm_error_handler_callback on_error;
-  labcomm_handle_new_datatype_callback on_new_datatype;
+  struct labcomm2014_error_handler *error;
+  struct labcomm2014_memory *memory;
+  struct labcomm2014_scheduler *scheduler;
+  labcomm2014_error_handler_callback on_error;
+  labcomm2014_handle_new_datatype_callback on_new_datatype;
   LABCOMM_SIGNATURE_ARRAY_DEF(local, struct sample_entry);
   LABCOMM_SIGNATURE_ARRAY_DEF(remote_to_local, int);
-  LABCOMM_SIGNATURE_ARRAY_DEF(local_ref, const struct labcomm_signature *);
+  LABCOMM_SIGNATURE_ARRAY_DEF(local_ref, const struct labcomm2014_signature *);
   LABCOMM_SIGNATURE_ARRAY_DEF(remote_to_local_ref, int);
 };
 
-struct labcomm_decoder *labcomm_decoder_new(
-  struct labcomm_reader *reader,
-  struct labcomm_error_handler *error,
-  struct labcomm_memory *memory,
-  struct labcomm_scheduler *scheduler)
+struct labcomm2014_decoder *labcomm2014_decoder_new(
+  struct labcomm2014_reader *reader,
+  struct labcomm2014_error_handler *error,
+  struct labcomm2014_memory *memory,
+  struct labcomm2014_scheduler *scheduler)
 {
-  struct labcomm_decoder *result;
+  struct labcomm2014_decoder *result;
 
-  result = labcomm_memory_alloc(memory, 0, sizeof(*result));
+  result = labcomm2014_memory_alloc(memory, 0, sizeof(*result));
   if (result) {
     result->reader = reader;
     result->reader->decoder = result;
@@ -83,38 +83,38 @@ struct labcomm_decoder *labcomm_decoder_new(
     result->error = error;
     result->memory = memory;
     result->scheduler = scheduler;
-    result->on_error = labcomm2014_on_error_fprintf;
+    result->on_error = labcomm20142014_on_error_fprintf;
     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 labcomm_signature*);
+                                 const struct labcomm2014_signature*);
     LABCOMM_SIGNATURE_ARRAY_INIT(result->remote_to_local_ref, int);
   }
   return result;
 }
 
-void labcomm_decoder_free(struct labcomm_decoder* d)
+void labcomm2014_decoder_free(struct labcomm2014_decoder* d)
 {
-  struct labcomm_memory *memory = d->memory;
+  struct labcomm2014_memory *memory = d->memory;
 
-  labcomm_reader_free(d->reader, d->reader->action_context);
+  labcomm2014_reader_free(d->reader, d->reader->action_context);
   LABCOMM_SIGNATURE_ARRAY_FREE(memory, d->local, struct sample_entry);
   LABCOMM_SIGNATURE_ARRAY_FREE(memory, d->remote_to_local, int);
   LABCOMM_SIGNATURE_ARRAY_FREE(memory, d->local_ref, 
-                               const struct labcomm_signature*);
+                               const struct labcomm2014_signature*);
   LABCOMM_SIGNATURE_ARRAY_FREE(memory, d->remote_to_local_ref, int);
-  labcomm_memory_free(memory, 0, d);
+  labcomm2014_memory_free(memory, 0, d);
 }
 
-static int handle_sample_def(struct labcomm_decoder *d, int remote_index,
-                             const struct labcomm_signature *signature)
+static int handle_sample_def(struct labcomm2014_decoder *d, int remote_index,
+                             const struct labcomm2014_signature *signature)
 {
   int result;
   int i;
-  const struct labcomm_signature *local_signature = NULL;
+  const struct labcomm2014_signature *local_signature = NULL;
   int local_index = 0;
 
-  labcomm_scheduler_data_lock(d->scheduler);
+  labcomm2014_scheduler_data_lock(d->scheduler);
   LABCOMM_SIGNATURE_ARRAY_FOREACH(d->local, struct sample_entry, i) {
     struct sample_entry *s;
     int *remote_to_local;
@@ -138,29 +138,29 @@ static int handle_sample_def(struct labcomm_decoder *d, int remote_index,
       break;
     }
   }
-  labcomm_scheduler_data_unlock(d->scheduler);
+  labcomm2014_scheduler_data_unlock(d->scheduler);
   if (local_signature) {
-    labcomm_reader_start(d->reader, d->reader->action_context,
+    labcomm2014_reader_start(d->reader, d->reader->action_context,
                          local_index, remote_index, local_signature,
                          NULL);
-    labcomm_reader_end(d->reader, d->reader->action_context);
+    labcomm2014_reader_end(d->reader, d->reader->action_context);
   }
   return result;
 }
 
-static int handle_sample_ref(struct labcomm_decoder *d, int remote_index,
-                             const struct labcomm_signature *signature)
+static int handle_sample_ref(struct labcomm2014_decoder *d, int remote_index,
+                             const struct labcomm2014_signature *signature)
 {
   int result;
   int i;
 
-  labcomm_scheduler_data_lock(d->scheduler);
-  LABCOMM_SIGNATURE_ARRAY_FOREACH(d->local_ref, const struct labcomm_signature *, i) {
-    const struct labcomm_signature *s;
+  labcomm2014_scheduler_data_lock(d->scheduler);
+  LABCOMM_SIGNATURE_ARRAY_FOREACH(d->local_ref, const struct labcomm2014_signature *, i) {
+    const struct labcomm2014_signature *s;
     int *remote_to_local_ref;
 
     result = -ENOENT;
-    s = LABCOMM_SIGNATURE_ARRAY_GET(d->local_ref, const struct labcomm_signature *, i, 0);
+    s = LABCOMM_SIGNATURE_ARRAY_GET(d->local_ref, const struct labcomm2014_signature *, i, 0);
     if (s &&
         s->signature &&
         s->size == signature->size &&
@@ -174,17 +174,17 @@ static int handle_sample_ref(struct labcomm_decoder *d, int remote_index,
       break;
     }
   }
-  labcomm_scheduler_data_unlock(d->scheduler);
+  labcomm2014_scheduler_data_unlock(d->scheduler);
   return result;
 }
 
-static int decoder_skip(struct labcomm_decoder *d, int len, int tag)
+static int decoder_skip(struct labcomm2014_decoder *d, 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, ".");
-    labcomm_read_byte(d->reader);
+    labcomm2014_read_byte(d->reader);
     if (d->reader->error < 0) {
       DECODER_DEBUG_FPRINTF(stderr, "\nerror while skipping: %d\n",  d->reader->error);
       return d->reader->error;
@@ -194,34 +194,34 @@ static int decoder_skip(struct labcomm_decoder *d, int len, int tag)
   return tag;
 }
 
-static int decode_sample_def_or_ref(struct labcomm_decoder *d, int kind)
+static int decode_sample_def_or_ref(struct labcomm2014_decoder *d, int kind)
 {
   int result;
-  struct labcomm_signature signature;
+  struct labcomm2014_signature signature;
   int i, remote_index;
 
-  remote_index = labcomm_read_packed32(d->reader);
+  remote_index = labcomm2014_read_packed32(d->reader);
   if (d->reader->error < 0) {
     result = d->reader->error;
     goto out;
   }
-  signature.name = labcomm_read_string(d->reader);
+  signature.name = labcomm2014_read_string(d->reader);
   if (d->reader->error < 0) {
     result = d->reader->error;
     goto out;
   }
-  signature.size = labcomm_read_packed32(d->reader);
+  signature.size = labcomm2014_read_packed32(d->reader);
   if (d->reader->error < 0) {
     result = d->reader->error;
     goto free_signature_name;
   }
-  signature.signature = labcomm_memory_alloc(d->memory, 1,  signature.size);
+  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] = labcomm_read_byte(d->reader);
+    signature.signature[i] = labcomm2014_read_byte(d->reader);
     if (d->reader->error < 0) {
       result = d->reader->error;
       goto free_signature_signature;
@@ -244,19 +244,19 @@ static int decode_sample_def_or_ref(struct labcomm_decoder *d, int kind)
       result = -EINVAL;
   }
 free_signature_signature:
-  labcomm_memory_free(d->memory, 1,  signature.signature);
+  labcomm2014_memory_free(d->memory, 1,  signature.signature);
 free_signature_name:
-  labcomm_memory_free(d->memory, 0, signature.name);
+  labcomm2014_memory_free(d->memory, 0, signature.name);
 out:
   return result;
 }
 
 struct call_handler_context {
-  struct labcomm_reader *reader;
+  struct labcomm2014_reader *reader;
   int local_index;
   int remote_index;
-  const struct labcomm_signature *signature;
-  labcomm_handler_function handler;
+  const struct labcomm2014_signature *signature;
+  labcomm2014_handler_function handler;
   void *context;
 };
 
@@ -265,52 +265,52 @@ static void call_handler(void *value, void *context)
   struct call_handler_context *wrap = context;
 
   if (wrap->reader->error >= 0) {
-    labcomm_reader_start(wrap->reader, wrap->reader->action_context,
+    labcomm2014_reader_start(wrap->reader, wrap->reader->action_context,
 			 wrap->local_index, wrap->remote_index, wrap->signature,
 			 value);
     wrap->handler(value, wrap->context);
-    labcomm_reader_end(wrap->reader, wrap->reader->action_context);
+    labcomm2014_reader_end(wrap->reader, wrap->reader->action_context);
   }
 }
 
-static void reader_alloc(struct labcomm_decoder *d)
+static void reader_alloc(struct labcomm2014_decoder *d)
 {
   if (!d->reader_allocated) {
     d->reader_allocated = 1;
-    labcomm_reader_alloc(d->reader, d->reader->action_context);
+    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 labcomm packet )
+   len      - length of the labcomm2014 packet )
 */
-static int decode_pragma(struct labcomm_decoder *d,
-		         struct labcomm_decoder *registry,
+static int decode_pragma(struct labcomm2014_decoder *d,
+		         struct labcomm2014_decoder *registry,
 		         int len)
 {
   char *pragma_type;
   int result;
-  pragma_type = labcomm_read_string(d->reader);
+  pragma_type = labcomm2014_read_string(d->reader);
   if (d->reader->error < 0) {
     result = d->reader->error;
     goto out;
   }
-  int bytes = labcomm_size_string(pragma_type);
+  int bytes = labcomm2014_size_string(pragma_type);
   int psize = len-bytes;
   result = decoder_skip(d, psize, LABCOMM_PRAGMA);
 out:
   return result;
 }
 
-static labcomm_decoder_function lookup_h(struct labcomm_decoder *d,
+static labcomm2014_decoder_function lookup_h(struct labcomm2014_decoder *d,
 		                         struct call_handler_context *wrap,
 		                         int remote_index,
 					 int **local_index)
 {
-  labcomm_decoder_function do_decode = NULL;
-  labcomm_scheduler_data_lock(d->scheduler);
+  labcomm2014_decoder_function do_decode = NULL;
+  labcomm2014_scheduler_data_lock(d->scheduler);
   *local_index = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
       				      d->remote_to_local, int,
       				      remote_index);
@@ -326,7 +326,7 @@ static labcomm_decoder_function lookup_h(struct labcomm_decoder *d,
     wrap->context = entry->context;
     do_decode = entry->decode;
   }
-  labcomm_scheduler_data_unlock(d->scheduler);
+  labcomm2014_scheduler_data_unlock(d->scheduler);
   return do_decode;
 }
 /* d            - decoder to read from
@@ -334,8 +334,8 @@ static labcomm_decoder_function lookup_h(struct labcomm_decoder *d,
                     nesting decoders, e.g., when decoding pragma)
    remote_index -  received type index )
 */
-static int decode_and_handle(struct labcomm_decoder *d,
-		             struct labcomm_decoder *registry,
+static int decode_and_handle(struct labcomm2014_decoder *d,
+		             struct labcomm2014_decoder *registry,
 		             int remote_index)
 {
   int result;
@@ -347,7 +347,7 @@ static int decode_and_handle(struct labcomm_decoder *d,
     .handler = NULL,
     .context = NULL,
   };
-  labcomm_decoder_function do_decode = lookup_h(registry, &wrap, remote_index, &local_index);
+  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);
@@ -359,23 +359,23 @@ static int decode_and_handle(struct labcomm_decoder *d,
   }
   return result;
 }
-int labcomm_decoder_decode_one(struct labcomm_decoder *d)
+int labcomm2014_decoder_decode_one(struct labcomm2014_decoder *d)
 {
   int result, remote_index, length;
 
   reader_alloc(d);
-  remote_index = labcomm_read_packed32(d->reader);
+  remote_index = labcomm2014_read_packed32(d->reader);
   if (d->reader->error < 0) {
     result = d->reader->error;
     goto out;
   }
-  length = labcomm_read_packed32(d->reader);
+  length = labcomm2014_read_packed32(d->reader);
   if (d->reader->error < 0) {
     result = d->reader->error;
     goto out;
   }
   if (remote_index == LABCOMM_VERSION) {
-    char *version = labcomm_read_string(d->reader);
+    char *version = labcomm2014_read_string(d->reader);
     if (d->reader->error < 0) {
       result = d->reader->error;
       goto out;
@@ -386,7 +386,7 @@ int labcomm_decoder_decode_one(struct labcomm_decoder *d)
     } else {
       result = -ECONNRESET;
     }  
-    labcomm_memory_free(d->memory, 1,  version);
+    labcomm2014_memory_free(d->memory, 1,  version);
   } else if (! d->version_ok) {
     DEBUG_FPRINTF(stderr, "No VERSION %d %d\n", remote_index, length);
     result = -ECONNRESET;
@@ -418,13 +418,13 @@ out:
   return result;
 }
 
-void labcomm_decoder_run(struct labcomm_decoder *d)
+void labcomm2014_decoder_run(struct labcomm2014_decoder *d)
 {
-  while (labcomm_decoder_decode_one(d) > 0) {
+  while (labcomm2014_decoder_decode_one(d) > 0) {
   }
 }
 
-int labcomm_decoder_ioctl(struct labcomm_decoder *d, 
+int labcomm2014_decoder_ioctl(struct labcomm2014_decoder *d, 
 			  uint32_t action,
 			  ...)
 {
@@ -432,26 +432,26 @@ int labcomm_decoder_ioctl(struct labcomm_decoder *d,
   va_list va;
     
   va_start(va, action);
-  result = labcomm_reader_ioctl(d->reader, 
+  result = labcomm2014_reader_ioctl(d->reader, 
 				d->reader->action_context,
 				0, 0, NULL, action, va);
   va_end(va);
   return result;
 }
 
-int labcomm_decoder_sample_ref_register(
-  struct labcomm_decoder *d,
-  const struct labcomm_signature *signature)
+int labcomm2014_decoder_sample_ref_register(
+  struct labcomm2014_decoder *d,
+  const struct labcomm2014_signature *signature)
 {
   int local_index, *remote_to_local_ref;
-  const struct labcomm_signature **s;
+  const struct labcomm2014_signature **s;
 
-  local_index = labcomm_get_local_index(signature);
+  local_index = labcomm2014_get_local_index(signature);
   if (local_index <= 0) { goto out; }
-  labcomm_scheduler_data_lock(d->scheduler);
+  labcomm2014_scheduler_data_lock(d->scheduler);
   s = LABCOMM_SIGNATURE_ARRAY_REF(d->memory, 
                                   d->local_ref, 
-                                  const struct labcomm_signature*, local_index);
+                                  const struct labcomm2014_signature*, local_index);
   if (s == NULL) { local_index = -ENOMEM; goto unlock; };
   if (*s) { goto unlock; }
   *s = signature;	
@@ -460,26 +460,26 @@ int labcomm_decoder_sample_ref_register(
                                                     int, local_index);
   *remote_to_local_ref = 0;
 unlock:
-  labcomm_scheduler_data_unlock(d->scheduler);
+  labcomm2014_scheduler_data_unlock(d->scheduler);
 out:
   return local_index;
 }
 
-int labcomm_internal_decoder_ioctl(struct labcomm_decoder *d, 
-				   const struct labcomm_signature *signature,
+int labcomm2014_internal_decoder_ioctl(struct labcomm2014_decoder *d, 
+				   const struct labcomm2014_signature *signature,
 				   uint32_t action, va_list va)
 {
   int result;
   int local_index, remote_index;
 
-  local_index = labcomm_get_local_index(signature);
-  labcomm_scheduler_data_lock(d->scheduler);
+  local_index = labcomm2014_get_local_index(signature);
+  labcomm2014_scheduler_data_lock(d->scheduler);
   remote_index = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
 					     d->local,
 					     struct sample_entry,
 					     local_index)->remote_index;
-  labcomm_scheduler_data_unlock(d->scheduler);
-  result = labcomm_reader_ioctl(d->reader, d->reader->action_context,
+  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;
@@ -490,41 +490,41 @@ int labcomm_internal_decoder_ioctl(struct labcomm_decoder *d,
 //// (should perhaps be moved to another file)
 
 static void decode_raw_type_def(
-  struct labcomm_reader *r,
+  struct labcomm2014_reader *r,
   void (*handle)(
-    struct labcomm_raw_type_def *v,
+    struct labcomm2014_raw_type_def *v,
     void *context
   ),
   void *context
 )
 {
-  struct labcomm_raw_type_def v;
-  v.index = labcomm_read_packed32(r);
+  struct labcomm2014_raw_type_def v;
+  v.index = labcomm2014_read_packed32(r);
   if (r->error < 0) { goto out; }
-  v.name  = labcomm_read_string(r);
+  v.name  = labcomm2014_read_string(r);
   if (r->error < 0) { goto free_name; }
-  v.length = labcomm_read_packed32(r);
+  v.length = labcomm2014_read_packed32(r);
   if (r->error < 0) { goto free_name; }
   int i;
-  v.signature_data = labcomm_memory_alloc(r->memory, 1, v.length);
+  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] = labcomm_read_byte(r);
+      v.signature_data[i] = labcomm2014_read_byte(r);
       if (r->error < 0) { goto free_sig; }
     }  
     handle(&v, context);
     }
 free_sig:
-  labcomm_memory_free(r->memory, 1, v.signature_data);
+  labcomm2014_memory_free(r->memory, 1, v.signature_data);
 free_name:
-  labcomm_memory_free(r->memory, 1, v.name);
+  labcomm2014_memory_free(r->memory, 1, v.name);
 out:
   return;
 }
-int labcomm_decoder_register_labcomm_type_def(
-  struct labcomm_decoder *d,
+int labcomm2014_decoder_register_labcomm2014_type_def(
+  struct labcomm2014_decoder *d,
   void (*handler)(
-    struct labcomm_raw_type_def *v,
+    struct labcomm2014_raw_type_def *v,
     void *context
   ),
   void *context
@@ -534,15 +534,15 @@ int labcomm_decoder_register_labcomm_type_def(
   struct sample_entry *entry;
   int *remote_to_local;
  
-  labcomm_scheduler_data_lock(d->scheduler);
+  labcomm2014_scheduler_data_lock(d->scheduler);
   entry = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
 				      d->local, struct sample_entry,
 				      tag);
   if (entry == NULL) { tag = -ENOMEM; goto unlock; }
   entry->remote_index = tag;
   entry->signature = NULL;
-  entry->decode = (labcomm_decoder_function) decode_raw_type_def;
-  entry->handler =(labcomm_handler_function) handler;
+  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,
@@ -550,35 +550,35 @@ int labcomm_decoder_register_labcomm_type_def(
                                                     tag);
   *remote_to_local = tag;
 unlock:
-  labcomm_scheduler_data_unlock(d->scheduler);
+  labcomm2014_scheduler_data_unlock(d->scheduler);
 
   return tag;
 }
 
 
 static void decode_type_binding(
-  struct labcomm_reader *r,
+  struct labcomm2014_reader *r,
   void (*handle)(
-    struct labcomm_type_binding *v,
+    struct labcomm2014_type_binding *v,
     void *context
   ),
   void *context
 )
 {
-  struct labcomm_type_binding v;
-  v.sample_index = labcomm_read_packed32(r);
+  struct labcomm2014_type_binding v;
+  v.sample_index = labcomm2014_read_packed32(r);
   if (r->error < 0) { goto out; }
-  v.type_index = labcomm_read_packed32(r);
+  v.type_index = labcomm2014_read_packed32(r);
   if (r->error < 0) { goto out; }
   handle(&v, context);
 out:
   return;
 }
 
-int labcomm_decoder_register_labcomm_type_binding(
-  struct labcomm_decoder *d,
+int labcomm2014_decoder_register_labcomm2014_type_binding(
+  struct labcomm2014_decoder *d,
   void (*handler)(
-    struct labcomm_type_binding *v,
+    struct labcomm2014_type_binding *v,
     void *context
   ),
   void *context
@@ -588,15 +588,15 @@ int labcomm_decoder_register_labcomm_type_binding(
   struct sample_entry *entry;
   int *remote_to_local;
  
-  labcomm_scheduler_data_lock(d->scheduler);
+  labcomm2014_scheduler_data_lock(d->scheduler);
   entry = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
 				      d->local, struct sample_entry,
 				      tag);
   if (entry == NULL) { tag = -ENOMEM; goto unlock; }
   entry->remote_index = tag;
   entry->signature = NULL;
-  entry->decode = (labcomm_decoder_function) decode_type_binding;
-  entry->handler =(labcomm_handler_function) handler;
+  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,
@@ -604,7 +604,7 @@ int labcomm_decoder_register_labcomm_type_binding(
                                                     tag);
   *remote_to_local = tag;
 unlock:
-  labcomm_scheduler_data_unlock(d->scheduler);
+  labcomm2014_scheduler_data_unlock(d->scheduler);
 
   return tag;
 }
@@ -612,25 +612,25 @@ unlock:
 //// End type_def handling
 #endif
 
-int labcomm_internal_decoder_register(
-  struct labcomm_decoder *d,
-  const struct labcomm_signature *signature,
-  labcomm_decoder_function decode, 
-  labcomm_handler_function handler,
+int labcomm2014_internal_decoder_register(
+  struct labcomm2014_decoder *d,
+  const struct labcomm2014_signature *signature,
+  labcomm2014_decoder_function decode, 
+  labcomm2014_handler_function handler,
   void *context)
 {
   int local_index;
   struct sample_entry *entry;
  
   reader_alloc(d);
-  local_index = labcomm_get_local_index(signature);
+  local_index = labcomm2014_get_local_index(signature);
   if (local_index <= 0) { goto out; }
-  labcomm_reader_start(d->reader, d->reader->action_context,
+  labcomm2014_reader_start(d->reader, d->reader->action_context,
 		       local_index, 0, signature,
 		       NULL);
-  labcomm_reader_end(d->reader, d->reader->action_context);
+  labcomm2014_reader_end(d->reader, d->reader->action_context);
 
-  labcomm_scheduler_data_lock(d->scheduler);
+  labcomm2014_scheduler_data_lock(d->scheduler);
   entry = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
 				      d->local, struct sample_entry,
 				      local_index);
@@ -641,25 +641,25 @@ int labcomm_internal_decoder_register(
   entry->handler = handler;
   entry->context = context;
 unlock:
-  labcomm_scheduler_data_unlock(d->scheduler);
+  labcomm2014_scheduler_data_unlock(d->scheduler);
 out:
   return local_index;
 }
 
-const struct labcomm_signature *labcomm_internal_decoder_index_to_signature(
-  struct labcomm_decoder *d, int index)
+const struct labcomm2014_signature *labcomm2014_internal_decoder_index_to_signature(
+  struct labcomm2014_decoder *d, int index)
 {
-  const struct labcomm_signature *result = 0;
+  const struct labcomm2014_signature *result = 0;
   int local_index;
 
-  labcomm_scheduler_data_lock(d->scheduler);
+  labcomm2014_scheduler_data_lock(d->scheduler);
   local_index = LABCOMM_SIGNATURE_ARRAY_GET(d->remote_to_local_ref, 
                                             int, index, 0);
   if (local_index) {
     result = LABCOMM_SIGNATURE_ARRAY_GET(d->local_ref, 
-                                         const struct labcomm_signature*, 
+                                         const struct labcomm2014_signature*, 
                                          local_index, 0);
   }
-  labcomm_scheduler_data_unlock(d->scheduler);
+  labcomm2014_scheduler_data_unlock(d->scheduler);
   return result;
 }
diff --git a/lib/c/2014/labcomm_default_error_handler.c b/lib/c/2014/labcomm2014_default_error_handler.c
similarity index 88%
rename from lib/c/2014/labcomm_default_error_handler.c
rename to lib/c/2014/labcomm2014_default_error_handler.c
index 61e04dd..ae9fe30 100644
--- a/lib/c/2014/labcomm_default_error_handler.c
+++ b/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;
diff --git a/lib/c/2014/labcomm_default_error_handler.h b/lib/c/2014/labcomm2014_default_error_handler.h
similarity index 80%
rename from lib/c/2014/labcomm_default_error_handler.h
rename to lib/c/2014/labcomm2014_default_error_handler.h
index 8f479a0..420cb40 100644
--- a/lib/c/2014/labcomm_default_error_handler.h
+++ b/lib/c/2014/labcomm2014_default_error_handler.h
@@ -18,11 +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 __LABCOMM_DEFAULT_ERROR_HANDLER_H__
-#define __LABCOMM_DEFAULT_ERROR_HANDLER_H__
+#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
diff --git a/lib/c/2014/labcomm_default_memory.c b/lib/c/2014/labcomm2014_default_memory.c
similarity index 73%
rename from lib/c/2014/labcomm_default_memory.c
rename to lib/c/2014/labcomm2014_default_memory.c
index d6b13c5..17dee8a 100644
--- a/lib/c/2014/labcomm_default_memory.c
+++ b/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;
diff --git a/lib/c/2014/labcomm_default_memory.h b/lib/c/2014/labcomm2014_default_memory.h
similarity index 82%
rename from lib/c/2014/labcomm_default_memory.h
rename to lib/c/2014/labcomm2014_default_memory.h
index f00b226..57947fb 100644
--- a/lib/c/2014/labcomm_default_memory.h
+++ b/lib/c/2014/labcomm2014_default_memory.h
@@ -18,12 +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 __LABCOMM_DEFAULT_MEMORY_H__
-#define __LABCOMM_DEFAULT_MEMORY_H__
+#ifndef __LABCOMM2014_DEFAULT_MEMORY_H__
+#define __LABCOMM2014_DEFAULT_MEMORY_H__
 
 #include <stdlib.h>
-#include "labcomm.h"
+#include "labcomm2014.h"
 
-extern struct labcomm_memory *labcomm_default_memory;
+extern struct labcomm2014_memory *labcomm2014_default_memory;
 
 #endif
diff --git a/lib/c/2014/labcomm_default_scheduler.c b/lib/c/2014/labcomm2014_default_scheduler.c
similarity index 67%
rename from lib/c/2014/labcomm_default_scheduler.c
rename to lib/c/2014/labcomm2014_default_scheduler.c
index a567b61..f1fd3d6 100644
--- a/lib/c/2014/labcomm_default_scheduler.c
+++ b/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,7 +78,7 @@ static int scheduler_wakeup(struct labcomm_scheduler *s)
   return 0;
 }
 
-static int scheduler_enqueue(struct labcomm_scheduler *s,
+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;
diff --git a/lib/c/2014/labcomm_default_scheduler.h b/lib/c/2014/labcomm2014_default_scheduler.h
similarity index 81%
rename from lib/c/2014/labcomm_default_scheduler.h
rename to lib/c/2014/labcomm2014_default_scheduler.h
index 7ec579b..db416f3 100644
--- a/lib/c/2014/labcomm_default_scheduler.h
+++ b/lib/c/2014/labcomm2014_default_scheduler.h
@@ -18,11 +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 __LABCOMM_DEFAULT_SCHEDULER_H__
-#define __LABCOMM_DEFAULT_SCHEDULER_H__
+#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
diff --git a/lib/c/2014/labcomm_dynamic_buffer_writer.c b/lib/c/2014/labcomm2014_dynamic_buffer_writer.c
similarity index 57%
rename from lib/c/2014/labcomm_dynamic_buffer_writer.c
rename to lib/c/2014/labcomm2014_dynamic_buffer_writer.c
index 32501e1..c209862 100644
--- a/lib/c/2014/labcomm_dynamic_buffer_writer.c
+++ b/lib/c/2014/labcomm2014_dynamic_buffer_writer.c
@@ -1,5 +1,5 @@
 /*
-  labcomm_dynamic_buffer_writer.c -- LabComm dynamic memory writer.
+  labcomm2014_dynamic_buffer_writer.c -- LabComm dynamic memory writer.
 
   Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
 
@@ -22,17 +22,17 @@
 #include <errno.h>
 #include <stdlib.h>
 #include <stdarg.h>
-#include "labcomm.h"
-#include "labcomm_private.h"
-#include "labcomm_ioctl.h"
-#include "labcomm_dynamic_buffer_writer.h"
+#include "labcomm2014.h"
+#include "labcomm2014_private.h"
+#include "labcomm2014_ioctl.h"
+#include "labcomm2014_dynamic_buffer_writer.h"
 
-static int dyn_alloc(struct labcomm_writer *w, 
-		     struct labcomm_writer_action_context *action_context)
+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 = labcomm_memory_alloc(w->memory, 1, w->data_size);
+  w->data = labcomm2014_memory_alloc(w->memory, 1, w->data_size);
   if (w->data == NULL) {
     w->error = -ENOMEM;
   }
@@ -41,29 +41,29 @@ static int dyn_alloc(struct labcomm_writer *w,
   return w->error;
 }
 
-static int dyn_free(struct labcomm_writer *w, 
-		    struct labcomm_writer_action_context *action_context)
+static int dyn_free(struct labcomm2014_writer *w, 
+		    struct labcomm2014_writer_action_context *action_context)
 {
-  labcomm_memory_free(w->memory, 1, w->data);
+  labcomm2014_memory_free(w->memory, 1, w->data);
   w->data = 0;
   w->data_size = 0;
   w->count = 0;
   w->pos = 0;
-  labcomm_memory_free(w->memory, 0, action_context->context);
+  labcomm2014_memory_free(w->memory, 0, action_context->context);
   return 0;
 }
 
-static int dyn_start(struct labcomm_writer *w, 
-		     struct labcomm_writer_action_context *action_context,
+static int dyn_start(struct labcomm2014_writer *w, 
+		     struct labcomm2014_writer_action_context *action_context,
 		     int index,
-		     const struct labcomm_signature *signature,
+		     const struct labcomm2014_signature *signature,
 		     void *value)
 {
   void *tmp;
 
   w->data_size = 1000;
   w->count = w->data_size;
-  tmp = labcomm_memory_realloc(w->memory, 1, w->data, w->data_size);
+  tmp = labcomm2014_memory_realloc(w->memory, 1, w->data, w->data_size);
   if (tmp != NULL) {
     w->data = tmp;
     w->error = 0;
@@ -75,20 +75,20 @@ static int dyn_start(struct labcomm_writer *w,
   return w->error;
 }
 
-static int dyn_end(struct labcomm_writer *w, 
-		   struct labcomm_writer_action_context *action_context)
+static int dyn_end(struct labcomm2014_writer *w, 
+		   struct labcomm2014_writer_action_context *action_context)
 {
   return 0;
 }
 
-static int dyn_flush(struct labcomm_writer *w, 
-		     struct labcomm_writer_action_context *action_context)
+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 = labcomm_memory_realloc(w->memory, 1, w->data, w->data_size);
+  tmp = labcomm2014_memory_realloc(w->memory, 1, w->data, w->data_size);
   if (tmp != NULL) {
     w->data = tmp;
     w->error = 0;
@@ -100,10 +100,10 @@ static int dyn_flush(struct labcomm_writer *w,
   return w->error; 
 }
 
-static int dyn_ioctl(struct labcomm_writer *w, 
-		     struct labcomm_writer_action_context *action_context, 
+static int dyn_ioctl(struct labcomm2014_writer *w, 
+		     struct labcomm2014_writer_action_context *action_context, 
 		     int signature_index,
-		     const struct labcomm_signature *signature,
+		     const struct labcomm2014_signature *signature,
 		     uint32_t action, va_list arg)
 {
   int result = -ENOTSUP;
@@ -122,7 +122,7 @@ static int dyn_ioctl(struct labcomm_writer *w,
   return result;
 }
 
-static const struct labcomm_writer_action action = {
+static const struct labcomm2014_writer_action action = {
   .alloc = dyn_alloc,
   .free = dyn_free,
   .start = dyn_start,
@@ -130,18 +130,18 @@ static const struct labcomm_writer_action action = {
   .flush = dyn_flush,
   .ioctl = dyn_ioctl
 };
-const struct labcomm_writer_action *labcomm_dynamic_buffer_writer_action = 
+const struct labcomm2014_writer_action *labcomm2014_dynamic_buffer_writer_action = 
   &action;
 
-struct labcomm_writer *labcomm_dynamic_buffer_writer_new(
-  struct labcomm_memory *memory)
+struct labcomm2014_writer *labcomm2014_dynamic_buffer_writer_new(
+  struct labcomm2014_memory *memory)
 {
   struct result {
-    struct labcomm_writer writer;
-    struct labcomm_writer_action_context action_context;
+    struct labcomm2014_writer writer;
+    struct labcomm2014_writer_action_context action_context;
   } *result;
 
-  result = labcomm_memory_alloc(memory, 0, sizeof(*result));
+  result = labcomm2014_memory_alloc(memory, 0, sizeof(*result));
   if (result != NULL) {
     result->action_context.next = NULL;
     result->action_context.context = result;
diff --git a/lib/c/2014/labcomm_dynamic_buffer_writer.h b/lib/c/2014/labcomm2014_dynamic_buffer_writer.h
similarity index 65%
rename from lib/c/2014/labcomm_dynamic_buffer_writer.h
rename to lib/c/2014/labcomm2014_dynamic_buffer_writer.h
index 9fea8ed..ce19d73 100644
--- a/lib/c/2014/labcomm_dynamic_buffer_writer.h
+++ b/lib/c/2014/labcomm2014_dynamic_buffer_writer.h
@@ -1,5 +1,5 @@
 /*
-  labcomm_dynamic_buffer_writer.h -- LabComm dynamic memory writer.
+  labcomm2014_dynamic_buffer_writer.h -- LabComm dynamic memory writer.
 
   Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
 
@@ -19,14 +19,14 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef __LABCOMM_DYNAMIC_BUFFER_READER_WRITER_H__
-#define __LABCOMM_DYNAMIC_BUFFER_READER_WRITER_H__
+#ifndef __LABCOMM2014_DYNAMIC_BUFFER_READER_WRITER_H__
+#define __LABCOMM2014_DYNAMIC_BUFFER_READER_WRITER_H__
 
-#include "labcomm.h"
+#include "labcomm2014.h"
 
-extern const struct labcomm_writer_action *labcomm_dynamic_buffer_writer_action;
+extern const struct labcomm2014_writer_action *labcomm2014_dynamic_buffer_writer_action;
 
-struct labcomm_writer *labcomm_dynamic_buffer_writer_new(
-  struct labcomm_memory *memory);
+struct labcomm2014_writer *labcomm2014_dynamic_buffer_writer_new(
+  struct labcomm2014_memory *memory);
 
 #endif
diff --git a/lib/c/2014/labcomm2014_encoder.c b/lib/c/2014/labcomm2014_encoder.c
new file mode 100644
index 0000000..864ff3f
--- /dev/null
+++ b/lib/c/2014/labcomm2014_encoder.c
@@ -0,0 +1,398 @@
+/*
+  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
+
+struct labcomm2014_encoder {
+  struct labcomm2014_writer *writer;
+  struct labcomm2014_error_handler *error;
+  struct labcomm2014_memory *memory;
+  struct labcomm2014_scheduler *scheduler;
+  LABCOMM_SIGNATURE_ARRAY_DEF(registered, int);
+  LABCOMM_SIGNATURE_ARRAY_DEF(sample_ref, int);
+  LABCOMM_SIGNATURE_ARRAY_DEF(typedefs, int);
+};
+
+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 labcomm2014_encoder *result;
+
+  result = labcomm2014_memory_alloc(memory, 0, sizeof(*result));
+  if (result) {
+    int length;
+
+    result->writer = writer;
+    result->writer->encoder = result;
+    result->writer->data = NULL;
+    result->writer->data_size = 0;
+    result->writer->count = 0;
+    result->writer->pos = 0;
+    result->writer->error = 0;
+    result->error = error;
+    result->memory = memory;
+    result->scheduler = scheduler;
+    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->writer,
+			 result->writer->action_context);
+    if(outputVer) {
+        labcomm2014_writer_start(result->writer,
+                            result->writer->action_context,
+                            LABCOMM_VERSION, NULL, CURRENT_VERSION);
+        labcomm2014_write_packed32(result->writer, LABCOMM_VERSION);
+        length = labcomm2014_size_string(CURRENT_VERSION);
+        labcomm2014_write_packed32(result->writer, length);
+        labcomm2014_write_string(result->writer, CURRENT_VERSION);
+        labcomm2014_writer_end(result->writer, result->writer->action_context);
+    }
+  }
+  return result;
+}
+
+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,TRUE);
+}
+void labcomm2014_encoder_free(struct labcomm2014_encoder* e)
+{
+  struct labcomm2014_memory *memory = e->memory;
+
+  labcomm2014_writer_free(e->writer, e->writer->action_context);
+  LABCOMM_SIGNATURE_ARRAY_FREE(e->memory, e->registered, int);
+  LABCOMM_SIGNATURE_ARRAY_FREE(e->memory, e->sample_ref, int);
+  LABCOMM_SIGNATURE_ARRAY_FREE(e->memory, e->typedefs, int);
+  labcomm2014_memory_free(memory, 0, e);
+}
+
+int labcomm2014_internal_encoder_register(
+  struct labcomm2014_encoder *e,
+  const struct labcomm2014_signature *signature,
+  labcomm2014_encoder_function encode)
+{
+  int result = -EINVAL;
+  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, e->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) +
+            labcomm2014_size_string(signature->name) +
+            labcomm2014_size_packed32(signature->size) +
+            signature->size);
+  labcomm2014_write_packed32(e->writer, length);
+  labcomm2014_write_packed32(e->writer, index);
+  labcomm2014_write_string(e->writer, signature->name);
+  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_internal_encode(
+  struct labcomm2014_encoder *e,
+  const struct labcomm2014_signature *signature,
+  labcomm2014_encoder_function encode,
+  void *value)
+{
+  int result, index, length;
+
+  index = labcomm2014_get_local_index(signature);
+  length = (signature->encoded_size(value));
+  labcomm2014_scheduler_writer_lock(e->scheduler);
+  if (! LABCOMM_SIGNATURE_ARRAY_GET(e->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)
+{
+  int result = -EINVAL;
+  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, e->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) +
+            labcomm2014_size_string(signature->name) +
+            labcomm2014_size_packed32(signature->size) +
+            signature->size);
+  labcomm2014_write_packed32(e->writer, length);
+  labcomm2014_write_packed32(e->writer, index);
+  labcomm2014_write_string(e->writer, signature->name);
+  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 = labcomm2014_writer_ioctl(encoder->writer,
+			       encoder->writer->action_context,
+			       0, NULL, action, va);
+  va_end(va);
+
+out:
+  return result;
+}
+
+int labcomm2014_internal_encoder_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;
+}
+
+int labcomm2014_internal_encoder_signature_to_index(
+  struct labcomm2014_encoder *e, const struct labcomm2014_signature *signature)
+{
+  /* writer_lock should be held at this point */
+  int index = 0;
+  if (signature != NULL) {
+    index = labcomm2014_get_local_index(signature);
+    if (! LABCOMM_SIGNATURE_ARRAY_GET(e->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, 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;
+
+  index = labcomm2014_get_local_index(signature);
+  labcomm2014_scheduler_writer_lock(e->scheduler);
+  if (index <= 0) { goto out; }
+  done = LABCOMM_SIGNATURE_ARRAY_REF(e->memory, e->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; }
+
+  int sig_size = calc_sig_encoded_size(e, signature);
+  int len =  labcomm2014_size_packed32(index) +
+             labcomm2014_size_string(signature->name) +
+             labcomm2014_size_packed32(sig_size) +
+              sig_size;
+
+  labcomm2014_write_packed32(e->writer, LABCOMM_TYPE_DEF);
+  labcomm2014_write_packed32(e->writer, len);
+  labcomm2014_write_packed32(e->writer, index);
+  labcomm2014_write_string(e->writer, signature->name);
+  labcomm2014_write_packed32(e->writer, sig_size);
+  do_write_signature(e, signature, FALSE);
+
+  labcomm2014_writer_end(e->writer, e->writer->action_context);
+  result = e->writer->error;
+out:
+  labcomm2014_scheduler_writer_unlock(e->scheduler);
+  return result;
+}
+#endif
+
+int labcomm2014_internal_encoder_type_register(
+  struct labcomm2014_encoder *e,
+  const struct labcomm2014_signature *signature)
+{
+#ifndef LABCOMM_WITHOUT_TYPE_DEFS
+  return internal_reg_type(e, signature, FALSE);
+#else
+  return 0;
+#endif
+}
+int labcomm2014_internal_encoder_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
+}
diff --git a/lib/c/2014/labcomm_error.c b/lib/c/2014/labcomm2014_error.c
similarity index 86%
rename from lib/c/2014/labcomm_error.c
rename to lib/c/2014/labcomm2014_error.c
index 5bfea6e..9ea193b 100644
--- a/lib/c/2014/labcomm_error.c
+++ b/lib/c/2014/labcomm2014_error.c
@@ -1,5 +1,5 @@
 /*
-  labcomm_error.c -- labcomm error handling
+  labcomm2014_error.c -- labcomm2014 error handling
 
   Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
 
@@ -22,9 +22,9 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdarg.h>
-#include "labcomm_error.h"
+#include "labcomm2014_error.h"
 
-void labcomm_error_fatal_global(enum labcomm_error error,
+void labcomm2014_error_fatal_global(enum labcomm2014_error error,
 				char *format,
 				...)
 {
diff --git a/lib/c/2014/labcomm_error.h b/lib/c/2014/labcomm2014_error.h
similarity index 81%
rename from lib/c/2014/labcomm_error.h
rename to lib/c/2014/labcomm2014_error.h
index 5ad344b..0b06ec2 100644
--- a/lib/c/2014/labcomm_error.h
+++ b/lib/c/2014/labcomm2014_error.h
@@ -1,5 +1,5 @@
 /*
-  labcomm_error.h -- labcomm error declarations
+  labcomm2014_error.h -- labcomm2014 error declarations
 
   Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
 
@@ -19,23 +19,23 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef __LABCOMM_ERROR_H___
-#define __LABCOMM_ERROR_H___
+#ifndef __LABCOMM2014_ERROR_H___
+#define __LABCOMM2014_ERROR_H___
 
-enum labcomm_error {
+enum labcomm2014_error {
 #define LABCOMM_ERROR(name, description) name ,
-#include "labcomm_error.h"
+#include "labcomm2014_error.h"
 #undef LABCOMM_ERROR
 };
 
-struct labcomm_error_handler;
+struct labcomm2014_error_handler;
 
-void labcomm_error_warning(struct labcomm_error_handler *e,
-			   enum labcomm_error,
+void labcomm2014_error_warning(struct labcomm2014_error_handler *e,
+			   enum labcomm2014_error,
 			   char *format,
 			   ...);
 			 
-void labcomm_error_fatal_global(enum labcomm_error error,
+void labcomm2014_error_fatal_global(enum labcomm2014_error error,
 				char *format,
 				...);
 			 
@@ -51,7 +51,7 @@ LABCOMM_ERROR(LABCOMM_ERROR_SIGNATURE_NOT_SET,
 LABCOMM_ERROR(LABCOMM_ERROR_ENC_NO_REG_SIGNATURE, 
 	      "Encoder has no registration for this signature")
 LABCOMM_ERROR(LABCOMM_ERROR_ENC_BUF_FULL,
-	      "The labcomm buffer is full")
+	      "The labcomm2014 buffer is full")
 LABCOMM_ERROR(LABCOMM_ERROR_DEC_UNKNOWN_DATATYPE,
 	      "Decoder: Unknown datatype")
 LABCOMM_ERROR(LABCOMM_ERROR_DEC_INDEX_MISMATCH, 
diff --git a/lib/c/2014/labcomm_fd_reader.c b/lib/c/2014/labcomm2014_fd_reader.c
similarity index 64%
rename from lib/c/2014/labcomm_fd_reader.c
rename to lib/c/2014/labcomm2014_fd_reader.c
index eaa59f9..ad2d222 100644
--- a/lib/c/2014/labcomm_fd_reader.c
+++ b/lib/c/2014/labcomm2014_fd_reader.c
@@ -1,5 +1,5 @@
 /*
-  labcomm_fd_reader.c -- LabComm reader for Unix file descriptors.
+  labcomm2014_fd_reader.c -- LabComm reader for Unix file descriptors.
 
   Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
 
@@ -23,26 +23,26 @@
 #include <unistd.h>
 #include <stdlib.h>
 #include <string.h>
-#include "labcomm_private.h"
-#include "labcomm_fd_reader.h"
+#include "labcomm2014_private.h"
+#include "labcomm2014_fd_reader.h"
 
 #define BUFFER_SIZE 2048
 
-struct labcomm_fd_reader {
-  struct labcomm_reader reader;
-  struct labcomm_reader_action_context action_context;
+struct labcomm2014_fd_reader {
+  struct labcomm2014_reader reader;
+  struct labcomm2014_reader_action_context action_context;
   int fd;
   int close_fd_on_free;
 };
 
-static int fd_alloc(struct labcomm_reader *r,
-		    struct labcomm_reader_action_context *action_context)
+static int fd_alloc(struct labcomm2014_reader *r,
+		    struct labcomm2014_reader_action_context *action_context)
 {
   int result = 0;
   
   r->count = 0;
   r->pos = 0;
-  r->data = labcomm_memory_alloc(r->memory, 0, BUFFER_SIZE);
+  r->data = labcomm2014_memory_alloc(r->memory, 0, BUFFER_SIZE);
   if (! r->data) {
     r->data_size = 0;
     result = -ENOMEM;
@@ -54,13 +54,13 @@ static int fd_alloc(struct labcomm_reader *r,
   return result;
 }
 
-static int fd_free(struct labcomm_reader *r, 
-		   struct labcomm_reader_action_context *action_context)
+static int fd_free(struct labcomm2014_reader *r, 
+		   struct labcomm2014_reader_action_context *action_context)
 {
-  struct labcomm_fd_reader *fd_reader = action_context->context;
-  struct labcomm_memory *memory = r->memory;
+  struct labcomm2014_fd_reader *fd_reader = action_context->context;
+  struct labcomm2014_memory *memory = r->memory;
 
-  labcomm_memory_free(memory, 0, r->data);
+  labcomm2014_memory_free(memory, 0, r->data);
   r->data = 0;
   r->data_size = 0;
   r->count = 0;
@@ -69,16 +69,16 @@ static int fd_free(struct labcomm_reader *r,
   if (fd_reader->close_fd_on_free) {
     close(fd_reader->fd);
   }
-  labcomm_memory_free(memory, 0, fd_reader);
+  labcomm2014_memory_free(memory, 0, fd_reader);
 
   return 0;
 }
 
-static int fd_fill(struct labcomm_reader *r, 
-		   struct labcomm_reader_action_context *action_context)
+static int fd_fill(struct labcomm2014_reader *r, 
+		   struct labcomm2014_reader_action_context *action_context)
 {
   int result = 0;
-  struct labcomm_fd_reader *fd_reader = action_context->context;
+  struct labcomm2014_fd_reader *fd_reader = action_context->context;
 
   if (r->pos < r->count) {
     result = r->count - r->pos;
@@ -99,7 +99,7 @@ static int fd_fill(struct labcomm_reader *r,
   return result;
 }
 
-static const struct labcomm_reader_action action = {
+static const struct labcomm2014_reader_action action = {
   .alloc = fd_alloc,
   .free = fd_free,
   .start = NULL,
@@ -108,12 +108,12 @@ static const struct labcomm_reader_action action = {
   .ioctl = NULL
 };
 
-struct labcomm_reader *labcomm_fd_reader_new(struct labcomm_memory *memory,
+struct labcomm2014_reader *labcomm2014_fd_reader_new(struct labcomm2014_memory *memory,
 					     int fd, int close_fd_on_free)
 {
-  struct labcomm_fd_reader *result;
+  struct labcomm2014_fd_reader *result;
 
-  result = labcomm_memory_alloc(memory, 0, sizeof(*result));
+  result = labcomm2014_memory_alloc(memory, 0, sizeof(*result));
   if (result == NULL) {
     return NULL;
   } else {
diff --git a/lib/c/2014/labcomm_fd_reader.h b/lib/c/2014/labcomm2014_fd_reader.h
similarity index 75%
rename from lib/c/2014/labcomm_fd_reader.h
rename to lib/c/2014/labcomm2014_fd_reader.h
index a00fe98..0391c6c 100644
--- a/lib/c/2014/labcomm_fd_reader.h
+++ b/lib/c/2014/labcomm2014_fd_reader.h
@@ -1,5 +1,5 @@
 /*
-  labcomm_fd_reader.c -- a reader for unix style file-descriptors
+  labcomm2014_fd_reader.c -- a reader for unix style file-descriptors
 
   Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
 
@@ -19,12 +19,12 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef __LABCOMM_FD_READER_H__
-#define __LABCOMM_FD_READER_H__
+#ifndef __LABCOMM2014_FD_READER_H__
+#define __LABCOMM2014_FD_READER_H__
 
-#include "labcomm.h"
+#include "labcomm2014.h"
 
-struct labcomm_reader *labcomm_fd_reader_new(struct labcomm_memory *memory,
+struct labcomm2014_reader *labcomm2014_fd_reader_new(struct labcomm2014_memory *memory,
 					     int fd, int close_fd_on_free);
 
 #endif
diff --git a/lib/c/2014/labcomm_fd_writer.c b/lib/c/2014/labcomm2014_fd_writer.c
similarity index 60%
rename from lib/c/2014/labcomm_fd_writer.c
rename to lib/c/2014/labcomm2014_fd_writer.c
index 5833acc..42c9dbc 100644
--- a/lib/c/2014/labcomm_fd_writer.c
+++ b/lib/c/2014/labcomm2014_fd_writer.c
@@ -1,5 +1,5 @@
 /*
-  labcomm_fd_writer.c -- LabComm writer for Unix file descriptors.
+  labcomm2014_fd_writer.c -- LabComm writer for Unix file descriptors.
 
   Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
 
@@ -24,25 +24,25 @@
 #include <string.h>
 #include <stdlib.h>
 #include <stdarg.h>
-#include "labcomm_private.h"
-#include "labcomm_fd_writer.h"
+#include "labcomm2014_private.h"
+#include "labcomm2014_fd_writer.h"
 
 #define BUFFER_SIZE 2048
 
-struct labcomm_fd_writer {
-  struct labcomm_writer writer;
-  struct labcomm_writer_action_context action_context;
+struct labcomm2014_fd_writer {
+  struct labcomm2014_writer writer;
+  struct labcomm2014_writer_action_context action_context;
   int fd;
   int close_fd_on_free;
 };
 
-static int fd_flush(struct labcomm_writer *w, 
-		    struct labcomm_writer_action_context *action_context);
+static int fd_flush(struct labcomm2014_writer *w, 
+		    struct labcomm2014_writer_action_context *action_context);
 
-static int fd_alloc(struct labcomm_writer *w, 
-		    struct labcomm_writer_action_context *action_context)
+static int fd_alloc(struct labcomm2014_writer *w, 
+		    struct labcomm2014_writer_action_context *action_context)
 {
-  w->data = labcomm_memory_alloc(w->memory, 0, BUFFER_SIZE);
+  w->data = labcomm2014_memory_alloc(w->memory, 0, BUFFER_SIZE);
   if (! w->data) {
     w->error = -ENOMEM;
     w->data_size = 0;
@@ -57,13 +57,13 @@ static int fd_alloc(struct labcomm_writer *w,
   return w->error;
 }
 
-static int fd_free(struct labcomm_writer *w, 
-		   struct labcomm_writer_action_context *action_context)
+static int fd_free(struct labcomm2014_writer *w, 
+		   struct labcomm2014_writer_action_context *action_context)
 {
-  struct labcomm_fd_writer *fd_writer = action_context->context;
-  struct labcomm_memory *memory = w->memory;
+  struct labcomm2014_fd_writer *fd_writer = action_context->context;
+  struct labcomm2014_memory *memory = w->memory;
 
-  labcomm_memory_free(memory, 0, w->data);
+  labcomm2014_memory_free(memory, 0, w->data);
   w->data = 0;
   w->data_size = 0;
   w->count = 0;
@@ -72,14 +72,14 @@ static int fd_free(struct labcomm_writer *w,
   if (fd_writer->close_fd_on_free) {
     close(fd_writer->fd);
   }
-  labcomm_memory_free(memory, 0, fd_writer);
+  labcomm2014_memory_free(memory, 0, fd_writer);
   return 0;
 }
 
-static int fd_start(struct labcomm_writer *w, 
-		    struct labcomm_writer_action_context *action_context,
+static int fd_start(struct labcomm2014_writer *w, 
+		    struct labcomm2014_writer_action_context *action_context,
 		    int index,
-		    const struct labcomm_signature *signature,
+		    const struct labcomm2014_signature *signature,
 		    void *value)
 {
   w->pos = 0;
@@ -87,10 +87,10 @@ static int fd_start(struct labcomm_writer *w,
   return w->error;
 }
 
-static int fd_flush(struct labcomm_writer *w, 
-		    struct labcomm_writer_action_context *action_context)
+static int fd_flush(struct labcomm2014_writer *w, 
+		    struct labcomm2014_writer_action_context *action_context)
 {
-  struct labcomm_fd_writer *fd_context = action_context->context;
+  struct labcomm2014_fd_writer *fd_context = action_context->context;
   int start, err;
   
   start = 0;
@@ -112,7 +112,7 @@ static int fd_flush(struct labcomm_writer *w,
   return w->error;
 }
 
-static const struct labcomm_writer_action action = {
+static const struct labcomm2014_writer_action action = {
   .alloc = fd_alloc,
   .free = fd_free,
   .start = fd_start,
@@ -121,12 +121,12 @@ static const struct labcomm_writer_action action = {
   .ioctl = NULL
 };
 
-struct labcomm_writer *labcomm_fd_writer_new(struct labcomm_memory *memory,
+struct labcomm2014_writer *labcomm2014_fd_writer_new(struct labcomm2014_memory *memory,
 					     int fd, int close_fd_on_free)
 {
-  struct labcomm_fd_writer *result;
+  struct labcomm2014_fd_writer *result;
 
-  result = labcomm_memory_alloc(memory, 0, sizeof(*result));
+  result = labcomm2014_memory_alloc(memory, 0, sizeof(*result));
   if (result == NULL) {
     return NULL;
   } else {
diff --git a/lib/c/2014/labcomm_fd_writer.h b/lib/c/2014/labcomm2014_fd_writer.h
similarity index 75%
rename from lib/c/2014/labcomm_fd_writer.h
rename to lib/c/2014/labcomm2014_fd_writer.h
index 3fbf42a..92145a5 100644
--- a/lib/c/2014/labcomm_fd_writer.h
+++ b/lib/c/2014/labcomm2014_fd_writer.h
@@ -1,5 +1,5 @@
 /*
-  labcomm_fd_writer.c -- a writer for unix style file-descriptors
+  labcomm2014_fd_writer.c -- a writer for unix style file-descriptors
 
   Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
 
@@ -19,12 +19,12 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef __LABCOMM_FD_WRITER_H__
-#define __LABCOMM_FD_WRITER_H__
+#ifndef __LABCOMM2014_FD_WRITER_H__
+#define __LABCOMM2014_FD_WRITER_H__
 
-#include "labcomm.h"
+#include "labcomm2014.h"
 
-struct labcomm_writer *labcomm_fd_writer_new(struct labcomm_memory *memory,
+struct labcomm2014_writer *labcomm2014_fd_writer_new(struct labcomm2014_memory *memory,
 					     int fd, int close_on_free);
 
 #endif
diff --git a/lib/c/2014/labcomm_ioctl.h b/lib/c/2014/labcomm2014_ioctl.h
similarity index 95%
rename from lib/c/2014/labcomm_ioctl.h
rename to lib/c/2014/labcomm2014_ioctl.h
index a00a6a8..bb321ed 100644
--- a/lib/c/2014/labcomm_ioctl.h
+++ b/lib/c/2014/labcomm2014_ioctl.h
@@ -1,5 +1,5 @@
 /*
-  labcomm_ioctl.h -- labcomm ioctl declarations
+  labcomm2014_ioctl.h -- labcomm2014 ioctl declarations
 
   Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
 
@@ -19,10 +19,10 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef __LABCOMM_IOCTL_H___
-#define __LABCOMM_IOCTL_H___
+#ifndef __LABCOMM2014_IOCTL_H___
+#define __LABCOMM2014_IOCTL_H___
 
-#include "labcomm.h"
+#include "labcomm2014.h"
 
 /*
  * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
@@ -35,7 +35,7 @@
  *  | +----------------------------------------------- direction (2)
  *  +------------------------------------------------- signature (1)
  *  
- * type 0-31     are reserved for labcomm library use
+ * type 0-31     are reserved for labcomm2014 library use
  */
 
 
diff --git a/lib/c/2014/labcomm_memory.c b/lib/c/2014/labcomm2014_memory.c
similarity index 74%
rename from lib/c/2014/labcomm_memory.c
rename to lib/c/2014/labcomm2014_memory.c
index 62bc9ac..757640a 100644
--- a/lib/c/2014/labcomm_memory.c
+++ b/lib/c/2014/labcomm2014_memory.c
@@ -1,5 +1,5 @@
 /*
-  labcomm_memory.c -- dynamic memory handlig dispatcher
+  labcomm2014_memory.c -- dynamic memory handlig dispatcher
 
   Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
 
@@ -19,21 +19,21 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include "labcomm_private.h"
+#include "labcomm2014_private.h"
 
-void *labcomm_memory_alloc(struct labcomm_memory *m, int lifetime, 
+void *labcomm2014_memory_alloc(struct labcomm2014_memory *m, int lifetime, 
 			   size_t size) 
 {
   return m->alloc(m, lifetime, size);
 }
 
-void *labcomm_memory_realloc(struct labcomm_memory *m, int lifetime, 
+void *labcomm2014_memory_realloc(struct labcomm2014_memory *m, int lifetime, 
 			     void *ptr, size_t size) 
 {
   return m->realloc(m, lifetime, ptr, size);
 }
 
-void labcomm_memory_free(struct labcomm_memory *m, int lifetime, 
+void labcomm2014_memory_free(struct labcomm2014_memory *m, int lifetime, 
 			 void *ptr)
 {
   m->free(m, lifetime, ptr);
diff --git a/lib/c/2014/labcomm_private.h b/lib/c/2014/labcomm2014_private.h
similarity index 52%
rename from lib/c/2014/labcomm_private.h
rename to lib/c/2014/labcomm2014_private.h
index 6422a90..42615c1 100644
--- a/lib/c/2014/labcomm_private.h
+++ b/lib/c/2014/labcomm2014_private.h
@@ -1,6 +1,6 @@
 /*
-  labcomm_private.h -- semi private declarations for handling encoding and 
-                       decoding of labcomm samples.
+  labcomm2014_private.h -- semi private declarations for handling encoding and 
+                       decoding of labcomm2014 samples.
 
   Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
 
@@ -20,8 +20,8 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef __LABCOMM_PRIVATE_H__
-#define __LABCOMM_PRIVATE_H__
+#ifndef __LABCOMM2014_PRIVATE_H__
+#define __LABCOMM2014_PRIVATE_H__
 
 #ifdef LABCOMM_COMPAT
   #include LABCOMM_COMPAT
@@ -34,7 +34,7 @@
 
 //#include <stdlib.h>
 #include <string.h>
-#include "labcomm.h"
+#include "labcomm2014.h"
 
 /*
  * Allowed packet tags
@@ -74,7 +74,7 @@
 
 /*
  * Macro to automagically call constructors in modules compiled 
- * with the labcomm compiler. If __attribute__((constructor)) is
+ * with the labcomm2014 compiler. If __attribute__((constructor)) is
  * not supported, these calls has to be done first in main program.
  */
 #ifndef LABCOMM_CONSTRUCTOR
@@ -85,36 +85,36 @@
  * Semi private dynamic memory declarations
  */
 
-struct labcomm_memory {
-  void *(*alloc)(struct labcomm_memory *m, int lifetime, size_t size);
-  void *(*realloc)(struct labcomm_memory *m, int lifetime, 
+struct labcomm2014_memory {
+  void *(*alloc)(struct labcomm2014_memory *m, int lifetime, size_t size);
+  void *(*realloc)(struct labcomm2014_memory *m, int lifetime, 
 		   void *ptr, size_t size);
-  void (*free)(struct labcomm_memory *m, int lifetime, void *ptr);
+  void (*free)(struct labcomm2014_memory *m, int lifetime, void *ptr);
   void *context;
 };
 
 /*
  * Semi private decoder declarations
  */
-typedef void (*labcomm_handler_function)(void *value, void *context);
+typedef void (*labcomm2014_handler_function)(void *value, void *context);
 
-typedef void (*labcomm_decoder_function)(
-  struct labcomm_reader *r,
-  labcomm_handler_function handler,
+typedef void (*labcomm2014_decoder_function)(
+  struct labcomm2014_reader *r,
+  labcomm2014_handler_function handler,
   void *context);
 
-struct labcomm_reader_action_context;
+struct labcomm2014_reader_action_context;
 
-struct labcomm_reader_action {
-  /* 'alloc' is called at the first invocation of 'labcomm_decoder_decode_one' 
+struct labcomm2014_reader_action {
+  /* 'alloc' is called at the first invocation of 'labcomm2014_decoder_decode_one' 
      on the decoder containing the reader.
 
      Returned value:
        >  0    Number of bytes allocated for buffering
        <= 0    Error
   */
-  int (*alloc)(struct labcomm_reader *r, 
-	       struct labcomm_reader_action_context *action_context);
+  int (*alloc)(struct labcomm2014_reader *r, 
+	       struct labcomm2014_reader_action_context *action_context);
   /* 'free' returns the resources claimed by 'alloc' and might have other
      reader specific side-effects as well.
 
@@ -122,8 +122,8 @@ struct labcomm_reader_action {
        == 0    Success
        != 0    Error
   */
-  int (*free)(struct labcomm_reader *r, 
-	      struct labcomm_reader_action_context *action_context);
+  int (*free)(struct labcomm2014_reader *r, 
+	      struct labcomm2014_reader_action_context *action_context);
   /* 'start' is called at the following instances:
      1. When a sample is registered 
           (local_index != 0, remote_index == 0, value == NULL)
@@ -132,33 +132,33 @@ struct labcomm_reader_action {
      3. When a sample is received
           (local_index != 0, remote_index != 0, value != NULL)
    */
-  int (*start)(struct labcomm_reader *r, 
-	       struct labcomm_reader_action_context *action_context,
+  int (*start)(struct labcomm2014_reader *r, 
+	       struct labcomm2014_reader_action_context *action_context,
 	       int local_index, int remote_index,
-	       const struct labcomm_signature *signature,
+	       const struct labcomm2014_signature *signature,
 	       void *value);
-  int (*end)(struct labcomm_reader *r, 
-	     struct labcomm_reader_action_context *action_context);
-  int (*fill)(struct labcomm_reader *r, 
-	      struct labcomm_reader_action_context *action_context);
-  int (*ioctl)(struct labcomm_reader *r, 
-	       struct labcomm_reader_action_context *action_context,
+  int (*end)(struct labcomm2014_reader *r, 
+	     struct labcomm2014_reader_action_context *action_context);
+  int (*fill)(struct labcomm2014_reader *r, 
+	      struct labcomm2014_reader_action_context *action_context);
+  int (*ioctl)(struct labcomm2014_reader *r, 
+	       struct labcomm2014_reader_action_context *action_context,
 	       int local_index, int remote_index,
-	       const struct labcomm_signature *signature, 
+	       const struct labcomm2014_signature *signature, 
 	       uint32_t ioctl_action, va_list args);
 };
 
-struct labcomm_reader_action_context {
-  struct labcomm_reader_action_context *next;
-  const struct labcomm_reader_action *action;
+struct labcomm2014_reader_action_context {
+  struct labcomm2014_reader_action_context *next;
+  const struct labcomm2014_reader_action *action;
   void *context;  
 };
 
-struct labcomm_reader {
-  struct labcomm_reader_action_context *action_context;
-  struct labcomm_memory *memory;
-  /* The following fields are initialized by labcomm_decoder_new */
-  struct labcomm_decoder *decoder;
+struct labcomm2014_reader {
+  struct labcomm2014_reader_action_context *action_context;
+  struct labcomm2014_memory *memory;
+  /* The following fields are initialized by labcomm2014_decoder_new */
+  struct labcomm2014_decoder *decoder;
   unsigned char *data;
   int data_size;
   int count;
@@ -166,51 +166,51 @@ struct labcomm_reader {
   int error;
 };
 
-int labcomm_reader_alloc(struct labcomm_reader *r, 
-			 struct labcomm_reader_action_context *action_context);
-int labcomm_reader_free(struct labcomm_reader *r, 
-			struct labcomm_reader_action_context *action_context);
-int labcomm_reader_start(struct labcomm_reader *r, 
-			 struct labcomm_reader_action_context *action_context,
+int labcomm2014_reader_alloc(struct labcomm2014_reader *r, 
+			 struct labcomm2014_reader_action_context *action_context);
+int labcomm2014_reader_free(struct labcomm2014_reader *r, 
+			struct labcomm2014_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,
-			 const struct labcomm_signature *signature,
+			 const struct labcomm2014_signature *signature,
 			 void *value);
-int labcomm_reader_end(struct labcomm_reader *r, 
-		       struct labcomm_reader_action_context *action_context);
-int labcomm_reader_fill(struct labcomm_reader *r, 
-			struct labcomm_reader_action_context *action_context);
-int labcomm_reader_ioctl(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);
+int labcomm2014_reader_fill(struct labcomm2014_reader *r, 
+			struct labcomm2014_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,
-			 const struct labcomm_signature *signature, 
+			 const struct labcomm2014_signature *signature, 
 			 uint32_t ioctl_action, va_list args);
 
 /*
  * Non typesafe registration function to be called from
- * generated labcomm_decoder_register_* functions.
+ * generated labcomm2014_decoder_register_* functions.
  */
-int labcomm_internal_decoder_register(
-  struct labcomm_decoder *d, 
-  const struct labcomm_signature *s, 
-  labcomm_decoder_function decoder,
-  labcomm_handler_function handler,
+int labcomm2014_internal_decoder_register(
+  struct labcomm2014_decoder *d, 
+  const struct labcomm2014_signature *s, 
+  labcomm2014_decoder_function decoder,
+  labcomm2014_handler_function handler,
   void *context);
 
-int labcomm_internal_decoder_ioctl(struct labcomm_decoder *decoder, 
-				   const struct labcomm_signature *signature,
+int labcomm2014_internal_decoder_ioctl(struct labcomm2014_decoder *decoder, 
+				   const struct labcomm2014_signature *signature,
 				   uint32_t ioctl_action, va_list args);
 
-const struct labcomm_signature *labcomm_internal_decoder_index_to_signature(
-  struct labcomm_decoder *decoder, int index);
+const struct labcomm2014_signature *labcomm2014_internal_decoder_index_to_signature(
+  struct labcomm2014_decoder *decoder, int index);
 
 #if __BYTE_ORDER == __LITTLE_ENDIAN
 
 #define LABCOMM_DECODE(name, type)					\
-  static inline type labcomm_read_##name(struct labcomm_reader *r) {	\
+  static inline type labcomm2014_read_##name(struct labcomm2014_reader *r) {	\
     type result; int i;							\
     for (i = sizeof(type) - 1 ; i >= 0 ; i--) {				\
       if (r->pos >= r->count) {						\
-	labcomm_reader_fill(r, r->action_context);			\
+	labcomm2014_reader_fill(r, r->action_context);			\
 	if (r->error < 0) {						\
 	  return 0;							\
 	}								\
@@ -224,11 +224,11 @@ const struct labcomm_signature *labcomm_internal_decoder_index_to_signature(
 #else
 
 #define LABCOMM_DECODE(name, type)					\
-  static inline type labcomm_read_##name(struct labcomm_reader *r) {	\
+  static inline type labcomm2014_read_##name(struct labcomm2014_reader *r) {	\
     type result; int i;							\
     for (i = 0 ; i < sizeof(type) ; i++) {				\
       if (r->pos >= r->count) {						\
-	labcomm_reader_fille(r, r->action_context);			\
+	labcomm2014_reader_fille(r, r->action_context);			\
 	if (r->error < 0) {						\
 	  return 0;							\
 	}								\
@@ -249,7 +249,7 @@ LABCOMM_DECODE(long, long long)
 LABCOMM_DECODE(float, float)
 LABCOMM_DECODE(double, double)
 
-static inline unsigned int labcomm_read_packed32(struct labcomm_reader *r)
+static inline unsigned int labcomm2014_read_packed32(struct labcomm2014_reader *r)
 {
   unsigned int result = 0;
   
@@ -257,7 +257,7 @@ static inline unsigned int labcomm_read_packed32(struct labcomm_reader *r)
     unsigned char tmp;
 
     if (r->pos >= r->count) {	
-      labcomm_reader_fill(r, r->action_context);
+      labcomm2014_reader_fill(r, r->action_context);
       if (r->error != 0) {
 	goto out;
       }
@@ -273,21 +273,21 @@ out:
   return result;
 }
  
-static inline char *labcomm_read_string(struct labcomm_reader *r)
+static inline char *labcomm2014_read_string(struct labcomm2014_reader *r)
 {
   char *result = NULL;
   int length, pos; 
   
-  length = labcomm_read_packed32(r);
-  result = labcomm_memory_alloc(r->memory, 1, length + 1);
+  length = labcomm2014_read_packed32(r);
+  result = labcomm2014_memory_alloc(r->memory, 1, length + 1);
   if (!result) {
-    labcomm2014_on_error_fprintf(LABCOMM_ERROR_MEMORY, 4, "%d byte at %s:%d",
+    labcomm20142014_on_error_fprintf(LABCOMM_ERROR_MEMORY, 4, "%d byte at %s:%d",
 		     length+1, __FUNCTION__, __LINE__);
     return NULL;
   }
   for (pos = 0 ; pos < length ; pos++) {
     if (r->pos >= r->count) {	
-      labcomm_reader_fill(r, r->action_context);
+      labcomm2014_reader_fill(r, r->action_context);
       if (r->error < 0) {
 	goto out;
       }
@@ -303,15 +303,15 @@ out:
 /*
  * Semi private encoder declarations
  */
-typedef int (*labcomm_encoder_function)(struct labcomm_writer *,
+typedef int (*labcomm2014_encoder_function)(struct labcomm2014_writer *,
 					void *value);
-struct labcomm_writer_action_context;
+struct labcomm2014_writer_action_context;
 
-struct labcomm_writer_action {
-  int (*alloc)(struct labcomm_writer *w, 
-	       struct labcomm_writer_action_context *action_context);
-  int (*free)(struct labcomm_writer *w, 
-	      struct labcomm_writer_action_context *action_context);
+struct labcomm2014_writer_action {
+  int (*alloc)(struct labcomm2014_writer *w, 
+	       struct labcomm2014_writer_action_context *action_context);
+  int (*free)(struct labcomm2014_writer *w, 
+	      struct labcomm2014_writer_action_context *action_context);
   /* 'start' is called right before a sample is to be sent. In the 
      case of a sample or typedef, 'value' == NULL.
 
@@ -321,31 +321,31 @@ struct labcomm_writer_action {
                                 'end' will not be called
        < 0           Error
    */
-  int (*start)(struct labcomm_writer *w, 
-	       struct labcomm_writer_action_context *action_context,
-	       int index, const struct labcomm_signature *signature,
+  int (*start)(struct labcomm2014_writer *w, 
+	       struct labcomm2014_writer_action_context *action_context,
+	       int index, const struct labcomm2014_signature *signature,
 	       void *value);
-  int (*end)(struct labcomm_writer *w, 
-	     struct labcomm_writer_action_context *action_context);
-  int (*flush)(struct labcomm_writer *w, 
-	       struct labcomm_writer_action_context *action_context); 
-  int (*ioctl)(struct labcomm_writer *w, 
-	       struct labcomm_writer_action_context *action_context, 
-	       int index, const struct labcomm_signature *signature, 
+  int (*end)(struct labcomm2014_writer *w, 
+	     struct labcomm2014_writer_action_context *action_context);
+  int (*flush)(struct labcomm2014_writer *w, 
+	       struct labcomm2014_writer_action_context *action_context); 
+  int (*ioctl)(struct labcomm2014_writer *w, 
+	       struct labcomm2014_writer_action_context *action_context, 
+	       int index, const struct labcomm2014_signature *signature, 
 	       uint32_t ioctl_action, va_list args);
 };
 
-struct labcomm_writer_action_context {
-  struct labcomm_writer_action_context *next;
-  const struct labcomm_writer_action *action;
+struct labcomm2014_writer_action_context {
+  struct labcomm2014_writer_action_context *next;
+  const struct labcomm2014_writer_action *action;
   void *context;  
 };
 
-struct labcomm_writer {
-  struct labcomm_writer_action_context *action_context;
-  struct labcomm_memory *memory;
-  /* The following fields are initialized by labcomm_encoder_new */
-  struct labcomm_encoder *encoder;
+struct labcomm2014_writer {
+  struct labcomm2014_writer_action_context *action_context;
+  struct labcomm2014_memory *memory;
+  /* The following fields are initialized by labcomm2014_encoder_new */
+  struct labcomm2014_encoder *encoder;
   unsigned char *data;
   int data_size;
   int count;
@@ -353,63 +353,63 @@ struct labcomm_writer {
   int error;
 };
 
-int labcomm_writer_alloc(struct labcomm_writer *w, 
-			 struct labcomm_writer_action_context *action_context);
-int labcomm_writer_free(struct labcomm_writer *w, 
-			struct labcomm_writer_action_context *action_context);
-int labcomm_writer_start(struct labcomm_writer *w, 
-			 struct labcomm_writer_action_context *action_context,
-			 int index, const struct labcomm_signature *signature,
+int labcomm2014_writer_alloc(struct labcomm2014_writer *w, 
+			 struct labcomm2014_writer_action_context *action_context);
+int labcomm2014_writer_free(struct labcomm2014_writer *w, 
+			struct labcomm2014_writer_action_context *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);
-int labcomm_writer_end(struct labcomm_writer *w, 
-		       struct labcomm_writer_action_context *action_context);
-int labcomm_writer_flush(struct labcomm_writer *w, 
-			 struct labcomm_writer_action_context *action_context); 
-int labcomm_writer_ioctl(struct labcomm_writer *w, 
-			 struct labcomm_writer_action_context *action_context, 
-			 int index, const struct labcomm_signature *signature, 
+int labcomm2014_writer_end(struct labcomm2014_writer *w, 
+		       struct labcomm2014_writer_action_context *action_context);
+int labcomm2014_writer_flush(struct labcomm2014_writer *w, 
+			 struct labcomm2014_writer_action_context *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);
 
-int labcomm_internal_encoder_type_register(
-  struct labcomm_encoder *e,
-  const struct labcomm_signature *signature);
+int labcomm2014_internal_encoder_type_register(
+  struct labcomm2014_encoder *e,
+  const struct labcomm2014_signature *signature);
 
-int labcomm_internal_encoder_type_bind(
-  struct labcomm_encoder *e,
-  const struct labcomm_signature *signature,
+int labcomm2014_internal_encoder_type_bind(
+  struct labcomm2014_encoder *e,
+  const struct labcomm2014_signature *signature,
   char has_deps);
 
-int labcomm_internal_encoder_register(
-  struct labcomm_encoder *encoder, 
-  const struct labcomm_signature *signature, 
-  labcomm_encoder_function encode);
+int labcomm2014_internal_encoder_register(
+  struct labcomm2014_encoder *encoder, 
+  const struct labcomm2014_signature *signature, 
+  labcomm2014_encoder_function encode);
 
-int labcomm_internal_encode(
-  struct labcomm_encoder *encoder, 
-  const struct labcomm_signature *signature, 
-  labcomm_encoder_function encode,
+int labcomm2014_internal_encode(
+  struct labcomm2014_encoder *encoder, 
+  const struct labcomm2014_signature *signature, 
+  labcomm2014_encoder_function encode,
   void *value);
 
-int labcomm_internal_encoder_ioctl(struct labcomm_encoder *encoder, 
-				   const struct labcomm_signature *signature,
+int labcomm2014_internal_encoder_ioctl(struct labcomm2014_encoder *encoder, 
+				   const struct labcomm2014_signature *signature,
 				   uint32_t ioctl_action, va_list args);
 
-int labcomm_internal_encoder_signature_to_index(
-  struct labcomm_encoder *encoder, const struct labcomm_signature *signature);
+int labcomm2014_internal_encoder_signature_to_index(
+  struct labcomm2014_encoder *encoder, const struct labcomm2014_signature *signature);
 
-int labcomm_internal_sizeof(const struct labcomm_signature *signature,
+int labcomm2014_internal_sizeof(const struct labcomm2014_signature *signature,
                             void *v);
 
 
 #if __BYTE_ORDER == __LITTLE_ENDIAN
 
 #define LABCOMM_ENCODE(name, type)					\
-  static inline int labcomm_write_##name(struct labcomm_writer *w, type data) { \
+  static inline int labcomm2014_write_##name(struct labcomm2014_writer *w, type data) { \
     int i;								\
     for (i = sizeof(type) - 1 ; i >= 0 ; i--) {				\
       if (w->pos >= w->count) { /*buffer is full*/			\
         int err;							\
-	err = labcomm_writer_flush(w, w->action_context);		\
+	err = labcomm2014_writer_flush(w, w->action_context);		\
 	if (err != 0) { return err; }					\
       }									\
       w->data[w->pos] = ((unsigned char*)(&data))[i];			\
@@ -421,12 +421,12 @@ int labcomm_internal_sizeof(const struct labcomm_signature *signature,
 #else
 
 #define LABCOMM_ENCODE(name, type)					\
-  static inline int labcomm_write_##name(struct labcomm_writer *w, type data) { \
+  static inline int labcomm2014_write_##name(struct labcomm2014_writer *w, type data) { \
     int i;								\
     for (i = 0 ; i < sizeof(type) ; i++) {				\
       if (w->pos >= w->count) {						\
         int err;							\
-	err = labcomm_writer_flush(w, w->action_context);		\
+	err = labcomm2014_writer_flush(w, w->action_context);		\
 	if (err != 0) { return err; }					\
       }									\
       w->data[w->pos] = ((unsigned char*)(&data))[i];			\
@@ -445,7 +445,7 @@ LABCOMM_ENCODE(long, long long)
 LABCOMM_ENCODE(float, float)
 LABCOMM_ENCODE(double, double)
 
-static inline int labcomm_write_packed32(struct labcomm_writer *w, 
+static inline int labcomm2014_write_packed32(struct labcomm2014_writer *w, 
 					 unsigned int data)
 {
   unsigned char tmp[5];
@@ -457,7 +457,7 @@ static inline int labcomm_write_packed32(struct labcomm_writer *w,
   for (i = i - 1 ; i >= 0 ; i--) {
     if (w->pos >= w->count) {					
       int err;
-      err = labcomm_writer_flush(w, w->action_context);	
+      err = labcomm2014_writer_flush(w, w->action_context);	
       if (err != 0) { return err; }
     }
     w->data[w->pos++] = tmp[i] | (i?0x80:0x00);
@@ -465,17 +465,17 @@ static inline int labcomm_write_packed32(struct labcomm_writer *w,
   return 0;
 }
 
-static inline int labcomm_write_string(struct labcomm_writer *w, char *s)
+static inline int labcomm2014_write_string(struct labcomm2014_writer *w, char *s)
 {
   int length, i, err; 
 
   length = strlen(s);
-  err = labcomm_write_packed32(w, length);
+  err = labcomm2014_write_packed32(w, length);
   if (err != 0) { return err; }
   for (i = 0 ; i < length ; i++) {
     if (w->pos >= w->count) {	
       int err;
-      err = labcomm_writer_flush(w, w->action_context);	
+      err = labcomm2014_writer_flush(w, w->action_context);	
       if (err != 0) { return err; }
     }
     w->data[w->pos] = s[i];
@@ -485,7 +485,7 @@ static inline int labcomm_write_string(struct labcomm_writer *w, char *s)
 }
 
 /* Size of packed32 variable */
-static inline int labcomm_size_packed32(unsigned int data)
+static inline int labcomm2014_size_packed32(unsigned int data)
 {
   int result = 0;
   int i;
@@ -497,11 +497,11 @@ static inline int labcomm_size_packed32(unsigned int data)
 
 }
 
-static inline int labcomm_size_string(char *s)
+static inline int labcomm2014_size_string(char *s)
 {
   int length = strlen(s);
   
-  return labcomm_size_packed32(length) + length;
+  return labcomm2014_size_packed32(length) + length;
 }
 
 /*
@@ -523,10 +523,10 @@ static inline int labcomm_size_string(char *s)
   name.data = (kind *)name.data; /* typechecking no-op */
 
 #define LABCOMM_SIGNATURE_ARRAY_FREE(memory, name, kind)	\
-  if (name.data) { labcomm_memory_free(memory, 0, name.data); }	\
+  if (name.data) { labcomm2014_memory_free(memory, 0, name.data); }	\
   name.data = (kind *)NULL; /* typechecking */
 
-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);
 /*
@@ -538,7 +538,7 @@ void *labcomm_signature_array_ref(struct labcomm_memory * memory,
  */
 #define LABCOMM_SIGNATURE_ARRAY_REF(memory, name, kind, index)		\
   (name.data = (kind *)name.data, /* typechecking no-op */		\
-   (kind *)(labcomm_signature_array_ref(memory,				\
+   (kind *)(labcomm2014_signature_array_ref(memory,				\
 					&name.first, &name.last,	\
 					(void **)&name.data,		\
 					sizeof(kind), index)))
@@ -553,11 +553,11 @@ void *labcomm_signature_array_ref(struct labcomm_memory * memory,
        var = name.first ; var < name.last ; var++)
 
 /* Give signature a free local index, this may not be used concurrently */
-void labcomm_set_local_index(struct labcomm_signature *signature);
+void labcomm2014_set_local_index(struct labcomm2014_signature *signature);
 
 /* Get the local index for a signature */
-int labcomm_get_local_index(const struct labcomm_signature *s);
+int labcomm2014_get_local_index(const struct labcomm2014_signature *s);
 
-int labcomm_get_local_type_index(const struct labcomm_signature *s);
+int labcomm2014_get_local_type_index(const struct labcomm2014_signature *s);
 
 #endif
diff --git a/lib/c/2014/labcomm_pthread_scheduler.c b/lib/c/2014/labcomm2014_pthread_scheduler.c
similarity index 75%
rename from lib/c/2014/labcomm_pthread_scheduler.c
rename to lib/c/2014/labcomm2014_pthread_scheduler.c
index a9b516a..e2f5a21 100644
--- a/lib/c/2014/labcomm_pthread_scheduler.c
+++ b/lib/c/2014/labcomm2014_pthread_scheduler.c
@@ -1,5 +1,5 @@
 /*
-  labcomm_pthread_scheduler.c -- labcomm pthread based task coordination
+  labcomm2014_pthread_scheduler.c -- labcomm2014 pthread based task coordination
 
   Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
 
@@ -23,18 +23,18 @@
 #include <stdlib.h>
 #include <errno.h>
 #include <pthread.h>
-#include "labcomm.h"
-#include "labcomm_scheduler.h"
-#include "labcomm_scheduler_private.h"
-#include "labcomm_pthread_scheduler.h"
+#include "labcomm2014.h"
+#include "labcomm2014_scheduler.h"
+#include "labcomm2014_scheduler_private.h"
+#include "labcomm2014_pthread_scheduler.h"
 
 #ifdef LABCOMM_COMPAT
   #include LABCOMM_COMPAT
 #endif 
 
 struct pthread_time {
-  struct labcomm_time time;
-  struct labcomm_memory *memory;
+  struct labcomm2014_time time;
+  struct labcomm2014_memory *memory;
   struct timespec abstime;
 };
 
@@ -47,8 +47,8 @@ struct pthread_deferred {
 };
 
 struct pthread_scheduler {
-  struct labcomm_scheduler scheduler;
-  struct labcomm_memory *memory;
+  struct labcomm2014_scheduler scheduler;
+  struct labcomm2014_memory *memory;
   int wakeup;
   pthread_mutex_t writer_mutex;
   pthread_mutex_t data_mutex;
@@ -58,7 +58,7 @@ struct pthread_scheduler {
   struct pthread_deferred deferred_with_delay;
 };
 
-static struct labcomm_time_action time_action;
+static struct labcomm2014_time_action time_action;
 
 static int queue_empty(struct pthread_deferred *queue)
 {
@@ -100,11 +100,11 @@ static int timespec_compare(struct timespec *t1, struct timespec *t2)
   }
 }
 
-static struct labcomm_time *time_new(struct labcomm_memory *memory)
+static struct labcomm2014_time *time_new(struct labcomm2014_memory *memory)
 {
   struct pthread_time *time;
 
-  time = labcomm_memory_alloc(memory, 0, sizeof(*time));
+  time = labcomm2014_memory_alloc(memory, 0, sizeof(*time));
   if (time == NULL) {
     return NULL;
   } else {
@@ -116,17 +116,17 @@ static struct labcomm_time *time_new(struct labcomm_memory *memory)
   }
 }
 
-static int time_free(struct labcomm_time *t)
+static int time_free(struct labcomm2014_time *t)
 {
   struct pthread_time *time = t->context;
-  struct labcomm_memory *memory = time->memory;
+  struct labcomm2014_memory *memory = time->memory;
   
-  labcomm_memory_free(memory, 0, time);
+  labcomm2014_memory_free(memory, 0, time);
   
   return 0;
 }
  
-static int time_add_usec(struct labcomm_time *t, uint32_t usec)
+static int time_add_usec(struct labcomm2014_time *t, uint32_t usec)
 {
   struct pthread_time *time = t->context;
 
@@ -135,7 +135,7 @@ static int time_add_usec(struct labcomm_time *t, uint32_t usec)
   return 0;
 }
 
-static struct labcomm_time_action time_action = {
+static struct labcomm2014_time_action time_action = {
   .free = time_free,
   .add_usec = time_add_usec
 };
@@ -146,10 +146,10 @@ static int run_action(struct pthread_scheduler *scheduler,
   /* Called with data_lock held */
   element->prev->next = element->next;
   element->next->prev = element->prev;
-  labcomm_scheduler_data_unlock(&scheduler->scheduler);
+  labcomm2014_scheduler_data_unlock(&scheduler->scheduler);
   element->action(element->context);
-  labcomm_memory_free(scheduler->memory, 1, element);
-  labcomm_scheduler_data_lock(&scheduler->scheduler);
+  labcomm2014_memory_free(scheduler->memory, 1, element);
+  labcomm2014_scheduler_data_lock(&scheduler->scheduler);
   return 0;
 }
 
@@ -175,44 +175,44 @@ out:
   return 0;
 }
 
-static int scheduler_free(struct labcomm_scheduler *s)
+static int scheduler_free(struct labcomm2014_scheduler *s)
 {
   struct pthread_scheduler *scheduler = s->context;
-  struct labcomm_memory *memory = scheduler->memory;
+  struct labcomm2014_memory *memory = scheduler->memory;
   
-  labcomm_memory_free(memory, 0, scheduler);
+  labcomm2014_memory_free(memory, 0, scheduler);
 
   return 0;
 }
  
-static int scheduler_writer_lock(struct labcomm_scheduler *s)
+static int scheduler_writer_lock(struct labcomm2014_scheduler *s)
 {
   struct pthread_scheduler *scheduler = s->context;
 
-  labcomm_scheduler_data_lock(&scheduler->scheduler);
+  labcomm2014_scheduler_data_lock(&scheduler->scheduler);
   run_deferred(scheduler);  /* Run deferred tasks before taking lock */
-  labcomm_scheduler_data_unlock(&scheduler->scheduler);
+  labcomm2014_scheduler_data_unlock(&scheduler->scheduler);
   if (pthread_mutex_lock(&scheduler->writer_mutex) != 0) {
     return -errno;
   }
   return 0;
 }
  
-static int scheduler_writer_unlock(struct labcomm_scheduler *s)
+static int scheduler_writer_unlock(struct labcomm2014_scheduler *s)
 {
   struct pthread_scheduler *scheduler = s->context;
 
   if (pthread_mutex_unlock(&scheduler->writer_mutex) != 0) {
     return -errno;
   }
-  labcomm_scheduler_data_lock(&scheduler->scheduler);
+  labcomm2014_scheduler_data_lock(&scheduler->scheduler);
   run_deferred(scheduler);  /* Run deferred tasks after releasing lock */
-  labcomm_scheduler_data_unlock(&scheduler->scheduler);
+  labcomm2014_scheduler_data_unlock(&scheduler->scheduler);
   
   return 0;
 }
 
-static int scheduler_data_lock(struct labcomm_scheduler *s)
+static int scheduler_data_lock(struct labcomm2014_scheduler *s)
 {
   struct pthread_scheduler *scheduler = s->context;
 
@@ -223,7 +223,7 @@ static int scheduler_data_lock(struct labcomm_scheduler *s)
   return 0;
 }
  
-static int scheduler_data_unlock(struct labcomm_scheduler *s)
+static int scheduler_data_unlock(struct labcomm2014_scheduler *s)
 {
   struct pthread_scheduler *scheduler = s->context;
 
@@ -235,20 +235,20 @@ static int scheduler_data_unlock(struct labcomm_scheduler *s)
   return 0;
 }
 
-static struct labcomm_time *scheduler_now(struct labcomm_scheduler *s)
+static struct labcomm2014_time *scheduler_now(struct labcomm2014_scheduler *s)
 {
   struct pthread_scheduler *scheduler = s->context;
 
   return time_new(scheduler->memory);
 }
  
-static int scheduler_sleep(struct labcomm_scheduler *s,
-			   struct labcomm_time *t)
+static int scheduler_sleep(struct labcomm2014_scheduler *s,
+			   struct labcomm2014_time *t)
 {
   struct pthread_scheduler *scheduler = s->context;
   struct pthread_time *time = t?t->context:NULL;
 
-  labcomm_scheduler_data_lock(&scheduler->scheduler);
+  labcomm2014_scheduler_data_lock(&scheduler->scheduler);
   while (1) {
     struct timespec *wakeup, now;
 
@@ -281,23 +281,23 @@ static int scheduler_sleep(struct labcomm_scheduler *s,
 			&scheduler->data_mutex);
     }
   }
-  labcomm_scheduler_data_unlock(&scheduler->scheduler);
+  labcomm2014_scheduler_data_unlock(&scheduler->scheduler);
   
   return 0;
 }
 
-static int scheduler_wakeup(struct labcomm_scheduler *s)
+static int scheduler_wakeup(struct labcomm2014_scheduler *s)
 {
   struct pthread_scheduler *scheduler = s->context;
 
-  labcomm_scheduler_data_lock(&scheduler->scheduler);
+  labcomm2014_scheduler_data_lock(&scheduler->scheduler);
   scheduler->wakeup = 1;
   pthread_cond_signal(&scheduler->data_cond);
-  labcomm_scheduler_data_unlock(&scheduler->scheduler);
+  labcomm2014_scheduler_data_unlock(&scheduler->scheduler);
   return 0;
 }
 
-static int scheduler_enqueue(struct labcomm_scheduler *s,
+static int scheduler_enqueue(struct labcomm2014_scheduler *s,
 			     uint32_t delay,
 			     void (*deferred)(void *context),
 			     void *context)
@@ -306,7 +306,7 @@ static int scheduler_enqueue(struct labcomm_scheduler *s,
   int result = 0;
   struct pthread_deferred *element, *insert_before;
 
-  element = labcomm_memory_alloc(scheduler->memory, 1, sizeof(*element));
+  element = labcomm2014_memory_alloc(scheduler->memory, 1, sizeof(*element));
   if (element == NULL) {
     result = -ENOMEM;
     goto out;
@@ -314,7 +314,7 @@ static int scheduler_enqueue(struct labcomm_scheduler *s,
   
   element->action = deferred;
   element->context = context;
-  labcomm_scheduler_data_lock(&scheduler->scheduler);
+  labcomm2014_scheduler_data_lock(&scheduler->scheduler);
   if (delay == 0) {
     insert_before = &scheduler->deferred;
   } else {
@@ -330,13 +330,13 @@ static int scheduler_enqueue(struct labcomm_scheduler *s,
   element->prev->next = element;
   element->next->prev = element;
   pthread_cond_signal(&scheduler->data_cond);
-  labcomm_scheduler_data_unlock(&scheduler->scheduler);
+  labcomm2014_scheduler_data_unlock(&scheduler->scheduler);
 
 out:
   return result;
 }
 
-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,
@@ -348,13 +348,13 @@ static const struct labcomm_scheduler_action scheduler_action = {
   .enqueue = scheduler_enqueue  
 };
 
-struct labcomm_scheduler *labcomm_pthread_scheduler_new(
-  struct labcomm_memory *memory)
+struct labcomm2014_scheduler *labcomm2014_pthread_scheduler_new(
+  struct labcomm2014_memory *memory)
 {
-  struct labcomm_scheduler *result = NULL;
+  struct labcomm2014_scheduler *result = NULL;
   struct pthread_scheduler *scheduler;
 
-  scheduler = labcomm_memory_alloc(memory, 0, sizeof(*scheduler));
+  scheduler = labcomm2014_memory_alloc(memory, 0, sizeof(*scheduler));
   if (scheduler == NULL) {
     goto out;
   } else {
@@ -386,7 +386,7 @@ destroy_data_mutex:
 destroy_writer_mutex:
   pthread_mutex_destroy(&scheduler->writer_mutex);
 free_scheduler:
-  labcomm_memory_free(memory, 0, scheduler);
+  labcomm2014_memory_free(memory, 0, scheduler);
 out:
   return result;
   
diff --git a/lib/c/2014/labcomm_pthread_scheduler.h b/lib/c/2014/labcomm2014_pthread_scheduler.h
similarity index 71%
rename from lib/c/2014/labcomm_pthread_scheduler.h
rename to lib/c/2014/labcomm2014_pthread_scheduler.h
index 64ace83..e8e5a1b 100644
--- a/lib/c/2014/labcomm_pthread_scheduler.h
+++ b/lib/c/2014/labcomm2014_pthread_scheduler.h
@@ -1,5 +1,5 @@
 /*
-  labcomm_pthread_scheduler.h -- labcomm pthread based task coordination
+  labcomm2014_pthread_scheduler.h -- labcomm2014 pthread based task coordination
 
   Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
 
@@ -19,13 +19,13 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef __LABCOMM_PTHREAD_SCHEDULER_H__
-#define __LABCOMM_PTHREAD_SCHEDULER_H__
+#ifndef __LABCOMM2014_PTHREAD_SCHEDULER_H__
+#define __LABCOMM2014_PTHREAD_SCHEDULER_H__
 
-#include "labcomm.h"
+#include "labcomm2014.h"
 
-struct labcomm_scheduler *labcomm_pthread_scheduler_new(
-  struct labcomm_memory *memory);
+struct labcomm2014_scheduler *labcomm2014_pthread_scheduler_new(
+  struct labcomm2014_memory *memory);
 
 #endif
 
diff --git a/lib/c/2014/labcomm_scheduler.c b/lib/c/2014/labcomm2014_scheduler.c
similarity index 66%
rename from lib/c/2014/labcomm_scheduler.c
rename to lib/c/2014/labcomm2014_scheduler.c
index 3ef62f3..4028820 100644
--- a/lib/c/2014/labcomm_scheduler.c
+++ b/lib/c/2014/labcomm2014_scheduler.c
@@ -1,5 +1,5 @@
 /*
-  labcomm_scheduler.c -- labcomm task coordination
+  labcomm2014_scheduler.c -- labcomm2014 task coordination
 
   Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
 
@@ -20,7 +20,7 @@
 */
 
 #include <errno.h>
-#include "labcomm_scheduler_private.h"
+#include "labcomm2014_scheduler_private.h"
 
 #define SCHEDULER_scheduler(scheduler, ...) scheduler
 #define SCHEDULER(func, ...)						\
@@ -30,32 +30,32 @@
   }									\
   return -ENOSYS;
 
-int labcomm_scheduler_free(struct labcomm_scheduler *s)
+int labcomm2014_scheduler_free(struct labcomm2014_scheduler *s)
 {
   SCHEDULER(free, s);
 }
 
-int labcomm_scheduler_writer_lock(struct labcomm_scheduler *s)
+int labcomm2014_scheduler_writer_lock(struct labcomm2014_scheduler *s)
 {
   SCHEDULER(writer_lock, s);
 }
 
-int labcomm_scheduler_writer_unlock(struct labcomm_scheduler *s)
+int labcomm2014_scheduler_writer_unlock(struct labcomm2014_scheduler *s)
 {
   SCHEDULER(writer_unlock, s);
 }
 
-int labcomm_scheduler_data_lock(struct labcomm_scheduler *s)
+int labcomm2014_scheduler_data_lock(struct labcomm2014_scheduler *s)
 {
   SCHEDULER(data_lock, s);
 }
 
-int labcomm_scheduler_data_unlock(struct labcomm_scheduler *s)
+int labcomm2014_scheduler_data_unlock(struct labcomm2014_scheduler *s)
 {
   SCHEDULER(data_unlock, s);
 }
 
-struct labcomm_time *labcomm_scheduler_now(struct labcomm_scheduler *s)
+struct labcomm2014_time *labcomm2014_scheduler_now(struct labcomm2014_scheduler *s)
 {
   if (s && s->action->now) {
     return s->action->now(s); 
@@ -63,18 +63,18 @@ struct labcomm_time *labcomm_scheduler_now(struct labcomm_scheduler *s)
   return NULL;
 }
 
-int labcomm_scheduler_sleep(struct labcomm_scheduler *s,
-			    struct labcomm_time *wakeup)
+int labcomm2014_scheduler_sleep(struct labcomm2014_scheduler *s,
+			    struct labcomm2014_time *wakeup)
 {
   SCHEDULER(sleep, s, wakeup);
 }
 
-int labcomm_scheduler_wakeup(struct labcomm_scheduler *s)
+int labcomm2014_scheduler_wakeup(struct labcomm2014_scheduler *s)
 {
   SCHEDULER(wakeup, s);
 }
 
-int labcomm_scheduler_enqueue(struct labcomm_scheduler *s,
+int labcomm2014_scheduler_enqueue(struct labcomm2014_scheduler *s,
 			      uint32_t delay,
 			      void (*func)(void *context),
 			      void *context)
diff --git a/lib/c/2014/labcomm_scheduler.h b/lib/c/2014/labcomm2014_scheduler.h
similarity index 50%
rename from lib/c/2014/labcomm_scheduler.h
rename to lib/c/2014/labcomm2014_scheduler.h
index b96b1ca..8d7e332 100644
--- a/lib/c/2014/labcomm_scheduler.h
+++ b/lib/c/2014/labcomm2014_scheduler.h
@@ -1,5 +1,5 @@
 /*
-  labcomm_scheduler.h -- labcomm task coordination
+  labcomm2014_scheduler.h -- labcomm2014 task coordination
 
   Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
 
@@ -19,8 +19,8 @@
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef __LABCOMM_SCHEDULER_H__
-#define __LABCOMM_SCHEDULER_H__
+#ifndef __LABCOMM2014_SCHEDULER_H__
+#define __LABCOMM2014_SCHEDULER_H__
 
 #ifdef LABCOMM_COMPAT
   #include LABCOMM_COMPAT
@@ -29,29 +29,29 @@
   #include <stdint.h>
 #endif
 
-struct labcomm_time;
+struct labcomm2014_time;
 
-int labcomm_time_free(struct labcomm_time *t);
-int labcomm_time_add_usec(struct labcomm_time *t, uint32_t usec);
+int labcomm2014_time_free(struct labcomm2014_time *t);
+int labcomm2014_time_add_usec(struct labcomm2014_time *t, uint32_t usec);
 
-struct labcomm_scheduler;
+struct labcomm2014_scheduler;
 
-int labcomm_scheduler_free(struct labcomm_scheduler *s);
+int labcomm2014_scheduler_free(struct labcomm2014_scheduler *s);
 
 /* Lock and event handling */
-int labcomm_scheduler_writer_lock(struct labcomm_scheduler *s);
-int labcomm_scheduler_writer_unlock(struct labcomm_scheduler *s);
-int labcomm_scheduler_data_lock(struct labcomm_scheduler *s);
-int labcomm_scheduler_data_unlock(struct labcomm_scheduler *s);
+int labcomm2014_scheduler_writer_lock(struct labcomm2014_scheduler *s);
+int labcomm2014_scheduler_writer_unlock(struct labcomm2014_scheduler *s);
+int labcomm2014_scheduler_data_lock(struct labcomm2014_scheduler *s);
+int labcomm2014_scheduler_data_unlock(struct labcomm2014_scheduler *s);
 
 /* Time handling */
-struct labcomm_time *labcomm_scheduler_now(struct labcomm_scheduler *s);
-int labcomm_scheduler_sleep(struct labcomm_scheduler *s,
-			    struct labcomm_time *wakeup);
-int labcomm_scheduler_wakeup(struct labcomm_scheduler *s);
+struct labcomm2014_time *labcomm2014_scheduler_now(struct labcomm2014_scheduler *s);
+int labcomm2014_scheduler_sleep(struct labcomm2014_scheduler *s,
+			    struct labcomm2014_time *wakeup);
+int labcomm2014_scheduler_wakeup(struct labcomm2014_scheduler *s);
 
 /* Deferred action handling */
-int labcomm_scheduler_enqueue(struct labcomm_scheduler *s,
+int labcomm2014_scheduler_enqueue(struct labcomm2014_scheduler *s,
 			      uint32_t delay,
 			      void (*deferred)(void *context),
 			      void *context);
diff --git a/lib/c/2014/labcomm2014_scheduler_private.h b/lib/c/2014/labcomm2014_scheduler_private.h
new file mode 100644
index 0000000..31f4cda
--- /dev/null
+++ b/lib/c/2014/labcomm2014_scheduler_private.h
@@ -0,0 +1,60 @@
+/*
+  labcomm2014_scheduler.h -- labcomm2014 task coordination, semi-private part
+
+  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_SCHEDULER_PRIVATE_H__
+#define __LABCOMM2014_SCHEDULER_PRIVATE_H__
+
+#ifdef LABCOMM_COMPAT
+  #include LABCOMM_COMPAT
+#else
+  #include <unistd.h>
+#endif
+
+#include "labcomm2014_scheduler.h"
+
+struct labcomm2014_time {
+  const struct labcomm2014_time_action {
+    int (*free)(struct labcomm2014_time *t);
+    int (*add_usec)(struct labcomm2014_time *t, uint32_t usec);
+  } *action;
+  void *context;
+};
+
+struct labcomm2014_scheduler {
+  const struct labcomm2014_scheduler_action {
+    int (*free)(struct labcomm2014_scheduler *s);
+    int (*writer_lock)(struct labcomm2014_scheduler *s);
+    int (*writer_unlock)(struct labcomm2014_scheduler *s);
+    int (*data_lock)(struct labcomm2014_scheduler *s);
+    int (*data_unlock)(struct labcomm2014_scheduler *s);
+    struct labcomm2014_time *(*now)(struct labcomm2014_scheduler *s);
+    int (*sleep)(struct labcomm2014_scheduler *s,
+		 struct labcomm2014_time *wakeup);
+    int (*wakeup)(struct labcomm2014_scheduler *s);
+    int (*enqueue)(struct labcomm2014_scheduler *s,
+		   uint32_t delay,
+		   void (*deferred)(void *context),
+		   void *context);
+  } *action;
+  void *context;
+};
+
+#endif
diff --git a/lib/c/2014/labcomm_time.c b/lib/c/2014/labcomm2014_time.c
similarity index 82%
rename from lib/c/2014/labcomm_time.c
rename to lib/c/2014/labcomm2014_time.c
index a1a5235..eb5e1f5 100644
--- a/lib/c/2014/labcomm_time.c
+++ b/lib/c/2014/labcomm2014_time.c
@@ -1,5 +1,5 @@
 /*
-  labcomm_time.c -- labcomm time handling
+  labcomm2014_time.c -- labcomm2014 time handling
 
   Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
 
@@ -20,7 +20,7 @@
 */
 
 #include <errno.h>
-#include "labcomm_scheduler_private.h"
+#include "labcomm2014_scheduler_private.h"
 
 #define TIME_time(time, ...) time
 #define TIME(func, ...)						\
@@ -30,12 +30,12 @@
   }									\
   return -ENOSYS;
 
-int labcomm_time_free(struct labcomm_time *s)
+int labcomm2014_time_free(struct labcomm2014_time *s)
 {
   TIME(free, s);
 }
 
-int labcomm_time_add_usec(struct labcomm_time *s, uint32_t usec)
+int labcomm2014_time_add_usec(struct labcomm2014_time *s, uint32_t usec)
 {
   TIME(add_usec, s, usec);
 }
diff --git a/lib/c/2014/labcomm_type_signature.c b/lib/c/2014/labcomm2014_type_signature.c
similarity index 70%
rename from lib/c/2014/labcomm_type_signature.c
rename to lib/c/2014/labcomm2014_type_signature.c
index 3cb9cc3..abc95a3 100644
--- a/lib/c/2014/labcomm_type_signature.c
+++ b/lib/c/2014/labcomm2014_type_signature.c
@@ -1,13 +1,13 @@
-#include "labcomm.h"
+#include "labcomm2014.h"
 #include <string.h>   // for memcmp
 #include <stdio.h>   // for debug printf
 
 /* Dump signature bytes on stdout 
  */
 
-void labcomm_signature_print(struct labcomm_signature_data *signature)
+void labcomm2014_signature_print(struct labcomm2014_signature_data *signature)
 {
-  struct labcomm_signature_data *p = signature ;
+  struct labcomm2014_signature_data *p = signature ;
   while (p->length != -1) {
     if (p->length) {
       int i;
@@ -15,7 +15,7 @@ void labcomm_signature_print(struct labcomm_signature_data *signature)
         printf("%02x ", p->u.bytes[i]);
       }
     } else if(p->u.signature){
-      labcomm_signature_print(p->u.signature->treedata);
+      labcomm2014_signature_print(p->u.signature->treedata);
     } else {
       printf("neither data nor ref, bailing out.\n");
       return;
@@ -24,7 +24,7 @@ void labcomm_signature_print(struct labcomm_signature_data *signature)
   }
   printf("\n");
 }
-static labcomm_bool sig_dump_checked(struct labcomm_signature_data *signature, 
+static labcomm2014_bool sig_dump_checked(struct labcomm2014_signature_data *signature, 
                             char *buf, int *len, int buflen);
 
 /* buf (out)   : byte array to write signature into
@@ -32,7 +32,7 @@ static labcomm_bool sig_dump_checked(struct labcomm_signature_data *signature,
 
    return TRUE if aborted due to overrun
  */
-labcomm_bool labcomm_signature_dump(struct labcomm_signature_data *signature, 
+labcomm2014_bool labcomm2014_signature_dump(struct labcomm2014_signature_data *signature, 
                            char *buf, int *len)
 {
   int buflen = *len;
@@ -43,10 +43,10 @@ labcomm_bool labcomm_signature_dump(struct labcomm_signature_data *signature,
 /* internal function with bounds checking for buf.
  * buflen: capacity of buf
  */
-static labcomm_bool sig_dump_checked(struct labcomm_signature_data *signature, 
+static labcomm2014_bool sig_dump_checked(struct labcomm2014_signature_data *signature, 
                             char *buf, int *len, int buflen)
 {
-  struct labcomm_signature_data *p = signature;
+  struct labcomm2014_signature_data *p = signature;
   while ( (p->length != -1) && (*len < buflen)) {
     if (p->length) {
       int i;
@@ -72,16 +72,16 @@ static labcomm_bool sig_dump_checked(struct labcomm_signature_data *signature,
 /* compare signature (flattened, if needed) to other
    return TRUE if equal
 */
-labcomm_bool labcomm_signature_cmp( struct labcomm_signature_data *s1,
-                           struct labcomm_signature_data *s2)
+labcomm2014_bool labcomm2014_signature_cmp( struct labcomm2014_signature_data *s1,
+                           struct labcomm2014_signature_data *s2)
 {
   int buflen=512;
   char buf1[buflen];
   int len1=buflen;
   char buf2[buflen];
   int len2=buflen;
-  labcomm_bool res1 = labcomm_signature_dump(s1, buf1, &len1);
-  labcomm_bool res2 = labcomm_signature_dump(s2, buf2, &len2);
+  labcomm2014_bool res1 = labcomm2014_signature_dump(s1, buf1, &len1);
+  labcomm2014_bool res2 = labcomm2014_signature_dump(s2, buf2, &len2);
   if(res1 || res2) {
     printf("WARNING: OVERRUN\n");
     return FALSE;
@@ -89,7 +89,7 @@ labcomm_bool labcomm_signature_cmp( struct labcomm_signature_data *s1,
     return(len1 == len2 && memcmp(buf1, buf2, len1)==0);
   }
 }
-/* maps a function f(char b, struct labcomm_signature *s, void *context) 
+/* maps a function f(char b, struct labcomm2014_signature *s, void *context) 
  * on each byte (or type ref) in the signature. 
  *
  * If flatten, the signature is flattened to a byte array, and the 
@@ -100,11 +100,11 @@ labcomm_bool labcomm_signature_cmp( struct labcomm_signature_data *s1,
  *
  * The context parameter is passed on, unaltered, to f
  */ 
-void map_signature( void(*f)(char, const struct labcomm_signature *, void *), 
+void map_signature( void(*f)(char, const struct labcomm2014_signature *, void *), 
                     void *context,
-                    const struct labcomm_signature *signature, labcomm_bool flatten)
+                    const struct labcomm2014_signature *signature, labcomm2014_bool flatten)
 {
-  struct labcomm_signature_data* p = signature->treedata;
+  struct labcomm2014_signature_data* p = signature->treedata;
   while (p->length != -1) {
     //fprintf(stderr, "%p %x\n", p, p->length);
     if (p->length) {
diff --git a/lib/c/2014/labcomm_type_signature.h b/lib/c/2014/labcomm2014_type_signature.h
similarity index 67%
rename from lib/c/2014/labcomm_type_signature.h
rename to lib/c/2014/labcomm2014_type_signature.h
index e556589..1d77640 100644
--- a/lib/c/2014/labcomm_type_signature.h
+++ b/lib/c/2014/labcomm2014_type_signature.h
@@ -1,9 +1,9 @@
-#ifndef LABCOMM_TYPE_SIGNATURE_H
-#define LABCOMM_TYPE_SIGNATURE_H
+#ifndef __LABCOMM2014_TYPE_SIGNATURE_H__
+#define __LABCOMM2014_TYPE_SIGNATURE_H__
 
 //XXX move to common.h
-#ifndef labcomm_bool
-#define labcomm_bool char
+#ifndef labcomm2014_bool
+#define labcomm2014_bool char
 #define TRUE 1
 #define FALSE 0
 #endif
@@ -19,7 +19,7 @@
 #define LABCOMM_SIGDEF_BYTES_OR_SIGNATURE          \
   union {                                   \
     char *bytes;                            \
-    struct labcomm_signature* signature;            \
+    struct labcomm2014_signature* signature;            \
   } u;
 
 #define LABCOMM_SIGDEF_BYTES(l, b) { l, .u.bytes=b }
@@ -31,7 +31,7 @@
 #define LABCOMM_SIGDEF_BYTES_OR_SIGNATURE          \
   struct {                                  \
     char *bytes;                            \
-    const struct labcomm_signature *signature;            \
+    const struct labcomm2014_signature *signature;            \
   } u;
 
 #define LABCOMM_SIGDEF_BYTES(l, b) { l, { b, 0 } }
@@ -40,13 +40,13 @@
 
 #endif
 
-struct labcomm_signature_data {
+struct labcomm2014_signature_data {
   int length;
   LABCOMM_SIGDEF_BYTES_OR_SIGNATURE
 };
 
 #endif
-struct labcomm_signature {
+struct labcomm2014_signature {
   char *name;
   int (*encoded_size)(void *); /* void* refers to sample_data */
   int size;
@@ -54,7 +54,7 @@ struct labcomm_signature {
   int index;
 #ifndef LABCOMM_NO_TYPEDECL
   int tdsize;
-  struct labcomm_signature_data *treedata;
+  struct labcomm2014_signature_data *treedata;
 #endif  
 #ifdef LABCOMM_EXPERIMENTAL_CACHED_ENCODED_SIZE
   int cached_encoded_size; // -1 if not initialized or type is variable size
@@ -65,7 +65,7 @@ struct labcomm_signature {
  * between decoder and signature parser
  */
 
-struct labcomm_raw_type_def {
+struct labcomm2014_raw_type_def {
     char *name;
     int index;
     int length;
@@ -75,7 +75,7 @@ struct labcomm_raw_type_def {
 /* a struct for type bindings
  */
 
-struct labcomm_type_binding {
+struct labcomm2014_type_binding {
     int sample_index;
     int type_index;
 };
@@ -88,19 +88,19 @@ struct labcomm_type_binding {
 /* register a handler for type_defs and type bindings
  */
 
-int labcomm_decoder_register_labcomm_type_def(
-  struct labcomm_decoder *d,
+int labcomm2014_decoder_register_labcomm2014_type_def(
+  struct labcomm2014_decoder *d,
   void (*handler)(
-    struct labcomm_raw_type_def *v,
+    struct labcomm2014_raw_type_def *v,
     void *context
   ),
   void *context
 );
 
-int labcomm_decoder_register_labcomm_type_binding(
-  struct labcomm_decoder *d,
+int labcomm2014_decoder_register_labcomm2014_type_binding(
+  struct labcomm2014_decoder *d,
   void (*handler)(
-    struct labcomm_type_binding *v,
+    struct labcomm2014_type_binding *v,
     void *context
   ),
   void *context
@@ -109,13 +109,13 @@ int labcomm_decoder_register_labcomm_type_binding(
 /* Dump signature bytes on stdout 
  */
 
-void labcomm_signature_print(struct labcomm_signature_data *signature);
+void labcomm2014_signature_print(struct labcomm2014_signature_data *signature);
 
 /* compare signatures (flattened, if needed) to other
 *  return TRUE if equal
 */
-labcomm_bool labcomm_signature_cmp( struct labcomm_signature_data *s2,
-                           struct labcomm_signature_data *s1);
+labcomm2014_bool labcomm2014_signature_cmp( struct labcomm2014_signature_data *s2,
+                           struct labcomm2014_signature_data *s1);
 
 /* flatten and dump signature to a byte array.
  * buf (out)   : byte array to write signature into
@@ -123,7 +123,7 @@ labcomm_bool labcomm_signature_cmp( struct labcomm_signature_data *s2,
  *
  * return TRUE if aborted due to overrun
  */
-labcomm_bool labcomm_signature_dump(struct labcomm_signature_data *signature, 
+labcomm2014_bool labcomm2014_signature_dump(struct labcomm2014_signature_data *signature, 
                            char *buf, int *len);
 
 /* maps function f on each byte in the signature
@@ -132,8 +132,8 @@ labcomm_bool labcomm_signature_dump(struct labcomm_signature_data *signature,
  * otherwise, when a type ref is encountered, f is called with the first
  * argument zero and the type ref as the second argument.
  */ 
-void map_signature( void(*f)(char, const struct labcomm_signature *, void *), 
+void map_signature( void(*f)(char, const struct labcomm2014_signature *, void *), 
                     void *context,
-                    const struct labcomm_signature *signature, labcomm_bool flatten);
+                    const struct labcomm2014_signature *signature, labcomm2014_bool flatten);
 
 #endif
diff --git a/lib/c/2014/labcomm_encoder.c b/lib/c/2014/labcomm_encoder.c
deleted file mode 100644
index 4b71ed0..0000000
--- a/lib/c/2014/labcomm_encoder.c
+++ /dev/null
@@ -1,398 +0,0 @@
-/*
-  labcomm_encoder.c -- handling encoding of labcomm 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 "labcomm.h"
-#include "labcomm_private.h"
-#include "labcomm_ioctl.h"
-#include "labcomm_dynamic_buffer_writer.h"
-
-//define the following to disable encoding of typedefs
-#undef LABCOMM_WITHOUT_TYPE_DEFS
-
-struct labcomm_encoder {
-  struct labcomm_writer *writer;
-  struct labcomm_error_handler *error;
-  struct labcomm_memory *memory;
-  struct labcomm_scheduler *scheduler;
-  LABCOMM_SIGNATURE_ARRAY_DEF(registered, int);
-  LABCOMM_SIGNATURE_ARRAY_DEF(sample_ref, int);
-  LABCOMM_SIGNATURE_ARRAY_DEF(typedefs, int);
-};
-
-static struct labcomm_encoder *internal_encoder_new(
-  struct labcomm_writer *writer,
-  struct labcomm_error_handler *error,
-  struct labcomm_memory *memory,
-  struct labcomm_scheduler *scheduler,
-  labcomm_bool outputVer)
-{
-  struct labcomm_encoder *result;
-
-  result = labcomm_memory_alloc(memory, 0, sizeof(*result));
-  if (result) {
-    int length;
-
-    result->writer = writer;
-    result->writer->encoder = result;
-    result->writer->data = NULL;
-    result->writer->data_size = 0;
-    result->writer->count = 0;
-    result->writer->pos = 0;
-    result->writer->error = 0;
-    result->error = error;
-    result->memory = memory;
-    result->scheduler = scheduler;
-    LABCOMM_SIGNATURE_ARRAY_INIT(result->registered, int);
-    LABCOMM_SIGNATURE_ARRAY_INIT(result->sample_ref, int);
-    LABCOMM_SIGNATURE_ARRAY_INIT(result->typedefs, int);
-    labcomm_writer_alloc(result->writer,
-			 result->writer->action_context);
-    if(outputVer) {
-        labcomm_writer_start(result->writer,
-                            result->writer->action_context,
-                            LABCOMM_VERSION, NULL, CURRENT_VERSION);
-        labcomm_write_packed32(result->writer, LABCOMM_VERSION);
-        length = labcomm_size_string(CURRENT_VERSION);
-        labcomm_write_packed32(result->writer, length);
-        labcomm_write_string(result->writer, CURRENT_VERSION);
-        labcomm_writer_end(result->writer, result->writer->action_context);
-    }
-  }
-  return result;
-}
-
-struct labcomm_encoder *labcomm_encoder_new(
-  struct labcomm_writer *writer,
-  struct labcomm_error_handler *error,
-  struct labcomm_memory *memory,
-  struct labcomm_scheduler *scheduler)
-{
-    return internal_encoder_new(writer,error,memory,scheduler,TRUE);
-}
-void labcomm_encoder_free(struct labcomm_encoder* e)
-{
-  struct labcomm_memory *memory = e->memory;
-
-  labcomm_writer_free(e->writer, e->writer->action_context);
-  LABCOMM_SIGNATURE_ARRAY_FREE(e->memory, e->registered, int);
-  LABCOMM_SIGNATURE_ARRAY_FREE(e->memory, e->sample_ref, int);
-  LABCOMM_SIGNATURE_ARRAY_FREE(e->memory, e->typedefs, int);
-  labcomm_memory_free(memory, 0, e);
-}
-
-int labcomm_internal_encoder_register(
-  struct labcomm_encoder *e,
-  const struct labcomm_signature *signature,
-  labcomm_encoder_function encode)
-{
-  int result = -EINVAL;
-  int index, *done, err, i, length;
-
-  index = labcomm_get_local_index(signature);
-  labcomm_scheduler_writer_lock(e->scheduler);
-  if (index <= 0) { goto out; }
-  done = LABCOMM_SIGNATURE_ARRAY_REF(e->memory, e->registered, int, index);
-  if (*done) {
-      goto out; }
-  *done = 1;
-  err = labcomm_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; }
-  labcomm_write_packed32(e->writer, LABCOMM_SAMPLE_DEF);
-  length = (labcomm_size_packed32(index) +
-            labcomm_size_string(signature->name) +
-            labcomm_size_packed32(signature->size) +
-            signature->size);
-  labcomm_write_packed32(e->writer, length);
-  labcomm_write_packed32(e->writer, index);
-  labcomm_write_string(e->writer, signature->name);
-  labcomm_write_packed32(e->writer, signature->size);
-  for (i = 0 ; i < signature->size ; i++) {
-    if (e->writer->pos >= e->writer->count) {
-      labcomm_writer_flush(e->writer, e->writer->action_context);
-    }
-    e->writer->data[e->writer->pos] = signature->signature[i];
-    e->writer->pos++;
-  }
-  labcomm_writer_end(e->writer, e->writer->action_context);
-  result = e->writer->error;
-out:
-  labcomm_scheduler_writer_unlock(e->scheduler);
-  return result;
-}
-
-int labcomm_internal_encode(
-  struct labcomm_encoder *e,
-  const struct labcomm_signature *signature,
-  labcomm_encoder_function encode,
-  void *value)
-{
-  int result, index, length;
-
-  index = labcomm_get_local_index(signature);
-  length = (signature->encoded_size(value));
-  labcomm_scheduler_writer_lock(e->scheduler);
-  if (! LABCOMM_SIGNATURE_ARRAY_GET(e->registered, int, index, 0)) {
-    result = -EINVAL;
-    goto no_end;
-  }
-  result = labcomm_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 = labcomm_write_packed32(e->writer, index);
-  result = labcomm_write_packed32(e->writer, length);
-  if (result != 0) { goto out; }
-  result = encode(e->writer, value);
-out:
-  labcomm_writer_end(e->writer, e->writer->action_context);
-no_end:
-  labcomm_scheduler_writer_unlock(e->scheduler);
-  return result;
-}
-
-int labcomm_encoder_sample_ref_register(
-  struct labcomm_encoder *e,
-  const struct labcomm_signature *signature)
-{
-  int result = -EINVAL;
-  int index, *done, err, i, length;
-
-  index = labcomm_get_local_index(signature);
-  labcomm_scheduler_writer_lock(e->scheduler);
-  if (index <= 0) { goto out; }
-
-  done = LABCOMM_SIGNATURE_ARRAY_REF(e->memory, e->sample_ref, int, index);
-  if (*done) { goto out; }
-  *done = 1;
-  err = labcomm_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; }
-  labcomm_write_packed32(e->writer, LABCOMM_SAMPLE_REF);
-  length = (labcomm_size_packed32(index) +
-            labcomm_size_string(signature->name) +
-            labcomm_size_packed32(signature->size) +
-            signature->size);
-  labcomm_write_packed32(e->writer, length);
-  labcomm_write_packed32(e->writer, index);
-  labcomm_write_string(e->writer, signature->name);
-  labcomm_write_packed32(e->writer, signature->size);
-  for (i = 0 ; i < signature->size ; i++) {
-    if (e->writer->pos >= e->writer->count) {
-      labcomm_writer_flush(e->writer, e->writer->action_context);
-    }
-    e->writer->data[e->writer->pos] = signature->signature[i];
-    e->writer->pos++;
-  }
-  labcomm_writer_end(e->writer, e->writer->action_context);
-  result = e->writer->error;
-out:
-  labcomm_scheduler_writer_unlock(e->scheduler);
-  return result;
-}
-
-int labcomm_encoder_ioctl(struct labcomm_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 = labcomm_writer_ioctl(encoder->writer,
-			       encoder->writer->action_context,
-			       0, NULL, action, va);
-  va_end(va);
-
-out:
-  return result;
-}
-
-int labcomm_internal_encoder_ioctl(struct labcomm_encoder *encoder,
-				   const struct labcomm_signature *signature,
-				   uint32_t action, va_list va)
-{
-  int result = -ENOTSUP;
-  int index;
-
-  index = labcomm_get_local_index(signature);
-  result = labcomm_writer_ioctl(encoder->writer,
-				encoder->writer->action_context,
-				index, signature, action, va);
-  return result;
-}
-
-int labcomm_internal_encoder_signature_to_index(
-  struct labcomm_encoder *e, const struct labcomm_signature *signature)
-{
-  /* writer_lock should be held at this point */
-  int index = 0;
-  if (signature != NULL) {
-    index = labcomm_get_local_index(signature);
-    if (! LABCOMM_SIGNATURE_ARRAY_GET(e->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 labcomm_signature *signature,
-                           void *context)
-{
-  struct labcomm_encoder *e = context;
-  if(signature) {
-    labcomm_write_packed32(e->writer, labcomm_get_local_index(signature));
-  }else {
-    if (e->writer->pos >= e->writer->count) {
-     labcomm_writer_flush(e->writer, e->writer->action_context);
-    }
-    e->writer->data[e->writer->pos] = b;
-    e->writer->pos++;
-  }
-}
-
-static void do_write_signature(struct labcomm_encoder * e, 
-                               const struct labcomm_signature *signature, 
-                               unsigned char flatten)
-{
-  map_signature(write_sig_tree_byte, e, signature, flatten);
-}
-
-static void sig_size(char b, const struct labcomm_signature *signature,
-                     void *context)
-{
-  int *result = context;
-  int diff;
-  if(signature) {
-    int idx = labcomm_get_local_index(signature);
-    diff = labcomm_size_packed32(idx);
-  }else {
-    diff = 1;
-  }
-    (*result)+=diff;
-}
-
-static int calc_sig_encoded_size(struct labcomm_encoder *e,
-                                 const struct labcomm_signature *sig)
-{
-  int result=0;
-  map_signature(sig_size, &result, sig, FALSE);
-  return result;
-}
-
-static int internal_reg_type(
-  struct labcomm_encoder *e,
-  const struct labcomm_signature *signature,
-  labcomm_bool flatten)
-{
-  int result = -EINVAL;
-  int index, *done, err;
-
-  index = labcomm_get_local_index(signature);
-  labcomm_scheduler_writer_lock(e->scheduler);
-  if (index <= 0) { goto out; }
-  done = LABCOMM_SIGNATURE_ARRAY_REF(e->memory, e->typedefs, int, index);
-  if (*done) { goto out; }
-  *done = 1;
-  err = labcomm_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; }
-
-  int sig_size = calc_sig_encoded_size(e, signature);
-  int len =  labcomm_size_packed32(index) +
-             labcomm_size_string(signature->name) +
-             labcomm_size_packed32(sig_size) +
-              sig_size;
-
-  labcomm_write_packed32(e->writer, LABCOMM_TYPE_DEF);
-  labcomm_write_packed32(e->writer, len);
-  labcomm_write_packed32(e->writer, index);
-  labcomm_write_string(e->writer, signature->name);
-  labcomm_write_packed32(e->writer, sig_size);
-  do_write_signature(e, signature, FALSE);
-
-  labcomm_writer_end(e->writer, e->writer->action_context);
-  result = e->writer->error;
-out:
-  labcomm_scheduler_writer_unlock(e->scheduler);
-  return result;
-}
-#endif
-
-int labcomm_internal_encoder_type_register(
-  struct labcomm_encoder *e,
-  const struct labcomm_signature *signature)
-{
-#ifndef LABCOMM_WITHOUT_TYPE_DEFS
-  return internal_reg_type(e, signature, FALSE);
-#else
-  return 0;
-#endif
-}
-int labcomm_internal_encoder_type_bind(
-  struct labcomm_encoder *e,
-  const struct labcomm_signature *signature,
-  char has_deps)
-{
-#ifndef LABCOMM_WITHOUT_TYPE_DEFS
-  int result = -EINVAL;
-  int err;
-  int sindex = labcomm_get_local_index(signature);
-  int tindex = has_deps ? labcomm_get_local_type_index(signature) : LABCOMM_BIND_SELF;
-  labcomm_scheduler_writer_lock(e->scheduler);
-  if(sindex <= 0 || (has_deps && tindex <= 0)) {goto out;}
-  err = labcomm_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 = (labcomm_size_packed32(sindex) +
-                labcomm_size_packed32(tindex));
-  labcomm_write_packed32(e->writer, LABCOMM_TYPE_BINDING);
-  labcomm_write_packed32(e->writer, length);
-  labcomm_write_packed32(e->writer, sindex);
-  labcomm_write_packed32(e->writer, tindex);
-  labcomm_writer_end(e->writer, e->writer->action_context);
-  result = e->writer->error;
-
-out:
-  labcomm_scheduler_writer_unlock(e->scheduler);
-  return result;
-#else
-  return 0;
-#endif
-}
diff --git a/lib/c/2014/labcomm_scheduler_private.h b/lib/c/2014/labcomm_scheduler_private.h
deleted file mode 100644
index 46b108d..0000000
--- a/lib/c/2014/labcomm_scheduler_private.h
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
-  labcomm_scheduler.h -- labcomm task coordination, semi-private part
-
-  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 __LABCOMM_SCHEDULER_PRIVATE_H__
-#define __LABCOMM_SCHEDULER_PRIVATE_H__
-
-#ifdef LABCOMM_COMPAT
-  #include LABCOMM_COMPAT
-#else
-  #include <unistd.h>
-#endif
-
-#include "labcomm_scheduler.h"
-
-struct labcomm_time {
-  const struct labcomm_time_action {
-    int (*free)(struct labcomm_time *t);
-    int (*add_usec)(struct labcomm_time *t, uint32_t usec);
-  } *action;
-  void *context;
-};
-
-struct labcomm_scheduler {
-  const struct labcomm_scheduler_action {
-    int (*free)(struct labcomm_scheduler *s);
-    int (*writer_lock)(struct labcomm_scheduler *s);
-    int (*writer_unlock)(struct labcomm_scheduler *s);
-    int (*data_lock)(struct labcomm_scheduler *s);
-    int (*data_unlock)(struct labcomm_scheduler *s);
-    struct labcomm_time *(*now)(struct labcomm_scheduler *s);
-    int (*sleep)(struct labcomm_scheduler *s,
-		 struct labcomm_time *wakeup);
-    int (*wakeup)(struct labcomm_scheduler *s);
-    int (*enqueue)(struct labcomm_scheduler *s,
-		   uint32_t delay,
-		   void (*deferred)(void *context),
-		   void *context);
-  } *action;
-  void *context;
-};
-
-#endif
diff --git a/lib/c/2014/test/test_labcomm.c b/lib/c/2014/test/test_labcomm.c
index c852677..de36a7f 100644
--- a/lib/c/2014/test/test_labcomm.c
+++ b/lib/c/2014/test/test_labcomm.c
@@ -1,5 +1,5 @@
 /*
-  test_labcomm.c -- Various labcomm tests
+  test_labcomm2014.c -- Various labcomm2014 tests
 
   Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
 
@@ -24,19 +24,19 @@
 #include <string.h>
 #include <stdlib.h>
 #include <errno.h>
-#include "labcomm_private.h"
-#include "labcomm_default_error_handler.h"
-#include "labcomm_default_memory.h"
-#include "labcomm_default_scheduler.h"
+#include "labcomm2014_private.h"
+#include "labcomm2014_default_error_handler.h"
+#include "labcomm2014_default_memory.h"
+#include "labcomm2014_default_scheduler.h"
 #include "test/gen/test_sample.h"
 
-static struct labcomm_writer writer;
+static struct labcomm2014_writer writer;
 
 static struct expect {
   char *description;
   int result;
-  int (*trampoline)(struct labcomm_decoder *context);
-  struct labcomm_decoder *context;
+  int (*trampoline)(struct labcomm2014_decoder *context);
+  struct labcomm2014_decoder *context;
 } *expect;
 
 static void check_expect()
@@ -70,8 +70,8 @@ static void check_expect()
 
 static unsigned char buffer[512];
 
-static int writer_alloc(struct labcomm_writer *w, 
-			struct labcomm_writer_action_context *action_context)
+static int writer_alloc(struct labcomm2014_writer *w, 
+			struct labcomm2014_writer_action_context *action_context)
 {
   w->data = buffer;
   w->data_size = sizeof(buffer);
@@ -80,35 +80,35 @@ static int writer_alloc(struct labcomm_writer *w,
   return 0;
 }
 
-static int writer_start(struct labcomm_writer *w, 
-			 struct labcomm_writer_action_context *action_context,
-			 int index, const struct labcomm_signature *signature,
+static int writer_start(struct labcomm2014_writer *w, 
+			 struct labcomm2014_writer_action_context *action_context,
+			 int index, const struct labcomm2014_signature *signature,
 			 void *value)
 {
   return 0;
 }
 
 static int buf_writer_end(
-  struct labcomm_writer *w, 
-  struct labcomm_writer_action_context *action_context)
+  struct labcomm2014_writer *w, 
+  struct labcomm2014_writer_action_context *action_context)
 {
   check_expect();
   return 0;
 }
 
-const struct labcomm_writer_action writer_action = {
+const struct labcomm2014_writer_action writer_action = {
   .alloc = writer_alloc,
   .start = writer_start,
   .end = buf_writer_end,
 };
 
-static struct labcomm_writer_action_context writer_action_context = {
+static struct labcomm2014_writer_action_context writer_action_context = {
   .next = NULL,
   .action = &writer_action,
   .context = NULL
 }; 
 
-static struct labcomm_writer writer =  {
+static struct labcomm2014_writer writer =  {
   .action_context = &writer_action_context,
   .data = buffer,
   .data_size = sizeof(buffer),
@@ -117,36 +117,36 @@ static struct labcomm_writer writer =  {
   .error = 0,
 };
 
-static int reader_alloc(struct labcomm_reader *r, 
-			struct labcomm_reader_action_context *action_context)
+static int reader_alloc(struct labcomm2014_reader *r, 
+			struct labcomm2014_reader_action_context *action_context)
 {
   r->data = buffer;
   r->data_size = sizeof(buffer);
   r->count = 0;
-  r->memory = labcomm_default_memory;
+  r->memory = labcomm2014_default_memory;
   
   return 0;
 }
 
-static int reader_fill(struct labcomm_reader *r, 
-		       struct labcomm_reader_action_context *action_context)
+static int reader_fill(struct labcomm2014_reader *r, 
+		       struct labcomm2014_reader_action_context *action_context)
 {
   r->error = -ENOMEM;
   return r->error;
 }
 
-const struct labcomm_reader_action reader_action = {
+const struct labcomm2014_reader_action reader_action = {
   .alloc = reader_alloc,
   .fill = reader_fill,
 };
 
-static struct labcomm_reader_action_context reader_action_context = {
+static struct labcomm2014_reader_action_context reader_action_context = {
   .next = NULL,
   .action = &reader_action,
   .context = NULL
 }; 
 
-static struct labcomm_reader reader =  {
+static struct labcomm2014_reader reader =  {
   .action_context = &reader_action_context,
   .data = buffer,
   .data_size = sizeof(buffer),
@@ -174,14 +174,14 @@ void handle_test_var(test_sample_test_var *v, void *ctx)
   decoder_var.a[0] = v->a[0];  
 }
 
-int test_decode_one(struct labcomm_decoder *decoder)
+int test_decode_one(struct labcomm2014_decoder *decoder)
 {
   int result;
 
   for (reader.count = 0 ; reader.count < writer.pos ; reader.count++) {
     reader.error = 0;
     reader.pos = 0;
-    result = labcomm_decoder_decode_one(decoder); 
+    result = labcomm2014_decoder_decode_one(decoder); 
     if (result >= 0 ) {
       fprintf(stderr,
               "Got result from buffer with bogus length (%d, %d != %d)\n",
@@ -192,7 +192,7 @@ int test_decode_one(struct labcomm_decoder *decoder)
   reader.error = 0;
   reader.pos = 0;
   reader.count = writer.pos;
-  result = labcomm_decoder_decode_one(decoder);
+  result = labcomm2014_decoder_decode_one(decoder);
   if (result < 0) {
     fprintf(stderr, "Got no result from buffer with correct length (%d)\n",
 	    result);
@@ -201,8 +201,8 @@ int test_decode_one(struct labcomm_decoder *decoder)
   return result;
 }
 
-static void test_encode_decode(struct labcomm_encoder *encoder,
-			       struct labcomm_decoder *decoder,
+static void test_encode_decode(struct labcomm2014_encoder *encoder,
+			       struct labcomm2014_decoder *decoder,
 			       int expected, uint32_t n_0, uint32_t n_2)
 {
   int err;
@@ -211,14 +211,14 @@ static void test_encode_decode(struct labcomm_encoder *encoder,
   encoder_var.n_0 = n_0;
   encoder_var.n_2 = n_2;
   encoder_var.a[0] = 314;
-  labcomm_encode_test_sample_test_var(encoder, &encoder_var);
+  labcomm2014_encode_test_sample_test_var(encoder, &encoder_var);
   err = test_decode_one(decoder);
   fprintf(stderr, "decode of sample %u * 2 * %u -> size=%d err=%d\n", 
 	  n_0, n_2, writer.pos, err);
-  if (writer.pos != labcomm_sizeof_test_sample_test_var(&encoder_var)) {
+  if (writer.pos != labcomm2014_sizeof_test_sample_test_var(&encoder_var)) {
     fprintf(stderr, "Incorrect sizeof %u * 2 * %u (%d != %d)\n",
 	    n_0, n_2, 
-	    writer.pos, labcomm_sizeof_test_sample_test_var(&encoder_var));
+	    writer.pos, labcomm2014_sizeof_test_sample_test_var(&encoder_var));
     exit(1);
   }
   if (writer.pos != expected) {
@@ -232,22 +232,22 @@ static void test_encode_decode(struct labcomm_encoder *encoder,
 int main(void)
 {
   int i;
-  struct labcomm_decoder *decoder = labcomm_decoder_new(
+  struct labcomm2014_decoder *decoder = labcomm2014_decoder_new(
     &reader,
-    labcomm_default_error_handler,
-    labcomm_default_memory,
-    labcomm_default_scheduler);
+    labcomm2014_default_error_handler,
+    labcomm2014_default_memory,
+    labcomm2014_default_scheduler);
   struct expect expect_version[] = {
     { "Version", 1, test_decode_one, decoder },
     { 0, 0, 0 }
   };
   expect = expect_version;
-  struct labcomm_encoder *encoder = labcomm_encoder_new(
+  struct labcomm2014_encoder *encoder = labcomm2014_encoder_new(
     &writer, 
-    labcomm_default_error_handler,
-    labcomm_default_memory,
-    labcomm_default_scheduler);
-  labcomm_decoder_register_test_sample_test_var(decoder,
+    labcomm2014_default_error_handler,
+    labcomm2014_default_memory,
+    labcomm2014_default_scheduler);
+  labcomm2014_decoder_register_test_sample_test_var(decoder,
 						handle_test_var, 
 						NULL);
   struct expect expect_registration[] = {
@@ -259,7 +259,7 @@ int main(void)
     { 0, 0, 0 }
   };
   expect = expect_registration;
-  labcomm_encoder_register_test_sample_test_var(encoder);
+  labcomm2014_encoder_register_test_sample_test_var(encoder);
   test_encode_decode(encoder, decoder, 12, 1, 1);
   if (decoder_var.a[0] != encoder_var.a[0]) {
     fprintf(stderr, "Failed to decode correct value %d != %d\n", 
diff --git a/lib/c/2014/test/test_labcomm_basic_type_encoding.c b/lib/c/2014/test/test_labcomm_basic_type_encoding.c
index b964c98..29079df 100644
--- a/lib/c/2014/test/test_labcomm_basic_type_encoding.c
+++ b/lib/c/2014/test/test_labcomm_basic_type_encoding.c
@@ -1,5 +1,5 @@
 /*
-  test_labcomm_basic_type_encoding.c -- LabComm tests of basic encoding
+  test_labcomm2014_basic_type_encoding.c -- LabComm tests of basic encoding
 
   Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
 
@@ -23,13 +23,13 @@
 #include <inttypes.h>
 #include <string.h>
 #include <stdlib.h>
-#include "labcomm_private.h"
+#include "labcomm2014_private.h"
 
 static int line;
 
 static unsigned char buffer[128];
 
-static struct labcomm_writer writer =  {
+static struct labcomm2014_writer writer =  {
   .action_context = NULL,
   .data = buffer,
   .data_size = sizeof(buffer),
@@ -38,7 +38,7 @@ static struct labcomm_writer writer =  {
   .error = 0,
 };
 
-static struct labcomm_reader reader =  {
+static struct labcomm2014_reader reader =  {
   .action_context = NULL,
   .data = buffer,
   .data_size = sizeof(buffer),
@@ -53,11 +53,11 @@ typedef uint32_t packed32;
     type decoded;							\
     line = __LINE__;							\
     writer.pos = 0;							\
-    labcomm_write_##ltype(&writer, value);				\
+    labcomm2014_write_##ltype(&writer, value);				\
     writer_assert(#ltype, expect_count, (uint8_t*)expect_bytes);	\
     reader.count = writer.pos;						\
     reader.pos = 0;							\
-    decoded = labcomm_read_##ltype(&reader);				\
+    decoded = labcomm2014_read_##ltype(&reader);				\
     if (decoded != value) {						\
       fprintf(stderr, "Decode error" format " != " format " @%s:%d \n", \
 	      value, decoded, __FILE__, __LINE__);					\
diff --git a/lib/c/2014/test/test_labcomm_copy.c b/lib/c/2014/test/test_labcomm_copy.c
index 9261e66..d26ef96 100644
--- a/lib/c/2014/test/test_labcomm_copy.c
+++ b/lib/c/2014/test/test_labcomm_copy.c
@@ -7,13 +7,13 @@
 #include <assert.h>
 #include <err.h>
 
-#include "labcomm.h"
-#include "labcomm_private.h"
-#include "labcomm_default_error_handler.h"
-#include "labcomm_default_memory.h"
-#include "labcomm_default_scheduler.h"
-#include "labcomm_fd_writer.h"
-#include "labcomm_fd_reader.h"
+#include "labcomm2014.h"
+#include "labcomm2014_private.h"
+#include "labcomm2014_default_error_handler.h"
+#include "labcomm2014_default_memory.h"
+#include "labcomm2014_default_scheduler.h"
+#include "labcomm2014_fd_writer.h"
+#include "labcomm2014_fd_reader.h"
 #include "test/gen/generated_encoding.h"
 #include "test/gen/test_sample.h"
 #include "test/gen/more_types.h"
@@ -22,58 +22,58 @@
 
 static void handle_s1(generated_encoding_S1 *v, void *context)
 {
-  labcomm_copy_generated_encoding_S1(labcomm_default_memory, context, v);
+  labcomm2014_copy_generated_encoding_S1(labcomm2014_default_memory, context, v);
 }
 
 static void handle_b(generated_encoding_B *v, void *context)
 {
-  labcomm_copy_generated_encoding_B(labcomm_default_memory, context, v);
+  labcomm2014_copy_generated_encoding_B(labcomm2014_default_memory, context, v);
 }
 
 static void handle_i(generated_encoding_I *v, void *context)
 {
-  labcomm_copy_generated_encoding_I(labcomm_default_memory, context, v);
+  labcomm2014_copy_generated_encoding_I(labcomm2014_default_memory, context, v);
 }
 
 static void handle_p(generated_encoding_P *v, void *context)
 {
-  labcomm_copy_generated_encoding_P(labcomm_default_memory, context, v);
+  labcomm2014_copy_generated_encoding_P(labcomm2014_default_memory, context, v);
 }
 
 static void handle_r(generated_encoding_R *v, void *context)
 {
-  labcomm_copy_generated_encoding_R(labcomm_default_memory, context, v);
+  labcomm2014_copy_generated_encoding_R(labcomm2014_default_memory, context, v);
 }
 
 static void handle_test_var(test_sample_test_var *v, void *context)
 {
-  labcomm_copy_test_sample_test_var(labcomm_default_memory, context, v);
+  labcomm2014_copy_test_sample_test_var(labcomm2014_default_memory, context, v);
 }
 
 static void handle_a(more_types_A *v, void *context)
 {
-  labcomm_copy_more_types_A(labcomm_default_memory, context, v);
+  labcomm2014_copy_more_types_A(labcomm2014_default_memory, context, v);
 }
 
 static void handle_s(more_types_S *v, void *context)
 {
-  labcomm_copy_more_types_S(labcomm_default_memory, context, v);
+  labcomm2014_copy_more_types_S(labcomm2014_default_memory, context, v);
 }
 
 static void handle_ns(more_types_NS *v, void *context)
 {
-  labcomm_copy_more_types_NS(labcomm_default_memory, context, v);
+  labcomm2014_copy_more_types_NS(labcomm2014_default_memory, context, v);
 }
 
 static void handle_as(more_types_AS *v, void *context)
 {
-  labcomm_copy_more_types_AS(labcomm_default_memory, context, v);
+  labcomm2014_copy_more_types_AS(labcomm2014_default_memory, context, v);
 }
 
 int main(int argc, char **argv)
 {
-  struct labcomm_encoder *encoder;
-  struct labcomm_decoder *decoder;
+  struct labcomm2014_encoder *encoder;
+  struct labcomm2014_decoder *decoder;
   int fd;
   generated_encoding_S1 s1;
   generated_encoding_S1 cache_s1;
@@ -100,35 +100,35 @@ int main(int argc, char **argv)
   if (fd == -1)
     err(1, "open()");
   encoder =
-    labcomm_encoder_new(labcomm_fd_writer_new(labcomm_default_memory, fd, 0),
-			labcomm_default_error_handler,
-			labcomm_default_memory,
-			labcomm_default_scheduler);
+    labcomm2014_encoder_new(labcomm2014_fd_writer_new(labcomm2014_default_memory, fd, 0),
+			labcomm2014_default_error_handler,
+			labcomm2014_default_memory,
+			labcomm2014_default_scheduler);
 
-  labcomm_encoder_register_generated_encoding_S1(encoder);
+  labcomm2014_encoder_register_generated_encoding_S1(encoder);
   s1.i = 1;
-  labcomm_encode_generated_encoding_S1(encoder, &s1);
+  labcomm2014_encode_generated_encoding_S1(encoder, &s1);
 
-  labcomm_encoder_register_generated_encoding_B(encoder);
+  labcomm2014_encoder_register_generated_encoding_B(encoder);
   b = 2;
-  labcomm_encode_generated_encoding_B(encoder, &b);
+  labcomm2014_encode_generated_encoding_B(encoder, &b);
 
-  labcomm_encoder_register_generated_encoding_I(encoder);
+  labcomm2014_encoder_register_generated_encoding_I(encoder);
   I.n_0 = 3;
   I.a = calloc(I.n_0, sizeof(I.a[0]));
   I.a[0] = 4;
   I.a[1] = 5;
   I.a[2] = 6;
-  labcomm_encode_generated_encoding_I(encoder, &I);
+  labcomm2014_encode_generated_encoding_I(encoder, &I);
 
-  labcomm_encoder_register_generated_encoding_P(encoder);
+  labcomm2014_encoder_register_generated_encoding_P(encoder);
   p.n_0 = 7;
   p.a = calloc(p.n_0, sizeof(p.a[0]));
   for (int i = 0; i < p.n_0; i++)
     p.a[i].i = 8 + i;
-  labcomm_encode_generated_encoding_P(encoder, &p);
+  labcomm2014_encode_generated_encoding_P(encoder, &p);
 
-  labcomm_encoder_register_test_sample_test_var(encoder);
+  labcomm2014_encoder_register_test_sample_test_var(encoder);
   test_var.n_0 = 2;
   test_var.n_2 = 7;
   test_var.a = calloc(test_var.n_0 * 2 * test_var.n_2, sizeof(*test_var.a));
@@ -137,67 +137,67 @@ int main(int argc, char **argv)
       for (int k = 0; k < test_var.n_2; k++) {
         test_var.a[(((i) * 2 + j) * test_var.n_2) + k] = 100 * i + 10 * j + k;
       }
-  labcomm_encode_test_sample_test_var(encoder, &test_var);
+  labcomm2014_encode_test_sample_test_var(encoder, &test_var);
 
-  labcomm_encoder_register_more_types_A(encoder);
+  labcomm2014_encoder_register_more_types_A(encoder);
   for (int i = 0; i < sizeof(a.a) / sizeof(a.a[0]); i++)
     a.a[i] = i;
-  labcomm_encode_more_types_A(encoder, &a);
+  labcomm2014_encode_more_types_A(encoder, &a);
 
-  labcomm_encoder_register_more_types_S(encoder);
+  labcomm2014_encoder_register_more_types_S(encoder);
   s = "this is a string";
-  labcomm_encode_more_types_S(encoder, &s);
+  labcomm2014_encode_more_types_S(encoder, &s);
 
-  labcomm_encoder_register_more_types_NS(encoder);
+  labcomm2014_encoder_register_more_types_NS(encoder);
   ns.s1 = "this is a string";
   ns.s2 = "this is a another string";
-  labcomm_encode_more_types_NS(encoder, &ns);
+  labcomm2014_encode_more_types_NS(encoder, &ns);
 
-  labcomm_encoder_register_more_types_AS(encoder);
+  labcomm2014_encoder_register_more_types_AS(encoder);
   as.n_0 = 3;
   as.a = calloc(as.n_0, sizeof(as.a[0]));
   as.a[0] = "string 0";
   as.a[1] = "string 1";
   as.a[2] = "string 2";
-  labcomm_encode_more_types_AS(encoder, &as);
-
-  labcomm_encoder_register_generated_encoding_R(encoder);
-  labcomm_encoder_sample_ref_register(encoder, labcomm_signature_generated_encoding_V);
-  labcomm_encoder_sample_ref_register(encoder, 
-                                      labcomm_signature_generated_encoding_UnusedD);
-  labcomm_encoder_sample_ref_register(encoder, labcomm_signature_generated_encoding_R);
-  r.a[0] = labcomm_signature_generated_encoding_V;
-  r.a[1] = labcomm_signature_generated_encoding_UnusedE;
-  r.a[2] = labcomm_signature_generated_encoding_UnusedD;
-  r.a[3] = labcomm_signature_generated_encoding_R;
-  labcomm_encode_generated_encoding_R(encoder, &r);
-
-  labcomm_encoder_free(encoder);
+  labcomm2014_encode_more_types_AS(encoder, &as);
+
+  labcomm2014_encoder_register_generated_encoding_R(encoder);
+  labcomm2014_encoder_sample_ref_register(encoder, labcomm2014_signature_generated_encoding_V);
+  labcomm2014_encoder_sample_ref_register(encoder, 
+                                      labcomm2014_signature_generated_encoding_UnusedD);
+  labcomm2014_encoder_sample_ref_register(encoder, labcomm2014_signature_generated_encoding_R);
+  r.a[0] = labcomm2014_signature_generated_encoding_V;
+  r.a[1] = labcomm2014_signature_generated_encoding_UnusedE;
+  r.a[2] = labcomm2014_signature_generated_encoding_UnusedD;
+  r.a[3] = labcomm2014_signature_generated_encoding_R;
+  labcomm2014_encode_generated_encoding_R(encoder, &r);
+
+  labcomm2014_encoder_free(encoder);
   encoder = NULL;
   lseek(fd, 0, SEEK_SET);
   decoder =
-    labcomm_decoder_new(labcomm_fd_reader_new(labcomm_default_memory, fd, 0),
-			labcomm_default_error_handler,
-			labcomm_default_memory,
-			labcomm_default_scheduler);
-
-  labcomm_decoder_register_generated_encoding_S1(decoder, handle_s1, &cache_s1);
-  labcomm_decoder_register_generated_encoding_B(decoder, handle_b, &cache_b);
-  labcomm_decoder_register_generated_encoding_I(decoder, handle_i, &cache_I);
-  labcomm_decoder_register_generated_encoding_P(decoder, handle_p, &cache_p);
-  labcomm_decoder_register_test_sample_test_var(decoder, handle_test_var,
+    labcomm2014_decoder_new(labcomm2014_fd_reader_new(labcomm2014_default_memory, fd, 0),
+			labcomm2014_default_error_handler,
+			labcomm2014_default_memory,
+			labcomm2014_default_scheduler);
+
+  labcomm2014_decoder_register_generated_encoding_S1(decoder, handle_s1, &cache_s1);
+  labcomm2014_decoder_register_generated_encoding_B(decoder, handle_b, &cache_b);
+  labcomm2014_decoder_register_generated_encoding_I(decoder, handle_i, &cache_I);
+  labcomm2014_decoder_register_generated_encoding_P(decoder, handle_p, &cache_p);
+  labcomm2014_decoder_register_test_sample_test_var(decoder, handle_test_var,
 						&cache_test_var);
-  labcomm_decoder_register_more_types_A(decoder, handle_a, &cache_a);
-  labcomm_decoder_register_more_types_S(decoder, handle_s, &cache_s);
-  labcomm_decoder_register_more_types_NS(decoder, handle_ns, &cache_ns);
-  labcomm_decoder_register_more_types_AS(decoder, handle_as, &cache_as);
-  labcomm_decoder_register_generated_encoding_R(decoder, handle_r, &cache_r);
-  labcomm_decoder_sample_ref_register(decoder, labcomm_signature_generated_encoding_V);
-  labcomm_decoder_sample_ref_register(decoder, 
-                                      labcomm_signature_generated_encoding_UnusedE);
-  labcomm_decoder_sample_ref_register(decoder, labcomm_signature_generated_encoding_R);
-
-  while (labcomm_decoder_decode_one(decoder) > 0) ;
+  labcomm2014_decoder_register_more_types_A(decoder, handle_a, &cache_a);
+  labcomm2014_decoder_register_more_types_S(decoder, handle_s, &cache_s);
+  labcomm2014_decoder_register_more_types_NS(decoder, handle_ns, &cache_ns);
+  labcomm2014_decoder_register_more_types_AS(decoder, handle_as, &cache_as);
+  labcomm2014_decoder_register_generated_encoding_R(decoder, handle_r, &cache_r);
+  labcomm2014_decoder_sample_ref_register(decoder, labcomm2014_signature_generated_encoding_V);
+  labcomm2014_decoder_sample_ref_register(decoder, 
+                                      labcomm2014_signature_generated_encoding_UnusedE);
+  labcomm2014_decoder_sample_ref_register(decoder, labcomm2014_signature_generated_encoding_R);
+
+  while (labcomm2014_decoder_decode_one(decoder) > 0) ;
 
   printf("cache_s1.i = %d, s1.i = %d\n", cache_s1.i, s1.i);
   assert(cache_s1.i == s1.i);
@@ -258,26 +258,26 @@ int main(int argc, char **argv)
   assert(cache_r.a[3] == r.a[3]);
   puts("R copied ok");
 
-  labcomm_decoder_free(decoder);
+  labcomm2014_decoder_free(decoder);
   close(fd);
   unlink(DATA_FILE);
 
-  labcomm_copy_free_generated_encoding_S1(labcomm_default_memory, &cache_s1);
+  labcomm2014_copy_free_generated_encoding_S1(labcomm2014_default_memory, &cache_s1);
   puts("S1 deallocated ok");
-  labcomm_copy_free_generated_encoding_B(labcomm_default_memory, &cache_b);
+  labcomm2014_copy_free_generated_encoding_B(labcomm2014_default_memory, &cache_b);
   puts("B deallocated ok");
-  labcomm_copy_free_generated_encoding_I(labcomm_default_memory, &cache_I);
+  labcomm2014_copy_free_generated_encoding_I(labcomm2014_default_memory, &cache_I);
   puts("I deallocated ok");
-  labcomm_copy_free_generated_encoding_P(labcomm_default_memory, &cache_p);
+  labcomm2014_copy_free_generated_encoding_P(labcomm2014_default_memory, &cache_p);
   puts("P deallocated ok");
-  labcomm_copy_free_test_sample_test_var(labcomm_default_memory, &cache_test_var);
+  labcomm2014_copy_free_test_sample_test_var(labcomm2014_default_memory, &cache_test_var);
   puts("test_var deallocated ok");
-  labcomm_copy_free_more_types_A(labcomm_default_memory, &cache_a);
+  labcomm2014_copy_free_more_types_A(labcomm2014_default_memory, &cache_a);
   puts("A deallocated ok");
-  labcomm_copy_free_more_types_S(labcomm_default_memory, &cache_s);
+  labcomm2014_copy_free_more_types_S(labcomm2014_default_memory, &cache_s);
   puts("S deallocated ok");
-  labcomm_copy_free_more_types_NS(labcomm_default_memory, &cache_ns);
+  labcomm2014_copy_free_more_types_NS(labcomm2014_default_memory, &cache_ns);
   puts("NS deallocated ok");
-  labcomm_copy_free_more_types_AS(labcomm_default_memory, &cache_as);
+  labcomm2014_copy_free_more_types_AS(labcomm2014_default_memory, &cache_as);
   puts("AS deallocated ok");
 }
diff --git a/lib/c/2014/test/test_labcomm_generated_encoding.c b/lib/c/2014/test/test_labcomm_generated_encoding.c
index 11f9d7c..f728ac0 100644
--- a/lib/c/2014/test/test_labcomm_generated_encoding.c
+++ b/lib/c/2014/test/test_labcomm_generated_encoding.c
@@ -1,5 +1,5 @@
 /*
-  test_labcomm_generated_encoding.c -- LabComm tests of generated encoding
+  test_labcomm2014_generated_encoding.c -- LabComm tests of generated encoding
 
   Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
 
@@ -23,19 +23,19 @@
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
-#include "labcomm_private.h"
-#include "labcomm_default_error_handler.h"
-#include "labcomm_default_memory.h"
-#include "labcomm_pthread_scheduler.h"
+#include "labcomm2014_private.h"
+#include "labcomm2014_default_error_handler.h"
+#include "labcomm2014_default_memory.h"
+#include "labcomm2014_pthread_scheduler.h"
 #include "test/gen/generated_encoding.h"
 
 #define IOCTL_WRITER_ASSERT_BYTES 4096
 #define IOCTL_WRITER_RESET 4097
 
 #define EXPECT(...)							\
-  {									\
+  {                                                                     \
     int expected[] = __VA_ARGS__;					\
-    labcomm_encoder_ioctl(encoder, IOCTL_WRITER_ASSERT_BYTES,		\
+    labcomm2014_encoder_ioctl(encoder, IOCTL_WRITER_ASSERT_BYTES,       \
 			  __LINE__,					\
 			  sizeof(expected)/sizeof(expected[0]),		\
 			  expected);					\
@@ -45,12 +45,12 @@
 #define IS_VARIABLE(i) (i < 0)
 
 static unsigned char buffer[128];
-struct labcomm_writer *writer;
+struct labcomm2014_writer *writer;
 static int seen_variable[1024];
 
 static int buf_writer_alloc(
-  struct labcomm_writer *w, 
-  struct labcomm_writer_action_context *action_context)
+  struct labcomm2014_writer *w, 
+  struct labcomm2014_writer_action_context *action_context)
 {
   writer = w; /* Hack */
   w->data_size = sizeof(buffer);
@@ -62,32 +62,32 @@ static int buf_writer_alloc(
 }
 
 static int buf_writer_free(
-  struct labcomm_writer *w, 
-  struct labcomm_writer_action_context *action_context)
+  struct labcomm2014_writer *w, 
+  struct labcomm2014_writer_action_context *action_context)
 {
   return 0;
 }
 
 static int buf_writer_start(
-  struct labcomm_writer *w,
-  struct labcomm_writer_action_context *action_context,
+  struct labcomm2014_writer *w,
+  struct labcomm2014_writer_action_context *action_context,
   int index,
-  const struct labcomm_signature *signature,
+  const struct labcomm2014_signature *signature,
   void *value)
 {
   return 0;
 }
 
 static int buf_writer_end(
-  struct labcomm_writer *w, 
-  struct labcomm_writer_action_context *action_context)
+  struct labcomm2014_writer *w, 
+  struct labcomm2014_writer_action_context *action_context)
 {
   return 0;
 }
 
 static int buf_writer_flush(
-  struct labcomm_writer *w, 
-  struct labcomm_writer_action_context *action_context)
+  struct labcomm2014_writer *w, 
+  struct labcomm2014_writer_action_context *action_context)
 {
   fprintf(stderr, "Should not come here %s:%d\n", __FILE__, __LINE__);
   exit(1);
@@ -96,9 +96,9 @@ static int buf_writer_flush(
 }
 
 static int buf_writer_ioctl(
-  struct labcomm_writer *w, 
-  struct labcomm_writer_action_context *action_context,
-  int signature_index, const struct labcomm_signature *signature,
+  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;
@@ -157,7 +157,7 @@ static int buf_writer_ioctl(
   return result;
 }
 
-const struct labcomm_writer_action writer_action = {
+const struct labcomm2014_writer_action writer_action = {
   .alloc = buf_writer_alloc,
   .free = buf_writer_free,
   .start = buf_writer_start,
@@ -166,12 +166,12 @@ const struct labcomm_writer_action writer_action = {
   .ioctl = buf_writer_ioctl
 };
 
-static struct labcomm_writer_action_context action_context = {
+static struct labcomm2014_writer_action_context action_context = {
   .next = NULL,
   .action = &writer_action,
   .context = NULL
 }; 
-static struct labcomm_writer buffer_writer = {
+static struct labcomm2014_writer buffer_writer = {
   .action_context = &action_context,
   .data = buffer,
   .data_size = sizeof(buffer),
@@ -180,7 +180,7 @@ static struct labcomm_writer buffer_writer = {
   .error = 0,
 };
 
-void dump_encoder(struct labcomm_encoder *encoder)
+void dump_encoder(struct labcomm2014_encoder *encoder)
 {
   int i;
   
@@ -194,83 +194,83 @@ int main(void)
 {
   generated_encoding_B B = 1;
   generated_encoding_R R;
-  struct labcomm_encoder *encoder;
+  struct labcomm2014_encoder *encoder;
   int i;
 
   for (i = 0 ; i < sizeof(seen_variable)/sizeof(seen_variable[0]) ; i++) {
     seen_variable[i] = -1;
   }
 
-  encoder = labcomm_encoder_new(
+  encoder = labcomm2014_encoder_new(
     &buffer_writer, 
-    labcomm_default_error_handler,
-    labcomm_default_memory,
-    labcomm_pthread_scheduler_new(labcomm_default_memory));
+    labcomm2014_default_error_handler,
+    labcomm2014_default_memory,
+    labcomm2014_pthread_scheduler_new(labcomm2014_default_memory));
   EXPECT({ 0x01, 0x0c, 0x0b, 
            'L', 'a', 'b', 'C', 'o', 'm', 'm', '2','0', '1', '4' });
 
-  labcomm_encoder_ioctl(encoder, IOCTL_WRITER_RESET);
+  labcomm2014_encoder_ioctl(encoder, IOCTL_WRITER_RESET);
   /* Register twice to make sure that only one registration gets encoded */
-  labcomm_encoder_register_generated_encoding_V(encoder);
-  labcomm_encoder_register_generated_encoding_V(encoder);
+  labcomm2014_encoder_register_generated_encoding_V(encoder);
+  labcomm2014_encoder_register_generated_encoding_V(encoder);
   EXPECT({ 0x02, 0x06, VARIABLE(0), 0x01, 'V', 0x02, 0x11, 0x00,
            0x04, 0x08, VARIABLE(1), 0x03, 'v', '_', 't', 0x02, 0x11, 0x00,
            0x04, 0x05, VARIABLE(2), 0x01, 'V', 0x01, VARIABLE(1),
            0x05, 0x02, VARIABLE(0), VARIABLE(2) });
 
-  labcomm_encoder_ioctl(encoder, IOCTL_WRITER_RESET);
+  labcomm2014_encoder_ioctl(encoder, IOCTL_WRITER_RESET);
   /* Register twice to make sure that only one registration gets encoded */
-  labcomm_encoder_register_generated_encoding_B(encoder);
-  labcomm_encoder_register_generated_encoding_B(encoder);
+  labcomm2014_encoder_register_generated_encoding_B(encoder);
+  labcomm2014_encoder_register_generated_encoding_B(encoder);
   EXPECT({ 0x02, 0x05, VARIABLE(3), 0x01, 'B', 0x01, 0x21,
            0x05, 0x02, VARIABLE(3), LABCOMM_BIND_SELF });
 
-  labcomm_encoder_ioctl(encoder, IOCTL_WRITER_RESET);
+  labcomm2014_encoder_ioctl(encoder, IOCTL_WRITER_RESET);
   /* Register twice to make sure that only one registration gets encoded */
-  labcomm_encoder_register_generated_encoding_R(encoder);
-  labcomm_encoder_register_generated_encoding_R(encoder);
+  labcomm2014_encoder_register_generated_encoding_R(encoder);
+  labcomm2014_encoder_register_generated_encoding_R(encoder);
   EXPECT({ 0x02, 0x08, VARIABLE(4), 0x01, 'R', 0x04, 0x10, 0x01, 0x04, 0x28,
            0x05, 0x02, VARIABLE(4), LABCOMM_BIND_SELF });
 
-  labcomm_encoder_ioctl(encoder, IOCTL_WRITER_RESET);
+  labcomm2014_encoder_ioctl(encoder, IOCTL_WRITER_RESET);
   /* Register twice to make sure that only one registration gets encoded */
-  labcomm_encoder_sample_ref_register(encoder, 
-                                      labcomm_signature_generated_encoding_V);
-  labcomm_encoder_sample_ref_register(encoder, 
-                                      labcomm_signature_generated_encoding_V);
+  labcomm2014_encoder_sample_ref_register(encoder, 
+                                      labcomm2014_signature_generated_encoding_V);
+  labcomm2014_encoder_sample_ref_register(encoder, 
+                                      labcomm2014_signature_generated_encoding_V);
   EXPECT({0x03, 0x06, VARIABLE(5), 0x01, 'V', 0x02, 0x11, 0x00});
 
-  labcomm_encoder_ioctl(encoder, IOCTL_WRITER_RESET);
+  labcomm2014_encoder_ioctl(encoder, IOCTL_WRITER_RESET);
   /* Register twice to make sure that only one registration gets encoded */
-  labcomm_encoder_sample_ref_register(encoder, 
-                                      labcomm_signature_generated_encoding_B);
-  labcomm_encoder_sample_ref_register(encoder, 
-                                      labcomm_signature_generated_encoding_B);
+  labcomm2014_encoder_sample_ref_register(encoder, 
+                                      labcomm2014_signature_generated_encoding_B);
+  labcomm2014_encoder_sample_ref_register(encoder, 
+                                      labcomm2014_signature_generated_encoding_B);
   EXPECT({0x03, 0x05, VARIABLE(6), 0x01, 'B', 0x01, 0x21});
 
-  labcomm_encoder_ioctl(encoder, IOCTL_WRITER_RESET);
+  labcomm2014_encoder_ioctl(encoder, IOCTL_WRITER_RESET);
   /* Register twice to make sure that only one registration gets encoded */
-  labcomm_encoder_sample_ref_register(encoder, 
-                                      labcomm_signature_generated_encoding_R);
-  labcomm_encoder_sample_ref_register(encoder, 
-                                      labcomm_signature_generated_encoding_R);
+  labcomm2014_encoder_sample_ref_register(encoder, 
+                                      labcomm2014_signature_generated_encoding_R);
+  labcomm2014_encoder_sample_ref_register(encoder, 
+                                      labcomm2014_signature_generated_encoding_R);
   EXPECT({0x03, 0x08, VARIABLE(7), 0x01, 'R', 0x04, 0x10, 0x01, 0x04, 0x28});
 
-  labcomm_encoder_ioctl(encoder, IOCTL_WRITER_RESET);
-  // was: labcomm_encode_generated_encoding_V(encoder, &V);
-  labcomm_encode_generated_encoding_V(encoder);
+  labcomm2014_encoder_ioctl(encoder, IOCTL_WRITER_RESET);
+  // was: labcomm2014_encode_generated_encoding_V(encoder, &V);
+  labcomm2014_encode_generated_encoding_V(encoder);
   EXPECT({VARIABLE(10), 0x00 });
 
-  labcomm_encoder_ioctl(encoder, IOCTL_WRITER_RESET);
-  labcomm_encode_generated_encoding_B(encoder, &B);
+  labcomm2014_encoder_ioctl(encoder, IOCTL_WRITER_RESET);
+  labcomm2014_encode_generated_encoding_B(encoder, &B);
   EXPECT({VARIABLE(20), 0x01, 1});
 
-  labcomm_encoder_ioctl(encoder, IOCTL_WRITER_RESET);
-  R.a[0] = labcomm_signature_generated_encoding_V;
-  R.a[1] = labcomm_signature_generated_encoding_B;
-  R.a[2] = labcomm_signature_generated_encoding_UnusedE;
-  R.a[3] = labcomm_signature_generated_encoding_R;
-  labcomm_encode_generated_encoding_R(encoder, &R);
+  labcomm2014_encoder_ioctl(encoder, IOCTL_WRITER_RESET);
+  R.a[0] = labcomm2014_signature_generated_encoding_V;
+  R.a[1] = labcomm2014_signature_generated_encoding_B;
+  R.a[2] = labcomm2014_signature_generated_encoding_UnusedE;
+  R.a[3] = labcomm2014_signature_generated_encoding_R;
+  labcomm2014_encode_generated_encoding_R(encoder, &R);
   EXPECT({VARIABLE(4), 0x10, 0x00, 0x00, 0x00, VARIABLE(5),
                              0x00, 0x00, 0x00, VARIABLE(6),
                              0x00, 0x00, 0x00, 0x00,
diff --git a/lib/c/2014/test/test_labcomm_pthread_scheduler.c b/lib/c/2014/test/test_labcomm_pthread_scheduler.c
index 718293d..aa7c5f0 100644
--- a/lib/c/2014/test/test_labcomm_pthread_scheduler.c
+++ b/lib/c/2014/test/test_labcomm_pthread_scheduler.c
@@ -1,5 +1,5 @@
 /*
-  test_labcomm_pthread_scheduler.c -- test labcomm pthread based task 
+  test_labcomm2014_pthread_scheduler.c -- test labcomm2014 pthread based task 
                                       coordination
 
   Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
@@ -22,13 +22,13 @@
 
 #include <stdio.h>
 #include <stdlib.h>
-#include "labcomm_default_memory.h"
-#include "labcomm_scheduler.h"
-#include "labcomm_pthread_scheduler.h"
+#include "labcomm2014_default_memory.h"
+#include "labcomm2014_scheduler.h"
+#include "labcomm2014_pthread_scheduler.h"
 
 #define TICK 100000
 struct func_arg {
-  struct labcomm_scheduler *scheduler;
+  struct labcomm2014_scheduler *scheduler;
   int i;
 };
 
@@ -38,11 +38,11 @@ static void func(void *arg)
   
   printf("%p %d\n", arg, func_arg->i);
   if (func_arg->i == 999) {
-    labcomm_scheduler_wakeup(func_arg->scheduler);
+    labcomm2014_scheduler_wakeup(func_arg->scheduler);
   }
 }
 
-void enqueue(struct labcomm_scheduler *scheduler, 
+void enqueue(struct labcomm2014_scheduler *scheduler, 
 	     int first, int last)
 {
   int i;
@@ -52,16 +52,16 @@ void enqueue(struct labcomm_scheduler *scheduler,
     
     tmp->scheduler = scheduler;
     tmp->i = i;
-    labcomm_scheduler_enqueue(scheduler, i*TICK, func, tmp);
+    labcomm2014_scheduler_enqueue(scheduler, i*TICK, func, tmp);
   }
 }
 
 int main(int argc, char *argv[])
 {
-  struct labcomm_scheduler *scheduler;
-  struct labcomm_time *time;
+  struct labcomm2014_scheduler *scheduler;
+  struct labcomm2014_time *time;
 
-  scheduler = labcomm_pthread_scheduler_new(labcomm_default_memory);
+  scheduler = labcomm2014_pthread_scheduler_new(labcomm2014_default_memory);
   enqueue(scheduler, 0, 5);
   enqueue(scheduler, 0, 1);
   enqueue(scheduler, 1, 3);
@@ -71,12 +71,12 @@ int main(int argc, char *argv[])
     
     tmp->scheduler = scheduler;
     tmp->i = 999;
-    labcomm_scheduler_enqueue(scheduler, 6*TICK, func, tmp);
+    labcomm2014_scheduler_enqueue(scheduler, 6*TICK, func, tmp);
   }
-  time = labcomm_scheduler_now(scheduler);
-  labcomm_time_add_usec(time, 12*TICK);
-  labcomm_scheduler_sleep(scheduler, NULL);
-  labcomm_scheduler_sleep(scheduler, time);
+  time = labcomm2014_scheduler_now(scheduler);
+  labcomm2014_time_add_usec(time, 12*TICK);
+  labcomm2014_scheduler_sleep(scheduler, NULL);
+  labcomm2014_scheduler_sleep(scheduler, time);
 
   return 0;
 }
diff --git a/lib/c/2014/test/test_signature_numbers.c b/lib/c/2014/test/test_signature_numbers.c
index 675088a..c540f81 100644
--- a/lib/c/2014/test/test_signature_numbers.c
+++ b/lib/c/2014/test/test_signature_numbers.c
@@ -1,14 +1,14 @@
 #include <stdlib.h>
 #include <stdio.h>
-#include "labcomm_private.h"
+#include "labcomm2014_private.h"
 #include "test/gen/another_encoding.h"
 #include "test/gen/generated_encoding.h"
 
 static void info(char *name, char *full_name, 
-		 const struct labcomm_signature *signature) {
+		 const struct labcomm2014_signature *signature) {
   printf("%s %s %p -> %d\n", name,  full_name, signature, 
-	 labcomm_get_local_index(signature));
-  if (labcomm_get_local_index(signature) < 0x40) {
+	 labcomm2014_get_local_index(signature));
+  if (labcomm2014_get_local_index(signature) < 0x40) {
     exit(1);
   }
 };
@@ -16,7 +16,7 @@ static void info(char *name, char *full_name,
 int main(int argc, char *argv[])
 {
 #define FUNC(name, full_name) \
-  info( #name, #full_name, labcomm_signature_##full_name)
+  info( #name, #full_name, labcomm2014_signature_##full_name)
 
   LABCOMM_FORALL_SAMPLES_generated_encoding(FUNC, ;);
   LABCOMM_FORALL_SAMPLES_another_encoding(FUNC, ;);
diff --git a/lib/c/version_compare.py b/lib/c/version_compare.py
index 47d016b..ad2c1b1 100755
--- a/lib/c/version_compare.py
+++ b/lib/c/version_compare.py
@@ -9,7 +9,9 @@ class File:
 
     def __init__(self, path, match, replacement):
         def replace(s):
-            return re.sub('[ \t]+', ' ', s).replace(match, replacement).strip()
+            r = re.sub('[ \t]+', ' ', s).replace(match, replacement)
+            r = r.strip() + '\n'
+            return r
         self.name = path.replace(match, replacement)
         self.path = path
         with open(path) as f:
@@ -50,7 +52,7 @@ if __name__ == '__main__':
         else:
             equal = True
             for l in difflib.unified_diff(a.lines, b.lines, a.path, b.path):
-                print l
+                print l,
                 equal = False
             if equal:
                 print "Identical", a.path, b.path
diff --git a/test/relay_gen_c.py b/test/relay_gen_c.py
index dd3f894..4d05064 100755
--- a/test/relay_gen_c.py
+++ b/test/relay_gen_c.py
@@ -27,32 +27,26 @@ if __name__ == '__main__':
       |#include <sys/types.h>
       |#include <sys/stat.h>
       |#include <fcntl.h>
-      |#include <labcomm.h>
-      |#include <labcomm_default_error_handler.h>
-      |#include <labcomm_default_memory.h>
-      |#include <labcomm_default_scheduler.h>
-      |#include <labcomm_fd_reader.h>
-      |#include <labcomm_fd_writer.h>
+      |#include <labcomm2014.h>
+      |#include <labcomm2014_default_error_handler.h>
+      |#include <labcomm2014_default_memory.h>
+      |#include <labcomm2014_default_scheduler.h>
+      |#include <labcomm2014_fd_reader.h>
+      |#include <labcomm2014_fd_writer.h>
       |#include "c_code.h"
     """))
     for func,arg,stype in sample:
         result.extend(split_match('^[^|]*\|(.*)$', """
           |void handle_%(func)s(%(arg)s *v, void *context)
           |{
-          |  struct labcomm_encoder *e = context;
-          |  labcomm_encode_%(func)s(e%(valargstr)s);
+          |  struct labcomm2014_encoder *e = context;
+          |  labcomm2014_encode_%(func)s(e%(valargstr)s);
           |}""" % { 'func': func, 'arg': arg, 'valargstr': '' if stype == "void" else', v' }))
-#        result.extend(split_match('^[^|]*\|(.*)$', """
-#          |void handle_%(func)s(%(arg)s *v, void *context)
-#          |{
-#          |  struct labcomm_encoder *e = context;
-#          |  labcomm_encode_%(func)s(e, v);
-#          |}""" % { 'func': func, 'arg': arg }))
         pass
     result.extend(split_match('^[^|]*\|(.*)$', """
       |int main(int argc, char *argv[]) {
-      |  struct labcomm_encoder *e;
-      |  struct labcomm_decoder *d;
+      |  struct labcomm2014_encoder *e;
+      |  struct labcomm2014_decoder *d;
       |  int in, out;
       |  
       |  if (argc < 3) { return 1; }
@@ -60,26 +54,26 @@ if __name__ == '__main__':
       |  if (in < 0) { return 1; }
       |  out = open(argv[2], O_WRONLY);
       |  if (out < 0) { return 1; }
-      |  e = labcomm_encoder_new(labcomm_fd_writer_new(
-      |                              labcomm_default_memory, out, 1), 
-      |                           labcomm_default_error_handler,
-      |                           labcomm_default_memory,
-      |                           labcomm_default_scheduler);
-      |  d = labcomm_decoder_new(labcomm_fd_reader_new(
-      |                              labcomm_default_memory, in, 1), 
-      |                           labcomm_default_error_handler,
-      |                           labcomm_default_memory,
-      |                           labcomm_default_scheduler);
+      |  e = labcomm2014_encoder_new(labcomm2014_fd_writer_new(
+      |                              labcomm2014_default_memory, out, 1), 
+      |                              labcomm2014_default_error_handler,
+      |                              labcomm2014_default_memory,
+      |                              labcomm2014_default_scheduler);
+      |  d = labcomm2014_decoder_new(labcomm2014_fd_reader_new(
+      |                              labcomm2014_default_memory, in, 1), 
+      |                              labcomm2014_default_error_handler,
+      |                              labcomm2014_default_memory,
+      |                              labcomm2014_default_scheduler);
     """))
     for func,arg,stype in sample:
         result.extend(split_match('^[^|]*\|(.*)$', """
-          |  labcomm_encoder_register_%(func)s(e);
-          |  labcomm_encoder_sample_ref_register(e, labcomm_signature_%(func)s);
-          |  labcomm_decoder_register_%(func)s(d, handle_%(func)s, e);
-          |  labcomm_decoder_sample_ref_register(d, labcomm_signature_%(func)s);
+          |  labcomm2014_encoder_register_%(func)s(e);
+          |  labcomm2014_encoder_sample_ref_register(e, labcomm2014_signature_%(func)s);
+          |  labcomm2014_decoder_register_%(func)s(d, handle_%(func)s, e);
+          |  labcomm2014_decoder_sample_ref_register(d, labcomm2014_signature_%(func)s);
        """ % { 'func': func, 'arg': arg }))
     result.extend(split_match('^[^|]*\|(.*)$', """
-      |  labcomm_decoder_run(d);
+      |  labcomm2014_decoder_run(d);
       |  return 0;
       |}
     """))
-- 
GitLab