lib/c/2014/test/test_labcomm_renaming_encoder.c

+/*
+  test_labcomm2014_renaming.c -- LabComm tests of renaming
+
+  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 <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include "labcomm2014_private.h"
+#include "labcomm2014_default_error_handler.h"
+#include "labcomm2014_default_memory.h"
+#include "labcomm2014_default_scheduler.h"
+#include "labcomm2014_renaming.h"
+#include "labcomm2014_renaming_encoder.h"
+#include "test/gen/generated_encoding.h"
+
+#define IOCTL_WRITER_ASSERT_BYTES 4096
+#define IOCTL_WRITER_RESET 4097
+
+#define EXPECT(...)							\
+  {                                                                     \
+    int expected[] = __VA_ARGS__;					\
+    labcomm2014_encoder_ioctl(encoder, IOCTL_WRITER_ASSERT_BYTES,       \
+			  __LINE__,					\
+			  sizeof(expected)/sizeof(expected[0]),		\
+			  expected);					\
+  }
+
+#define VARIABLE(i) -(i + 1)
+#define IS_VARIABLE(i) (i < 0)
+
+static unsigned char buffer[128];
+struct labcomm2014_writer *writer;
+static int seen_variable[1024];
+
+static int buf_writer_alloc(
+  struct labcomm2014_writer *w, 
+  struct labcomm2014_writer_action_context *action_context)
+{
+  writer = w; /* Hack */
+  w->data_size = sizeof(buffer);
+  w->count = w->data_size;
+  w->data = buffer;
+  w->pos = 0;
+  
+  return 0;
+}
+
+static int buf_writer_free(
+  struct labcomm2014_writer *w, 
+  struct labcomm2014_writer_action_context *action_context)
+{
+  return 0;
+}
+
+static int buf_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 labcomm2014_writer *w, 
+  struct labcomm2014_writer_action_context *action_context)
+{
+  return 0;
+}
+
+static int buf_writer_flush(
+  struct labcomm2014_writer *w, 
+  struct labcomm2014_writer_action_context *action_context)
+{
+  fprintf(stderr, "Should not come here %s:%d\n", __FILE__, __LINE__);
+  exit(1);
+  
+  return 0;
+}
+
+static int buf_writer_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 IOCTL_WRITER_ASSERT_BYTES: {
+      int line = va_arg(arg, int);
+      int count = va_arg(arg, int);
+      int *expected = va_arg(arg, int *);
+      int i, mismatch;
+
+      mismatch = 0;
+      if (w->pos != count) {
+	fprintf(stderr, "Invalid length detected %d != %d (%s:%d)\n", 
+		w->pos, count, __FILE__, line);
+	mismatch = 1;
+      } 
+      for (i = 0 ; i < count ; i++) {
+        if (IS_VARIABLE(expected[i])) {
+          if (seen_variable[VARIABLE(expected[i])] == -1) {
+            seen_variable[VARIABLE(expected[i])] = buffer[i];
+          }
+          if (seen_variable[VARIABLE(expected[i])] != buffer[i]) {
+            fprintf(stderr, "Unexpected variable v%d (%02x:  != %02x)\n",
+                    VARIABLE(expected[i]),
+                    seen_variable[VARIABLE(expected[i])], buffer[i]);
+            mismatch = 1;
+          }
+        } else if (expected[i] != buffer[i]) {
+	  mismatch = 1;
+	}
+      }
+      if (mismatch) {
+	fprintf(stderr, "Encoder mismatch (%s:%d)\n",
+		__FILE__, line);
+
+	for (i = 0 ; i < w->pos ; i++) {
+          if (32 <= w->data[i] &&  w->data[i] < 127) {
+            printf("%2c ", w->data[i]);
+          } else {
+            printf("%2.2x ", w->data[i]);
+          }
+	}
+	printf("\n");
+	for (i = 0 ; i < w->pos ; i++) {
+	  printf("%2.2x ", w->data[i]);
+	}
+	printf("\n");
+	for (i = 0 ; i < count ; i++) {
+	  if (expected[i] < 0) {
+	    printf("v%d ", VARIABLE(expected[i]));
+	  } else {
+	    printf("%2.2x ", expected[i] );
+	  }
+	}
+	printf("\n");
+	if (mismatch) { exit(1); }
+      }
+      result = 0;
+    } break;
+    case IOCTL_WRITER_RESET: {
+      w->pos = 0;
+      result = 0;
+    }
+  }
+  return result;
+}
+
+const struct labcomm2014_writer_action writer_action = {
+  .alloc = buf_writer_alloc,
+  .free = buf_writer_free,
+  .start = buf_writer_start,
+  .end = buf_writer_end,
+  .flush = buf_writer_flush,
+  .ioctl = buf_writer_ioctl
+};
+
+static struct labcomm2014_writer_action_context action_context = {
+  .next = NULL,
+  .action = &writer_action,
+  .context = NULL
+}; 
+static struct labcomm2014_writer buffer_writer = {
+  .action_context = &action_context,
+  .data = buffer,
+  .data_size = sizeof(buffer),
+  .count = sizeof(buffer),
+  .pos = 0,
+  .error = 0,
+};
+
+void dump_encoder(struct labcomm2014_encoder *encoder)
+{
+  int i;
+  
+  for (i = 0 ; i < writer->pos ; i++) {
+    printf("%2.2x ", writer->data[i]);
+  }
+  printf("\n");
+}
+
+static int do_test(int argc, char *argv[])
+{
+  struct labcomm2014_renaming_registry *registry;
+  struct labcomm2014_encoder *encoder, *prefix, *suffix;
+  int i;
+
+  for (i = 0 ; i < sizeof(seen_variable)/sizeof(seen_variable[0]) ; i++) {
+    seen_variable[i] = -1;
+  }
+
+  registry = labcomm2014_renaming_registry_new(
+    labcomm2014_default_error_handler,
+    labcomm2014_default_memory,
+    labcomm2014_default_scheduler);
+  encoder = labcomm2014_encoder_new(
+    &buffer_writer, 
+    labcomm2014_default_error_handler,
+    labcomm2014_default_memory,
+    labcomm2014_default_scheduler);
+  prefix = labcomm2014_renaming_encoder_new(encoder,
+                                            registry,
+                                            labcomm2014_renaming_prefix,
+                                            "p.");
+  suffix = labcomm2014_renaming_encoder_new(prefix,
+                                            registry,
+                                            labcomm2014_renaming_suffix,
+                                            ".s");
+  EXPECT({ 0x01, 0x0c, 0x0b, 
+           'L', 'a', 'b', 'C', 'o', 'm', 'm', '2','0', '1', '4' });
+
+  labcomm2014_encoder_ioctl(encoder, IOCTL_WRITER_RESET);
+  /* Register twice to make sure that only one registration gets encoded */
+  labcomm2014_encoder_register_generated_encoding_V(encoder);
+  labcomm2014_encoder_register_generated_encoding_V(encoder);
+  EXPECT({ 0x02, 0x08, VARIABLE(0), 0x01, 0x00, 0x01, 'V', 0x02, 0x11, 0x00,
+           0x04, 0x0a, VARIABLE(1), 0x01, 0x00, 0x03, 'v', '_', 't', 0x02, 0x11, 0x00,
+           0x04, 0x07, VARIABLE(2), 0x01, 0x00, 0x01, 'V', 0x01, VARIABLE(1),
+           0x05, 0x02, VARIABLE(0), VARIABLE(2) });
+
+  labcomm2014_encoder_ioctl(prefix, IOCTL_WRITER_RESET);
+  labcomm2014_encoder_register_generated_encoding_V(prefix);
+  labcomm2014_encoder_register_generated_encoding_V(prefix);
+  EXPECT({ 0x02, 0x0a, VARIABLE(3), 0x01, 0x00, 0x03, 'p', '.', 'V', 0x02, 0x11, 0x00,
+           0x04, 0x09, VARIABLE(4), 0x01, 0x00, 0x03, 'p', '.', 'V', 0x01, VARIABLE(2),
+           0x05, 0x02, VARIABLE(3), VARIABLE(4) });
+
+  labcomm2014_encoder_ioctl(suffix, IOCTL_WRITER_RESET);
+  labcomm2014_encoder_register_generated_encoding_V(suffix);
+  labcomm2014_encoder_register_generated_encoding_V(suffix);
+// XXX HERE BE DRAGONS!  What does "BOGUS" man in the below renaming test?
+// previous version (from merge conflict): VARIABLE(6) vs VARIABLE(2)
+// <<<<<<< ours
+//   EXPECT({ 0x02, 0x0c, VARIABLE(5), 0x01, 0x00, 0x05, 'p', '.', 'V', '.', 's', 0x02, 0x11, 0x00,
+//            0x04, 0x09, VARIABLE(6), 0x01, 0x00, 0x03, 'V', '.', 's', 0x01, VARIABLE(2),
+//            0x04, 0x0b, VARIABLE(7), 0x01, 0x00, 0x05, 'p', '.', 'V', '.', 's', 0x01, VARIABLE(6),
+// =======
+  EXPECT({ 0x02, 0x0c, VARIABLE(5), 0x01, 0x00, 0x05, 'p', '.', 'V', '.', 's', 0x02, 0x11, 0x00,
+           0x04, 0x09, VARIABLE(6), 0x01, 0x00, 0x03, 'V', '.', 's', 0x01, VARIABLE(2), /* BOGUS */
+           0x04, 0x0b, VARIABLE(7), 0x01, 0x00, 0x05, 'p', '.', 'V', '.', 's', 0x01, VARIABLE(2),
+           0x05, 0x02, VARIABLE(5), VARIABLE(7) });
+
+
+  labcomm2014_encoder_ioctl(encoder, IOCTL_WRITER_RESET);
+  /* Register twice to make sure that only one registration gets encoded */
+  labcomm2014_encoder_sample_ref_register(encoder, 
+                                          labcomm2014_signature_generated_encoding_V);
+  labcomm2014_encoder_sample_ref_register(encoder, 
+                                          labcomm2014_signature_generated_encoding_V);
+  EXPECT({0x03, 0x08, VARIABLE(8), 0x01, 0x00, 0x01, 'V', 0x02, 0x11, 0x00});
+
+  labcomm2014_encoder_ioctl(prefix, IOCTL_WRITER_RESET);
+  /* Register twice to make sure that only one registration gets encoded */
+  labcomm2014_encoder_sample_ref_register(prefix, 
+                                          labcomm2014_signature_generated_encoding_V);
+  labcomm2014_encoder_sample_ref_register(prefix, 
+                                          labcomm2014_signature_generated_encoding_V);
+  EXPECT({0x03, 0x0a, VARIABLE(9), 0x01, 0x00, 0x03, 'p', '.', 'V', 0x02, 0x11, 0x00});
+  labcomm2014_encoder_ioctl(suffix, IOCTL_WRITER_RESET);
+  /* Register twice to make sure that only one registration gets encoded */
+  labcomm2014_encoder_sample_ref_register(suffix, 
+                                          labcomm2014_signature_generated_encoding_V);
+  labcomm2014_encoder_sample_ref_register(suffix, 
+                                          labcomm2014_signature_generated_encoding_V);
+  EXPECT({0x03, 0x0c, VARIABLE(10), 0x01, 0x00, 0x05, 'p', '.', 'V', '.', 's', 0x02, 0x11, 0x00});
+
+
+  labcomm2014_encoder_ioctl(encoder, IOCTL_WRITER_RESET);
+  labcomm2014_encode_generated_encoding_V(encoder);
+  EXPECT({VARIABLE(0), 0x00 });
+
+  labcomm2014_encoder_ioctl(prefix, IOCTL_WRITER_RESET);
+  labcomm2014_encode_generated_encoding_V(prefix);
+  EXPECT({VARIABLE(3), 0x00 });
+
+  labcomm2014_encoder_ioctl(suffix, IOCTL_WRITER_RESET);
+  labcomm2014_encode_generated_encoding_V(suffix);
+  EXPECT({VARIABLE(5), 0x00 });
+
+  labcomm2014_encoder_free(suffix);
+  labcomm2014_encoder_free(prefix);
+  labcomm2014_encoder_free(encoder);
+  labcomm2014_renaming_registry_free(registry);
+
+  return 0;
+}
+
+int main(int argc, char *argv[])
+{
+  return do_test(argc, argv);
+}

