lib/c/2014/labcomm2014_fd_reader.c

+/*
+  labcomm2014_fd_reader.c -- LabComm reader for Unix file descriptors.
+
+  Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
+
+  This file is part of LabComm.
+
+  LabComm is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  LabComm is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <errno.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include "labcomm2014_private.h"
+#include "labcomm2014_fd_reader.h"
+
+#define BUFFER_SIZE 2048
+
+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 labcomm2014_reader *r,
+		    struct labcomm2014_reader_action_context *action_context)
+{
+  int result = 0;
+  
+  r->count = 0;
+  r->pos = 0;
+  r->data = labcomm2014_memory_alloc(r->memory, 0, BUFFER_SIZE);
+  if (! r->data) {
+    r->data_size = 0;
+    result = -ENOMEM;
+  } else {
+
+    r->data_size = BUFFER_SIZE;
+    result = r->data_size;
+  }
+  return result;
+}
+
+static int fd_free(struct labcomm2014_reader *r, 
+		   struct labcomm2014_reader_action_context *action_context)
+{
+  struct labcomm2014_fd_reader *fd_reader = action_context->context;
+  struct labcomm2014_memory *memory = r->memory;
+
+  labcomm2014_memory_free(memory, 0, r->data);
+  r->data = 0;
+  r->data_size = 0;
+  r->count = 0;
+  r->pos = 0;
+
+  if (fd_reader->close_fd_on_free) {
+    close(fd_reader->fd);
+  }
+  labcomm2014_memory_free(memory, 0, fd_reader);
+
+  return 0;
+}
+
+static int fd_fill(struct labcomm2014_reader *r, 
+		   struct labcomm2014_reader_action_context *action_context)
+{
+  int result = 0;
+  struct labcomm2014_fd_reader *fd_reader = action_context->context;
+
+  if (r->pos < r->count) {
+    result = r->count - r->pos;
+  } else {
+    int err;
+    
+    r->pos = 0;
+    err = read(fd_reader->fd, (char *)r->data, r->data_size);
+    if (err <= 0) {
+      r->count = 0;
+      r->error = -EPIPE;
+      result = -EPIPE;
+    } else {
+      r->count = err;
+      result = r->count - r->pos;
+    }
+  }
+  return result;
+}
+
+static const struct labcomm2014_reader_action action = {
+  .alloc = fd_alloc,
+  .free = fd_free,
+  .start = NULL,
+  .fill = fd_fill,
+  .end = NULL,
+  .ioctl = NULL
+};
+
+struct labcomm2014_reader *labcomm2014_fd_reader_new(struct labcomm2014_memory *memory,
+					     int fd, int close_fd_on_free)
+{
+  struct labcomm2014_fd_reader *result;
+
+  result = labcomm2014_memory_alloc(memory, 0, sizeof(*result));
+  if (result == NULL) {
+    return NULL;
+  } else {
+    result->action_context.next = NULL;
+    result->action_context.action = &action;
+    result->action_context.context = result;
+    result->reader.action_context = &result->action_context;
+    result->reader.memory = memory;
+    result->fd = fd;
+    result->close_fd_on_free = close_fd_on_free;
+    return &result->reader;
+  }
+}

lib/c/2014/labcomm2014_fd_reader.h

+/*
+  labcomm2014_fd_reader.c -- a reader for unix style file-descriptors
+
+  Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
+
+  This file is part of LabComm.
+
+  LabComm is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  LabComm is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __LABCOMM2014_FD_READER_H__
+#define __LABCOMM2014_FD_READER_H__
+
+#include "labcomm2014.h"
+
+struct labcomm2014_reader *labcomm2014_fd_reader_new(struct labcomm2014_memory *memory,
+					     int fd, int close_fd_on_free);
+
+#endif
+

lib/c/2014/labcomm2014_fd_writer.c

+/*
+  labcomm2014_fd_writer.c -- LabComm writer for Unix file descriptors.
+
+  Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
+
+  This file is part of LabComm.
+
+  LabComm is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  LabComm is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <errno.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include "labcomm2014_private.h"
+#include "labcomm2014_fd_writer.h"
+#include "labcomm2014_ioctl.h"
+
+#define BUFFER_SIZE 2048
+
+#ifdef LABCOMM_WITH_SANITY_CHECKS
+static int bytecount_carry = 0;
+#endif
+
+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 labcomm2014_writer *w,
+		    struct labcomm2014_writer_action_context *action_context);
+
+static int fd_alloc(struct labcomm2014_writer *w,
+		    struct labcomm2014_writer_action_context *action_context)
+{
+  w->data = labcomm2014_memory_alloc(w->memory, 0, BUFFER_SIZE);
+  if (! w->data) {
+    w->error = -ENOMEM;
+    w->data_size = 0;
+    w->count = 0;
+    w->pos = 0;
+  } else {
+    w->data_size = BUFFER_SIZE;
+    w->count = BUFFER_SIZE;
+    w->pos = 0;
+  }
+
+  return w->error;
+}
+
+static int fd_free(struct labcomm2014_writer *w,
+		   struct labcomm2014_writer_action_context *action_context)
+{
+  struct labcomm2014_fd_writer *fd_writer = action_context->context;
+  struct labcomm2014_memory *memory = w->memory;
+
+  labcomm2014_memory_free(memory, 0, w->data);
+  w->data = 0;
+  w->data_size = 0;
+  w->count = 0;
+  w->pos = 0;
+
+  if (fd_writer->close_fd_on_free) {
+    close(fd_writer->fd);
+  }
+  labcomm2014_memory_free(memory, 0, fd_writer);
+  return 0;
+}
+
+static int fd_start(struct labcomm2014_writer *w,
+		    struct labcomm2014_writer_action_context *action_context,
+		    int index,
+		    const struct labcomm2014_signature *signature,
+		    void *value)
+{
+#ifdef LABCOMM_WITH_SANITY_CHECKS
+  bytecount_carry = w->pos;
+#endif
+  w->pos = 0;
+
+  return w->error;
+}
+
+static int fd_flush(struct labcomm2014_writer *w,
+		    struct labcomm2014_writer_action_context *action_context)
+{
+  struct labcomm2014_fd_writer *fd_context = action_context->context;
+  int start, err;
+
+  start = 0;
+  err = 0;
+  while (start < w->pos) {
+    err = write(fd_context->fd, (char *)&w->data[start], w->pos - start);
+    if (err <= 0) {
+      break;
+    }
+    start = start + err;
+  }
+  if (err < 0) {
+    w->error = -errno;
+  } else if (err == 0) {
+    w->error = -EINVAL;
+  }
+#ifdef LABCOMM_WITH_SANITY_CHECKS
+  bytecount_carry = w->pos;
+#endif
+  w->pos = 0;
+
+  return w->error;
+}
+
+
+#ifdef LABCOMM_WITH_SANITY_CHECKS
+static int fd_ioctl(struct labcomm2014_writer *w,
+		     struct labcomm2014_writer_action_context *action_context,
+		     int signature_index,
+		     const struct labcomm2014_signature *signature,
+		     uint32_t action, va_list arg)
+{
+  int result = -ENOTSUP;
+  switch (action) {
+    case LABCOMM_IOCTL_WRITER_GET_BYTES_WRITTEN: {
+      int *value = va_arg(arg, int*);
+      *value = w->pos + bytecount_carry;
+      result = 0;
+    } break;
+  }
+  return result;
+}
+#endif
+
+static const struct labcomm2014_writer_action action = {
+  .alloc = fd_alloc,
+  .free = fd_free,
+  .start = fd_start,
+  .end = fd_flush,
+  .flush = fd_flush,
+#ifdef LABCOMM_WITH_SANITY_CHECKS
+  .ioctl = fd_ioctl
+#else
+  .ioctl = NULL
+#endif
+};
+
+struct labcomm2014_writer *labcomm2014_fd_writer_new(struct labcomm2014_memory *memory,
+					     int fd, int close_fd_on_free)
+{
+  struct labcomm2014_fd_writer *result;
+
+  result = labcomm2014_memory_alloc(memory, 0, sizeof(*result));
+  if (result == NULL) {
+    return NULL;
+  } else {
+    result->action_context.next = NULL;
+    result->action_context.action = &action;
+    result->action_context.context = result;
+    result->writer.action_context = &result->action_context;
+    result->writer.memory = memory;
+    result->fd = fd;
+    result->close_fd_on_free = close_fd_on_free;
+    return &result->writer;
+  }
+}

lib/c/2014/labcomm2014_fd_writer.h

+/*
+  labcomm2014_fd_writer.c -- a writer for unix style file-descriptors
+
+  Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
+
+  This file is part of LabComm.
+
+  LabComm is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  LabComm is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __LABCOMM2014_FD_WRITER_H__
+#define __LABCOMM2014_FD_WRITER_H__
+
+#include "labcomm2014.h"
+
+struct labcomm2014_writer *labcomm2014_fd_writer_new(struct labcomm2014_memory *memory,
+					     int fd, int close_on_free);
+
+#endif
+

lib/c/2014/labcomm2014_ioctl.h

+/*
+  labcomm2014_ioctl.h -- labcomm2014 ioctl declarations
+
+  Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
+
+  This file is part of LabComm.
+
+  LabComm is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  LabComm is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __LABCOMM2014_IOCTL_H___
+#define __LABCOMM2014_IOCTL_H___
+
+#include "labcomm2014.h"
+
+/*
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ * | |   |                         |               |               |  
+ * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+ *  | |   |                         |               |
+ *  | |   |                         |               +- number    (8)
+ *  | |   |                         +----------------- type      (8)
+ *  | |   +------------------------------------------- size      (13)
+ *  | +----------------------------------------------- direction (2)
+ *  +------------------------------------------------- signature (1)
+ *  
+ * type 0-31     are reserved for labcomm2014 library use
+ */
+
+
+#define LABCOMM_IOC_NRBITS      8
+#define LABCOMM_IOC_TYPEBITS    8
+#define LABCOMM_IOC_SIZEBITS   13
+#define LABCOMM_IOC_DIRBITS     2
+#define LABCOMM_IOC_SIGBITS     1
+#define LABCOMM_IOC_NRMASK     ((1 << LABCOMM_IOC_NRBITS)-1)
+#define LABCOMM_IOC_TYPEMASK   ((1 << LABCOMM_IOC_TYPEBITS)-1)
+#define LABCOMM_IOC_SIZEMASK   ((1 << LABCOMM_IOC_SIZEBITS)-1)
+#define LABCOMM_IOC_DIRMASK    ((1 << LABCOMM_IOC_DIRBITS)-1)
+#define LABCOMM_IOC_SIGMASK    ((1 << LABCOMM_IOC_SIGBITS)-1)
+#define LABCOMM_IOC_NRSHIFT    0
+#define LABCOMM_IOC_TYPESHIFT  (LABCOMM_IOC_NRSHIFT+LABCOMM_IOC_NRBITS)
+#define LABCOMM_IOC_SIZESHIFT  (LABCOMM_IOC_TYPESHIFT+LABCOMM_IOC_TYPEBITS)
+#define LABCOMM_IOC_DIRSHIFT   (LABCOMM_IOC_SIZESHIFT+LABCOMM_IOC_SIZEBITS)
+#define LABCOMM_IOC_SIGSHIFT   (LABCOMM_IOC_DIRSHIFT+LABCOMM_IOC_DIRBITS)
+
+#define LABCOMM_IOC_NOSIG       0U
+#define LABCOMM_IOC_USESIG      1U
+
+#define LABCOMM_IOC_NONE        0U
+#define LABCOMM_IOC_WRITE       1U
+#define LABCOMM_IOC_READ        2U
+
+#define LABCOMM_IOC(signature,dir,type,nr,size)	  \
+  (((signature) << LABCOMM_IOC_SIGSHIFT) |	  \
+   ((dir)       << LABCOMM_IOC_DIRSHIFT) |	  \
+   ((size)      << LABCOMM_IOC_SIZESHIFT) |	  \
+   ((type)      << LABCOMM_IOC_TYPESHIFT) |	  \
+   ((nr)        << LABCOMM_IOC_NRSHIFT))	  
+
+#define LABCOMM_IOC_SIG(nr) \
+  (((nr) >> LABCOMM_IOC_SIGSHIFT) & LABCOMM_IOC_SIGMASK)
+#define LABCOMM_IOC_DIR(nr) \
+  (((nr) >> LABCOMM_IOC_DIRSHIFT) & LABCOMM_IOC_DIRMASK)
+#define LABCOMM_IOC_SIZE(nr) \
+  (((nr) >> LABCOMM_IOC_SIZESHIFT) & LABCOMM_IOC_SIZEMASK)
+#define LABCOMM_IOC_TYPE(nr) \
+  (((nr) >> LABCOMM_IOC_TYPESHIFT) & LABCOMM_IOC_TYPEMASK)
+#define LABCOMM_IOC_NR(nr) \
+  (((nr) >> LABCOMM_IOC_NRSHIFT) & LABCOMM_IOC_NRMASK)
+
+#define LABCOMM_IO(type,nr)						\
+  LABCOMM_IOC(LABCOMM_IOC_NOSIG,LABCOMM_IOC_NONE,type,nr,0)
+#define LABCOMM_IOR(type,nr,size)					\
+  LABCOMM_IOC(LABCOMM_IOC_NOSIG,LABCOMM_IOC_READ,type,nr,sizeof(size))
+#define LABCOMM_IOW(type,nr,size)					\
+  LABCOMM_IOC(LABCOMM_IOC_NOSIG,LABCOMM_IOC_WRITE,type,nr,sizeof(size))
+#define LABCOMM_IOS(type,nr)                                    \
+  LABCOMM_IOC(LABCOMM_IOC_USESIG,LABCOMM_IOC_READ,type,nr,0)
+#define LABCOMM_IOSR(type,nr,size)					\
+  LABCOMM_IOC(LABCOMM_IOC_USESIG,LABCOMM_IOC_READ,type,nr,sizeof(size))
+#define LABCOMM_IOSW(type,nr,size)					\
+  LABCOMM_IOC(LABCOMM_IOC_USESIG,LABCOMM_IOC_WRITE,type,nr,sizeof(size))
+
+#define LABCOMM_IOCTL_WRITER_GET_BYTES_WRITTEN \
+  LABCOMM_IOR(0,1,int)
+#define LABCOMM_IOCTL_WRITER_GET_BYTE_POINTER \
+  LABCOMM_IOR(0,2,void*)
+
+#endif

