examples/jgrafchart/turtle_dec.c

+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <labcomm_fd_reader.h>
+#include <labcomm_default_error_handler.h>
+#include <labcomm_default_memory.h>
+#include <labcomm_default_scheduler.h>
+#include <stdio.h>
+#include "turtle1.h"
+
+static struct labcomm_encoder *encoder;
+
+static void handle_pose(turtle1_pose *v, void *context) {
+#if 1
+	printf("got pose\n");
+#else
+	turtle1_velocity vel;
+	sleep(1);
+
+	labcomm_encode_turtle1_velocity(encoder, vel);
+	vel.angular = -1;
+	sleep(1);
+
+	labcomm_encode_turtle1_velocity(encoder, vel);
+	sleep(1);
+
+	vel.angular = -1;
+	labcomm_encode_turtle1_velocity(encoder, vel);
+#endif
+}
+
+struct labcomm_decoder *turtle_dec_init(int fd, struct labcomm_encoder *e) {
+  struct labcomm_decoder *decoder;
+  encoder = e;
+  void  *context = NULL;
+
+  decoder = labcomm_decoder_new(labcomm_fd_reader_new(
+				  labcomm_default_memory, fd, 1), 
+				labcomm_default_error_handler, 
+				labcomm_default_memory,
+				labcomm_default_scheduler);
+  if (!decoder) { 
+    printf("Failed to allocate decoder %s:%d\n", __FUNCTION__, __LINE__);
+    return (void *)0;
+  }
+
+  labcomm_decoder_register_turtle1_pose(decoder, handle_pose, context);
+
+  return decoder;
+}
+
+
+void turtle_dec_run(struct labcomm_decoder *decoder) {
+  printf("Decoding:\n");
+  labcomm_decoder_run(decoder);
+  printf("--- End Of File ---:\n");
+}
+
+void turtle_dec_cleanup(struct labcomm_decoder *decoder) {
+  labcomm_decoder_free(decoder);
+}

examples/jgrafchart/turtle_dec.h

+#include <labcomm_fd_reader.h>
+#include <labcomm_default_error_handler.h>
+#include <labcomm_default_memory.h>
+#include <labcomm_default_scheduler.h>
+#include <stdio.h>
+
+struct labcomm_decoder * turtle_dec_init(int fd, struct labcomm_encoder *e) ;
+void turtle_dec_run(struct labcomm_decoder *decoder) ;
+void turtle_dec_cleanup(struct labcomm_decoder *decoder) ;

examples/jgrafchart/turtle_enc.c

+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <labcomm_fd_writer.h>
+#include <labcomm_default_error_handler.h>
+#include <labcomm_default_memory.h>
+#include <labcomm_default_scheduler.h>
+#include "turtle1.h"
+#include <stdio.h>
+
+struct labcomm_encoder *turtle_enc_init( int fd) {
+  struct labcomm_encoder *encoder;
+
+  encoder = labcomm_encoder_new(labcomm_fd_writer_new(
+				  labcomm_default_memory, fd, 1), 
+				labcomm_default_error_handler, 
+				labcomm_default_memory,
+				labcomm_default_scheduler);
+  labcomm_encoder_register_turtle1_velocity(encoder);
+  return encoder;
+}
+
+void turtle_enc_run(struct labcomm_encoder *encoder, turtle1_velocity *v) {
+#if 0
+	jg_foo v;
+
+	v.b = 17.17;
+	v.c = 1742;
+	v.d = 4217;
+	v.e = "hello";
+	v.f = 17;
+	v.g = 42;
+	v.h = 2;
+	v.i = 42.42;
+#endif
+ 	printf("Encoding for turtle1\n");
+	v->turtle_name="/turtlesim1/turtle1";
+	labcomm_encode_turtle1_velocity(encoder, v);
+	sleep(1);
+ 	printf("Encoding for turtle1\n");
+	v->angular *= -1;
+	labcomm_encode_turtle1_velocity(encoder, v);
+	sleep(1);
+	v->angular *= -1;
+	//v->h += 42000000;
+	labcomm_encode_turtle1_velocity(encoder, v);
+}
+
+void turtle_enc_cleanup(struct labcomm_encoder *encoder) {
+	labcomm_encoder_free(encoder);
+}