lib/c/2014/test/test_labcomm_renaming_registry.c

+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <assert.h>
+#include <err.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_renaming.h"
+#include "labcomm2014_renaming_private.h"
+#include "test/gen/generated_encoding.h"
+
+static int do_test(int argc, char **argv)
+{
+  struct labcomm2014_renaming_registry *registry;
+  struct labcomm2014_renaming_rename *r1, *r2, *r3, *r4;
+
+  registry = labcomm2014_renaming_registry_new(
+    labcomm2014_default_error_handler,
+    labcomm2014_default_memory,
+    labcomm2014_default_scheduler);
+  r1 = labcomm2014_renaming_rename_new(
+    registry,
+    labcomm2014_signature_generated_encoding_R,
+    labcomm2014_renaming_prefix, "p:");
+  r2 = labcomm2014_renaming_rename_new(
+    registry,
+    labcomm2014_renaming_rename_signature(r1),
+    labcomm2014_renaming_suffix, ":s");
+  r3 = labcomm2014_renaming_rename_new(
+    registry,
+    labcomm2014_signature_generated_encoding_R,
+    labcomm2014_renaming_suffix, ":s");
+  r4 = labcomm2014_renaming_rename_new(
+    registry,
+    labcomm2014_renaming_rename_signature(r3),
+    labcomm2014_renaming_prefix, "p:");
+  assert(r2 == r4);
+  labcomm2014_renaming_rename_free(registry, r1);
+  labcomm2014_renaming_rename_free(registry, r2);
+  labcomm2014_renaming_rename_free(registry, r3);
+  labcomm2014_renaming_rename_free(registry, r4);
+  labcomm2014_renaming_registry_free(registry);
+  return 0;
+}
+
+int main(int argc, char **argv)
+{
+  return do_test(argc, argv);
+}

lib/c/2014/test/test_sample.lc

+sample int test_var[_,2,_];

lib/c/test/test_signature_numbers.c → lib/c/2014/test/test_signature_numbers.c

 #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, 
