examples/simple/example_encoder_mismatch.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 "gen06/simple.h"
+#include <stdio.h>
+
+int main(int argc, char *argv[]) {
+  int fd;
+  struct labcomm_encoder *encoder;
+
+  char *filename = argv[1];
+  printf("C encoder writing to %s\n", filename);
+  fd = open(filename, O_WRONLY|O_CREAT|O_TRUNC, 0644);
+  encoder = labcomm_encoder_new(labcomm_fd_writer_new(
+				  labcomm_default_memory, fd, 1), 
+				labcomm_default_error_handler, 
+				labcomm_default_memory,
+				labcomm_default_scheduler);
+  labcomm_encoder_register_simple_theTwoInts(encoder);
+  labcomm_encoder_register_simple_anotherTwoInts(encoder);
+  labcomm_encoder_register_simple_IntString(encoder);
+  simple_IntString is;
+  is.x = 24;
+  is.s = "Hello, LabComm!";
+  printf("Encoding IntString, x=%d, s=%s\n", is.x, is.s);
+  labcomm_encode_simple_IntString(encoder, &is);
+
+  simple_theTwoInts ti;
+  ti.a = 13;
+  ti.b = 37;
+  printf("Encoding theTwoInts, a=%d, b=%d\n", ti.a, ti.b);
+  labcomm_encode_simple_theTwoInts(encoder, &ti);
+
+  simple_anotherTwoInts ati;
+  ati.a = 23;
+  ati.b = 47;
+  printf("Encoding anotherTwoInts, a=%d, b=%d\n", ati.a, ati.b);
+  labcomm_encode_simple_anotherTwoInts(encoder, &ati);
+
+  int foo[20];
+
+  labcomm_encoder_register_simple_TwoArrays(encoder);
+
+  simple_TwoArrays ta;
+  ta.fixed.a[0] = 17;
+  ta.fixed.a[1] = 42;
+  ta.variable.n_1 = 10;
+  ta.variable.a = foo;
+  
+  int k;
+  for(k=0; k<20; k++) {
+	foo[k] = k;
+  }
+
+  printf("Encoding TwoArrays...\n");
+  labcomm_encode_simple_TwoArrays(encoder, &ta);
+
+  ti.a = 23;
+  ti.b = 47;
+  printf("Encoding theTwoInts, a=%d, b=%d\n", ti.a, ti.b);
+  labcomm_encode_simple_theTwoInts(encoder, &ti);
+
+
+  simple_TwoFixedArrays tfa;
+
+  tfa.a.a[0] = 41;
+  tfa.a.a[1] = 42;
+
+  tfa.b.a[0][0] = 51;
+  tfa.b.a[0][1] = 52;
+  tfa.b.a[0][2] = 53;
+  tfa.b.a[1][0] = 61;
+  tfa.b.a[1][1] = 62;
+  tfa.b.a[1][2] = 63;
+
+  printf("Encoding TwoFixedArrays...\n");
+  labcomm_encoder_register_simple_TwoFixedArrays(encoder);
+  labcomm_encode_simple_TwoFixedArrays(encoder, &tfa);
+
+  return 0;
+}

examples/simple/notypes.lc

+sample int AnInt;
+
+sample struct {
+  int x;
+  string s;
+} IntString;
+
+sample struct {
+  struct {
+    float x;
+    float y;
+  } point;
+  boolean b;
+} nestedStruct;

examples/simple/run.sh

+export LD_LIBRARY_PATH=../../lib/c/
+echo
+echo "********************************************"
+echo "***   Running example for version 2013   ***"
+echo "********************************************"
+echo
+
+java -cp .:../../lib/java/labcomm2014.jar:gen Encoder encoded_data
+./example_decoder encoded_data
+
+PYTHONPATH=../../lib/python:gen ./example_encoder.py encoded_data
+java -cp .:../../lib/java/labcomm2014.jar:gen Decoder encoded_data
+
+./example_encoder encoded_data
+java -cp .:../../lib/java/labcomm2014.jar:gen Decoder encoded_data
+
+echo "running python decoder (from wiki_example):"
+PYTHONPATH=../../lib/python ../wiki_example/example_decoder.py encoded_data LabComm2014
+