examples/jgrafchart/turtle_enc.h

+#include <labcomm_fd_writer.h>
+#include <labcomm_default_error_handler.h>
+#include <labcomm_default_memory.h>
+#include <labcomm_default_scheduler.h>
+
+#include "turtle1.h"
+
+struct labcomm_encoder *turtle_enc_init(int fd) ;
+void turtle_enc_run(struct labcomm_encoder *encoder, turtle1_velocity *v) ;
+void turtle_enc_cleanup(struct labcomm_encoder *encoder) ;

examples/jgrafchart/turtleclient.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netdb.h> 
+
+#include "turtle_dec.h"
+#include "turtle_enc.h"
+
+void error(const char *msg)
+{
+    perror(msg);
+    exit(0);
+}
+
+void do_labcomm(int sockfd)
+{
+    void *turtle_enc = turtle_enc_init(sockfd);
+//    void *turtle_dec = turtle_dec_init(sockfd, turtle_enc);
+    turtle1_velocity v;
+    v.linear=4;
+    v.angular=0.4;
+    turtle_enc_run(turtle_enc, &v);
+//    turtle_dec_run(turtle_dec);
+//    turtle_dec_cleanup(turtle_dec);
+    turtle_enc_cleanup(turtle_enc);
+}
+
+int main(int argc, char *argv[])
+{
+    int sockfd, portno, n;
+    struct sockaddr_in serv_addr;
+    struct hostent *server;
+
+    char buffer[256];
+    if (argc < 3) {
+       fprintf(stderr,"usage %s hostname port\n", argv[0]);
+       exit(0);
+    }
+    portno = atoi(argv[2]);
+    sockfd = socket(AF_INET, SOCK_STREAM, 0);
+    if (sockfd < 0) 
+        error("ERROR opening socket");
+    server = gethostbyname(argv[1]);
+    if (server == NULL) {
+        fprintf(stderr,"ERROR, no such host\n");
+        exit(0);
+    }
+    bzero((char *) &serv_addr, sizeof(serv_addr));
+    serv_addr.sin_family = AF_INET;
+    bcopy((char *)server->h_addr, 
+         (char *)&serv_addr.sin_addr.s_addr,
+         server->h_length);
+    serv_addr.sin_port = htons(portno);
+    if (connect(sockfd,(struct sockaddr *) &serv_addr,sizeof(serv_addr)) < 0) 
+        error("ERROR connecting");
+
+    do_labcomm(sockfd);
+
+    close(sockfd);
+    return 0;
+}

examples/robot/App.config

+<?xml version="1.0" encoding="utf-8" ?>
+<configuration>
+    <startup> 
+        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
+    </startup>
+</configuration>

examples/robot/Follow.mod