-		 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,8 +16,8 @@ static void info(char *name, char *full_name,
 int main(int argc, char *argv[])
 {
 #define FUNC(name, full_name) \
-  extern struct labcomm_signature labcomm_signature_##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, ;);
   return 0;

lib/c/Makefile

-## Macros
-UNAME_S=$(shell uname -s)
-ALL_DEPS=liblabcomm.a liblabcomm.so.1
+VERSIONS=2014
 
-ifeq ($(UNAME_S),Linux)
-  CFLAGS=-std=c99 -g -Wall -Werror -O3  -I. -Itest
-  ifndef TARGET
-    CC=gcc	
-  else ifeq ($(TARGET),vx)
-    CC=i586-wrs-vxworks-gcc
-    LD=i586-wrs-vxworks-ld
-    ALL_DEPS:=$(filter-out %.so.1, $(ALL_DEPS))
-    CFLAGS:=$(CFLAGS) -DLABCOMM_COMPAT=\"labcomm_compat_vxworks.h\"
-  else
-    @echo 'Invalid target.'
-  endif
-  LDFLAGS=-L.
-  LDLIBS=-llabcomm -lrt
-  MAKESHARED=gcc -o $1 -shared -Wl,-soname,$2 $3 -lc -lrt
-else ifeq ($(UNAME_S),Darwin)
-  CC=clang
-  CFLAGS=-g -Wall -Werror -O3  -I. -Itest \
-	 -DLABCOMM_COMPAT=\"labcomm_compat_osx.h\" \
-	 -Wno-tautological-compare -Wno-unused-function
-  LDFLAGS=-L.
-  LDLIBS=-llabcomm
-  MAKESHARED=clang -o $1 -shared -Wl,-install_name,$2 $3 -lc
-else
-  $(error Unknown system $(UNAME_S))
-endif
+all:
 
-OBJS=labcomm_memory.o \
-     labcomm_error.o \
-     labcomm_default_error_handler.o \
-     labcomm_default_memory.o \
-     labcomm_default_scheduler.o \
-     labcomm_time.o labcomm_scheduler.o \
-     labcomm_encoder.o labcomm_decoder.o \
-     labcomm.o \
-     labcomm_dynamic_buffer_writer.o \
-     labcomm_fd_reader.o labcomm_fd_writer.o \
-     labcomm_pthread_scheduler.o 
+%: 
+	for v in $(VERSIONS) ; do $(MAKE) -C $${v} $@ || exit 1 ; done
 
-#FIXME: labcomm_mem_reader.o labcomm_mem_writer.o
-LABCOMM_JAR=../../compiler/labComm.jar
-LABCOMM=java -jar $(LABCOMM_JAR) 
 
-TESTS=test_labcomm_basic_type_encoding test_labcomm_generated_encoding \
-      test_signature_numbers \
-      test_labcomm \
-      test_labcomm_pthread_scheduler \
-#
-#FIXME: test_labcomm test_labcomm_errors
-TEST_DIR=test
+.PHONY: clean
+clean: 
+	for v in $(VERSIONS) ; do $(MAKE) -C $${v} $@ || exit 1 ; done
 
-VPATH=$(TEST_DIR)
+.PHONY: distclean
+distclean:
+	for v in $(VERSIONS) ; do $(MAKE) -C $${v} $@ || exit 1 ; done
+	rm -f *.o *.so *.so.1 *.a
 
-# Enable experimental objects by invoking make like `make LABCOMM_EXPERIMENTAL=true`
-ifeq ($(LABCOMM_EXPERIMENTAL),true)
-	OBJS += experimental/udp_hack.o experimental/ethaddr.o \
-		experimental/labcomm_thr_reader_writer.o \
-		experimental/ThrottleDrv/ethernet_drv.o \
-		experimental/ThrottleDrv/throttle_drv.o \
-		experimental/labcomm_udp_reader_writer.o
-endif
-
-## Targets
-
-.PHONY: all run-test clean distclean
-
-all: $(ALL_DEPS)
-
-liblabcomm.a: $(OBJS)
-	ar -r $@ $^
-
-liblabcomm.so.1: $(OBJS:%.o=%.pic.o)
-	$(call MAKESHARED,$@,$@,$^)
-
-labcomm.o : labcomm.c labcomm.h  labcomm_private.h
-
-labcomm_fd_reader_writer.o : labcomm_fd_reader_writer.c  labcomm_fd_reader_writer.h  labcomm.h  labcomm_private.h
-
-#$(TEST_DIR)/labcomm_mem_reader.o: labcomm_fd_reader_writer.c labcomm_fd_reader_writer.h
-
-#$(TEST_DIR)/labcomm_mem_writer.o: labcomm_mem_writer.c labcomm_mem_writer.h cppmacros.h
-
-ethaddr.o: ethaddr.c
-
-run-test: $(TESTS:%=run-test-%)
-
-run-test-%: $(TEST_DIR)/% | $(TEST_DIR)
-	$<
-
-$(TEST_DIR)/%.o: $(TEST_DIR)/%.c
-	$(CC) $(CFLAGS) -o $@ -c $<
-
-.PRECIOUS: $(TEST_DIR)/%
-$(TEST_DIR)/%: $(TEST_DIR)/%.o 
-	$(CC) $(LDFLAGS) -o $@ $^ $(LDLIBS) 
-
-$(TEST_DIR)/gen:
-	mkdir -p $@
-
-.PRECIOUS: $(TEST_DIR)/gen/%.c
-.PRECIOUS: $(TEST_DIR)/gen/%.h
-$(TEST_DIR)/gen/%.c $(TEST_DIR)/gen/%.h: $(TEST_DIR)/%.lc | $(TEST_DIR)/gen
-	$(LABCOMM) \
-		--c=$(TEST_DIR)/gen/$*.c \
-		--h=$(TEST_DIR)/gen/$*.h \
-		$<
-
-$(TEST_GEN_DIR)/%.c $(TEST_GEN_DIR)/%.h: $(TESTDATA_DIR)/%.lc \
-					 $(LABCOMM_JAR) | $(TEST_GEN_DIR)
-	$(LABCOMM) \
-		--c=$(patsubst %.h,%.c,$@) --h=$(patsubst %.c,%.h,$@) $<
-
-$(LABCOMM_JAR):
-	@echo "======Building LabComm compiler======"
-	cd $(shell dirname $(LABCOMM_JAR)); ant jar
-	@echo "======End building LabComm compiler======"
-
-%.pic.o:	%.c
-	$(CC) -fPIC $(CFLAGS) -c -o $@ $<
-
-%.o: %.c %.h
-
-clean:
-	$(RM) *.o
-	$(RM) experimental/*.o experimental/ThrottleDrv/*.o
-	$(RM) test/*.o
-	$(RM) test/*.gch
-	$(RM) test/test_labcomm_errors
-	$(RM) test/testdata/gen/*.[cho]
-	$(RM) test/gen/*.[cho]
-	$(RM) $(TEST_DIR)/test_labcomm
-
-distclean: clean
-	$(RM) liblabcomm.so.1
-	$(RM) liblabcomm.a
-
-# Extra dependencies
-$(TEST_DIR)/test_labcomm_basic_type_encoding.o: labcomm_private.h
-
-$(TEST_DIR)/test_labcomm_generated_encoding.o: labcomm_private.h
-$(TEST_DIR)/test_labcomm_generated_encoding.o: $(TEST_DIR)/gen/generated_encoding.h
-$(TEST_DIR)/test_labcomm_generated_encoding : $(TEST_DIR)/gen/generated_encoding.o
-
-$(TEST_DIR)/test_labcomm:  $(TEST_DIR)/gen/test_sample.o
-$(TEST_DIR)/test_signature_numbers.c: $(TEST_DIR)/gen/another_encoding.h
-$(TEST_DIR)/test_signature_numbers.c: $(TEST_DIR)/gen/generated_encoding.h
-$(TEST_DIR)/test_signature_numbers: $(TEST_DIR)/gen/another_encoding.o
-$(TEST_DIR)/test_signature_numbers: $(TEST_DIR)/gen/generated_encoding.o
-labcomm_fd_reader.o: labcomm_private.h
-labcomm_fd_writer.o: labcomm_private.h
-labcomm_dynamic_buffer_writer.o: labcomm_private.h

lib/c/labcomm.linkscript

-/* Hack to get a link error with (hopefully) useful information if not linked
-   with -Tlabcomm.linkscript */
-"You need to link with '-Tlabcomm.linkscript'"=0;
-
-SECTIONS { 
-  labcomm : {
-    labcomm_first_signature = ABSOLUTE(.) ;
-    *(labcomm)
-    labcomm_last_signature = ABSOLUTE(.) ;
-  }
-}
-INSERT AFTER .data;

lib/c/labcomm_decoder.c

-/*
-  labcomm_decoder.c -- runtime for handling 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/>.
-*/
-#define LABCOMM_VERSION "LabComm2013"
-
-#include <errno.h>
-#include "labcomm.h"
-#include "labcomm_private.h"
-#include "labcomm_ioctl.h"
-#include "labcomm_dynamic_buffer_writer.h"
-
-struct sample_entry {
-  int remote_index;
-  struct labcomm_signature *signature;
-  labcomm_decoder_function decode;
-  labcomm_handler_function handler;
-  void *context;
-};
-
-struct labcomm_decoder {
-  struct labcomm_reader *reader;
-  int reader_allocated;
-  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;
-  LABCOMM_SIGNATURE_ARRAY_DEF(local, struct sample_entry);
-  LABCOMM_SIGNATURE_ARRAY_DEF(remote_to_local, 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 labcomm_decoder *result;
-
-  result = labcomm_memory_alloc(memory, 0, sizeof(*result));
-  if (result) {
-    result->reader = reader;
-    result->reader->decoder = result;
-    result->reader->data = 0;
-    result->reader->data_size = 0;
-    result->reader->count = 0;
-    result->reader->pos = 0;
-    result->reader->error = 0;
-    result->reader_allocated = 0;
-    result->error = error;
-    result->memory = memory;
-    result->scheduler = scheduler;
-    LABCOMM_SIGNATURE_ARRAY_INIT(result->local, struct sample_entry);
-    LABCOMM_SIGNATURE_ARRAY_INIT(result->remote_to_local, int);
-  }
-  return result;
-}
-
-void labcomm_decoder_free(struct labcomm_decoder* d)
-{
-  struct labcomm_memory *memory = d->memory;
-
-  labcomm_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_memory_free(memory, 0, d);
-}
-
-static int collect_flat_signature(
-  struct labcomm_decoder *decoder,
-  struct labcomm_writer *writer)
-{
-  int result, type;
-
-  type = labcomm_read_packed32(decoder->reader); 
-  result = decoder->reader->error;
-  if (result < 0) { goto out; }
-  if (type >= LABCOMM_USER) {
-    decoder->on_error(LABCOMM_ERROR_UNIMPLEMENTED_FUNC, 3,
-			"Implement %s ... (1) for type 0x%x\n", __FUNCTION__, type);
-  } else {
-    labcomm_write_packed32(writer, type); 
-    switch (type) {
-      case LABCOMM_ARRAY: {
-	int dimensions, i;
-
-	dimensions = labcomm_read_packed32(decoder->reader);
-	labcomm_write_packed32(writer, dimensions);
-	for (i = 0 ; i < dimensions ; i++) {
-	  int n = labcomm_read_packed32(decoder->reader);
-	  labcomm_write_packed32(writer, n);
-	}
-	result = collect_flat_signature(decoder, writer);
-	if (result < 0) { goto out; }
-      } break;
-      case LABCOMM_STRUCT: {
-	int fields, i;
-
-	fields = labcomm_read_packed32(decoder->reader); 
-	labcomm_write_packed32(writer, fields); 
-	for (i = 0 ; i < fields ; i++) {
-	  char *name = labcomm_read_string(decoder->reader);
-	  labcomm_write_string(writer, name);
-	  labcomm_memory_free(decoder->memory, 1, name);
-	  result = collect_flat_signature(decoder, writer);
-	  if (result < 0) { goto out; }
-	}
-      } break;
-      case LABCOMM_BOOLEAN:
-      case LABCOMM_BYTE:
-      case LABCOMM_SHORT:
-      case LABCOMM_INT:
-      case LABCOMM_LONG:
-      case LABCOMM_FLOAT:
-      case LABCOMM_DOUBLE:
-      case LABCOMM_STRING: {
-      } break;
-      default: {
-	result = -ENOSYS;
-        decoder->on_error(LABCOMM_ERROR_UNIMPLEMENTED_FUNC, 3,
-				"Implement %s (2) for type 0x%x...\n", __FUNCTION__, type);
-      } break;
-    }
-  }
-out:
-  return result;
-}
-
-static int writer_ioctl(struct labcomm_writer *writer,
-			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(writer, writer->action_context, 
-				0, NULL, action, va);
-  va_end(va);
-out:
-  return result;
-}
-
-static int decode_typedef_or_sample(struct labcomm_decoder *d, int kind)
-{
-  int result;
-
-  /* TODO: should the labcomm_dynamic_buffer_writer be 
-     a permanent part of labcomm_decoder? */
-  struct labcomm_writer_action_context action_context = {
-    .next = NULL,
-    .action = labcomm_dynamic_buffer_writer_action,
-    .context = NULL
-  };
-  struct labcomm_writer writer = {
-    .action_context = &action_context,
-    .memory = d->memory,
-    .data = NULL,
-    .data_size = 0,
-    .count = 0,
-    .pos = 0,
-    .error = 0,
-  };
-  struct labcomm_signature signature, *local_signature;
-  int remote_index, local_index, err;
-  
-  local_signature = NULL;
-  local_index = 0;
-  labcomm_writer_alloc(&writer, writer.action_context, "");
-  labcomm_writer_start(&writer, writer.action_context, 0, NULL, NULL);
-  remote_index = labcomm_read_packed32(d->reader);
-  signature.name = labcomm_read_string(d->reader);
-  signature.type = kind;
-  collect_flat_signature(d, &writer);
-  labcomm_writer_end(&writer, writer.action_context);
-  err = writer_ioctl(&writer, 
-		     LABCOMM_IOCTL_WRITER_GET_BYTES_WRITTEN,
-		     &signature.size);
-  if (err < 0) {
-    /* fprintf(stderr, "Failed to get size: %s\n", strerror(-err)); */
-    labcomm_error_warning(d->error, LABCOMM_ERROR_BAD_WRITER,
-			  "Failed to get size: %s\n", strerror(-err));
-    result = -ENOENT;
-    goto free_signature_name;
-  }
-  err = writer_ioctl(&writer, 
-		     LABCOMM_IOCTL_WRITER_GET_BYTE_POINTER,
-		     &signature.signature);
-  if (err < 0) {
-    /* fprintf(stderr, "Failed to get pointer: %s\n", strerror(-err)); */
-    labcomm_error_warning(d->error, LABCOMM_ERROR_BAD_WRITER,
-			  "Failed to get pointer: %s\n", strerror(-err));
-    result = -ENOENT;
-    goto free_signature_name;
-  }
-  {
-    int i;
-
-    labcomm_scheduler_data_lock(d->scheduler);
-    LABCOMM_SIGNATURE_ARRAY_FOREACH(d->local, struct sample_entry, i) {
-      struct sample_entry *s;
-      int *remote_to_local;
-      
-      result = -ENOENT;
-      s = LABCOMM_SIGNATURE_ARRAY_REF(d->memory, 
-				      d->local,  struct sample_entry, i);
-      if (s->signature &&
-	  s->signature->type == signature.type &&
-	  s->signature->size == signature.size &&
-	  strcmp(s->signature->name, signature.name) == 0 &&
-	  memcmp((void*)s->signature->signature, (void*)signature.signature,
-	       signature.size) == 0) {
-	s->remote_index = remote_index;
-	local_signature = s->signature;
-	local_index = i;
-	remote_to_local = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
-						      d->remote_to_local, int,
-						      remote_index);
-	*remote_to_local = i;
-	result = remote_index;
-	break;
-      }
-    }
-    labcomm_scheduler_data_unlock(d->scheduler);
-    if (local_signature) {
-      labcomm_reader_start(d->reader, d->reader->action_context,
-			   local_index, remote_index, local_signature,
-			   NULL);
-      labcomm_reader_end(d->reader, d->reader->action_context);
-    }
-  }
-#if 0
-  if (! entry) {
-    /* Unknown datatype, bail out */
-    d->on_new_datatype(d, &signature);
-    result = -ENOENT;
-  } else if (entry->index && entry->index != remote_index) {
-    d->on_error(LABCOMM_ERROR_DEC_INDEX_MISMATCH, 5, 
-		"%s(): index mismatch '%s' (id=0x%x != 0x%x)\n", 
-		__FUNCTION__, signature.name, entry->index, remote_index);
-    result = -ENOENT;
-#endif
-free_signature_name:
-  labcomm_memory_free(d->memory, 0, signature.name);
-  labcomm_writer_free(&writer, writer.action_context);
-  return result;
-}
-
-struct call_handler_context {
-  struct labcomm_reader *reader;
-  int local_index;
-  int remote_index;
-  struct labcomm_signature *signature;
-  labcomm_handler_function handler;
-  void *context;
-};
-
-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,
-			 wrap->local_index, wrap->remote_index, wrap->signature,
-			 value);
-    wrap->handler(value, wrap->context);
-    labcomm_reader_end(wrap->reader, wrap->reader->action_context);
-  }
-}
-
-static void reader_alloc(struct labcomm_decoder *d)
-{
-  if (!d->reader_allocated) {
-    d->reader_allocated = 1;
-    labcomm_reader_alloc(d->reader, d->reader->action_context,
-			 LABCOMM_VERSION);
-  }
-}
-
-int labcomm_decoder_decode_one(struct labcomm_decoder *d)
-{
-  int result, remote_index;
-
-  reader_alloc(d);
-  remote_index = labcomm_read_packed32(d->reader);
-  if (d->reader->error < 0) {
-    result = d->reader->error;
-    goto out;
-  }
-  if (remote_index == LABCOMM_TYPEDEF || remote_index == LABCOMM_SAMPLE) {
-    result = decode_typedef_or_sample(d, remote_index); 
-  } else {
-    int *local_index;
-    struct call_handler_context wrap = {
-      .reader = d->reader,
-      .remote_index = remote_index,
-      .signature = NULL,
-      .handler = NULL,
-      .context = NULL,
-    };
-    labcomm_decoder_function do_decode = NULL;
-
-    labcomm_scheduler_data_lock(d->scheduler);
-    local_index = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
-					      d->remote_to_local, int,
-					      remote_index);
-    if (*local_index != 0) {
-      struct sample_entry *entry;
-
-      entry = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
-					  d->local, struct sample_entry,
-					  *local_index);
-      wrap.local_index = *local_index;
-      wrap.signature = entry->signature;
-      wrap.handler = entry->handler;
-      wrap.context = entry->context;
-      do_decode = entry->decode;
-      result = *local_index;
-    }
-    labcomm_scheduler_data_unlock(d->scheduler);
-    if (do_decode) {
-      do_decode(d->reader, call_handler, &wrap);
-      if (d->reader->error < 0) {
-	result = d->reader->error;
-      }
-    } else {
-      result = -ENOENT;
-    }
-  }
-out:
-  return result;
-}
-
-void labcomm_decoder_run(struct labcomm_decoder *d)
-{
-  while (labcomm_decoder_decode_one(d) > 0) {
-  }
-}
-
-int labcomm_decoder_ioctl(struct labcomm_decoder *d, 
-			  uint32_t action,
-			  ...)
-{
-  int result;  
-  va_list va;
-    
-  va_start(va, action);
-  result = labcomm_reader_ioctl(d->reader, 
-				d->reader->action_context,
-				0, 0, NULL, action, va);
-  va_end(va);
-  return result;
-}
-
-int labcomm_internal_decoder_ioctl(struct labcomm_decoder *d, 
-				   struct labcomm_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);
-  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,
-				local_index, remote_index, 
-				signature, action, va);
-  return result;
-}
-
-int labcomm_internal_decoder_register(
-  struct labcomm_decoder *d,
-  struct labcomm_signature *signature,
-  labcomm_decoder_function decode, 
-  labcomm_handler_function handler,
-  void *context)
-{
-  int local_index;
-  struct sample_entry *entry;
- 
-  reader_alloc(d);
-  local_index = labcomm_get_local_index(signature);
-  if (local_index <= 0) { goto out; }
-  labcomm_reader_start(d->reader, d->reader->action_context,
-		       local_index, 0, signature,
-		       NULL);
-  labcomm_reader_end(d->reader, d->reader->action_context);
-
-  labcomm_scheduler_data_lock(d->scheduler);
-  entry = LABCOMM_SIGNATURE_ARRAY_REF(d->memory,
-				      d->local, struct sample_entry,
-				      local_index);
-  if (entry == NULL) { local_index = -ENOMEM; goto unlock; }
-  entry->remote_index = 0;
-  entry->signature = signature;
-  entry->decode = decode;
-  entry->handler = handler;
-  entry->context = context;
-unlock:
-  labcomm_scheduler_data_unlock(d->scheduler);
-out:
-  return local_index;
-}
-