examples/simple/simple.lc

+typedef struct {
+  int a;
+  int b;
+} TwoInts;
+
+sample TwoInts theTwoInts;
+sample TwoInts anotherTwoInts;
+
+sample struct {
+  int x;
+  string s;
+} IntString;
+
+sample struct {
+  double x;
+  double y;
+} TwoDoubles;
+
+sample struct {
+  int fixed[2];
+  int variable[2,_];
+} TwoArrays;
+
+sample struct {
+  int a[2];
+  int b[2,3];
+} TwoFixedArrays;
+
+typedef void avoid;
+
+sample avoid doavoid;
+
+// examples of errors: void may not be used
+// in structs or arrays
+//
+// sample struct {
+//  int a;
+//  avoid error;
+//} foo;
+//
+//sample void error2[2] ;
+//sample avoid error3[_];

examples/simple/thr_decoder.c

+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <labcomm_thr_reader_writer.h>
+#include "gen/simple.h"
+#include "ThrottleDrv/throttle_drv.h"
+
+static void handle_simple_TwoInts(simple_TwoInts *v,void *context) {
+  printf("Got TwoInts. a=%d, b=%d\n", v->a, v->b);
+}
+
+static void handle_simple_IntString(simple_IntString *v,void *context) {
+  printf("Got IntString. x=%d, s=%s\n", v->x, v->s);
+}
+
+int main(int argc, char *argv[]) {
+  struct thr_chn_t *p_thr_chn = NULL;
+  struct labcomm_decoder *decoder;
+  void  *context = NULL;
+  int ret = 0;
+  unsigned char dest_mac[ETH_ADR_SIZE] = {0x06, 0x05, 0x04, 0x03, 0x02, 0x01};	/* other host MAC address, hardcoded...... :-( */
+  unsigned char chn_id = 0x01;
+  unsigned short frag_size = 60;
+  unsigned short freq = 1000;  /* milliseconds */
+  unsigned char data[200];
+
+  char *ifname = argv[1];
+  char *dest_mac_str = argv[2];
+
+  if(argc != 3) {
+        printf("usage: thr_encoder ethN xx:xx:xx:xx:xx:xx\n");
+        return 1;
+  }
+
+  if(parse_MAC_address(dest_mac_str, dest_mac)) {
+        printf("failed to parse dest MAC address\n");
+        return 1;
+  }
+
+  if (-1 == thr_init(ifname))
+  {
+     printf("Throttle Init failure.");
+  }
+  else
+  {
+    p_thr_chn = thr_open_chn(dest_mac, chn_id, frag_size, freq, labcomm_decoder_decode_one);
+    decoder = labcomm_decoder_new(labcomm_thr_reader, p_thr_chn);
+    if (!decoder)
+    {
+      printf("Failed to allocate decoder %s:%d\n", __FUNCTION__, __LINE__);
+      return 1;
+    }
+    labcomm_decoder_register_simple_TwoInts(decoder, handle_simple_TwoInts, context);
+    labcomm_decoder_register_simple_IntString(decoder, handle_simple_IntString, context);
+
+    printf("Decoding:\n");
+    do {
+    ret = thr_receive(p_thr_chn, data, decoder);
+    } while(-1 != ret);
+    {
+      printf("Throttle Send receive failure.");
+    }
+    printf("--- End Of File ---:\n");
+    labcomm_decoder_free(decoder);
+
+    //server_exit(fd);
+  }
+}

examples/simple/thr_encoder.c