lib/c/2014/labcomm2014_memory.c

+/*
+  labcomm2014_memory.c -- dynamic memory handlig dispatcher
+
+  Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
+
+  This file is part of LabComm.
+
+  LabComm is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  LabComm is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "labcomm2014_private.h"
+
+void *labcomm2014_memory_alloc(struct labcomm2014_memory *m, int lifetime, 
+			   size_t size) 
+{
+  return m->alloc(m, lifetime, size);
+}
+
+void *labcomm2014_memory_realloc(struct labcomm2014_memory *m, int lifetime, 
+			     void *ptr, size_t size) 
+{
+  return m->realloc(m, lifetime, ptr, size);
+}
+
+void labcomm2014_memory_free(struct labcomm2014_memory *m, int lifetime, 
+			 void *ptr)
+{
+  m->free(m, lifetime, ptr);
+}

lib/c/2014/labcomm2014_private.h

+/*
+  labcomm2014_private.h -- semi private declarations for handling encoding and 
+                       decoding of labcomm2014 samples.
+
+  Copyright 2006-2013 Anders Blomdell <anders.blomdell@control.lth.se>
+
+  This file is part of LabComm.
+
+  LabComm is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  LabComm is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __LABCOMM2014_PRIVATE_H__
+#define __LABCOMM2014_PRIVATE_H__
+
+#ifdef LABCOMM_COMPAT
+  #include LABCOMM_COMPAT
+#else
+  #include <endian.h>
+  #include <stdio.h>
+  #include <stdint.h>
+  #include <unistd.h>
+#endif
+
+//#include <stdlib.h>
+#include <string.h>
+#include "labcomm2014.h"
+
+/*
+ * Allowed packet tags
+ */
+#define LABCOMM_VERSION      0x01
+#define LABCOMM_SAMPLE_DEF   0x02
+#define LABCOMM_SAMPLE_REF   0x03
+#define LABCOMM_TYPE_DEF     0x04
+#define LABCOMM_TYPE_BINDING 0x05
+#define LABCOMM_PRAGMA       0x3f
+#define LABCOMM_USER         0x40 /* ..0xffffffff */
+
+/*
+ * Predefined aggregate type indices
+ */
+#define LABCOMM_ARRAY        0x10
+#define LABCOMM_STRUCT       0x11
+
+/*
+ * Predefined primitive type indices
+ */
+#define LABCOMM_BOOLEAN      0x20 
+#define LABCOMM_BYTE         0x21
+#define LABCOMM_SHORT        0x22
+#define LABCOMM_INT          0x23
+#define LABCOMM_LONG         0x24
+#define LABCOMM_FLOAT        0x25
+#define LABCOMM_DOUBLE       0x26
+#define LABCOMM_STRING       0x27
+#define LABCOMM_REF          0x28
+
+/* 
+ * other special values
+ */
+
+#define LABCOMM_BIND_SELF    0
+
+/*
+ * Macro to automagically call constructors in modules compiled 
+ * with the labcomm2014 compiler. If __attribute__((constructor)) is
+ * not supported, these calls has to be done first in main program.
+ */
+#ifndef LABCOMM_CONSTRUCTOR
+#define LABCOMM_CONSTRUCTOR __attribute__((constructor))
+#endif
+
+/*
+ * Semi private dynamic memory declarations
+ */
+
+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 labcomm2014_memory *m, int lifetime, void *ptr);
+  void *context;
+};
+
+/*
+ * sample_ref/signature helpers 
+ */
+static const inline
+struct labcomm2014_signature *labcomm2014_sample_ref_to_signature(
+  const struct labcomm2014_sample_ref *sample_ref
+  )
+{
+  return (struct labcomm2014_signature *)sample_ref;
+}
+
+static const inline
+struct labcomm2014_sample_ref *labcomm2014_signature_to_sample_ref(
+  const struct labcomm2014_signature *signature
+  )
+{
+  return (struct labcomm2014_sample_ref *)signature;
+}
+
+/*
+ * Semi private decoder declarations
+ */
+typedef void (*labcomm2014_handler_function)(void *value, void *context);
+
+typedef void (*labcomm2014_decoder_function)(
+  struct labcomm2014_reader *r,
+  labcomm2014_handler_function handler,
+  void *context);
+
+struct labcomm2014_reader_action_context;
+
+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 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.
+
+     Returned value:
+       == 0    Success
+       != 0    Error
+  */
+  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)
+     2. When a sample definition is received 
+          (local_index != 0, remote_index != 0, value == NULL)
+     3. When a sample is received
+          (local_index != 0, remote_index != 0, value != NULL)
+   */
+  int (*start)(struct labcomm2014_reader *r, 
+	       struct labcomm2014_reader_action_context *action_context,
+	       int local_index, int remote_index,
+	       const struct labcomm2014_signature *signature,
+	       void *value);
+  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 labcomm2014_signature *signature, 
+	       uint32_t ioctl_action, va_list args);
+};
+
+struct labcomm2014_reader_action_context {
+  struct labcomm2014_reader_action_context *next;
+  const struct labcomm2014_reader_action *action;
+  void *context;  
+};
+
+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;
+  int pos;
+  int error;
+};
+
+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 labcomm2014_signature *signature,
+			 void *value);
+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 labcomm2014_signature *signature, 
+			 uint32_t ioctl_action, va_list args);
+
+struct labcomm2014_decoder {
+  void *context;
+  struct labcomm2014_reader *reader;
+  struct labcomm2014_error_handler *error;
+  struct labcomm2014_memory *memory;
+  struct labcomm2014_scheduler *scheduler;
+  int reader_allocated;
+  int version_ok;
+  labcomm2014_error_handler_callback on_error;
+  labcomm2014_handle_new_datatype_callback on_new_datatype;
+  void (*free)(struct labcomm2014_decoder *d);
+  int (*decode_one)(struct labcomm2014_decoder *d);
+  int (*ref_register)(struct labcomm2014_decoder *d, 
+                      const struct labcomm2014_signature *s);
+  /*
+   * Non typesafe registration function to be called from
+   * generated labcomm2014_decoder_register_* functions.
+   */
+  int (*sample_register)(struct labcomm2014_decoder *d, 
+                         const struct labcomm2014_signature *s, 
+                         labcomm2014_decoder_function decoder,
+                         labcomm2014_handler_function handler,
+                         void *context);
+  int (*ioctl)(struct labcomm2014_decoder *d, 
+               const struct labcomm2014_signature *s,
+               uint32_t ioctl_action, va_list args);
+  const struct labcomm2014_sample_ref *(*index_to_sample_ref)(
+    struct labcomm2014_decoder *decoder, int index);
+  const struct labcomm2014_sample_ref *(*ref_get)(
+    struct labcomm2014_decoder *d,
+    const struct labcomm2014_signature *signature);
+};
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+
+#define LABCOMM_DECODE(name, type)					\
+  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) {						\
+	labcomm2014_reader_fill(r, r->action_context);			\
+	if (r->error < 0) {						\
+	  return 0;							\
+	}								\
+      }									\
+      ((unsigned char*)(&result))[i] = r->data[r->pos];			\
+      r->pos++;								\
+    }									\
+    return result;							\
+  }
+
+#else
+
+#define LABCOMM_DECODE(name, type)					\
+  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) {						\
+	labcomm2014_reader_fille(r, r->action_context);			\
+	if (r->error < 0) {						\
+	  return 0;							\
+	}								\
+      }				>					\
+      ((unsigned char*)(&result))[i] = r->data[r->pos];			\
+      r->pos++;								\
+    }									\
+    return result;							\
+  }
+
+#endif
+
+LABCOMM_DECODE(boolean, unsigned char)
+LABCOMM_DECODE(byte, unsigned char)
+LABCOMM_DECODE(short, short)
+LABCOMM_DECODE(int, int)
+LABCOMM_DECODE(long, long long)
+LABCOMM_DECODE(float, float)
+LABCOMM_DECODE(double, double)
+
+static inline unsigned int labcomm2014_read_packed32(struct labcomm2014_reader *r)
+{
+  unsigned int result = 0;
+  
+  while (1) {
+    unsigned char tmp;
+
+    if (r->pos >= r->count) {	
+      labcomm2014_reader_fill(r, r->action_context);
+      if (r->error != 0) {
+	goto out;
+      }
+    }
+    tmp = r->data[r->pos];
+    r->pos++;
+    result = (result << 7) | (tmp & 0x7f);
+    if ((tmp & 0x80) == 0) { 
+      break; 
+    }
+  }
+out:
+  return result;
+}
+ 
+static inline char *labcomm2014_read_string(struct labcomm2014_reader *r)
+{
+  char *result = NULL;
+  int length, pos; 
+  
+  length = labcomm2014_read_packed32(r);
+  result = labcomm2014_memory_alloc(r->memory, 1, length + 1);
+  if (!result) {
+    labcomm20142014_on_error_fprintf(LABCOMM2014_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) {	
+      labcomm2014_reader_fill(r, r->action_context);
+      if (r->error < 0) {
+	goto out;
+      }
+    }
+    result[pos] = r->data[r->pos];
+    r->pos++;
+  }
+out:
+  result[pos] = 0;
+  return result;
+}
+
+/*
+ * Semi private encoder declarations
+ */
+typedef int (*labcomm2014_encoder_function)(struct labcomm2014_writer *,
+					void *value);
+struct labcomm2014_writer_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.
+
+     Returned value:
+       == 0          Success -> continue sending the sample
+       == -EALREADY  Success -> silently skip sending the sample,
+                                'end' will not be called
+       < 0           Error
+   */
+  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 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 labcomm2014_writer_action_context {
+  struct labcomm2014_writer_action_context *next;
+  const struct labcomm2014_writer_action *action;
+  void *context;  
+};
+
+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;
+  int pos;
+  int error;
+};
+
+struct labcomm2014_encoder {
+  void *context;
+  struct labcomm2014_writer *writer;
+  struct labcomm2014_error_handler *error;
+  struct labcomm2014_memory *memory;
+  struct labcomm2014_scheduler *scheduler;
+  void (*free)(struct labcomm2014_encoder *e);
+  int (*type_register)(struct labcomm2014_encoder *e,
+                       const struct labcomm2014_signature *signature);
+  int (*type_bind)(struct labcomm2014_encoder *e,
+                   const struct labcomm2014_signature *signature,
+                   char has_deps);
+  int (*sample_register)(struct labcomm2014_encoder *e, 
+                         const struct labcomm2014_signature *signature, 
+                         labcomm2014_encoder_function encode);
+  int (*ref_register)(struct labcomm2014_encoder *e, 
+                      const struct labcomm2014_signature *signature);
+  int (*encode)(struct labcomm2014_encoder *e, 
+                const struct labcomm2014_signature *signature, 
+                labcomm2014_encoder_function encode,
+                void *value);
+  int (*ioctl)(struct labcomm2014_encoder *e, 
+             const struct labcomm2014_signature *signature,
+             uint32_t ioctl_action, va_list args);
+  int (*sample_ref_to_index)(struct labcomm2014_encoder *e,
+                             const struct labcomm2014_sample_ref *s);
+  const struct labcomm2014_sample_ref *(*ref_get)(
+    struct labcomm2014_encoder *e,
+    const struct labcomm2014_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 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 labcomm2014_internal_sizeof(const struct labcomm2014_signature *signature,
+                            void *v);
+
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+
+#define LABCOMM_ENCODE(name, type)					\
+  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 = labcomm2014_writer_flush(w, w->action_context);		\
+	if (err != 0) { return err; }					\
+      }									\
+      w->data[w->pos] = ((unsigned char*)(&data))[i];			\
+      w->pos++;								\
+    }									\
+    return 0;								\
+  }
+
+#else
+
+#define LABCOMM_ENCODE(name, type)					\
+  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 = labcomm2014_writer_flush(w, w->action_context);		\
+	if (err != 0) { return err; }					\
+      }									\
+      w->data[w->pos] = ((unsigned char*)(&data))[i];			\
+      w->pos++;								\
+    }									\
+    return 0;								\
+  }
+
+#endif
+
+LABCOMM_ENCODE(boolean, unsigned char)
+LABCOMM_ENCODE(byte, unsigned char)
+LABCOMM_ENCODE(short, short)
+LABCOMM_ENCODE(int, int)
+LABCOMM_ENCODE(long, long long)
+LABCOMM_ENCODE(float, float)
+LABCOMM_ENCODE(double, double)
+
+static inline int labcomm2014_write_packed32(struct labcomm2014_writer *w, 
+					 unsigned int data)
+{
+  unsigned char tmp[5];
+  int i;
+  
+  for (i = 0 ; i == 0 || data ; i++, data = (data >> 7)) {
+    tmp[i] = data & 0x7f;
+  }
+  for (i = i - 1 ; i >= 0 ; i--) {
+    if (w->pos >= w->count) {					
+      int err;
+      err = labcomm2014_writer_flush(w, w->action_context);	
+      if (err != 0) { return err; }
+    }
+    w->data[w->pos++] = tmp[i] | (i?0x80:0x00);
+  }
+  return 0;
+}
+
+static inline int labcomm2014_write_string(struct labcomm2014_writer *w, char *s)
+{
+  int length, i, err; 
+
+  length = strlen(s);
+  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 = labcomm2014_writer_flush(w, w->action_context);	
+      if (err != 0) { return err; }
+    }
+    w->data[w->pos] = s[i];
+    w->pos++;
+  }
+  return 0;
+}
+
+/* Size of packed32 variable */
+static inline int labcomm2014_size_packed32(unsigned int data)
+{
+  int result = 0;
+  int i;
+
+  for (i = 0 ; i == 0 || data ; i++, data = (data >> 7)) {
+    result++;
+  }
+  return result;
+
+}
+
+static inline int labcomm2014_size_string(char *s)
+{
+  int length = strlen(s);
+  
+  return labcomm2014_size_packed32(length) + length;
+}
+
+/*
+ * Macros for handling arrays indexed by signature index
+ */
+
+#define LABCOMM_SIGNATURE_ARRAY_DEF(name, kind)	\
+  struct {					\
+    int first;					\
+    int last;					\
+    kind *data;					\
+  } name
+
+#define LABCOMM_SIGNATURE_ARRAY_DEF_INIT(name, kind)		\
+  LABCOMM_SIGNATURE_ARRAY_DEF(name, kind) = { 0, 0, NULL }
+
+#define LABCOMM_SIGNATURE_ARRAY_INIT(name, kind)		\
+  name.first = 0; name.last = 0; name.data = NULL;		\
+  name.data = (kind *)name.data; /* typechecking no-op */
+
+#define LABCOMM_SIGNATURE_ARRAY_FREE(memory, name, kind)	\
+  if (name.data) { labcomm2014_memory_free(memory, 0, name.data); }	\
+  name.data = (kind *)NULL; /* typechecking */
+
+void *labcomm2014_signature_array_ref(struct labcomm2014_memory * memory,
+				  int *first, int *last, void **data,
+				  int size, int index);
+/*
+ * NB: the pointer returned by LABCOMM_SIGNATURE_ARRAY_REF might be
+ *     rendered invalid by a subsequent call to LABCOMM_SIGNATURE_ARRAY_REF
+ *     on the same SIGNATURE_ARRAY, so make sure not to use the result if 
+ *     any other code might have made a call to LABCOMM_SIGNATURE_ARRAY_REF
+ *     on the same SIGNATURE_ARRAY.
+ */
+#define LABCOMM_SIGNATURE_ARRAY_REF(memory, name, kind, index)		\
+  (name.data = (kind *)name.data, /* typechecking no-op */		\
+   (kind *)(labcomm2014_signature_array_ref(memory,				\
+					&name.first, &name.last,	\
+					(void **)&name.data,		\
+					sizeof(kind), index)))
+
+#define LABCOMM_SIGNATURE_ARRAY_GET(name, kind, index, nomatch)         \
+  (name.data = (kind *)name.data, /* typechecking no-op */		\
+   (name.first <= index &&                                              \
+    index < name.last) ? name.data[index - name.first] : nomatch)
+
+#define LABCOMM_SIGNATURE_ARRAY_FOREACH(name, kind, var)		\
+  for (name.data = (kind *)name.data, /* typechecking no-op */		\
+       var = name.first ; var < name.last ; var++)
+
+/* Give signature a free local index, this may not be used concurrently */
+void labcomm2014_set_local_index(struct labcomm2014_signature *signature);
+
+/* Get the local index for a signature */
+int labcomm2014_get_local_index(const struct labcomm2014_signature *s);
+
+int labcomm2014_get_local_type_index(const struct labcomm2014_signature *s);
+
+#endif