lib/c/labcomm_encoder.c

-/*
-  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 LABCOMM_VERSION "LabComm2013"
-
-#include <errno.h>
-#include "labcomm.h"
-#include "labcomm_private.h"
-#include "labcomm_ioctl.h"
-
-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);
-};
-
-struct labcomm_encoder *labcomm_encoder_new(
-  struct labcomm_writer *writer,
-  struct labcomm_error_handler *error,
-  struct labcomm_memory *memory,
-  struct labcomm_scheduler *scheduler)
-{
-  struct labcomm_encoder *result;
-
-  result = labcomm_memory_alloc(memory, 0, sizeof(*result));
-  if (result) {
-    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_writer_alloc(result->writer,
-			 result->writer->action_context, LABCOMM_VERSION);
-  }
-  return result;
-}
-
-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_memory_free(memory, 0, e);
-}
-
-int labcomm_internal_encoder_register(
-  struct labcomm_encoder *e,
-  struct labcomm_signature *signature,
-  labcomm_encoder_function encode)
-{
-  int result = -EINVAL;
-  int index, *done, err, i;
-
-  index = labcomm_get_local_index(signature);
-  labcomm_scheduler_writer_lock(e->scheduler);
-  if (signature->type != LABCOMM_SAMPLE) { goto out; }
-  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, signature->type);
-  labcomm_write_packed32(e->writer, index);
-  labcomm_write_string(e->writer, signature->name);
-  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,
-  struct labcomm_signature *signature,
-  labcomm_encoder_function encode,
-  void *value)
-{
-  int result;
-  int index;
-
-  index = labcomm_get_local_index(signature);
-  labcomm_scheduler_writer_lock(e->scheduler);
-  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);
-  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_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, 
-				   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;
-}

lib/c/liblabcomm.so

-liblabcomm.so.1
\ No newline at end of file

lib/c/os_compat.mk

+## Macros
+UNAME_S=$(shell uname -s)
+VERSION=2014
+LIBVERSION=2014
+
+ifeq ($(UNAME_S),Linux)
+  CC=$(CROSS_COMPILE)gcc
+  LD=$(CROSS_COMPILE)gcc
+  CFLAGS=-std=c99 -g -Wall -Werror -O3  -I.
+  CFLAGS_TEST=$(CFLAGS) -Itest
+  LDFLAGS=-L..
+  LDLIBS=-llabcomm$(LIBVERSION) -lrt
+  LD_LIBRARY_PATH_NAME=LD_LIBRARY_PATH
+  MAKESHARED=gcc -o $1 -shared -Wl,-soname,$2 $3 -lc -lrt
+else ifeq ($(UNAME_S),Darwin)
+  #CC=$(CROSS_COMPILE)clang
+  #LD=$(CROSS_COMPILE)ld
+  CC=$(CROSS_COMPILE)gcc
+  LD=$(CROSS_COMPILE)gcc
+  CFLAGS=-g -Wall -Werror -O3  -I. -Itest \
+	 -DLABCOMM_COMPAT=\"labcomm$(VERSION)_compat_osx.h\" \
+	 -DLABCOMM_OS_DARWIN=1 \
+	 -Wno-unused-function
+#	 -Wno-tautological-compare
+  CFLAGS+=-std=c99
+  LDFLAGS=-L..
+  LDLIBS=-llabcomm$(LIBVERSION)
+  LD_LIBRARY_PATH_NAME=DYLD_LIBRARY_PATH
+  MAKESHARED=clang -o $1 -shared -Wl,-install_name,$2 $3 -lc
+else ifneq ($(findstring CYGWIN,$(UNAME_S)),)
+  CC=$(CROSS_COMPILE)gcc
+  LD=$(CROSS_COMPILE)ld
+  CFLAGS=-std=c99 -g -Wall -Werror -O3  -I.
+  LDFLAGS=-L..
+  LDLIBS=-llabcomm$(LIBVERSION) -lrt
+  ALL_DEPS:=$(filter-out %.so.1, $(ALL_DEPS)) # No -fPIC supported in windows?
+else
+  $(error Unknown system $(UNAME_S))
+endif
+CFLAGS_TEST=$(CFLAGS) -Itest -DVERSION=$(VERSION)
+
+ifeq ($(CROSS_COMPILE),i586-wrs-vxworks-)
+  ALL_DEPS:=$(filter-out %.so.1, $(ALL_DEPS)) # PIC is only supported for RTPs
+  CFLAGS:=$(CFLAGS) -DLABCOMM_COMPAT=\"labcomm_compat_vxworks.h\"
+endif

lib/c/test/test_labcomm.c

-/*
-  test_labcomm.c -- Various labcomm tests
-
-  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 <stdint.h>
-#include <inttypes.h>
-#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 "test/gen/test_sample.h"
-
-static unsigned char buffer[512];
-
-static int writer_alloc(struct labcomm_writer *w, 
-			struct labcomm_writer_action_context *action_context, 
-			char *labcomm_version)
-{
-  w->data = buffer;
-  w->data_size = sizeof(buffer);
-  w->count = sizeof(buffer);
-  
-  return 0;
-}
-static int writer_start(struct labcomm_writer *w, 
-			 struct labcomm_writer_action_context *action_context,
-			 int index, struct labcomm_signature *signature,
-			 void *value)
-{
-  return 0;
-}
-const struct labcomm_writer_action writer_action = {
-  .alloc = writer_alloc,
-  .start = writer_start,
-};
-static struct labcomm_writer_action_context writer_action_context = {
-  .next = NULL,
-  .action = &writer_action,
-  .context = NULL
-}; 
-static struct labcomm_writer writer =  {
-  .action_context = &writer_action_context,
-  .data = buffer,
-  .data_size = sizeof(buffer),
-  .count = sizeof(buffer),
-  .pos = 0,
-  .error = 0,
-};
-
-static int reader_alloc(struct labcomm_reader *r, 
-			struct labcomm_reader_action_context *action_context, 
-			char *labcomm_version)
-{
-  r->data = buffer;
-  r->data_size = sizeof(buffer);
-  r->count = 0;
-  r->memory = labcomm_default_memory;
-  
-  return 0;
-}
-static int reader_fill(struct labcomm_reader *r, 
-		       struct labcomm_reader_action_context *action_context)
-{
-  r->error = -ENOMEM;
-  return r->error;
-}
-const struct labcomm_reader_action reader_action = {
-  .alloc = reader_alloc,
-  .fill = reader_fill,
-};
-static struct labcomm_reader_action_context reader_action_context = {
-  .next = NULL,
-  .action = &reader_action,
-  .context = NULL
-}; 
-static struct labcomm_reader reader =  {
-  .action_context = &reader_action_context,
-  .data = buffer,
-  .data_size = sizeof(buffer),
-  .count = 0,
-  .pos = 0,
-  .error = 0,
-};
-
-static int32_t encoder_data[256];
-static test_sample_test_var encoder_var = {
-  .n_0 = 1,
-  .n_1 = 1,
-  .a = encoder_data,
-};
-static int32_t decoder_data[256];
-static test_sample_test_var decoder_var = {
-  .n_0 = 1,
-  .n_1 = 1,
-  .a = decoder_data,
-};;
-
-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 result;
-
-  for (reader.count = 0 ; reader.count < writer.pos ; reader.count++) {
-    reader.error = 0;
-    reader.pos = 0;
-    result = labcomm_decoder_decode_one(decoder);
-    if (result >= 0) {
-      fprintf(stderr, "Got result from buffer with bogus length (%d)\n",
-	      result);
-      exit(1);
-    }
-  }
-  reader.error = 0;
-  reader.pos = 0;
-  reader.count = writer.pos;
-  result = labcomm_decoder_decode_one(decoder);
-  if (result < 0) {
-    fprintf(stderr, "Got result from buffer with correct length (%d)\n",
-	    result);
-    exit(1);
-  }
-  return result;
-}
-
-static void test_encode_decode(struct labcomm_encoder *encoder,
-			       struct labcomm_decoder *decoder,
-			       int expected, uint32_t n_0, uint32_t n_1)
-{
-  int err;
-
-  writer.pos = 0;
-  encoder_var.n_0 = n_0;
-  encoder_var.n_1 = n_1;
-  encoder_var.a[0] = 314;
-  labcomm_encode_test_sample_test_var(encoder, &encoder_var);
-  err = test_decode_one(decoder);
-  fprintf(stderr, "decode of sample %u * %u -> size=%d err=%d\n", 
-	  n_0, n_1, writer.pos, err);
-  if (writer.pos != labcomm_sizeof_test_sample_test_var(&encoder_var)) {
-    fprintf(stderr, "Incorrect sizeof %u * %u (%d != %d)\n",
-	    n_0, n_1, 
-	    writer.pos, labcomm_sizeof_test_sample_test_var(&encoder_var));
-    exit(1);
-  }
-  if (writer.pos != expected) {
-    fprintf(stderr, "Unexpected size %u * %u (%d != %d)\n",
-	    n_0, n_1, 
-	    writer.pos, expected);
-    exit(1);
-  }
-}
-
-int main(void)
-{
-  int err, i;
-  struct labcomm_encoder *encoder = labcomm_encoder_new(
-    &writer, 
-    labcomm_default_error_handler,
-    labcomm_default_memory,
-    labcomm_default_scheduler);
-  struct labcomm_decoder *decoder = labcomm_decoder_new(
-    &reader,
-    labcomm_default_error_handler,
-    labcomm_default_memory,
-    labcomm_default_scheduler);
-  labcomm_decoder_register_test_sample_test_var(decoder,
-						handle_test_var, 
-						NULL);
-  labcomm_encoder_register_test_sample_test_var(encoder);
-  err = test_decode_one(decoder);
-  fprintf(stderr, "decode of register -> index %d\n", err);
-  test_encode_decode(encoder, decoder, 7, 1, 1);
-  if (decoder_var.a[0] != encoder_var.a[0]) {
-    fprintf(stderr, "Failed to decode correct value %d != %d\n", 
-	    encoder_var.a[0], decoder_var.a[0]);
-    exit(1);
-  }
-  test_encode_decode(encoder, decoder, 19, 2, 2);
-  test_encode_decode(encoder, decoder, 3, 0, 0);
-  for (i = 1 ; i <= 4 ; i++) {
-    test_encode_decode(encoder, decoder, 2+i, 0, (1<<(7*i))-1);
-    test_encode_decode(encoder, decoder, 3+i, 0, (1<<(7*i)));
-  }
-  test_encode_decode(encoder, decoder, 7, 0, 4294967295);
-  return 0;
-}
-
-#if 0
-#include <stdbool.h>
-#include <stdlib.h>
-
-#include <labcomm.h>
-#include <labcomm_mem_writer.h>
-#include <labcomm_mem_reader.h>
-#include "test/testdata/gen/test_sample.h"
-
-#define TEST_BUFFER_SIZE (50)
-
-void test_error_handler(enum labcomm_error error_id, size_t nbr_va_args, ...);
-
-int init_suit_labcomm()
-{
-	return 0;
-}
-
-int clean_suit_labcomm()
-{
-	return 0;
-}
-
-void setup_connected_encoder_decoder(struct labcomm_encoder **enc,
-		labcomm_mem_writer_context_t *enc_ctx,
-		struct labcomm_decoder **dec,
-		labcomm_mem_reader_context_t *dec_ctx)
-{
-	enc_ctx->write_pos = 0;
-	enc_ctx->buf = malloc(TEST_BUFFER_SIZE);
-	enc_ctx->length = TEST_BUFFER_SIZE;
-
-	*enc = labcomm_encoder_new(labcomm_mem_writer, enc_ctx);
-
-	dec_ctx->size = 0;
-	dec_ctx->enc_data = enc_ctx->buf;
-	*dec = labcomm_decoder_new(labcomm_mem_reader, dec_ctx);
-
-	labcomm_register_error_handler_decoder(*dec, test_error_handler);
-	labcomm_register_error_handler_encoder(*enc, test_error_handler);
-}
-
-static bool in_error = false;
-static enum labcomm_error in_error_id = LABCOMM_ERROR_ENUM_BEGIN_GUARD;
-void test_error_handler(enum labcomm_error error_id, size_t nbr_va_args, ...)
-{
-	in_error = true;
-	in_error_id = error_id;
-}
-
-static bool got_sample = false;
-void test_decoder_handle_test_sample_test_var(test_sample_test_var *v, void *ctx)
-{
-	got_sample = true;
-}
-
-void test_decoder_decode_sig()
-{
-	labcomm_mem_writer_context_t enc_ctx;
-	struct labcomm_encoder *encoder;
-	labcomm_mem_reader_context_t dec_ctx;
-	struct labcomm_decoder *decoder;
-	setup_connected_encoder_decoder(&encoder, &enc_ctx, &decoder, &dec_ctx);
-
-	labcomm_encoder_register_test_sample_test_var(encoder);
-	dec_ctx.size = enc_ctx.write_pos;
-
-	labcomm_decoder_register_test_sample_test_var(decoder,
-			test_decoder_handle_test_sample_test_var, NULL);
-	labcomm_decoder_decode_one(decoder);
-
-	CU_ASSERT_FALSE(in_error);
-	enc_ctx.write_pos = 0;
-	test_sample_test_var var = 1;
-	labcomm_encode_test_sample_test_var(encoder, &var);
-	dec_ctx.size = enc_ctx.write_pos;
-	labcomm_decoder_decode_one(decoder);
-
-	CU_ASSERT_FALSE(in_error);
-	CU_ASSERT_FALSE(got_sample);
-
-	labcomm_decoder_free(decoder);
-	labcomm_encoder_free(encoder);
-	free(enc_ctx.buf);
-
-	in_error = false;
-	in_error_id = LABCOMM_ERROR_ENUM_BEGIN_GUARD;
-	got_sample = false;
-}
-
-static bool got_new_datatype = false;
-static labcomm_signature_t new_sig;
-int test_new_datatype(struct labcomm_decoder *decoder,
-		labcomm_signature_t *sig)
-{
-	got_new_datatype = true;
-	memcpy(&new_sig, sig, sizeof(labcomm_signature_t));
-	return 0;
-}
-
-void test_decode_unreg_signature_handle()
-{
-	labcomm_mem_writer_context_t enc_ctx;
-	struct labcomm_encoder *encoder;
-	labcomm_mem_reader_context_t dec_ctx;
-	struct labcomm_decoder *decoder;
-	setup_connected_encoder_decoder(&encoder, &enc_ctx, &decoder, &dec_ctx);
-
-	labcomm_encoder_register_test_sample_test_var(encoder);
-	dec_ctx.size = enc_ctx.write_pos;
-	labcomm_decoder_register_new_datatype_handler(decoder, test_new_datatype);
-	labcomm_decoder_decode_one(decoder);
-
-	CU_ASSERT_TRUE(got_new_datatype);
-	CU_ASSERT_EQUAL(
-			memcmp(new_sig.signature, dec_ctx.enc_data, dec_ctx.size), 0);
-
-	got_new_datatype = false;
-	labcomm_decoder_free(decoder);
-	labcomm_encoder_free(encoder);
-	free(enc_ctx.buf);
-}
-
-void test_decode_unreg_signature_error()
-{
-	labcomm_mem_writer_context_t enc_ctx;
-	struct labcomm_encoder *encoder;
-	labcomm_mem_reader_context_t dec_ctx;
-	struct labcomm_decoder *decoder;
-	setup_connected_encoder_decoder(&encoder, &enc_ctx, &decoder, &dec_ctx);
-
-	labcomm_encoder_register_test_sample_test_var(encoder);
-	dec_ctx.size = enc_ctx.write_pos;
-
-	labcomm_decoder_decode_one(decoder);
-
-	CU_ASSERT_TRUE(in_error);
-	CU_ASSERT_EQUAL(in_error_id, LABCOMM_ERROR_DEC_UNKNOWN_DATATYPE);
-	got_new_datatype = false;
-	labcomm_decoder_free(decoder);
-	labcomm_encoder_free(encoder);
-	free(enc_ctx.buf);
-}
-int main()
-{
-	CU_pSuite suite_decoder = NULL;
-
-	// Initialize CUnit test registry.
-	if (CUE_SUCCESS != CU_initialize_registry()) {
-		return CU_get_error();
-	}
-
-	// Add our test suites.
-	suite_decoder = CU_add_suite("transport_enc_dec",
-			init_suit_labcomm, clean_suit_labcomm);
-	if (suite_decoder == NULL) {
-		CU_cleanup_registry();
-		return CU_get_error();
-	}
-
-	if (
-			(CU_add_test(suite_decoder, "test_decoder_decode_sig",
-					test_decoder_decode_sig) == NULL)
-			||
-			(CU_add_test(suite_decoder, "test_decode_unreg_signature_handle",
-					test_decode_unreg_signature_handle) == NULL)
-			||
-			(CU_add_test(suite_decoder, "test_decode_unreg_signature_error",
-					test_decode_unreg_signature_error) == NULL)
-		) {
-		CU_cleanup_registry();
-		return CU_get_error();
-	}
-
-	// Set verbosity.
-	CU_basic_set_mode(CU_BRM_VERBOSE);
-	/*CU_console_run_tests();*/
-
-	// Run all test suites.
-	CU_basic_run_tests();
-
-	// Clean up.
-	CU_cleanup_registry();
-
-	return CU_get_error();
-}
-#endif