+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <labcomm_thr_reader_writer.h>
+#include "gen/simple.h"
+#include "ThrottleDrv/throttle_drv.h"
+
+
+int main(int argc, char *argv[]) {
+  struct thr_chn_t *p_thr_chn = NULL;
+  struct labcomm_encoder *encoder;
+  int i, j;
+//  unsigned char dest_mac[ETH_ADR_SIZE] = {0x00, 0x09, 0x6b, 0x10, 0xf3, 0x80};	/* other host MAC address, hardcoded...... :-( */
+  unsigned char dest_mac[ETH_ADR_SIZE] = {0x00, 0x09, 0x6b, 0xe3, 0x81, 0xbf};	/* other host MAC address, hardcoded...... :-( */
+  unsigned char chn_id = 0x01;
+  unsigned short frag_size = 60;
+  unsigned short freq = 1000;  /* milliseconds */
+
+  char *ifname = argv[1];
+  char *dest_mac_str = argv[2];
+
+  if(argc != 3) {
+	printf("usage: thr_encoder ethN xx:xx:xx:xx:xx:xx\n");
+	return 1;
+  } 
+
+  if(parse_MAC_address(dest_mac_str, dest_mac)) {
+	printf("failed to parse dest MAC address\n");
+	return 1;
+  }
+  
+  if (-1 == thr_init(ifname))
+  {
+     printf("Throttle Init failure.");
+  }
+  else
+  {
+    p_thr_chn = thr_open_chn(dest_mac, chn_id, frag_size, freq, NULL);
+    encoder = labcomm_encoder_new(labcomm_thr_writer, p_thr_chn);
+    labcomm_encoder_register_simple_TwoInts(encoder);
+    labcomm_encoder_register_simple_IntString(encoder);
+    simple_IntString is;
+    is.x = 24;
+    is.s = "Hello, LabComm!";
+    printf("Encoding IntString, x=%d, s=%s\n", is.x, is.s);
+    labcomm_encode_simple_IntString(encoder, &is);
+
+    simple_TwoInts ti;
+    ti.a = 13;
+    ti.b = 37;
+    printf("Encoding TwoInts, a=%d, b=%d\n", ti.a, ti.b);
+    labcomm_encode_simple_TwoInts(encoder, &ti);
+
+    //client_exit(fd);
+ }
+}

examples/tcp/Makefile

