.gitignore

@@ -6,9 +6,9 @@ lib/c/liblabcomm.so.1
 lib/c/liblabcomm2006.so.1
 lib/c/liblabcomm2006.so
 lib/c/liblabcomm2006.a
-lib/c/liblabcomm2013.so.1
-lib/c/liblabcomm2013.so
-lib/c/liblabcomm2013.a
+lib/c/liblabcomm20141009.so.1
+lib/c/liblabcomm20141009.so
+lib/c/liblabcomm20141009.a
 lib/c/test/test_labcomm
 lib/c/test/test_labcomm_basic_type_encoding
 lib/c/test/test_labcomm_copy
@@ -26,3 +26,7 @@ examples/twoway/gen/
 lib/csharp/labcomm.dll
 lib/java/gen/
 lib/java/labcomm*.jar
+examples/simple/example_decoder
+examples/simple/example_decoder06
+examples/simple/example_encoder
+examples/simple/example_encoder06

Makefile

 SUBDIRS=compiler lib test examples
-export LABCOMM_JAR=$(shell pwd)/compiler/labComm.jar
+export LABCOMM_JAR=$(shell pwd)/compiler/labcomm_compiler.jar
 export LABCOMM=java -jar $(LABCOMM_JAR) 
 
 all: $(SUBDIRS:%=make-%)

compiler/CS_CodeGen.jrag