lib/c/test/test_sample.lc

-sample int test_var[_,_];

lib/c/version_compare.py

+#!/usr/bin/python
+
+import os
+import sys
+import difflib
+import re
+
+class File:
+
+    def __init__(self, path, match, replacement):
+        def replace(s):
+            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:
+            self.lines = map(replace, f.readlines())
+
+    def __cmp__(self, other):
+        if other == None:
+            return cmp(self.name, other)
+        return cmp(self.name, other.name)
+
+def readfiles(root, match, replacement):
+    result = []
+    for n in os.listdir(root):
+        path = os.path.join(root, n)
+        if os.path.islink(path):
+            pass
+        elif os.path.isdir(path):
+            for f in filter(None, readfiles(path, match, replacement)):
+                result.append(f)
+        else:
+            result.append(File(path, match, replacement))
+    for f in sorted(result):
+        yield f
+    yield None
+
+if __name__ == '__main__':
+    A = readfiles(*sys.argv[1:4])
+    B = readfiles(*sys.argv[4:7])
+    a = A.next()
+    b = B.next()
+    while a != None or b != None:
+        if b == None or a.name < b.name:
+            print "Only in %s:" %sys.argv[1], a.path
+            a = A.next()
+        elif a == None or a.name > b.name: 
+            print "Only in %s:" %sys.argv[4], b.path
+            b = B.next()
+        else:
+            equal = True
+            for l in difflib.unified_diff(a.lines, b.lines, a.path, b.path):
+                print l,
+                equal = False
+            if equal:
+                print "Identical", a.path, b.path
+                
+            a = A.next() 
+            b = B.next() 