lib/c/2014/labcomm2014_pthread_scheduler.c

+/*
+  labcomm2014_pthread_scheduler.c -- labcomm2014 pthread based task coordination
+
+  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/>.
+*/
+#define _POSIX_C_SOURCE (200112L)
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <pthread.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 labcomm2014_time time;
+  struct labcomm2014_memory *memory;
+  struct timespec abstime;
+};
+
+struct pthread_deferred {
+  struct pthread_deferred *next;
+  struct pthread_deferred *prev;
+  struct timespec when;
+  void (*action)(void *context);
+  void *context;
+};
+
+struct pthread_scheduler {
+  struct labcomm2014_scheduler scheduler;
+  struct labcomm2014_memory *memory;
+  int wakeup;
+  pthread_mutex_t writer_mutex;
+  pthread_mutex_t data_mutex;
+  pthread_cond_t data_cond;
+  int running_deferred;
+  struct pthread_deferred deferred;
+  struct pthread_deferred deferred_with_delay;
+};
+
+static struct labcomm2014_time_action time_action;
+
+static int queue_empty(struct pthread_deferred *queue)
+{
+  return queue->next == queue;
+}
+
+static void timespec_add_usec(struct timespec *t, uint32_t usec)
+{
+  time_t sec = usec / 1000000;
+  long nsec = (usec % 1000000) * 1000;
+  
+  t->tv_nsec += nsec;
+  t->tv_sec += sec + t->tv_nsec / 1000000000;
+  t->tv_nsec %= 1000000000;
+}
+
+static int timespec_compare(struct timespec *t1, struct timespec *t2)
+{
+  if (t1->tv_sec == t2->tv_sec && t1->tv_nsec == t2->tv_nsec) {
+    return 0;
+  } else if (t1->tv_sec == 0 && t1->tv_nsec == 0) {
+    /* t1 is at end of time */
+    return 1;
+  } else  if (t2->tv_sec == 0 && t2->tv_nsec == 0) {
+    /* t2 is at end of time */
+    return -1;
+  } else if (t1->tv_sec < t2->tv_sec) {
+    return -1;
+  } else if (t1->tv_sec == t2->tv_sec) {
+    if (t1->tv_nsec < t2->tv_nsec) {
+      return -1;
+    } else if (t1->tv_nsec == t2->tv_nsec) {
+      return 0;
+    } else {
+      return 1;
+    }
+  } else {
+    return 1;
+  }
+}
+
+static struct labcomm2014_time *time_new(struct labcomm2014_memory *memory)
+{
+  struct pthread_time *time;
+
+  time = labcomm2014_memory_alloc(memory, 0, sizeof(*time));
+  if (time == NULL) {
+    return NULL;
+  } else {
+    time->time.action = &time_action;
+    time->time.context = time;
+    time->memory = memory;
+    clock_gettime(CLOCK_REALTIME, &time->abstime);
+    return &time->time;
+  }
+}
+
+static int time_free(struct labcomm2014_time *t)
+{
+  struct pthread_time *time = t->context;
+  struct labcomm2014_memory *memory = time->memory;
+  
+  labcomm2014_memory_free(memory, 0, time);
+  
+  return 0;
+}
+ 
+static int time_add_usec(struct labcomm2014_time *t, uint32_t usec)
+{
+  struct pthread_time *time = t->context;
+
+  timespec_add_usec(&time->abstime, usec);
+
+  return 0;
+}
+
+static struct labcomm2014_time_action time_action = {
+  .free = time_free,
+  .add_usec = time_add_usec
+};
+
+static int run_action(struct pthread_scheduler *scheduler,
+		      struct pthread_deferred *element)
+{
+  /* Called with data_lock held */
+  element->prev->next = element->next;
+  element->next->prev = element->prev;
+  labcomm2014_scheduler_data_unlock(&scheduler->scheduler);
+  element->action(element->context);
+  labcomm2014_memory_free(scheduler->memory, 1, element);
+  labcomm2014_scheduler_data_lock(&scheduler->scheduler);
+  return 0;
+}
+
+static int run_deferred(struct pthread_scheduler *scheduler)
+{
+  /* Called with data_lock held */
+  if (scheduler->running_deferred) { goto out; }
+  scheduler->running_deferred = 1;
+  while (!queue_empty(&scheduler->deferred)) {
+    run_action(scheduler, scheduler->deferred.next);
+  }
+  if (!queue_empty(&scheduler->deferred_with_delay)) {
+    struct timespec now;
+
+    clock_gettime(CLOCK_REALTIME, &now);
+    while (timespec_compare(&scheduler->deferred_with_delay.next->when,
+			    &now) <= 0) {
+      run_action(scheduler, scheduler->deferred_with_delay.next);
+    }
+  }
+  scheduler->running_deferred = 0;
+out:
+  return 0;
+}
+
+static int scheduler_free(struct labcomm2014_scheduler *s)
+{
+  struct pthread_scheduler *scheduler = s->context;
+  struct labcomm2014_memory *memory = scheduler->memory;
+  
+  labcomm2014_memory_free(memory, 0, scheduler);
+
+  return 0;
+}
+ 
+static int scheduler_writer_lock(struct labcomm2014_scheduler *s)
+{
+  struct pthread_scheduler *scheduler = s->context;
+
+  labcomm2014_scheduler_data_lock(&scheduler->scheduler);
+  run_deferred(scheduler);  /* Run deferred tasks before taking lock */
+  labcomm2014_scheduler_data_unlock(&scheduler->scheduler);
+  if (pthread_mutex_lock(&scheduler->writer_mutex) != 0) {
+    return -errno;
+  }
+  return 0;
+}
+ 
+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;
+  }
+  labcomm2014_scheduler_data_lock(&scheduler->scheduler);
+  run_deferred(scheduler);  /* Run deferred tasks after releasing lock */
+  labcomm2014_scheduler_data_unlock(&scheduler->scheduler);
+  
+  return 0;
+}
+
+static int scheduler_data_lock(struct labcomm2014_scheduler *s)
+{
+  struct pthread_scheduler *scheduler = s->context;
+
+  if (pthread_mutex_lock(&scheduler->data_mutex) != 0) {
+    perror("Failed to lock data_mutex");
+    exit(1);
+  }
+  return 0;
+}
+ 
+static int scheduler_data_unlock(struct labcomm2014_scheduler *s)
+{
+  struct pthread_scheduler *scheduler = s->context;
+
+  if (pthread_mutex_unlock(&scheduler->data_mutex) != 0) {
+    perror("Failed to unlock data_mutex");
+    exit(1);
+  }
+  
+  return 0;
+}
+
+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 labcomm2014_scheduler *s,
+			   struct labcomm2014_time *t)
+{
+  struct pthread_scheduler *scheduler = s->context;
+  struct pthread_time *time = t?t->context:NULL;
+
+  labcomm2014_scheduler_data_lock(&scheduler->scheduler);
+  while (1) {
+    struct timespec *wakeup, now;
+
+    /* Run deferred tasks before sleeping */
+    run_deferred(scheduler);
+    
+    clock_gettime(CLOCK_REALTIME, &now);
+    if (scheduler->wakeup ||
+	(time && timespec_compare(&time->abstime, &now) <= 0)) {
+      /* Done waiting */
+      scheduler->wakeup = 0;
+      break;
+    }
+    wakeup = NULL;
+    if (!queue_empty(&scheduler->deferred_with_delay)) {
+      wakeup = &scheduler->deferred_with_delay.next->when;
+      if (time && timespec_compare(&time->abstime, wakeup) < 0) {
+	wakeup = &time->abstime;
+      }
+    } else if (time) {
+      wakeup = &time->abstime;
+    }
+ 
+    if (wakeup) {
+      pthread_cond_timedwait(&scheduler->data_cond, 
+			     &scheduler->data_mutex, 
+			     wakeup);
+    } else {
+      pthread_cond_wait(&scheduler->data_cond, 
+			&scheduler->data_mutex);
+    }
+  }
+  labcomm2014_scheduler_data_unlock(&scheduler->scheduler);
+  
+  return 0;
+}
+
+static int scheduler_wakeup(struct labcomm2014_scheduler *s)
+{
+  struct pthread_scheduler *scheduler = s->context;
+
+  labcomm2014_scheduler_data_lock(&scheduler->scheduler);
+  scheduler->wakeup = 1;
+  pthread_cond_signal(&scheduler->data_cond);
+  labcomm2014_scheduler_data_unlock(&scheduler->scheduler);
+  return 0;
+}
+
+static int scheduler_enqueue(struct labcomm2014_scheduler *s,
+			     uint32_t delay,
+			     void (*deferred)(void *context),
+			     void *context)
+{
+  struct pthread_scheduler *scheduler = s->context;
+  int result = 0;
+  struct pthread_deferred *element, *insert_before;
+
+  element = labcomm2014_memory_alloc(scheduler->memory, 1, sizeof(*element));
+  if (element == NULL) {
+    result = -ENOMEM;
+    goto out;
+  }
+  
+  element->action = deferred;
+  element->context = context;
+  labcomm2014_scheduler_data_lock(&scheduler->scheduler);
+  if (delay == 0) {
+    insert_before = &scheduler->deferred;
+  } else {
+    clock_gettime(CLOCK_REALTIME, &element->when);
+    timespec_add_usec(&element->when, delay);
+    for (insert_before = scheduler->deferred_with_delay.next ; 
+	 timespec_compare(&element->when, &insert_before->when) >= 0 ;
+	 insert_before = insert_before->next) {
+    }
+  }
+  element->next = insert_before;
+  element->prev = insert_before->prev;
+  element->prev->next = element;
+  element->next->prev = element;
+  pthread_cond_signal(&scheduler->data_cond);
+  labcomm2014_scheduler_data_unlock(&scheduler->scheduler);
+
+out:
+  return result;
+}
+
+static const struct labcomm2014_scheduler_action scheduler_action = {
+  .free = scheduler_free,
+  .writer_lock = scheduler_writer_lock,
+  .writer_unlock = scheduler_writer_unlock,
+  .data_lock = scheduler_data_lock,
+  .data_unlock = scheduler_data_unlock,
+  .now = scheduler_now,
+  .sleep = scheduler_sleep,
+  .wakeup = scheduler_wakeup,
+  .enqueue = scheduler_enqueue  
+};
+
+struct labcomm2014_scheduler *labcomm2014_pthread_scheduler_new(
+  struct labcomm2014_memory *memory)
+{
+  struct labcomm2014_scheduler *result = NULL;
+  struct pthread_scheduler *scheduler;
+
+  scheduler = labcomm2014_memory_alloc(memory, 0, sizeof(*scheduler));
+  if (scheduler == NULL) {
+    goto out;
+  } else {
+    scheduler->scheduler.action = &scheduler_action;
+    scheduler->scheduler.context = scheduler;
+    scheduler->wakeup = 0;
+    scheduler->memory = memory;
+    if (pthread_mutex_init(&scheduler->writer_mutex, NULL) != 0) {
+      goto free_scheduler;
+    }
+     if (pthread_mutex_init(&scheduler->data_mutex, NULL) != 0) {
+       goto destroy_writer_mutex;
+    }
+    if (pthread_cond_init(&scheduler->data_cond, NULL) != 0) {
+      goto destroy_data_mutex;
+    }
+    scheduler->running_deferred = 0;
+    scheduler->deferred.next = &scheduler->deferred;
+    scheduler->deferred.prev = &scheduler->deferred;
+    scheduler->deferred_with_delay.next = &scheduler->deferred_with_delay;
+    scheduler->deferred_with_delay.prev = &scheduler->deferred_with_delay;
+    scheduler->deferred_with_delay.when.tv_sec = 0;
+    scheduler->deferred_with_delay.when.tv_nsec = 0;
+    result = &scheduler->scheduler;
+    goto out;
+  }
+destroy_data_mutex:
+  pthread_mutex_destroy(&scheduler->data_mutex);
+destroy_writer_mutex:
+  pthread_mutex_destroy(&scheduler->writer_mutex);
+free_scheduler:
+  labcomm2014_memory_free(memory, 0, scheduler);
+out:
+  return result;
+  
+}
+