+MODULE Follow
+    PROC LCjt2jt(VAR LCRobot_jointtarget a, VAR jointtarget b)
+        b.robax.rax_1 := a.robax.rax_1;
+        b.robax.rax_2 := a.robax.rax_2;
+        b.robax.rax_3 := a.robax.rax_3;
+        b.robax.rax_4 := a.robax.rax_4;
+        b.robax.rax_5 := a.robax.rax_5;
+        b.robax.rax_6 := a.robax.rax_6;
+        
+        b.extax.eax_a := a.extax.eax_a;
+        b.extax.eax_b := a.extax.eax_b;
+        b.extax.eax_c := a.extax.eax_c;
+        b.extax.eax_d := a.extax.eax_d;
+        b.extax.eax_e := a.extax.eax_e;
+        b.extax.eax_f := a.extax.eax_f;
+    ENDPROC
+    
+    PROC handle_jointtarget(LCRobot_jointtarget val)
+        VAR jointtarget jt;
+        LCjt2jt val, jt;
+        MoveAbsJ jt, v100, z1, tool0, \WObj:=wobj0;
+    ENDPROC
+    
+    PROC main()
+        VAR LabComm_Stream st;
+        VAR socketdev srv;
+        SocketCreate srv;
+        SocketBind srv, "127.0.0.1", 51337;
+        SocketListen srv;
+        WHILE TRUE DO
+            SocketAccept srv, st.soc;
+            Receive_targets st;
+        ENDWHILE
+    ENDPROC
+    
+    PROC Receive_targets(VAR LabComm_Stream st)
+        VAR Decoder d;
+        VAR LabComm_Decoder_Sample s{1};
+        Init_Decoder d, st;
+        % "LCRobot:Dec_Reg_jointtarget" % s{1}, "handle_jointtarget";
+        WHILE TRUE DO
+            Decode_One d, st, s;
+        ENDWHILE
+    ERROR
+        SocketClose st.soc;
+        RETURN;
+    ENDPROC
+    
+ENDMODULE

examples/robot/LCRobot.lc

+sample struct {
+	struct {
+		float x;
+		float y;
+		float z;
+	} trans;
+	struct {
+		float q1;
+		float q2;
+		float q3;
+		float q4;
+	} rot;
+	struct {
+		short cf1;
+		short cf4;
+		short cf6;
+		short cfx;
+	} robconfig;
+} robtarget;
+
+sample struct {
+	struct {
+		float rax_1;
+		float rax_2;
+		float rax_3;
+		float rax_4;
+		float rax_5;
+		float rax_6;
+	} robax;
+	struct {
+		float eax_a;
+		float eax_b;
+		float eax_C;
+		float eax_d;
+		float eax_e;
+		float eax_f;
+	} extax;
+} jointtarget;

examples/robot/Makefile

+all:
+
+clean:
+
+distclean:

examples/robot/Program.cs

+using se.lth.control.labcomm2014;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Net.Sockets;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace RobotCtrl
+{
+    class Specification
+    {
+
+        public static string IP_ADDRESS = "127.0.0.1";
+        public static int PORT = 51337;
+
+        static void Main(string[] args)
+        {
+            jointtarget val = new jointtarget { robax = new jointtarget.struct_robax(), extax = new jointtarget.struct_extax() };
+            TcpClient client = new TcpClient();
+            IPEndPoint serverEndPoint = new IPEndPoint(IPAddress.Parse(Specification.IP_ADDRESS), Specification.PORT);
+            try
+            {
+                client.Connect(serverEndPoint);
+                Encoder enc = new EncoderChannel(client.GetStream(), true);
+                jointtarget.register(enc);
+                jointtarget.encode(enc, val);
+                for (int i = 0; i < 10; i++)
+                {
+                    val.robax.rax_2 += 2;
+                    jointtarget.encode(enc, val);
+                }
+                for (int i = 0; i < 20; i++)
+                {
+                    val.robax.rax_2 -= 2;
+                    jointtarget.encode(enc, val);
+                }
+                for (int i = 0; i < 10; i++)
+                {
+                    val.robax.rax_2 += 2;
+                    jointtarget.encode(enc, val);
+                }
+            }
+            finally
+            {
+                client.Close();
+            }
+        }
+    }
+}

examples/robot/Properties/AssemblyInfo.cs