lib/csharp/.gitignore

+labcomm2014.dll

lib/csharp/LabComm.csproj

-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup>
-    <OutputType>Library</OutputType>
-    <AssemblyName>LabComm</AssemblyName>
-    <ProjectGuid>{755CD5A6-C48E-4D35-B0BE-8EC0FDE1A2A1}</ProjectGuid>
-    <!-- Properties which affect the build process -->
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)' == 'Debug'">
-    <OutputPath>bin\Debug\</OutputPath>
-  </PropertyGroup>
-  <ItemGroup>
-    <Compile Include="se\lth\control\labcomm\LabCommDispatcher.cs" />
-    <Compile Include="se\lth\control\labcomm\LabCommDecoderRegistry.cs" />
-    <Compile Include="se\lth\control\labcomm\LabComm.cs" />
-    <Compile Include="se\lth\control\labcomm\LabCommSample.cs" />
-    <Compile Include="se\lth\control\labcomm\LabCommHandler.cs" />
-    <Compile Include="se\lth\control\labcomm\LabCommEncoderRegistry.cs" />
-    <Compile Include="se\lth\control\labcomm\LabCommDecoder.cs" />
-    <Compile Include="se\lth\control\labcomm\LabCommType.cs" />
-    <Compile Include="se\lth\control\labcomm\LabCommEncoderChannel.cs" />
-    <Compile Include="se\lth\control\labcomm\LabCommEncoder.cs" />
-    <Compile Include="se\lth\control\labcomm\LabCommDecoderChannel.cs" />
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-</Project>
\ No newline at end of file