lib/c/2014/labcomm2014_pthread_scheduler.h

+/*
+  labcomm2014_pthread_scheduler.h -- labcomm2014 pthread based task coordination
+
+  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_PTHREAD_SCHEDULER_H__
+#define __LABCOMM2014_PTHREAD_SCHEDULER_H__
+
+#include "labcomm2014.h"
+
+struct labcomm2014_scheduler *labcomm2014_pthread_scheduler_new(
+  struct labcomm2014_memory *memory);
+
+#endif
+

lib/c/2014/labcomm2014_renaming.c

+/*
+  labcomm2014_renaming.c -- functions intended for renaming
+                            encoders and decoders
+
+  Copyright 2015 Anders Blomdell <anders.blomdell@control.lth.se>
+
+  This file is part of LabComm.
+
+  LabComm is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  LabComm is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "labcomm2014_renaming.h"
+#include <string.h>
+
+char *labcomm2014_renaming_prefix(struct labcomm2014_memory *m,
+                                  char *name, void *context)
+{
+  char *result, *prefix = context;
+  int length;
+
+  length = strlen(name) + strlen(prefix) + 1;
+  result = labcomm2014_memory_alloc(m, 0, length);
+  if (result != NULL) {
+    strcpy(result, prefix);
+    strcat(result, name);
+  }
+  return result;
+  
+}
+
+char *labcomm2014_renaming_suffix(struct labcomm2014_memory *m,
+                                  char *name, void *context)
+{
+  return labcomm2014_renaming_prefix(m, context, name);
+}
+

lib/c/2014/labcomm2014_renaming.h

+/*
+  labcomm2014_renaming.h -- functions intended for renaming
+                            encoders and decoders
+
+  Copyright 2015 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_RENAMING_H__
+#define __LABCOMM2014_RENAMING_H__
+
+#include "labcomm2014.h"
+
+char *labcomm2014_renaming_prefix(struct labcomm2014_memory *m,
+                                  char *name, void *context);
+
+char *labcomm2014_renaming_suffix(struct labcomm2014_memory *m,
+                                  char *name, void *context);
+
+struct labcomm2014_renaming_registry *labcomm2014_renaming_registry_new(
+  struct labcomm2014_error_handler *error,
+  struct labcomm2014_memory *memory,
+  struct labcomm2014_scheduler *scheduler);
+
+void labcomm2014_renaming_registry_free(
+  struct labcomm2014_renaming_registry *r);
+
+#endif

lib/c/2014/labcomm2014_renaming_decoder.c

+/*
+  labcomm2014_renaming_decoder.c -- a stacked decoder that renames samples
+
+  Copyright 2015 Anders Blomdell <anders.blomdell@control.lth.se>
+
+  This file is part of LabComm.
+
+  LabComm is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  LabComm is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <errno.h>
+#include "labcomm2014_renaming_decoder.h"
+#include "labcomm2014.h"
+#include "labcomm2014_private.h"
+#include "labcomm2014_renaming_private.h"
+
+struct decoder {
+  struct labcomm2014_decoder decoder;
+  struct labcomm2014_decoder *next;
+  struct labcomm2014_renaming_registry *registry;
+  char *(*rename_func)(struct labcomm2014_memory *m, char *name, void *context);
+  void *context;
+  LABCOMM_SIGNATURE_ARRAY_DEF(renamed,
+                              struct labcomm2014_renaming_rename *);
+};
+
+static struct labcomm2014_renaming_rename *get_renamed(
+  struct labcomm2014_decoder *d,
+  const struct labcomm2014_signature *signature)
+{
+  struct labcomm2014_renaming_rename *result;
+  struct decoder *id = d->context;
+  int index;
+
+  index = labcomm2014_get_local_index(signature);
+  labcomm2014_scheduler_data_lock(d->scheduler);
+  result = LABCOMM_SIGNATURE_ARRAY_GET(id->renamed,
+                                      struct labcomm2014_renaming_rename *,
+                                      index, NULL);
+  labcomm2014_scheduler_data_unlock(d->scheduler);
+  return result;
+}
+  
+static struct labcomm2014_renaming_rename *set_renamed(
+  struct labcomm2014_decoder *d,
+  const struct labcomm2014_signature *signature)
+{
+  struct labcomm2014_renaming_rename *result = NULL;
+
+  result = get_renamed(d, signature);
+  if (result == NULL) {
+    struct decoder *id = d->context;
+    struct labcomm2014_renaming_rename **renamed;
+    struct labcomm2014_renaming_rename *entry = NULL;
+    int index;
+
+    index = labcomm2014_get_local_index(signature);
+    entry = labcomm2014_renaming_rename_new(id->registry, signature,
+                                            id->rename_func, id->context);
+    if (entry == NULL) { goto out; }
+    labcomm2014_scheduler_data_lock(d->scheduler);
+    renamed = LABCOMM_SIGNATURE_ARRAY_REF(d->memory, id->renamed,
+                                          struct labcomm2014_renaming_rename *,
+                                          index);
+    if (renamed == NULL) { goto free_unlock; }
+    if (*renamed != NULL) { result = *renamed; goto free_unlock; }
+    *renamed = entry;
+    result = entry;
+    goto unlock;
+  free_unlock:
+    labcomm2014_renaming_rename_free(id->registry, entry);
+  unlock:
+    labcomm2014_scheduler_data_unlock(d->scheduler);
+  out:
+    ;
+  }
+  return result;
+}
+
+static int do_sample_register(struct labcomm2014_decoder *d, 
+                         const struct labcomm2014_signature *signature, 
+                         labcomm2014_decoder_function decoder,
+                         labcomm2014_handler_function handler,
+                         void *context)
+{
+  const struct labcomm2014_renaming_rename *renamed;
+  struct decoder *id = d->context;
+  
+  renamed = set_renamed(d, signature);  
+  return id->next->sample_register(
+    id->next, labcomm2014_renaming_rename_signature(renamed),
+    decoder, handler, context);
+}
+
+static int do_ref_register(struct labcomm2014_decoder *d, 
+                      const struct labcomm2014_signature *signature)
+{
+  const struct labcomm2014_renaming_rename *renamed;
+  struct decoder *id = d->context;
+
+  renamed = set_renamed(d, signature);  
+  return id->next->ref_register(
+    id->next, labcomm2014_renaming_rename_signature(renamed));
+}
+
+static int do_ioctl(struct labcomm2014_decoder *d, 
+                    const struct labcomm2014_signature *signature,
+                    uint32_t ioctl_action, va_list args)
+{
+  const struct labcomm2014_renaming_rename *renamed;
+  struct decoder *id = d->context;
+  
+  renamed = get_renamed(d, signature);
+  return id->next->ioctl(
+    id->next, labcomm2014_renaming_rename_signature(renamed),
+    ioctl_action, args);
+}
+
+static int do_decode_one(struct labcomm2014_decoder *d)
+{
+  struct decoder *id = d->context;
+
+  return id->next->decode_one(id->next);
+}
+
+static const struct labcomm2014_sample_ref *do_index_to_sample_ref(
+  struct labcomm2014_decoder *d, int index)
+{
+  struct decoder *id = d->context;
+  
+  return id->next->index_to_sample_ref(id->next, index);
+}
+
+static const struct labcomm2014_sample_ref *do_ref_get(
+  struct labcomm2014_decoder *d,
+  const struct labcomm2014_signature *signature)
+{
+  const struct labcomm2014_renaming_rename *renamed;
+  struct decoder *id = d->context;
+
+  renamed = get_renamed(d, signature);
+  if (renamed == NULL) {
+    return id->next->ref_get(id->next, signature);
+  } else {
+    return id->next->ref_get(id->next,
+                             labcomm2014_renaming_rename_signature(renamed));
+  }
+}
+
+static void do_free(struct labcomm2014_decoder *d)
+{
+  struct decoder *id = d->context;
+  int i;
+
+  LABCOMM_SIGNATURE_ARRAY_FOREACH(id->renamed,
+                                  struct labcomm2014_renaming_rename *,
+                                  i) {
+    struct labcomm2014_renaming_rename *r;
+    r = LABCOMM_SIGNATURE_ARRAY_GET(id->renamed,
+                                    struct labcomm2014_renaming_rename *,
+                                    i, NULL);
+    if (r) {
+      labcomm2014_renaming_rename_free(id->registry, r);
+    }
+  }
+  LABCOMM_SIGNATURE_ARRAY_FREE(d->memory, id->renamed,
+                               struct labcomm2014_renaming_rename *);
+  labcomm2014_memory_free(d->memory, 0, id);
+}
+
+struct labcomm2014_decoder *labcomm2014_renaming_decoder_new(
+  struct labcomm2014_decoder *d,
+  struct labcomm2014_renaming_registry *registry,
+  char *(*rename)(struct labcomm2014_memory *m, char *name, void *context),
+  void *context)
+{
+  struct decoder *result;
+  result = labcomm2014_memory_alloc(d->memory, 0, sizeof(*result));
+  if (!result) {
+    return NULL;
+  } else {
+      result->decoder.context = result;
+      result->decoder.reader = d->reader;
+      result->decoder.error = d->error;
+      result->decoder.memory = d->memory;
+      result->decoder.scheduler = d->scheduler;
+      result->decoder.free = do_free;
+      result->decoder.decode_one = do_decode_one;
+      result->decoder.sample_register = do_sample_register;
+      result->decoder.ref_register = do_ref_register;
+      result->decoder.ioctl = do_ioctl;
+      result->decoder.index_to_sample_ref = do_index_to_sample_ref;
+      result->decoder.ref_get = do_ref_get;
+      result->next = d;
+      result->registry = registry;
+      result->rename_func = rename;
+      result->context = context;
+      LABCOMM_SIGNATURE_ARRAY_INIT(result->renamed,
+                                   struct labcomm2014_renaming_rename *);
+      return &(result->decoder);
+  }
+}

lib/c/2014/labcomm2014_renaming_decoder.h

+/*
+  labcomm2014_renaming_decoder.h -- a stacked decoder that renames samples
+
+  Copyright 2015 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_RENAMING_DECODER_H__
+#define __LABCOMM2014_RENAMING_DECODER_H__
+
+#include "labcomm2014.h"
+#include "labcomm2014_renaming.h"
+
+struct labcomm2014_decoder *labcomm2014_renaming_decoder_new(
+  struct labcomm2014_decoder *d,
+  struct labcomm2014_renaming_registry *r,
+  char *(*rename)(struct labcomm2014_memory *m, char *name, void *context),
+  void *context);
+
+#endif

lib/c/2014/labcomm2014_renaming_encoder.c

+/*
+  labcomm2014_renaming_encoder.c -- a stacked encoder that renames samples
+
+  Copyright 2015 Anders Blomdell <anders.blomdell@control.lth.se>
+
+  This file is part of LabComm.
+
+  LabComm is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  LabComm is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <errno.h>
+#include "labcomm2014_renaming_encoder.h"
+#include "labcomm2014.h"
+#include "labcomm2014_private.h"
+#include "labcomm2014_renaming_private.h"
+
+struct encoder {
+  struct labcomm2014_encoder encoder;
+  struct labcomm2014_encoder *next;
+  struct labcomm2014_renaming_registry *registry;
+  char *(*rename_func)(struct labcomm2014_memory *m, char *name, void *context);
+  void *context;
+  LABCOMM_SIGNATURE_ARRAY_DEF(renamed,
+                              struct labcomm2014_renaming_rename *);
+};
+
+static struct labcomm2014_renaming_rename *get_renamed(
+  struct labcomm2014_encoder *e,
+  const struct labcomm2014_signature *signature)
+{
+  struct labcomm2014_renaming_rename *result;
+  struct encoder *ie = e->context;
+  int index;
+
+  index = labcomm2014_get_local_index(signature);
+  labcomm2014_scheduler_writer_lock(e->scheduler);
+  result = LABCOMM_SIGNATURE_ARRAY_GET(ie->renamed,
+                                      struct labcomm2014_renaming_rename *,
+                                      index, NULL);
+  labcomm2014_scheduler_writer_unlock(e->scheduler);
+  return result;
+}
+  
+static struct labcomm2014_renaming_rename *set_renamed(
+  struct labcomm2014_encoder *e,
+  const struct labcomm2014_signature *signature)
+{
+  struct labcomm2014_renaming_rename *result = NULL;
+
+  result = get_renamed(e, signature);
+  if (result == NULL) {
+    struct encoder *ie = e->context;
+    struct labcomm2014_renaming_rename **renamed;
+    struct labcomm2014_renaming_rename *entry = NULL;
+    int index;
+
+    index = labcomm2014_get_local_index(signature);
+    entry = labcomm2014_renaming_rename_new(ie->registry, signature,
+                                            ie->rename_func, ie->context);
+    if (entry == NULL) { goto out; }
+    labcomm2014_scheduler_writer_lock(e->scheduler);
+    renamed = LABCOMM_SIGNATURE_ARRAY_REF(e->memory, ie->renamed,
+                                          struct labcomm2014_renaming_rename *,
+                                          index);
+    if (renamed == NULL) { goto free_unlock; }
+    if (*renamed != NULL) { result = *renamed; goto free_unlock; }
+    *renamed = entry;
+    result = entry;
+    goto unlock;
+  free_unlock:
+    labcomm2014_renaming_rename_free(ie->registry, entry);
+  unlock:
+    labcomm2014_scheduler_writer_unlock(e->scheduler);
+  out:
+    ;
+  }
+  return result;
+}
+  
+static int do_type_register(struct labcomm2014_encoder *e,
+                            const struct labcomm2014_signature *signature)
+{
+  const struct labcomm2014_renaming_rename *renamed;
+  struct encoder *ie = e->context;
+
+  renamed = get_renamed(e, signature);
+  if (renamed) {
+    /* Register base type and renamed type */
+    ie->next->type_register(ie->next, signature);
+    return ie->next->type_register(
+      ie->next, labcomm2014_renaming_rename_signature(renamed));
+  } else {
+    return ie->next->type_register(ie->next, signature);
+  }
+}
+
+static int do_type_bind(struct labcomm2014_encoder *e,
+                        const struct labcomm2014_signature *signature,
+                        char has_deps)
+{
+  const struct labcomm2014_renaming_rename *renamed;
+  struct encoder *ie = e->context;
+
+  renamed = get_renamed(e, signature);
+  if (renamed) {
+    return ie->next->type_bind(
+      ie->next, labcomm2014_renaming_rename_signature(renamed), 1);
+  } else {
+    return ie->next->type_bind(ie->next, signature, has_deps);
+  }
+}
+
+static int do_sample_register(struct labcomm2014_encoder *e, 
+                         const struct labcomm2014_signature *signature, 
+                         labcomm2014_encoder_function encode)
+{
+  const struct labcomm2014_renaming_rename *renamed;
+  struct encoder *ie = e->context;
+
+  renamed = set_renamed(e, signature);  
+  return ie->next->sample_register(
+    ie->next, labcomm2014_renaming_rename_signature(renamed), encode);
+}
+
+static int do_ref_register(struct labcomm2014_encoder *e, 
+                      const struct labcomm2014_signature *signature)
+{
+  const struct labcomm2014_renaming_rename *renamed;
+  struct encoder *ie = e->context;
+
+  renamed = set_renamed(e, signature);  
+  return ie->next->ref_register(ie->next,
+                                labcomm2014_renaming_rename_signature(renamed));
+}
+
+static int do_encode(struct labcomm2014_encoder *e, 
+                     const struct labcomm2014_signature *signature, 
+                     labcomm2014_encoder_function encode,
+                     void *value)
+{
+  const struct labcomm2014_renaming_rename *renamed;
+  struct encoder *ie = e->context;
+
+  renamed = get_renamed(e, signature);
+  if (renamed == NULL) {
+    return -EINVAL;
+  } else {
+    return ie->next->encode(ie->next,
+                            labcomm2014_renaming_rename_signature(renamed),
+                            encode, value);
+  }
+}
+
+static int do_ioctl(struct labcomm2014_encoder *e, 
+                    const struct labcomm2014_signature *signature,
+                    uint32_t ioctl_action, va_list args)
+{
+  const struct labcomm2014_renaming_rename *renamed;
+  struct encoder *ie = e->context;
+
+  renamed = get_renamed(e, signature);
+  if (renamed != NULL) {
+    signature = labcomm2014_renaming_rename_signature(renamed);
+  }
+  return ie->next->ioctl(ie->next, signature, ioctl_action, args);
+}
+
+static int do_sample_ref_to_index(
+  struct labcomm2014_encoder *e,
+  const struct labcomm2014_sample_ref *sample_ref)
+{
+  struct encoder *ie = e->context;
+
+  return ie->next->sample_ref_to_index(ie->next,sample_ref);
+}
+
+static const struct labcomm2014_sample_ref *do_ref_get(
+  struct labcomm2014_encoder *e,
+  const struct labcomm2014_signature *signature)
+{
+  const struct labcomm2014_renaming_rename *renamed;
+  struct encoder *ie = e->context;
+
+  renamed = get_renamed(e, signature);
+  if (renamed == NULL) {
+    return ie->next->ref_get(ie->next, signature);
+  } else {
+    return ie->next->ref_get(
+      ie->next, labcomm2014_renaming_rename_signature(renamed));
+  }
+}
+
+static void do_free(struct labcomm2014_encoder *e)
+{
+  struct encoder *ie = e->context;
+  int i;
+
+  LABCOMM_SIGNATURE_ARRAY_FOREACH(ie->renamed,
+                                  struct labcomm2014_renaming_rename *, i) {
+    struct labcomm2014_renaming_rename *r;
+    r = LABCOMM_SIGNATURE_ARRAY_GET(ie->renamed,
+                                    struct labcomm2014_renaming_rename *, i,
+                                    NULL);
+    if (r) {
+      labcomm2014_renaming_rename_free(ie->registry, r);
+    }
+  }
+  LABCOMM_SIGNATURE_ARRAY_FREE(e->memory, ie->renamed, struct labcomm2014_renaming_rename *);
+  labcomm2014_memory_free(e->memory, 0, ie);
+}
+
+struct labcomm2014_encoder *labcomm2014_renaming_encoder_new(
+  struct labcomm2014_encoder *e,
+  struct labcomm2014_renaming_registry *registry,
+  char *(*rename)(struct labcomm2014_memory *m, char *name, void *context),
+  void *context)
+{
+  struct encoder *result;
+  result = labcomm2014_memory_alloc(e->memory, 0, sizeof(*result));
+  if (!result) {
+    return NULL;
+  } else {
+      result->encoder.context = result;
+      result->encoder.writer = e->writer;
+      result->encoder.error = e->error;
+      result->encoder.memory = e->memory;
+      result->encoder.scheduler = e->scheduler;
+      result->encoder.free = do_free;
+      result->encoder.type_register = do_type_register;
+      result->encoder.type_bind = do_type_bind;
+      result->encoder.sample_register = do_sample_register;
+      result->encoder.ref_register = do_ref_register;
+      result->encoder.encode = do_encode;
+      result->encoder.ioctl = do_ioctl;
+      result->encoder.sample_ref_to_index = do_sample_ref_to_index;
+      result->encoder.ref_get = do_ref_get;
+      result->next = e;
+      result->registry = registry;
+      result->rename_func = rename;
+      result->context = context;
+      LABCOMM_SIGNATURE_ARRAY_INIT(result->renamed,
+                                   struct labcomm2014_renaming_rename *);
+      return &(result->encoder);
+  }
+}