+LCDIR=../..
+LABCOMM_JAR=../../compiler/labcomm2014_compiler.jar
+LABCOMM=java -jar $(LABCOMM_JAR)
+LCLJAR=${LCDIR}/lib/java/labcomm2014.jar  # the LabComm library
+JAVA_PKG=labcommTCPtest
+
+.PHONY : clean run runserver runOSserver runclient
+
+#### The main example #########################
+
+run : ${JAVA_PKG}/Example.class ${JAVA_PKG}/server/TestServer.class ${JAVA_PKG}/client/TestClient.class
+	java -cp ${CLASSPATH} $(<:.class=)
+
+###############################################
+### dependencies and parts ####################
+###############################################
+
+CLASSPATH=.:${LCLJAR}
+
+${LABCOMM_JAR} :
+	cd ${LCDIR} && make make-compiler
+
+${LCLJAR} :
+	cd ${LCDIR}/lib/java && make labcomm2014.jar
+
+${JAVA_PKG}/gen/FooSample.java: test.lc ${LCCJAR}
+	${LABCOMM} --javapackage=${JAVA_PKG}.gen --java=${JAVA_PKG}/gen $<
+
+${JAVA_PKG}/gen/FooSample.class: ${JAVA_PKG}/gen/FooSample.java test.lc ${LCLJAR}   
+	javac -cp ${CLASSPATH} $<
+
+${JAVA_PKG}/Example.class: ${JAVA_PKG}/Example.java ${JAVA_PKG}/gen/FooSample.class ${LCLJAR} 
+	javac -cp ${CLASSPATH} $<
+
+${JAVA_PKG}/server/TestServer.class: ${JAVA_PKG}/server/TestServer.java ${JAVA_PKG}/gen/FooSample.class ${LCLJAR} 
+	javac -cp ${CLASSPATH} $<
+
+${JAVA_PKG}/server/OneShotServer.class: ${JAVA_PKG}/server/OneShotServer.java ${JAVA_PKG}/gen/FooSample.class ${LCLJAR} 
+	javac -cp ${CLASSPATH} $<
+
+${JAVA_PKG}/client/TestClient.class: ${JAVA_PKG}/client/TestClient.java ${JAVA_PKG}/gen//FooSample.class ${LCLJAR} 
+	javac -cp ${CLASSPATH} $<
+
+runserver : ${JAVA_PKG}/server/TestServer.class
+	java -cp ${CLASSPATH} $(<:.class=)
+
+runOSserver : ${JAVA_PKG}/server/OneShotServer.class
+	java -cp ${CLASSPATH} $(<:.class=)
+
+runclient : ${JAVA_PKG}/client/TestClient.class
+	java -cp ${CLASSPATH} $(<:.class=)
+
+clean :
+	rm -f ${JAVA_PKG}/server/*.class 
+	rm -f ${JAVA_PKG}/client/*.class 
+	rm -f ${JAVA_PKG}/gen/* 
+
+distclean: clean

examples/tcp/README.txt

+A simple (mostly Java) example of a LabComm channel over TCP
+
+The class labcommTCPtest/Example.java contains set up of a server
+and a client, and can be run by 'make run' 
+
+Also included is a generic decoder in python, and a server that only sends
+one sample to the first client that connects, and then closes the connection
+and exits.
+
+Those can be run by
+
+* first, in one terminal: make runOSserver
+* then, in another terminal: ./runpy localhost 9999
+

examples/tcp/example_tcp_client_decoder.py

+#!/usr/bin/python
+
+import os
+import sys
+import socket
+import rwsocket
+
+if not any('labcomm2014' in p for p in sys.path):
+    sys.path.append('../../lib/python')
+import labcomm2014
+
+
+if __name__ == "__main__":
+    print "Trying to connect..."
+    host = sys.argv[1] #'localhost'
+    port = sys.argv[2] #'8081'
+    addr = (host,int(port))
+    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    sock.connect(addr)
+    print "Connected!"
+
+    d = labcomm2014.Decoder(labcomm2014.StreamReader(sock))
+
+    while True:
+        try:
+            data,decl = d.decode()
+            if data:
+                print data
+        except KeyError as e:
+            print 'KeyError : "%s"' % str(e)
+        except:
+            print 'exception...', sys.exc_info()[0]
+            break

examples/tcp/labcommTCPtest/Example.java

+package labcommTCPtest;
+import labcommTCPtest.server.TestServer;
+import labcommTCPtest.client.TestClient;
+import java.net.Socket;
+import java.net.ServerSocket;
+
+public class Example {
+
+	public static void main(String a[]) {
+		String server = "localhost";
+		int port = 9999;
+		ServerThread serverThread = new ServerThread(port);
+       		ClientThread clientThread = new ClientThread(server, port);
+
+		serverThread.start();
+		clientThread.start();
+	}
+
+
+	private static class ServerThread extends Thread {
+	        private	int port;
+
+		public ServerThread(int port) {
+			this.port = port;
+		}
+		public void run() {
+			try {
+				ServerSocket ss = new ServerSocket(port);
+				Socket s = ss.accept();
+
+				TestServer ts = new TestServer(s);
+				ts.runOne();
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+		}
+	}
+
+	private static class ClientThread extends Thread {
+		private String server;
+	        private	int port;
+
+		public ClientThread(String server, int port) {
+			this.server = server;
+			this.port = port;
+		}
+		public void run() {
+			try {
+				Socket s = new Socket(server, port);
+				TestClient c = new TestClient(s);
+				c.test();
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+		}
+	}
+}
+

examples/tcp/labcommTCPtest/client/TestClient.java

+package labcommTCPtest.client;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.Socket;
+import java.net.UnknownHostException;
+
+import se.lth.control.labcomm2014.DecoderChannel;
+import se.lth.control.labcomm2014.EncoderChannel;
+import labcommTCPtest.gen.FooSample;
+import labcommTCPtest.gen.FooSample.Handler;
+
+public class TestClient implements Handler {
+
+
+	private OutputStream out;
+	private InputStream in;
+
+	public TestClient(Socket server) throws IOException {
+		out = server.getOutputStream();
+		in = server.getInputStream();
+	}
+
+	public void test() {
+		
+		try {
+			EncoderChannel e = new EncoderChannel(out );
+			FooSample.register(e);
+			FooSample sample = new FooSample();
+			int a[] = new int[3];
+			a[0] = 1;
+			a[1] = 2;
+			a[2] = 3;
+
+			sample.s = "Some random values";
+			sample.x = 17;
+			sample.y = 42;
+			sample.a = a;
+			sample.t = 1717;
+			sample.d = 0.42;
+			printSample("Client sending", sample);
+			FooSample.encode(e, sample);
+
+			DecoderChannel c = new DecoderChannel(in);
+			FooSample.register(c,this);
+			c.runOne();
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	public static void main(String... args) {
+		String server = "localhost";
+		int port = 9999;
+		try {
+			Socket s = new Socket(server, port);
+			TestClient c = new TestClient(s);
+			c.test();
+		} catch (UnknownHostException e) {
+			e.printStackTrace();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+
+	private String formatArray(int a[]) {
+		StringBuilder sb = new StringBuilder();
+		sb.append("[");
+		for(int i=0; i < a.length; i++) {
+			sb.append(a[i]);
+			if(i < a.length-1) {
+				sb.append(", ");
+			}
+		}
+		sb.append("]");
+
+		return sb.toString();
+	}
+
+	private void printSample(String header, FooSample sample2) throws Exception {
+		System.out.format("[TestClient] %s: (%s, %d, %d, %s, %d, %f )\n", header, sample2.s, sample2.x, sample2.y, formatArray(sample2.a), sample2.t, sample2.d);
+	}
+
+	public void handle_FooSample(FooSample sample2) throws Exception {
+		printSample("TestClient.handle_FooSample", sample2);
+
+	}
+}

examples/tcp/labcommTCPtest/client/TestClientSingleshot.java

+package labcommTCPtest.client;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.Socket;
+import java.net.UnknownHostException;
+
+import se.lth.control.labcomm2014.DecoderChannel;
+import se.lth.control.labcomm2014.EncoderChannel;
+import labcommTCPtest.gen.FooSample;
+import labcommTCPtest.gen.FooSample.Handler;
+
+public class TestClientSingleshot implements Handler {
+
+
+	private OutputStream out;
+	private InputStream in;
+
+	public TestClientSingleshot(Socket server) throws IOException {
+		out = server.getOutputStream();
+		in = server.getInputStream();
+	}
+
+	public void test() {
+		
+		try {
+			EncoderChannel e = new EncoderChannel(out );
+			FooSample.register(e);
+			FooSample sample = new FooSample();
+			sample.x = 17;
+			sample.y = 42;
+			sample.t = 1717;
+			sample.d = 0.42;
+			printSample("Client sending", sample);
+			FooSample.encode(e, sample);
+
+			DecoderChannel c = new DecoderChannel(in);
+			FooSample.register(c,this);
+			c.runOne();
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	public static void main(String... args) {
+		String server = "localhost";
+		int port = 9999;
+		try {
+			Socket s = new Socket(server, port);
+			TestClientSingleshot c = new TestClientSingleshot(s);
+			c.test();
+		} catch (UnknownHostException e) {
+			e.printStackTrace();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+
+	private void printSample(String header, FooSample sample2) throws Exception {
+		System.out.println(header);
+		System.out.format("TestClientSingleshot.invoke(%d, %d, %d, %f)\n", sample2.x, sample2.y, sample2.t, sample2.d);
+	}
+
+	public void handle_FooSample(FooSample sample2) throws Exception {
+		printSample("TestClientSingleshot.handle_FooSample", sample2);
+
+	}
+}

examples/tcp/labcommTCPtest/server/OneShotServer.java

+package labcommTCPtest.server;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.Socket;
+import java.net.ServerSocket;
+
+import se.lth.control.labcomm2014.DecoderChannel;
+import se.lth.control.labcomm2014.EncoderChannel;
+import labcommTCPtest.gen.FooSample;
+
+public class OneShotServer {//implements Handler {
+
+	private OutputStream out;
+
+	public OneShotServer(Socket s) throws IOException {
+		out = s.getOutputStream();
+	}
+
+	public void test() {
+		
+		try {
+			EncoderChannel e = new EncoderChannel(out );
+			FooSample.register(e);
+			FooSample sample = new FooSample();
+			sample.s = "OneShotServer message";
+			sample.x = 17;
+			sample.y = 42;
+			sample.a = new int[]{10,11,12};
+			sample.t = 1717;
+			sample.d = 0.42;
+			printSample("Server sending", sample);
+			FooSample.encode(e, sample);
+			Thread.sleep(1);
+			sample.x++;
+			sample.y--;
+			printSample("Server sending", sample);
+			FooSample.encode(e, sample);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	public static void main(String... args) {
+		String server = "localhost";
+		int port = 9999;
+		try {
+			ServerSocket ss = new ServerSocket(port);
+			Socket s = ss.accept();
+			OneShotServer c = new OneShotServer(s);
+			c.test();
+		} catch (IOException e) {
+			e.printStackTrace();
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	private void printSample(String header, FooSample sample2) throws Exception {
+		System.out.println(header);
+		System.out.format("TestClient.invoke(%d, %d, %d, %f)\n", sample2.x, sample2.y, sample2.t, sample2.d);
+	}
+}

examples/tcp/labcommTCPtest/server/TestObject.java

+package labcommTCPtest.server;
+
+/**
+ * The service object to be accessed remotely via a LabComm channel
+ * 
+ */
+public class TestObject {
+
+	/**
+	 * A test method. The matching LabComm description is in test.lc
+	 * 
+	 * @param x
+	 * @param y
+	 * @param t
+	 * @param d
+	 */
+	public void foo(int x, int y, long t, double d) {
+		System.out.format("TestObject.foo(%d, %d, %d, %f)\n", x, y, t, d);
+	}
+
+}