lib/csharp/Makefile

-MODULES=LabCommDispatcher \
-	LabCommDecoderRegistry \
-	LabComm \
-	LabCommSample \
-	LabCommHandler \
-	LabCommEncoderRegistry \
-	LabCommDecoder \
-	LabCommType \
-	LabCommEncoderChannel \
-	LabCommEncoder \
-	LabCommDecoderChannel \
+MODULES=Constant\
+	Decoder \
+	DecoderChannel \
+	DecoderRegistry \
+	Encoder \
+	EncoderChannel \
+	EncoderRegistry \
+	RenamingDecoder \
+	RenamingEncoder \
+	RenamingRegistry \
+	Sample \
+	SampleDispatcher \
+	SampleHandler \
+	SampleType \
+	WrappingDecoder \
+	WrappingEncoder
 
-all: labcomm.dll
+.PHONY: all
+all: labcomm2014.dll
 
-labcomm.dll: $(MODULES:%=se/lth/control/labcomm/%.cs) Makefile
+labcomm2014.dll: $(MODULES:%=se/lth/control/labcomm2014/%.cs) Makefile
 	mcs -out:$@ -target:library $(filter %.cs, $^)
 
+.PHONY: test
+test:
+
+.PHONY: clean
 clean:
-	rm -f labcomm.dll
+
+.PHONY: distclean
+distclean:
+	rm -f labcomm2014.dll