lib/c/2014/labcomm2014_renaming_encoder.h

+/*
+  labcomm2014_renaming_encoder.h -- a stacked encoder that renames samples
+
+  Copyright 2015 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_RENAMING_ENCODER_H__
+#define __LABCOMM2014_RENAMING_ENCODER_H__
+
+#include "labcomm2014.h"
+#include "labcomm2014_renaming.h"
+
+struct labcomm2014_encoder *labcomm2014_renaming_encoder_new(
+  struct labcomm2014_encoder *e,
+  struct labcomm2014_renaming_registry *r,
+  char *(*rename)(struct labcomm2014_memory *m, char *name, void *context),
+  void *context);
+
+#endif

lib/c/2014/labcomm2014_renaming_private.h

+/*
+  labcomm2014_renaming_private.h -- functions intended for renaming
+                                    encoders and decoders
+
+  Copyright 2015 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_RENAMING__PRIVATE_H__
+#define __LABCOMM2014_RENAMING_PRIVATE_H__
+
+#include "labcomm2014.h"
+#include "labcomm2014_renaming.h"
+
+struct labcomm2014_renaming_rename *labcomm2014_renaming_rename_new(
+  struct labcomm2014_renaming_registry *r,
+  const struct labcomm2014_signature *signature,
+  char *(*rename)(struct labcomm2014_memory *m, char *name, void *context),
+  void *context);
+
+void labcomm2014_renaming_rename_free(
+  struct labcomm2014_renaming_registry *r,
+  struct labcomm2014_renaming_rename *rename);
+
+const struct labcomm2014_signature *labcomm2014_renaming_rename_signature(
+  const struct labcomm2014_renaming_rename *rename);
+
+#endif

lib/c/2014/labcomm2014_renaming_registry.c

+/*
+  labcomm2014_renaming_registry.c -- renaming registry
+
+  Copyright 2015 Anders Blomdell <anders.blomdell@control.lth.se>
+
+  This file is part of LabComm.
+
+  LabComm is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  LabComm is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "labcomm2014.h"
+#include "labcomm2014_private.h"
+#include "labcomm2014_renaming_private.h"
+
+struct alias {
+  int usecount;
+  struct alias *next;
+  char *name;
+};
+
+struct registry {
+  struct registry *base; /* NULL if this is the base type */
+  const struct labcomm2014_signature *signature;
+  struct labcomm2014_renaming_rename *rename;
+};
+
+struct labcomm2014_renaming_rename {
+  struct labcomm2014_renaming_rename *next;
+  int use_count;
+  struct registry *base;
+  struct labcomm2014_signature signature;
+  struct labcomm2014_signature_data s_treedata[2];
+};
+
+struct labcomm2014_renaming_registry {
+  struct labcomm2014_error_handler *error;
+  struct labcomm2014_memory *memory;
+  struct labcomm2014_scheduler *scheduler;
+  LABCOMM_SIGNATURE_ARRAY_DEF(registry, struct registry *);
+};
+
+struct labcomm2014_renaming_registry *labcomm2014_renaming_registry_new(
+  struct labcomm2014_error_handler *error,
+  struct labcomm2014_memory *memory,
+  struct labcomm2014_scheduler *scheduler)
+{
+  struct labcomm2014_renaming_registry *result;
+  result = labcomm2014_memory_alloc(memory, 0, sizeof(*result));
+  if (! result) {
+    return NULL;
+  } else {
+    result->error = error;
+    result->memory = memory;
+    result->scheduler = scheduler;
+    LABCOMM_SIGNATURE_ARRAY_INIT(result->registry, struct registry *);
+    return result;
+  }
+}
+
+void labcomm2014_renaming_registry_free(
+  struct labcomm2014_renaming_registry *r)
+{
+  LABCOMM_SIGNATURE_ARRAY_FREE(r->memory, r->registry, struct registry *);
+  labcomm2014_memory_free(r->memory, 0, r);
+}
+
+static struct registry *registry_new(
+  struct labcomm2014_renaming_registry *r,
+  const struct labcomm2014_signature *signature,
+  struct registry *base)
+{
+  /* Called with registry locked */
+  struct registry *result = NULL;
+  struct registry **registry;
+  int index;
+
+  index = labcomm2014_get_local_index(signature);
+  if (index <= 0) {
+    labcomm2014_error_warning(r->error,
+                              LABCOMM2014_ERROR_MEMORY,
+                              "Signature has no index: %s\n",
+                              signature->name);
+    goto out;
+  }
+  registry = LABCOMM_SIGNATURE_ARRAY_REF(r->memory, r->registry,
+                                          struct registry *, index);
+  if (registry == NULL) { goto out; }
+  if (*registry != NULL) {
+    result = *registry;
+  } else {
+    /* Add previosly unknown sample to registry */
+    registry = LABCOMM_SIGNATURE_ARRAY_REF(r->memory, r->registry,
+                                          struct registry *, index);
+    if (registry == NULL) { goto out; }
+    result = labcomm2014_memory_alloc(r->memory, 0, sizeof(*result));
+    if (result == NULL) { goto out; }
+    result->base = base;
+    result->signature = signature;
+    result->rename = NULL;
+    *registry = result;
+  }
+out:
+  return result;
+}
+
+struct labcomm2014_renaming_rename *labcomm2014_renaming_rename_new(
+  struct labcomm2014_renaming_registry *r,
+  const struct labcomm2014_signature *signature,
+  char *(*rename)(struct labcomm2014_memory *m, char *name, void *context),
+  void *context)
+{
+  struct labcomm2014_renaming_rename *result = NULL;
+
+  labcomm2014_scheduler_data_lock(r->scheduler);
+  {
+    char *new_name = NULL;
+    static struct registry *base, *renamed;
+    struct labcomm2014_renaming_rename **l;
+
+    base = registry_new(r, signature, NULL);
+    if (base == NULL) { goto out; }
+    if (base->base) {
+      base = base->base;
+    }
+
+    /* Find if renamed entry already exists */
+    new_name = rename(r->memory, signature->name, context);
+    if (new_name == NULL) { goto out; }
+    for (l = &base->rename ; *l ; l = &(*l)->next) {
+      if (strcmp((*l)->signature.name, new_name) == 0) { break; }
+    }
+    if ((*l) == NULL) {
+      /* Create a new rename entry */
+      struct labcomm2014_renaming_rename *entry = NULL;
+
+      entry = labcomm2014_memory_alloc(r->memory, 0, sizeof(*entry));
+      if (entry == NULL) { goto out; }
+      entry->signature.name = new_name;
+      new_name = NULL;
+      entry->signature.encoded_size = base->signature->encoded_size;
+      entry->signature.size = base->signature->size;
+      entry->signature.signature = base->signature->signature;
+      entry->signature.index = 0;
+#ifndef LABCOMM_NO_TYPEDECL
+      struct labcomm2014_signature_data s_treedata[2] = {
+        LABCOMM_SIGDEF_SIGNATURE(*base->signature),
+        LABCOMM_SIGDEF_END
+      };
+      entry->s_treedata[0] = s_treedata[0];
+      entry->s_treedata[1] = s_treedata[1];
+      entry->signature.tdsize = sizeof(entry->s_treedata);
+      entry->signature.treedata = entry->s_treedata;
+#endif
+      labcomm2014_set_local_index(&entry->signature);
+      renamed = registry_new(r, &entry->signature, base);
+      if (renamed == NULL) {
+        /* Failed to create registry entry */
+        labcomm2014_memory_free(r->memory, 0, entry);
+        goto out;
+      } else {
+        entry->next = NULL;
+        entry->use_count = 0;
+        entry->base = base;
+        (*l) = entry;
+      }
+    }
+    result = *l;
+    if (result) {
+      result->use_count++;
+    }
+  out:
+    if (new_name != NULL) {
+      labcomm2014_memory_free(r->memory, 0, new_name);
+    }
+  }
+  labcomm2014_scheduler_data_unlock(r->scheduler);
+  return result;
+}
+
+void labcomm2014_renaming_rename_free(
+  struct labcomm2014_renaming_registry *r,
+  struct labcomm2014_renaming_rename *rename)
+{
+  labcomm2014_scheduler_data_lock(r->scheduler);
+  rename->use_count--;
+  if (rename->use_count == 0) {
+    int index;
+    struct labcomm2014_renaming_rename **l;
+    struct registry **registry;
+
+    for (l = &rename->base->rename ; *l ; l = &(*l)->next) {
+      if (*l == rename) { break; }
+    }
+    *l = rename->next;
+    if (rename->base->rename == NULL) {
+      /* Last use of base signature */
+      index = labcomm2014_get_local_index(rename->base->signature);
+      registry = LABCOMM_SIGNATURE_ARRAY_REF(r->memory, r->registry,
+                                             struct registry *, index);
+      labcomm2014_memory_free(r->memory, 0, *registry);
+      *registry = NULL;
+    }
+    index = labcomm2014_get_local_index(&rename->signature);
+    registry = LABCOMM_SIGNATURE_ARRAY_REF(r->memory, r->registry,
+                                           struct registry *, index);
+    labcomm2014_memory_free(r->memory, 0, *registry);
+    *registry = NULL;
+       
+    /* TODO: We should return the index to the pool*/
+    labcomm2014_memory_free(r->memory, 0, rename->signature.name);
+    labcomm2014_memory_free(r->memory, 0, rename);
+  }
+  labcomm2014_scheduler_data_unlock(r->scheduler);
+
+}
+
+const struct labcomm2014_signature *labcomm2014_renaming_rename_signature(
+  const struct labcomm2014_renaming_rename *rename)
+{
+  return &rename->signature;
+}