examples/tcp/labcommTCPtest/server/TestServer.java

+package labcommTCPtest.server;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.net.ServerSocket;
+import java.net.Socket;
+
+import se.lth.control.labcomm2014.DecoderChannel;
+import se.lth.control.labcomm2014.EncoderChannel;
+import labcommTCPtest.gen.FooSample;
+import labcommTCPtest.gen.FooSample.Handler;
+
+public class TestServer implements Handler {
+
+	private OutputStream out;
+	private InputStream in;
+
+	public static void main(String a[]) {
+		try {
+			ServerSocket ss = new ServerSocket(9999);
+			Socket s = ss.accept();
+			
+			TestServer ts = new TestServer(s);
+			ts.runOne();
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+	
+	public TestServer(Socket s) throws IOException {
+		out = s.getOutputStream();
+		in = s.getInputStream();
+	}
+	
+	public void runOne() {
+		
+		try {
+			DecoderChannel c = new DecoderChannel(in);
+			FooSample.register(c,this);
+			c.runOne();
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	public void handle_FooSample(FooSample sample) throws Exception {
+		EncoderChannel e = new EncoderChannel(out );
+		FooSample.register(e);
+		System.out.println("TestServer.handle_FooSample: "+sample.s);
+		int tmp[] = new int[2*sample.a.length];
+		for (int i = 0; i < sample.a.length;i++) {
+			tmp[2*i] = tmp[2*i+1] = sample.a[i];
+		}
+		
+		sample.s = "double!";
+		sample.x *= 2;
+		sample.y *= 2;
+		sample.a = tmp;
+		sample.t *= 2;
+		sample.d *= 2;
+		FooSample.encode(e, sample);
+	}
+}

examples/tcp/runpy

+#!/bin/sh
+
+PYTHONPATH=../../lib/python ./example_tcp_client_decoder.py $@

examples/tcp/rwsocket.py

+import socket
+import types
+
+def flush(self):
+    pass
+
+socket.socket.write = socket.socket.send
+socket.socket.read = socket.socket.recv
+socket.socket.flush = flush
+
+# class rwsocket(socket.socket):
+#     write=socket.socket.send
+#     read=socket.socket.recv
+
+#     def flush(self):
+#         pass
+
+#     def accept(self):
+#         sock, addr = super(rwsocket, self).accept()
+#         # sock.write = types.MethodType(self.write, sock, sock.__class__)
+#         # sock.read = types.MethodType(self.write, sock, sock.__class__)
+#         sock.__class__ = rwsocket
+
+#         return (sock, addr)

examples/tcp/test.lc

+sample struct {
+    string s;
+    int x;
+    int y;
+    int a[_];
+    long t;
+    double d;
+} FooSample;

examples/twoway/.gitignore

+gen

examples/twoway/Makefile

+UNAME_S=$(shell uname -s)
+
+TARGETS=client server
+LABCOMM_JAR=../../compiler/labcomm2014_compiler.jar
+LABCOMM=java -jar $(LABCOMM_JAR)
+
+#include ../../lib/c/os_compat.mk
+
+CFLAGS=-O3 -g -Wall -Werror -I../../lib/c/2014 -I. -Wno-unused-function
+
+ifeq ($(UNAME_S),Darwin)
+    CFLAGS+=-DLABCOMM_COMPAT=\"labcomm2014_compat_osx.h\" -DLABCOMM_OS_DARWIN=1
+else
+    CFLAGS+=-Wno-tautological-compare
+endif
+
+all: $(TARGETS:%=gen/%)
+
+test: all
+	LD_LIBRARY_PATH=../../lib/c ./gen/server 2000 &
+	LD_LIBRARY_PATH=../../lib/c ./gen/client localhost 2000
+
+gen/.dir:
+	mkdir -p $@
+
+.PRECIOUS: gen/%.o
+gen/%.o: gen/%.c | gen/.dir
+	$(CC) $(CFLAGS) -c -o $@ $<
+
+gen/%.o: %.c | gen/.dir
+	$(CC) $(CFLAGS) -c -o $@ $<
+
+.PRECIOUS: gen/%.c gen/%.h
+gen/%.c gen/%.h: %.lc | gen/.dir
+	$(LABCOMM) --c=gen/$*.c --h=gen/$*.h $<
+
+gen/client: client.c
+	$(CC) -o $@ $(CFLAGS) $^ -lpthread \
+		-L../../lib/c -llabcomm2014
+
+gen/server: server.c
+	$(CC) -o $@ $(CFLAGS) $^ -lpthread \
+		-L../../lib/c -llabcomm2014
+
+.PHONY: clean distclean
+clean distclean:
+	rm -rf gen
+
+gen/decimating.o: decimating.h
+gen/decimating.o: gen/decimating_messages.h
+gen/introspecting.o: introspecting.h
+gen/introspecting.o: gen/introspecting_messages.h
+gen/client.o: decimating.h
+gen/client.o: gen/types.h
+gen/client: gen/decimating.o
+gen/client: gen/decimating_messages.o
+gen/client: gen/introspecting.o
+gen/client: gen/introspecting_messages.o
+gen/client: gen/types.o
+gen/server: gen/types.o
+gen/server: gen/decimating.o
+gen/server: gen/decimating_messages.o
+gen/server: gen/introspecting.o
+gen/server: gen/introspecting_messages.o