@@ -268,7 +268,7 @@ aspect CS_Class {
       pp(env.getPrintStream());
       env.println("*/");
       env.println();
-      env.println("public class " + getName() + " : LabCommType {");
+      env.println("public class " + getName() + " : SampleType {");
       env.println();
       env.indent();
       getType().CS_emitInstance(env);
@@ -284,11 +284,11 @@ aspect CS_Class {
     pp(env.getPrintStream());
     env.println("*/");
     env.println();
-    env.println("public class " + getName() + " : LabCommSample {");
+    env.println("public class " + getName() + " : Sample {");
     env.println();
     env.indent();
     getType().CS_emitInstance(env);
-    env.println("public interface Handler : LabCommHandler {");
+    env.println("public interface Handler : SampleHandler {");
     env.print("  void handle(");
     if (!isVoid()) {
       getType().CS_emitType(env);
@@ -297,21 +297,21 @@ aspect CS_Class {
     env.println(");");
     env.println("}");
     env.println();
-    env.println("public static void register(LabCommDecoder d, Handler h) {");
+    env.println("public static void register(Decoder d, Handler h) {");
     env.indent();
     env.println("d.register(new Dispatcher(), h);");
     env.unindent();
     env.println("}");
     env.println();
 
-    env.println("public static void register(LabCommEncoder e) {");
+    env.println("public static void register(Encoder e) {");
     env.indent();
     env.println("e.register(new Dispatcher());");
     env.unindent();
     env.println("}");
     env.println(); 
 
-    env.println("private class Dispatcher : LabCommDispatcher {");
+    env.println("private class Dispatcher : SampleDispatcher {");
     env.indent();
     env.println(); 
     env.println("public Type getSampleClass() {");
@@ -332,7 +332,7 @@ aspect CS_Class {
     env.unindent();
     env.println("}");
     env.println(); 
-    env.println("public void decodeAndHandle(LabCommDecoder d, LabCommHandler h) {");
+    env.println("public void decodeAndHandle(Decoder d, SampleHandler h) {");
     env.indent();
     if (isVoid()) {
       env.println(getName() + ".decode(d);");
@@ -374,7 +374,7 @@ aspect CS_Class {
   }
 
   public void TypeDecl.CS_emitEncoder(CS_env env) {
-    env.print("public static void encode(LabCommEncoder e");
+    env.print("public static void encode(Encoder e");
     if (!isVoid()) {
       env.print(", ");
       getType().CS_emitType(env);
@@ -389,7 +389,7 @@ aspect CS_Class {
   }
 
   public void SampleDecl.CS_emitEncoder(CS_env env) {
-    env.print("public static void encode(LabCommEncoder e");
+    env.print("public static void encode(Encoder e");
     if (!isVoid()) {
       env.print(", ");
       getType().CS_emitType(env);
@@ -485,7 +485,7 @@ aspect CS_Class {
   public void Decl.CS_emitDecoder(CS_env env) {
     env.print("public static ");
     getType().CS_emitType(env);
-    env.println(" decode(LabCommDecoder d) {");
+    env.println(" decode(Decoder d) {");
     env.indent();
     if (!isVoid()) {
       getType().CS_emitType(env);

compiler/C_CodeGen.jrag

@@ -1188,12 +1188,12 @@ aspect C_Signature {
       }
     }
     env.println("};");
+    C_emitSizeofValue(env);
     env.println("struct labcomm"+env.verStr+"_signature labcomm"+env.verStr+"_signature_" + 
 		env.prefix + getName() + " = {");
     env.indent();
-    env.println("LABCOMM_SAMPLE, \"" + getName() + "\",");
-    env.println("(int (*)(struct labcomm"+env.verStr+"_signature *, void *))labcomm"+env.verStr+"_sizeof_" + 
-		env.prefix + getName() + ",");
+    env.println("\"" + getName() + "\",");
+    env.println("sizeof_" + env.prefix + getName() + ",");
     env.println("sizeof(signature_bytes_" + env.prefix + getName() + "),");
     env.println("signature_bytes_" + env.prefix + getName() + ",");
     env.println("0");
@@ -1260,6 +1260,22 @@ aspect C_Sizeof {
     return getType().C_fixedSizeof();
   }
 
+  public void Decl.C_emitSizeof(C_env env) {
+  }
+
+  public void SampleDecl.C_emitSizeof(C_env env) {
+    env = env.nestStruct("(*v)");
+    env.println("int labcomm"+env.verStr+"_sizeof_" + env.prefix + getName() +
+		"(" + env.prefix + getName() + " *v)");
+    env.println("{");
+    env.indent();
+    env.println("return labcomm"+env.verStr+"_internal_sizeof(" +
+                "&labcomm" + env.verStr+"_signature_" + env.prefix + getName() +
+                ", v);");
+    env.unindent();
+    env.println("}");
+  }
+
   public int Type.C_fixedSizeof() {
     throw new Error(this.getClass().getName() + 
 		    ".C_fixedSizeof()" + 
@@ -1308,18 +1324,17 @@ aspect C_Sizeof {
     return getType().C_fixedSizeof() * elements;
   }
 
-  public void Decl.C_emitSizeof(C_env env) {
+  public void Decl.C_emitSizeofValue(C_env env) {
   }
 
-  public void SampleDecl.C_emitSizeof(C_env env) {
+  public void SampleDecl.C_emitSizeofValue(C_env env) {
     env = env.nestStruct("(*v)");
-    env.println("int labcomm"+env.verStr+"_sizeof_" + env.prefix + getName() +
-		"(" + env.prefix + getName() + " *v)");
+    env.println("static int sizeof_" + env.prefix + getName() + "(void *vv)");
     env.println("{");
     env.indent();
-    env.println("int result = labcomm"+env.verStr+"_size_packed32(labcomm"+env.verStr+"_signature_" + 
-                env.prefix + getName() +".index);");
+    env.println("int result = 0;");
     if (C_isDynamic()) {
+      env.println(env.prefix + getName() + " *v = vv;");
       getType().C_emitSizeof(env);
     } else {
       env.println("result += " + C_fixedSizeof() + ";");
@@ -1338,7 +1353,8 @@ aspect C_Sizeof {
   public void PrimType.C_emitSizeof(C_env env) {
     switch (getToken()) {
       case LABCOMM_STRING: { 
-	env.println("result += 0 + strlen(" + env.qualid + ");"); 
+        env.print("{ int l = strlen(" + env.qualid + "); ");
+	env.println("result += labcomm"+env.verStr+"_size_packed32(l) + l; }"); 
       } break;
       default: { 
 	throw new Error(this.getClass().getName() + 

compiler/Java_CodeGen.jrag

@@ -206,21 +206,6 @@ aspect Java_CodeGen {
 
   public void Program.J_gen(PrintStream ps, String pack, int version) throws IOException {
     Java_env env;
-/*
-    // Registration class
-    env = new Java_env(version, ps);
-    if (pack != null && pack.length() > 0) {
-      env.println("package " + pack + ";");
-    }
-    env.println("public class LabCommRegister {");
-    env.println();
-    env.indent();
-    Java_emitTypeRegister(env);
-    env.unindent();
-    env.println();
-    env.println("}");
-//    env.close();
-*/
     env = new Java_env(version, ps);
     for (int i = 0; i < getNumDecl(); i++) {
       Decl d = getDecl(i);
@@ -236,21 +221,6 @@ aspect Java_CodeGen {
 
   public void Program.J_gen(String dir, String pack, int version) throws IOException {
     Java_env env;
-/*
-    // Registration class
-    env = new Java_env(version, new File(dir, "LabCommRegister.java"));
-    if (pack != null && pack.length() > 0) {
-      env.println("package " + pack + ";");
-    }
-    env.println("public class LabCommRegister {");
-    env.println();
-    env.indent();
-    Java_emitTypeRegister(env);
-    env.unindent();
-    env.println();
-    env.println("}");
-    env.close();
-*/
     for (int i = 0; i < getNumDecl(); i++) {
       Decl d = getDecl(i);
       try {
@@ -286,38 +256,6 @@ aspect Java_CodeGen {
       }
     }
   }
-
-}
-
-aspect Java_Register {
-
-  public void Program.Java_emitTypeRegister(Java_env env) {
-    /*
-    env.println("static void register(LabCommChannel c) {");
-    env.indent();
-    for (int i = 0; i < getNumDecl(); i++) {
-      getDecl(i).Java_emitTypeRegister(env);
-    }
-    env.unindent();
-    env.println("}");
-*/
-
-  }
-
-  public void Decl.Java_emitTypeRegister(Java_env env) {
-    throw new Error(this.getClass().getName() + 
-		    ".Java_emitTypeRegister(Java_env env)" + 
-		    " not declared");
-  }
-
-  public void SampleDecl.Java_emitTypeRegister(Java_env env) {
-    env.println(getName() + ".register(c);");
-  }
-
-  public void TypeDecl.Java_emitTypeRegister(Java_env env) {
-    // TODO
-  }
-
 }
 
 aspect Java_Class {
@@ -340,11 +278,11 @@ aspect Java_Class {
       }
 
       env.println("import java.io.IOException;");
-      env.println("import se.lth.control.labcomm"+env.verStr+".LabCommType;");
-      env.println("import se.lth.control.labcomm"+env.verStr+".LabCommEncoder;");
-      env.println("import se.lth.control.labcomm"+env.verStr+".LabCommDecoder;");
+      env.println("import se.lth.control.labcomm"+env.verStr+".SampleType;");
+      env.println("import se.lth.control.labcomm"+env.verStr+".Encoder;");
+      env.println("import se.lth.control.labcomm"+env.verStr+".Decoder;");
       env.println();
-      env.println("public class " + getName() + " implements LabCommType {");
+      env.println("public class " + getName() + " implements SampleType {");
       env.println();
       env.indent();
       getType().Java_emitInstance(env);
@@ -380,21 +318,21 @@ aspect Java_Class {
     }
 
     env.println("import java.io.IOException;");
-    env.println("import se.lth.control.labcomm"+env.verStr+".LabCommDecoder;");
-    env.println("import se.lth.control.labcomm"+env.verStr+".LabCommDispatcher;");
-    env.println("import se.lth.control.labcomm"+env.verStr+".LabCommEncoder;");
-    env.println("import se.lth.control.labcomm"+env.verStr+".LabCommHandler;");
-    env.println("import se.lth.control.labcomm"+env.verStr+".LabCommSample;");
+    env.println("import se.lth.control.labcomm"+env.verStr+".Decoder;");
+    env.println("import se.lth.control.labcomm"+env.verStr+".SampleDispatcher;");
+    env.println("import se.lth.control.labcomm"+env.verStr+".Encoder;");
+    env.println("import se.lth.control.labcomm"+env.verStr+".SampleHandler;");
+    env.println("import se.lth.control.labcomm"+env.verStr+".Sample;");
     env.println();
     env.print("public class " + getName());
 //    if(getType().isUserType()) {
 //        env.print(" extends "+getType().getTypeName());
 //    }
-    env.println(" implements LabCommSample {");
+    env.println(" implements Sample {");
     env.println();
     env.indent();
     getType().Java_emitInstance(env);
-    env.println("public interface Handler extends LabCommHandler {");
+    env.println("public interface Handler extends SampleHandler {");
     env.print("  public void handle_" + getName() + "(");
     if (!isVoid()) {
       getType().Java_emitType(env);
@@ -403,21 +341,21 @@ aspect Java_Class {
     env.println(") throws Exception;");
     env.println("}");
     env.println();
-    env.println("public static void register(LabCommDecoder d, Handler h) throws IOException {");
+    env.println("public static void register(Decoder d, SampleHandler h) throws IOException {");
     env.indent();
     env.println("d.register(new Dispatcher(), h);");
     env.unindent();
     env.println("}");
     env.println();
 
-    env.println("public static void register(LabCommEncoder e) throws IOException {");
+    env.println("public static void register(Encoder e) throws IOException {");
     env.indent();
     env.println("e.register(new Dispatcher());");
     env.unindent();
     env.println("}");
     env.println(); 
 
-    env.println("private static class Dispatcher implements LabCommDispatcher {");
+    env.println("private static class Dispatcher implements SampleDispatcher {");
     env.indent();
     env.println(); 
     env.println("public Class getSampleClass() {");
@@ -438,8 +376,8 @@ aspect Java_Class {
     env.unindent();
     env.println("}");
     env.println(); 
-    env.println("public void decodeAndHandle(LabCommDecoder d,");
-    env.println("                            LabCommHandler h) throws Exception {");
+    env.println("public void decodeAndHandle(Decoder d,");
+    env.println("                            SampleHandler h) throws Exception {");
     env.indent();
     if (isVoid()) {
       env.println(getName() + ".decode(d);");
@@ -481,7 +419,7 @@ aspect Java_Class {
   }
 
   public void TypeDecl.Java_emitEncoder(Java_env env) {
-    env.print("public static void encode(LabCommEncoder e");
+    env.print("public static void encode(Encoder e");
     if (!isVoid()) {
       env.print(", ");
       getType().Java_emitType(env);
@@ -496,7 +434,7 @@ aspect Java_Class {
   }
 
   public void SampleDecl.Java_emitEncoder(Java_env env) {
-    env.print("public static void encode(LabCommEncoder e");
+    env.print("public static void encode(Encoder e");
     if (!isVoid()) {
       env.print(", ");
       getType().Java_emitType(env);
@@ -588,7 +526,7 @@ aspect Java_Class {
   public void Decl.Java_emitDecoder(Java_env env) {
     env.print("public static ");
     getType().Java_emitType(env);
-    env.println(" decode(LabCommDecoder d) throws IOException {");
+    env.println(" decode(Decoder d) throws IOException {");
     env.indent();
     if (!isVoid()) {
       getType().Java_emitType(env);

compiler/Python_CodeGen.jrag

@@ -83,6 +83,7 @@ aspect Python_CodeGen {
     env.println("import labcomm");
     env.println();
     Python_genTypes(env);
+/* Typedefs curenntly disabled
     env.println("typedef = [");
     env.indent();
     for (int i = 0 ; i < getNumDecl() ; i++) {
@@ -90,6 +91,7 @@ aspect Python_CodeGen {
     }
     env.unindent();
     env.println("]");
+*/
     env.println("sample = [");
     env.indent();
     for (int i = 0 ; i < getNumDecl() ; i++) {
@@ -105,11 +107,7 @@ aspect PythonTypes {
   
   public void Program.Python_genTypes(Python_env env) {
     for (int i = 0 ; i < getNumDecl() ; i++) {
-      env.println("class " + getDecl(i).getName() + "(object):");
-      env.indent();
       getDecl(i).Python_genSignature(env);
-      env.unindent();
-      env.println();
     }
   }
 
@@ -120,19 +118,29 @@ aspect PythonTypes {
   }
 
   public void TypeDecl.Python_genSignature(Python_env env) {
+/*
+    env.println("class " + getName() + "(object):");
+    env.indent();
     env.println("signature = labcomm.typedef('" + getName() + "',");
     env.indent();
     getType().Python_genSignature(env);
     env.unindent();
     env.println(")");
+    env.unindent();
+    env.println();
+*/
   }
 
   public void SampleDecl.Python_genSignature(Python_env env) {
+    env.println("class " + getName() + "(object):");
+    env.indent();
     env.println("signature = labcomm.sample('" + getName() + "', ");
     env.indent();
     getType().Python_genSignature(env);
     env.unindent();
     env.println(")");
+    env.unindent();
+    env.println();
   }
 
   public void UserType.Python_genSignature(Python_env env) {

compiler/build.xml

@@ -90,7 +90,7 @@ classpath="tools/jastadd2.jar"/>
 
 
 <target name="jar" depends="build">
-  <jar destfile="labComm.jar">
+  <jar destfile="labcomm_compiler.jar">
     <fileset dir="." includes="LabComm*.class"/>
     <fileset dir="." includes="AST/*.class"/>
     <zipfileset src="tools/beaver-rt.jar" includes="beaver/*.class"/>

doc/pragma-skiss.txt

+Discussion 141023
+
+TODO:
+
+*** new labcomm packet types:
+    TYPE_DEF = 0x03     // for (possibly) hierarchical type definitions
+    TYPE_BINDING = 0x04 // binding a sample def to a type def
+
+*** rewrite malloc of received samples to utilize the packet length field
+    to allocate a single object before parsing the sample byte stream
+
+*** labcomm language: add type for type_ref to facilitate references to
+    labcomm sample_defs (and type_defs) in (primarily) pragmas
+    E.g.,  sample ... foo;
+         sample ... bar;
+
+         sample struct {
+             ...
+             type[2] some_refs;
+         } some_pragma;
+
+	my_lc_some_pragma sp;
+
+	sp.some_refs = {&labcomm_signature_my_lc_foo,
+                        &labcomm_signature_my_lc_bar};
+
+ 	labcomm_encode_my_lc_some_pragma(enc, &sp);
+
+    This is to avoid exposing local_to_remote and remote_to_local
+
+*** refactor {encoder,decoder}registry to separate the actual encoder
+    from the registry
+
+    - currently, the assignment of local indices is done in the "constructor"
+      which means that the registries will be very thin
+
+*** labcomm_pragma_builder(struct labcomm_encoder *enc);
+
+    - looks like an encoder to enable reuse of the generated encode functions
+    - allocates memory in the enclosing encoder, enc.
+    - deallocates memory when packet is sent
+
+*** Pragma handler
+    - is a decoder, to which the user registers handlers for pragma samples
+    - has/gets a byte_array_reader in the context
+    - the "surrounding" decoder will deallocate the pragma packet when the
+      pragma handler returns
+
+
+
+
+______________________________________________________________
+______________preliminary sketch of pragma____________________
+
+
+A pragma "packet" is a sequence of fields, where each field is
+a labcomm sample (in order to keep labcomm in-band self-describing).
+
+A pragma packet has a type, which is a globally unique string
+(e.g., java package-like name, URI, or UUID)
+
+One predefined pragma sample type is labcomm_type_ref, which is used to refer
+to labcomm sample types in a way that is unique on a given encoder/channel.
+
+Sending:
+
+/* create a pragma packet for pragma type type
+   allocated in e->memory */
+// (or, if that is visible to user code, should
+// the parameter be a struct labcomm_memory*?)
+struct labcom_pragma_packet * = labcomm_pragma_new(struct labcomm_encoder e*,
+                                                   char *type);
+
+/* add type reference field*/
+void labcomm_pragma_add_ref(struct labcomm_signature sig);
+
+// the semantics if more than one type reference field is undefined
+// (as far as labcomm is concerned).
+// One possible (pragma-type defined) semantic is that the latest type
+// reference applies to the fields following it.
+
+A pragma packet is (under the hood) a struct labcomm_encoder, so that we
+can reuse the sample_type_encode() function for adding pragma fields.
+
+
+// an example session
+struct labcom_pragma_packet pp = labcomm_pragma_new(enc, some_type));
+labcomm_pragma_add_ref(some_sig);
+some_pragma_type_encode(pp, some_pragma_instance);
+another_pragma_type_encode(pp, another_pragma_instance);
+labcomm_pragma_send(pp, enc);
+
+
+#define labcomm_pragma_add_field(some_pragma_sample_type, value) \
+	labcomm_encode_#some_pragma_sample_type, value)
+
+int labcomm_encode_test_twoLines( struct labcomm_encoder *e,
+                                  test_twoLines *v)
+{
+return labcomm_internal_encode(e,
+                               &labcomm_signature_test_twoLines,
+                               (labcomm_enc oder_function) encode_test_twoLines,
+                                v);
+}
+
+
+
+receiving:
+
+alt 1. standard handlers, parameter pragma_type to handle function
+	-- this means adding a parameter to all handlers
+           (where null means not pragma)
+
+void handle_some_pragma(some_pragma *v, void *context, char * pragma_type);
+
+alt 2. standard handlers, but separate register_pragma_handler function
+       use the handler context to store and communicate pragma-specific data.
+
+	-- this means that the decoder interface needs to be extended,
+           and that the handler context for pragmas need to be specified
+           (by labcomm)
+
+alt 3  have a single handler for pragma packets as the interface upwards
+       from the labcomm lib. That handler is then responsible for managing
+       and multiplexing pragma types based on the type field in the pragma
+       packet.
+
+       The labcomm libraries can provide a default implementation of a
+       pragma_handler, to facilitate the common cases and reduce the
+       amount of boilerplate code.
+
+struct pragma_packet {
+	char *pragma_type;
+	char *packed_data;
+}
+
+void handle_pragma(struct pragma_packet *p, void *context);
+
+
+
+

examples/duck_typing/Makefile

-LABCOMM_JAR=../../compiler/labComm.jar
+LABCOMM_JAR=../../compiler/labcomm_compiler.jar
 LABCOMM=java -jar $(LABCOMM_JAR) 
 
 all: gen/animal.py

examples/dynamic/test/DynamicPart.java

@@ -18,12 +18,12 @@ import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.Map;
 
-import se.lth.control.labcomm.LabCommDecoder;
-import se.lth.control.labcomm.LabCommDecoderChannel;
-import se.lth.control.labcomm.LabCommEncoder;
-import se.lth.control.labcomm.LabCommEncoderChannel;
-import AST.LabCommParser;
-import AST.LabCommScanner;
+import se.lth.control.labcomm.Decoder;
+import se.lth.control.labcomm.DecoderChannel;
+import se.lth.control.labcomm.Encoder;
+import se.lth.control.labcomm.EncoderChannel;
+import AST.Parser;
+import AST.Scanner;
 import AST.Program;
 import beaver.Parser.Exception;
 
@@ -160,8 +160,8 @@ public class DynamicPart {
 	public static InRAMCompiler generateCode(String lcDecl, HashMap<String, String> handlers) {
 		Program ast = null;
 		InputStream in = new ByteArrayInputStream(lcDecl.getBytes());
-		LabCommScanner scanner = new LabCommScanner(in);
-		LabCommParser parser = new LabCommParser();
+		Scanner scanner = new Scanner(in);
+		Parser parser = new Parser();
 		Collection errors = new LinkedList();
 
 		InRAMCompiler irc = null;
@@ -272,7 +272,7 @@ public class DynamicPart {
 	private void decodeTest(InRAMCompiler irc, HandlerContext ctxt, String tmpFile, String... sampleNames) {
 		try {
 			FileInputStream in = new FileInputStream(tmpFile);
-			LabCommDecoderChannel dec = new LabCommDecoderChannel(in);
+			DecoderChannel dec = new DecoderChannel(in);
 			Class handlerClass =  irc.load(handlerClassName);
 			Constructor hcc = handlerClass.getDeclaredConstructor(Object.class);
 			Object handler = hcc.newInstance(ctxt);
@@ -282,7 +282,7 @@ public class DynamicPart {
 				Class sampleClass = irc.load(sampleName);
 				Class handlerInterface = irc.load(sampleName+"$Handler");
 
-				Method reg = sampleClass.getDeclaredMethod("register", LabCommDecoder.class, handlerInterface);
+				Method reg = sampleClass.getDeclaredMethod("register", Decoder.class, handlerInterface);
 				reg.invoke(sampleClass, dec, handler);
 			}
 
@@ -324,20 +324,20 @@ public class DynamicPart {
 
 
 			FileOutputStream out = new FileOutputStream(tmpFile);
-			LabCommEncoderChannel enc = new LabCommEncoderChannel(out);
+			EncoderChannel enc = new EncoderChannel(out);
 
 			/* register and send foo */
-			Method regFoo = fc.getDeclaredMethod("register", LabCommEncoder.class);
+			Method regFoo = fc.getDeclaredMethod("register", Encoder.class);
 			regFoo.invoke(fc, enc);
 
-			Method doEncodeFoo = fc.getDeclaredMethod("encode", LabCommEncoder.class, ft);
+			Method doEncodeFoo = fc.getDeclaredMethod("encode", Encoder.class, ft);
 			doEncodeFoo.invoke(fc, enc, fv);
 
 			/* register and send bar (NB! uses primitive type int) */
-			Method regBar = bc.getDeclaredMethod("register", LabCommEncoder.class);
+			Method regBar = bc.getDeclaredMethod("register", Encoder.class);
 			regBar.invoke(bc, enc);
 
-			Method doEncodeBar = bc.getDeclaredMethod("encode", LabCommEncoder.class, Integer.TYPE);
+			Method doEncodeBar = bc.getDeclaredMethod("encode", Encoder.class, Integer.TYPE);
 			doEncodeBar.invoke(bc, enc, ctxt.bar);
 
 			out.close();

examples/dynamic/test/StaticDecoder.java

@@ -6,16 +6,16 @@ import gen.bar;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.InputStream;
-import se.lth.control.labcomm.LabCommDecoderChannel;
+import se.lth.control.labcomm.DecoderChannel;
 
 
 public class StaticDecoder implements foo.Handler, bar.Handler
 {
 
-  LabCommDecoderChannel decoder;
+  DecoderChannel decoder;
 
   public StaticDecoder(InputStream in) throws Exception {
-    decoder = new LabCommDecoderChannel(in);
+    decoder = new DecoderChannel(in);
     foo.register(decoder, this);
     bar.register(decoder, this);
 

examples/dynamic/test/StaticEncoder.java

@@ -2,19 +2,19 @@ package test;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.OutputStream;
-import se.lth.control.labcomm.LabCommEncoderChannel;
+import se.lth.control.labcomm.EncoderChannel;
 
 import gen.foo;
 import gen.bar;
 
 public class StaticEncoder {
 
-  LabCommEncoderChannel encoder;
+  EncoderChannel encoder;
 
   public StaticEncoder(OutputStream out) 
     throws Exception 
   {
-    encoder = new LabCommEncoderChannel(out);
+    encoder = new EncoderChannel(out);
     foo.register(encoder);
     bar.register(encoder);
   }

examples/dynamic/test/TestLabCommCompiler.java

@@ -16,18 +16,18 @@ import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.Map;
 
-import se.lth.control.labcomm.LabCommDecoder;
-import se.lth.control.labcomm.LabCommDecoderChannel;
-import se.lth.control.labcomm.LabCommEncoder;
-import se.lth.control.labcomm.LabCommEncoderChannel;
-import AST.LabCommParser;
-import AST.LabCommScanner;
+import se.lth.control.labcomm.Decoder;
+import se.lth.control.labcomm.DecoderChannel;
+import se.lth.control.labcomm.Encoder;
+import se.lth.control.labcomm.EncoderChannel;
+import AST.Parser;
+import AST.Scanner;
 import AST.Program;
 import beaver.Parser.Exception;
 
 
 
-public class TestLabCommCompiler {
+public class TestCompiler {
 
 	private static final String BAR = "bar";
 	private static final String FOO = "foo";
@@ -73,7 +73,7 @@ public class TestLabCommCompiler {
 	private static void decodeTest(InRAMCompiler irc, String tmpFile) {
 		try {
 			FileInputStream in = new FileInputStream(tmpFile);
-			LabCommDecoderChannel dec = new LabCommDecoderChannel(in);
+			DecoderChannel dec = new DecoderChannel(in);
 	
 			Class fc = irc.load(FOO);
 			Class hc = irc.load("gen_"+FOO+"Handler");
@@ -81,7 +81,7 @@ public class TestLabCommCompiler {
 
 			Object h = hc.newInstance(); 
 		
-			Method reg = fc.getDeclaredMethod("register", LabCommDecoder.class, hi);
+			Method reg = fc.getDeclaredMethod("register", Decoder.class, hi);
 			reg.invoke(fc, dec, h);
 			
 			dec.runOne();
@@ -106,11 +106,11 @@ public class TestLabCommCompiler {
 			z.setInt(f, 12);
 			
 			FileOutputStream out = new FileOutputStream(tmpFile);
-			LabCommEncoderChannel enc = new LabCommEncoderChannel(out);
-			Method reg = fc.getDeclaredMethod("register", LabCommEncoder.class);
+			EncoderChannel enc = new EncoderChannel(out);
+			Method reg = fc.getDeclaredMethod("register", Encoder.class);
 			reg.invoke(fc, enc);
 			
-			Method doEncode = fc.getDeclaredMethod("encode", LabCommEncoder.class, fc);
+			Method doEncode = fc.getDeclaredMethod("encode", Encoder.class, fc);
 			doEncode.invoke(fc, enc, f);
 			
 			out.close();
@@ -123,8 +123,8 @@ public class TestLabCommCompiler {
 	public static InRAMCompiler generateCode(String lcDecl, HashMap<String, String> handlers) {
 		Program ast = null;
 		InputStream in = new ByteArrayInputStream(lcDecl.getBytes());
-		LabCommScanner scanner = new LabCommScanner(in);
-		LabCommParser parser = new LabCommParser();
+		Scanner scanner = new Scanner(in);
+		Parser parser = new Parser();
 		Collection errors = new LinkedList();
 
 		InRAMCompiler irc = null;

examples/dynamic/test/TestLabcommGen.java

@@ -18,12 +18,12 @@ import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.Map;
 
-import se.lth.control.labcomm.LabCommDecoder;
-import se.lth.control.labcomm.LabCommDecoderChannel;
-import se.lth.control.labcomm.LabCommEncoder;
-import se.lth.control.labcomm.LabCommEncoderChannel;
-import AST.LabCommParser;
-import AST.LabCommScanner;
+import se.lth.control.labcomm.Decoder;
+import se.lth.control.labcomm.DecoderChannel;
+import se.lth.control.labcomm.Encoder;
+import se.lth.control.labcomm.EncoderChannel;
+import AST.Parser;
+import AST.Scanner;
 import AST.Program;
 import beaver.Parser.Exception;
 
@@ -163,8 +163,8 @@ public class TestLabcommGen {
 	public static InRAMCompiler generateCode(String lcDecl, HashMap<String, String> handlers) {
 		Program ast = null;
 		InputStream in = new ByteArrayInputStream(lcDecl.getBytes());
-		LabCommScanner scanner = new LabCommScanner(in);
-		LabCommParser parser = new LabCommParser();
+		Scanner scanner = new Scanner(in);
+		Parser parser = new Parser();
 		Collection errors = new LinkedList();
 
 		InRAMCompiler irc = null;
@@ -332,7 +332,7 @@ public class TestLabcommGen {
 	private static void decodeTest(InRAMCompiler irc, String tmpFile, String... sampleNames) {
 		try {
 			FileInputStream in = new FileInputStream(tmpFile);
-			LabCommDecoderChannel dec = new LabCommDecoderChannel(in);
+			DecoderChannel dec = new DecoderChannel(in);
 			Class handlerClass =  irc.load(handlerClassName);
 			Constructor hcc = handlerClass.getDeclaredConstructor(Object.class);
 //			Object handler = handlerClass.newInstance(); 
@@ -344,7 +344,7 @@ public class TestLabcommGen {
 				Class sampleClass = irc.load(sampleName);
 				Class handlerInterface = irc.load(sampleName+"$Handler");
 
-				Method reg = sampleClass.getDeclaredMethod("register", LabCommDecoder.class, handlerInterface);
+				Method reg = sampleClass.getDeclaredMethod("register", Decoder.class, handlerInterface);
 				reg.invoke(sampleClass, dec, handler);
 			}
 
@@ -389,20 +389,20 @@ public class TestLabcommGen {
 
 
 			FileOutputStream out = new FileOutputStream(tmpFile);
-			LabCommEncoderChannel enc = new LabCommEncoderChannel(out);
+			EncoderChannel enc = new EncoderChannel(out);
 
 			/* register and send foo */
-			Method regFoo = fc.getDeclaredMethod("register", LabCommEncoder.class);
+			Method regFoo = fc.getDeclaredMethod("register", Encoder.class);
 			regFoo.invoke(fc, enc);
 
-			Method doEncodeFoo = fc.getDeclaredMethod("encode", LabCommEncoder.class, ft);
+			Method doEncodeFoo = fc.getDeclaredMethod("encode", Encoder.class, ft);
 			doEncodeFoo.invoke(fc, enc, f);
 
 			/* register and send bar (NB! uses primitive type int) */
-			Method regBar = bc.getDeclaredMethod("register", LabCommEncoder.class);
+			Method regBar = bc.getDeclaredMethod("register", Encoder.class);
 			regBar.invoke(bc, enc);
 
-			Method doEncodeBar = bc.getDeclaredMethod("encode", LabCommEncoder.class, Integer.TYPE);
+			Method doEncodeBar = bc.getDeclaredMethod("encode", Encoder.class, Integer.TYPE);
 			doEncodeBar.invoke(bc, enc, 42);
 
 			out.close();
@@ -475,7 +475,7 @@ public class TestLabcommGen {
 	private static void decodeTestSeparate(InRAMCompiler irc, String tmpFile, String... sampleNames) {
 		try {
 			FileInputStream in = new FileInputStream(tmpFile);
-			LabCommDecoderChannel dec = new LabCommDecoderChannel(in);
+			DecoderChannel dec = new DecoderChannel(in);
 			for (String sampleName : sampleNames) {
 				System.out.println("registering handler for "+sampleName);
 				Class sampleClass = irc.load(sampleName);
@@ -484,7 +484,7 @@ public class TestLabcommGen {
 
 				Object handler = handlerClass.newInstance(); 
 
-				Method reg = sampleClass.getDeclaredMethod("register", LabCommDecoder.class, handlerInterface);
+				Method reg = sampleClass.getDeclaredMethod("register", Decoder.class, handlerInterface);
 				reg.invoke(sampleClass, dec, handler);
 			}
 

examples/jgrafchart/Makefile

 LCDIR=../..
-LCC=java -jar ${LCDIR}/compiler/labComm.jar
+LCC=java -jar ${LCDIR}/compiler/labcomm_compiler.jar
 CLASSPATH=.:${LCDIR}/lib/java/labcomm.jar
 JAVA_PKG=labcommTCPtest
 SAMPLENAME=foo
-LCC=java -jar ${LCDIR}/compiler/labComm.jar
 LCLIBDIR=${LCDIR}/lib/c
 
 LCFILE=jg

examples/jgrafchart/labcommTCPtest/client/TestClient.java

@@ -6,8 +6,8 @@ import java.io.OutputStream;
 import java.net.Socket;
 import java.net.UnknownHostException;
 
-import se.lth.control.labcomm.LabCommDecoderChannel;
-import se.lth.control.labcomm.LabCommEncoderChannel;
+import se.lth.control.labcomm.DecoderChannel;
+import se.lth.control.labcomm.EncoderChannel;
 import labcommTCPtest.gen.foo;
 import labcommTCPtest.gen.foo.Handler;
 
@@ -25,7 +25,7 @@ public class TestClient implements Handler {
 	public void test() {
 		
 		try {
-			LabCommEncoderChannel e = new LabCommEncoderChannel(out );
+			EncoderChannel e = new EncoderChannel(out );
 			foo.register(e);
 			foo sample = new foo();
 			sample.c = 17;
@@ -36,7 +36,7 @@ public class TestClient implements Handler {
 			printSample("Client sending", sample);
 			foo.encode(e, sample);
 
-			LabCommDecoderChannel c = new LabCommDecoderChannel(in);
+			DecoderChannel c = new DecoderChannel(in);
 			foo.register(c,this);
 			c.run();
 		} catch (Exception e) {

examples/jgrafchart/labcommTCPtest/client/TestClientSingleshot.java

@@ -6,8 +6,8 @@ import java.io.OutputStream;
 import java.net.Socket;
 import java.net.UnknownHostException;
 
-import se.lth.control.labcomm.LabCommDecoderChannel;
-import se.lth.control.labcomm.LabCommEncoderChannel;
+import se.lth.control.labcomm.DecoderChannel;
+import se.lth.control.labcomm.EncoderChannel;
 import labcommTCPtest.gen.FooSample;
 import labcommTCPtest.gen.FooSample.Handler;
 
@@ -25,7 +25,7 @@ public class TestClientSingleshot implements Handler {
 	public void test() {
 		
 		try {
-			LabCommEncoderChannel e = new LabCommEncoderChannel(out );
+			EncoderChannel e = new EncoderChannel(out );
 			FooSample.register(e);
 			FooSample sample = new FooSample();
 			sample.x = 17;
@@ -35,7 +35,7 @@ public class TestClientSingleshot implements Handler {
 			printSample("Client sending", sample);
 			FooSample.encode(e, sample);
 
-			LabCommDecoderChannel c = new LabCommDecoderChannel(in);
+			DecoderChannel c = new DecoderChannel(in);
 			FooSample.register(c,this);
 			c.runOne();
 		} catch (Exception e) {

examples/jgrafchart/labcommTCPtest/server/TestServer.java

@@ -8,8 +8,8 @@ import java.lang.reflect.Method;
 import java.net.ServerSocket;
 import java.net.Socket;
 
-import se.lth.control.labcomm.LabCommDecoderChannel;
-import se.lth.control.labcomm.LabCommEncoderChannel;
+import se.lth.control.labcomm.DecoderChannel;
+import se.lth.control.labcomm.EncoderChannel;
 import labcommTCPtest.gen.foo;
 import labcommTCPtest.gen.foo.Handler;
 
@@ -38,7 +38,7 @@ public class TestServer implements Handler {
 	public void runOne() {
 		
 		try {
-			LabCommDecoderChannel c = new LabCommDecoderChannel(in);
+			DecoderChannel c = new DecoderChannel(in);
 			foo.register(c,this);
 			c.runOne();
 		} catch (Exception e) {
@@ -47,7 +47,7 @@ public class TestServer implements Handler {
 	}
 
 	public void handle_foo(foo sample) throws Exception {
-		LabCommEncoderChannel e = new LabCommEncoderChannel(out );
+		EncoderChannel e = new EncoderChannel(out );
 		foo.register(e);
 		System.out.println("TestServer.handle_foo...");
 		sample.b *= 2;

examples/robot/Program.cs

@@ -24,7 +24,7 @@ namespace RobotCtrl
             try
             {
                 client.Connect(serverEndPoint);
-                LabCommEncoder enc = new LabCommEncoderChannel(client.GetStream(), true);
+                Encoder enc = new EncoderChannel(client.GetStream(), true);
                 jointtarget.register(enc);
                 jointtarget.encode(enc, val);
                 for (int i = 0; i < 10; i++)

examples/simple/Decoder.java

@@ -2,19 +2,19 @@ import java.io.File;
 import java.io.FileInputStream;
 import java.io.InputStream;
 
-import se.lth.control.labcomm.LabCommDecoderChannel;
+import se.lth.control.labcomm.DecoderChannel;
 
 public class Decoder
   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);