lib/csharp/se/lth/control/labcomm/LabCommHandler.cs

-namespace se.lth.control.labcomm {
-
-  public interface LabCommHandler {
-  }
-
-}
\ No newline at end of file

lib/csharp/se/lth/control/labcomm/LabCommSample.cs

-public interface LabCommSample {
-
-}

lib/csharp/se/lth/control/labcomm/LabCommType.cs

-public interface LabCommType {
-
-}

lib/csharp/se/lth/control/labcomm/LabComm.cs → lib/csharp/se/lth/control/labcomm2014/Constant.cs

-namespace se.lth.control.labcomm {
+namespace se.lth.control.labcomm2014 {
 
-  public class LabComm {
+  public class Constant {
 
-   public const string VERSION = "LabComm2013";
+    public const string CURRENT_VERSION = "LabComm2014";
 
-   /*
-     * Predeclared aggregate type indices
+    /*
+     * Allowed packet tags
+     */
+    public const int VERSION          = 0x01;
+    public const int SAMPLE_DEF       = 0x02;
+    public const int SAMPLE_REF       = 0x03;
+    public const int TYPE_DEF         = 0x04;
+    public const int TYPE_BINDING     = 0x05;
+    public const int PRAGMA           = 0x3f;
+    public const int FIRST_USER_INDEX = 0x40; /* ..0xffffffff */
+
+    /*
+     * Predefined aggregate type indices
      */
-    public const int TYPEDEF          = 0x01;
-    public const int SAMPLE           = 0x02;
     public const int ARRAY            = 0x10;
     public const int STRUCT           = 0x11;
     
@@ -23,12 +32,8 @@ namespace se.lth.control.labcomm {
     public const int FLOAT            = 0x25;
     public const int DOUBLE           = 0x26;
     public const int STRING           = 0x27;
+    public const int SAMPLE           = 0x28;
     
-    /*
-     * start of user defined types 
-     */
-    public const int FIRST_USER_INDEX = 0x40;
-
   }
 
 }