lib/c/2014/labcomm2014_scheduler.c

+/*
+  labcomm2014_scheduler.c -- labcomm2014 task coordination
+
+  Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
+
+  This file is part of LabComm.
+
+  LabComm is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  LabComm is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <errno.h>
+#include "labcomm2014_scheduler_private.h"
+
+#define SCHEDULER_scheduler(scheduler, ...) scheduler
+#define SCHEDULER(func, ...)						\
+  if (SCHEDULER_scheduler(__VA_ARGS__) &&				\
+      SCHEDULER_scheduler(__VA_ARGS__)->action->func) {			\
+    return SCHEDULER_scheduler(__VA_ARGS__)->action->func(__VA_ARGS__);	\
+  }									\
+  return -ENOSYS;
+
+int labcomm2014_scheduler_free(struct labcomm2014_scheduler *s)
+{
+  SCHEDULER(free, s);
+}
+
+int labcomm2014_scheduler_writer_lock(struct labcomm2014_scheduler *s)
+{
+  SCHEDULER(writer_lock, s);
+}
+
+int labcomm2014_scheduler_writer_unlock(struct labcomm2014_scheduler *s)
+{
+  SCHEDULER(writer_unlock, s);
+}
+
+int labcomm2014_scheduler_data_lock(struct labcomm2014_scheduler *s)
+{
+  SCHEDULER(data_lock, s);
+}
+
+int labcomm2014_scheduler_data_unlock(struct labcomm2014_scheduler *s)
+{
+  SCHEDULER(data_unlock, s);
+}
+
+struct labcomm2014_time *labcomm2014_scheduler_now(struct labcomm2014_scheduler *s)
+{
+  if (s && s->action->now) {
+    return s->action->now(s); 
+  } 
+  return NULL;
+}
+
+int labcomm2014_scheduler_sleep(struct labcomm2014_scheduler *s,
+			    struct labcomm2014_time *wakeup)
+{
+  SCHEDULER(sleep, s, wakeup);
+}
+
+int labcomm2014_scheduler_wakeup(struct labcomm2014_scheduler *s)
+{
+  SCHEDULER(wakeup, s);
+}
+
+int labcomm2014_scheduler_enqueue(struct labcomm2014_scheduler *s,
+			      uint32_t delay,
+			      void (*func)(void *context),
+			      void *context)
+{
+  SCHEDULER(enqueue, s, delay, func, context);
+}
+
+

lib/c/2014/labcomm2014_scheduler.h

+/*
+  labcomm2014_scheduler.h -- labcomm2014 task coordination
+
+  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_H__
+#define __LABCOMM2014_SCHEDULER_H__
+
+#ifdef LABCOMM_COMPAT
+  #include LABCOMM_COMPAT
+#else
+  #include <unistd.h>
+  #include <stdint.h>
+#endif
+
+struct labcomm2014_time;
+
+int labcomm2014_time_free(struct labcomm2014_time *t);
+int labcomm2014_time_add_usec(struct labcomm2014_time *t, uint32_t usec);
+
+struct labcomm2014_scheduler;
+
+int labcomm2014_scheduler_free(struct labcomm2014_scheduler *s);
+
+/* Lock and event handling */
+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 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 labcomm2014_scheduler_enqueue(struct labcomm2014_scheduler *s,
+			      uint32_t delay,
+			      void (*deferred)(void *context),
+			      void *context);
+
+#endif
+

lib/c/2014/labcomm2014_scheduler_private.h

+/*
+  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