+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("RobotCtrl")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("RobotCtrl")]
+[assembly: AssemblyCopyright("Copyright ©  2013")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("bd5ee6d6-1dff-4043-8ca9-b56a29116e61")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

examples/robot/RobotCtrl.csproj

+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{F0051A25-4FFF-4421-A5CB-01B512D6CEC5}</ProjectGuid>
+    <OutputType>Exe</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>RobotCtrl</RootNamespace>
+    <AssemblyName>RobotCtrl</AssemblyName>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <PlatformTarget>AnyCPU</PlatformTarget>
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="LCRobot.cs" />
+    <Compile Include="Specification.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="App.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\lib\csharp\LabComm.csproj">
+      <Project>{755cd5a6-c48e-4d35-b0be-8ec0fde1a2a1}</Project>
+      <Name>LabComm</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

examples/robot/RobotCtrl.sln

+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 2012
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "RobotCtrl", "RobotCtrl.csproj", "{F0051A25-4FFF-4421-A5CB-01B512D6CEC5}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LabComm", "..\..\lib\csharp\LabComm.csproj", "{755CD5A6-C48E-4D35-B0BE-8EC0FDE1A2A1}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{F0051A25-4FFF-4421-A5CB-01B512D6CEC5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F0051A25-4FFF-4421-A5CB-01B512D6CEC5}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F0051A25-4FFF-4421-A5CB-01B512D6CEC5}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F0051A25-4FFF-4421-A5CB-01B512D6CEC5}.Release|Any CPU.Build.0 = Release|Any CPU
+		{755CD5A6-C48E-4D35-B0BE-8EC0FDE1A2A1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{755CD5A6-C48E-4D35-B0BE-8EC0FDE1A2A1}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{755CD5A6-C48E-4D35-B0BE-8EC0FDE1A2A1}.Release|Any CPU.ActiveCfg = Debug|Any CPU
+		{755CD5A6-C48E-4D35-B0BE-8EC0FDE1A2A1}.Release|Any CPU.Build.0 = Debug|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

examples/simple/.gitignore

+encoded_data
+encoded_data06
+example_decoder
+example_decoder06
+example_encoder
+example_encoder06
+gen
+gen06

examples/simple/Decoder.java

@@ -2,24 +2,25 @@ import java.io.File;
 import java.io.FileInputStream;
 import java.io.InputStream;
 
-import se.lth.control.labcomm.LabCommDecoderChannel;
+import se.lth.control.labcomm2014.DecoderChannel;
 
 public class Decoder
-  implements theTwoInts.Handler, anotherTwoInts.Handler, IntString.Handler, TwoArrays.Handler, TwoFixedArrays.Handler
+  implements theTwoInts.Handler, anotherTwoInts.Handler, IntString.Handler, TwoArrays.Handler, TwoFixedArrays.Handler, doavoid.Handler
 
 {
 
-  LabCommDecoderChannel decoder;
+  DecoderChannel decoder;
 
   public Decoder(InputStream in) 
     throws Exception 
   {
-    decoder = new LabCommDecoderChannel(in);
+    decoder = new DecoderChannel(in);
     theTwoInts.register(decoder, this);
     anotherTwoInts.register(decoder, this);
     IntString.register(decoder, this);
     TwoArrays.register(decoder, this);
     TwoFixedArrays.register(decoder, this);
+    doavoid.register(decoder, this);
 
     try {
       System.out.println("Running decoder.");
@@ -72,6 +73,10 @@ public class Decoder
     }
     System.out.println();
   }
+  public void handle_doavoid() throws java.io.IOException {
+    System.out.println("Got doavoid");
+  }
+
 
 
   public static void main(String[] arg) throws Exception {

examples/simple/Encoder.java

@@ -2,7 +2,7 @@ import java.io.File;
 import java.io.FileOutputStream;
 import java.io.OutputStream;
 
-import se.lth.control.labcomm.LabCommEncoderChannel;
+import se.lth.control.labcomm2014.EncoderChannel;
 
 /**
  * Simple encoder 
@@ -10,18 +10,20 @@ import se.lth.control.labcomm.LabCommEncoderChannel;
 public class Encoder 
 {
 
-  LabCommEncoderChannel encoder;
+  EncoderChannel encoder;
 
   public Encoder(OutputStream out) 
     throws Exception 
   {
-    encoder = new LabCommEncoderChannel(out);
+    encoder = new EncoderChannel(out);
+    doavoid.register(encoder);
     theTwoInts.register(encoder);
     IntString.register(encoder);
     TwoArrays.register(encoder);
   }
 
   public void doEncode() throws java.io.IOException {
+
     TwoInts x = new TwoInts();
     x.a = 17;
     x.b = 42;
@@ -35,6 +37,9 @@ public class Encoder
 //    ta.variable = new int[][] {{1,2},{0x11,0x12},{0x21,0x22},{0x31,0x32}};
     ta.variable = new int[][] {{1,2, 3, 4},{0x21,0x22,0x23,0x24}};
 
+    System.out.println("Encoding doavoid");
+    doavoid.encode(encoder);
+
     System.out.println("Encoding theTwoInts, a="+x.a+", b="+x.b);
     theTwoInts.encode(encoder, x);
 

examples/simple/EncoderIS.java

+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.OutputStream;
+
+import se.lth.control.labcomm2014.EncoderChannel;
+
+/**
+ * Simple encoder 
+ */
+public class EncoderIS 
+{
+
+  EncoderChannel encoder;
+
+  public EncoderIS(OutputStream out) 
+    throws Exception 
+  {
+    encoder = new EncoderChannel(out);
+//    doavoid.register(encoder);
+//    theTwoInts.register(encoder);
+    IntString.register(encoder);
+//    TwoArrays.register(encoder);
+  }
+
+  public void doEncodeIS() throws java.io.IOException {
+    IntString a = new IntString();
+    a.x = 17;
+    a.s = "A string";
+
+    IntString b = new IntString();
+    b.x = 9;
+    b.s = "Hej";
+
+    IntString c = new IntString();
+    c.x = 133742;
+    c.s = "Thirteenthirtysevenfourtytwo";
+
+    System.out.println("Encoding IntStrings");
+    IntString.encode(encoder, a);
+    IntString.encode(encoder, b);
+    IntString.encode(encoder, c);
+  }
+
+
+  public static void main(String[] arg) throws Exception {
+    FileOutputStream fos = new FileOutputStream(arg[0]);
+    EncoderIS example = new EncoderIS(fos);
+    example.doEncodeIS();
+    fos.close();
+  }
+
+}
+

examples/simple/Makefile

+all:
+
+clean:
+
+distclean:
+	rm -rf gen
+	rm -f *.class
+	rm -f example_encoder
+	rm -f example_decoder
+	rm -f encoded_data

examples/simple/compile.sh

+#!/bin/sh
+set -x
+set -e
+### Example compile script, showing the steps required to build a labcomm application
+### (including compiler and libs). Also illustrates how versions 2013 and 2006 coexist
+
+# For current version (2013)
 (cd ../..; make all)
 
 mkdir -p gen
-java -jar ../../compiler/labComm.jar --java=gen --c=gen/simple.c --h=gen/simple.h  --python=gen/simple.py simple.lc 
+java -jar ../../compiler/labcomm2014_compiler.jar --java=gen --c=gen/simple.c --h=gen/simple.h  --python=gen/simple.py simple.lc 
 
-javac -cp ../../lib/java:. gen/*.java Encoder.java Decoder.java
+javac -cp ../../lib/java/labcomm2014.jar:. gen/*.java Encoder.java Decoder.java
 
-gcc -Wall -Werror -I. -I../../lib/c -L../../lib/c \
+gcc -Wall -Werror -Wno-unused-function \
+    -I. -I../../lib/c/2014 -L../../lib/c \
     -o example_encoder example_encoder.c gen/simple.c \
-    -llabcomm -Tlabcomm.linkscript
-gcc -Wall -Werror -I . -I ../../lib/c -L../../lib/c \
+    -llabcomm2014 
+gcc -Wall -Werror -I . -I ../../lib/c/2014 -L../../lib/c \
     -o example_decoder example_decoder.c gen/simple.c \
-    -llabcomm -Tlabcomm.linkscript
-
-#gcc -o example_encoder -I . -I ../../lib/c example_encoder.c gen/simple.c ../../lib/c/labcomm.c ../../lib/c/labcomm_fd_reader_writer.c
-
-#gcc -o example_decoder -I . -I ../../lib/c example_decoder.c gen/simple.c ../../lib/c/labcomm.c ../../lib/c/labcomm_fd_reader_writer.c
-
+    -llabcomm2014 
 

examples/simple/example_decoder.c

 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
-#include <labcomm_fd_reader.h>
-#include <labcomm_default_error_handler.h>
-#include <labcomm_default_memory.h>
-#include <labcomm_default_scheduler.h>
+#include <labcomm2014_fd_reader.h>
+#include <labcomm2014_default_error_handler.h>
+#include <labcomm2014_default_memory.h>
+#include <labcomm2014_default_scheduler.h>
 #include "gen/simple.h"
 #include <stdio.h>
 
+static void handle_simple_doavoid(simple_doavoid *v, void *context) {
+  printf("Got a void.\n");
+}
+
 static void handle_simple_theTwoInts(simple_TwoInts *v,void *context) {
   printf("Got theTwoInts. a=%d, b=%d\n", v->a, v->b);
 }
@@ -53,32 +57,33 @@ static void handle_simple_TwoFixedArrays(simple_TwoFixedArrays *d,void *context)
 
 int main(int argc, char *argv[]) {
   int fd;
-  struct labcomm_decoder *decoder;
+  struct labcomm2014_decoder *decoder;
   void  *context = NULL;
 
   char *filename = argv[1];
   printf("C decoder reading from %s\n", filename);
   fd = open(filename, O_RDONLY);
-  decoder = labcomm_decoder_new(labcomm_fd_reader_new(
-				  labcomm_default_memory, fd, 1), 
-				labcomm_default_error_handler, 
-				labcomm_default_memory,
-				labcomm_default_scheduler);
+  decoder = labcomm2014_decoder_new(labcomm2014_fd_reader_new(
+				  labcomm2014_default_memory, fd, 1), 
+				labcomm2014_default_error_handler, 
+				labcomm2014_default_memory,
+				labcomm2014_default_scheduler);
   if (!decoder) { 
     printf("Failed to allocate decoder %s:%d\n", __FUNCTION__, __LINE__);
     return 1;
   }
 
-  labcomm_decoder_register_simple_theTwoInts(decoder, handle_simple_theTwoInts, context);
-  labcomm_decoder_register_simple_anotherTwoInts(decoder, handle_simple_anotherTwoInts, context);
-  labcomm_decoder_register_simple_IntString(decoder, handle_simple_IntString, context);
-  labcomm_decoder_register_simple_TwoArrays(decoder, handle_simple_TwoArrays, context);
-  labcomm_decoder_register_simple_TwoFixedArrays(decoder, handle_simple_TwoFixedArrays, context);
+  labcomm2014_decoder_register_simple_doavoid(decoder, handle_simple_doavoid, context);
+  labcomm2014_decoder_register_simple_theTwoInts(decoder, handle_simple_theTwoInts, context);
+  labcomm2014_decoder_register_simple_anotherTwoInts(decoder, handle_simple_anotherTwoInts, context);
+  labcomm2014_decoder_register_simple_IntString(decoder, handle_simple_IntString, context);
+  labcomm2014_decoder_register_simple_TwoArrays(decoder, handle_simple_TwoArrays, context);
+  labcomm2014_decoder_register_simple_TwoFixedArrays(decoder, handle_simple_TwoFixedArrays, context);
 
   printf("Decoding:\n");
-  labcomm_decoder_run(decoder);
+  labcomm2014_decoder_run(decoder);
   printf("--- End Of File ---:\n");
-  labcomm_decoder_free(decoder);
+  labcomm2014_decoder_free(decoder);
 
   return 0;
 }