Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found
Select Git revision

Target

Select target project
  • anders_blomdell/labcomm
  • klaren/labcomm
  • tommyo/labcomm
  • erikj/labcomm
  • sven/labcomm
5 results
Select Git revision
Show changes
Hide whitespace changes
Inline Side-by-side
Showing
with 1719 additions and 17 deletions
examples/dynamic/simple.lc
View file @ d3921882
typedef struct {
int a;
int b;
} TwoInts;
sample TwoInts theTwoInts;
sample TwoInts anotherTwoInts;
sample struct {
int x;
string s;
} IntString;
int y;
int z;
} foo;
sample int bar;
examples/dynamic/simple_type.lc 0 → 100644
View file @ d3921882
typedef struct {
int x;
int y;
int z;
} foo_t;
sample foo_t foo;
sample int bar;
examples/dynamic/static.sh 0 → 100644
View file @ d3921882
#dummy script to test the static part
# run labcomm compilation
java -jar ../../compiler/labcomm2014_compiler.jar --java=gen --javapackage=gen simple.lc
# compile example programs
javac -cp .:gen:../../lib/java/labcomm2014.jar test/StaticEncoder.java
javac -cp .:gen:../../lib/java/labcomm2014.jar test/StaticDecoder.java
# run example programs
java -cp .:gen:../../lib/java//labcomm2014.jar test.StaticEncoder encoded_data
java -cp .:gen:../../lib/java//labcomm2014.jar test.StaticDecoder encoded_data
examples/dynamic/test.sh 0 → 100644
View file @ d3921882
#dummy script to test the on-the-fly compilation
javac -cp .:../../compiler/labcomm2014_compiler.jar:../../lib/java/labcomm2014.jar:../../lib/tools/beaver.jar:../../lib/tools/beaver-rt.jar:../../lib/tools/jastadd2.jar:../../lib/tools/JFlex.jar:../../lib/tools/proj.jar test/TestLabcommGen.java
javac test/HandlerContext.java
java -cp .:../../compiler/labcomm2014_compiler.jar:../../lib/java/labcomm2014.jar:../../lib/tools/beaver.jar:../../lib/tools/beaver-rt.jar:../../lib/tools/jastadd2.jar:../../lib/tools/JFlex.jar:../../lib/tools/proj.jar test.TestLabcommGen simple.lc handlers2.txt encoded_data
examples/dynamic/test/DynamicPart.java 0 → 100644
View file @ d3921882
package test;
import java.io.ByteArrayInputStream;
import java.io.EOFException;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.nio.CharBuffer;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;
import se.lth.control.labcomm2014.Decoder;
import se.lth.control.labcomm2014.DecoderChannel;
import se.lth.control.labcomm2014.Encoder;
import se.lth.control.labcomm2014.EncoderChannel;
import se.lth.control.labcomm2014.compiler.LabCommParser;
import se.lth.control.labcomm2014.compiler.LabCommScanner;
import se.lth.control.labcomm2014.compiler.Program;
import beaver.Parser.Exception;
public class DynamicPart {
private static final String TYPE_NAME_FOO = "foo_t";
private static final String SAMPLE_NAME_FOO = "foo";
private static final String SAMPLE_NAME_BAR = "bar";
static final String handlerClassName= "HandlerContainer";
static class HandlerSrc {
private String sampleName;
private String param;
private String body;
private final String proto = "public void handle_";
public HandlerSrc(String sampleName, String param, String body) {
this.sampleName = sampleName;
this.param = param;
this.body = body;
}
public String getSrc() {
String res = proto+sampleName+"("+param+")"+body;
return res;
}
}
public void doTest(InRAMCompiler irc, String iFile, String oFile) {
HandlerContext ctxt = new HandlerContext();
System.out.println("*** reading file "+iFile);
decodeTest(irc, ctxt, iFile, SAMPLE_NAME_FOO, SAMPLE_NAME_BAR);
System.out.println("*** writing "+oFile);
encodeTest(irc, ctxt, oFile);
}
/**
* @param args
*/
public static void main(String[] args) {
/* input data: */
String labcommStr = readLabcommDecl(args[0]);
String srcStr = readHandlerDecl(args[1]);
/*Map<sample name, handler code>*/
HashMap <String, String> handlers = new HashMap<String, String>();
generateHandlers(srcStr, handlers);
// System.out.println("*** Generated handler source:");
handlers.keySet();
// for (String n : handlers.keySet()) {
// System.out.println(n+":");
// System.out.println(handlers.get(n));
// }
InRAMCompiler irc = generateCode(labcommStr, handlers);
if(irc != null) {
String iFile = args[2];
String oFile = args[3];
new DynamicPart().doTest(irc, iFile, oFile);
}
}
public static void generateHandlers(String srcStr, HashMap<String,String> handlers) {
int pos = 0;
while(pos < srcStr.length()) {
int nameEnd = srcStr.indexOf(':', pos);
if(nameEnd <0) break;
String name = srcStr.substring(pos,nameEnd);
pos=nameEnd+1;
String par = "";
final String handler_decl = "handler(";
if(srcStr.startsWith(handler_decl, pos)) {
int endPar = srcStr.indexOf(')', pos);
par = srcStr.substring(pos+handler_decl.length(), endPar);
pos = endPar+1;
} else {
System.out.println("expeced handler decl:\n"+srcStr.substring(pos));
}
int bodyEnd = srcStr.indexOf("}###", pos); // HERE BE DRAGONS! a bit brittle
String body = srcStr.substring(pos, bodyEnd+1);
pos = bodyEnd+5;
HandlerSrc s = new HandlerSrc(name, par, body);
final String genSrc = s.getSrc();
handlers.put(name,genSrc);
}
}
public static String readHandlerDecl(String decl) {
FileReader fr;
int len=0;;
CharBuffer buf = CharBuffer.allocate(1024);
try {
fr = new FileReader(decl);
len = fr.read(buf);
buf.rewind();
} catch (Throwable e) {
e.printStackTrace();
System.exit(1);
}
String srcStr = buf.toString().substring(0, len);
return srcStr;
}
private static String readLabcommDecl(String lcfile) {
FileReader fr;
int len=0;;
CharBuffer buf = CharBuffer.allocate(1024);
try {
fr = new FileReader(lcfile);
len = fr.read(buf);
// buf.append((char) 0x04);
buf.rewind();
} catch (Throwable e) {
e.printStackTrace();
System.exit(1);
}
String labcommStr = buf.toString().substring(0, len-1);
return labcommStr;
}
public static InRAMCompiler generateCode(String lcDecl, HashMap<String, String> handlers) {
Specification ast = null;
InputStream in = new ByteArrayInputStream(lcDecl.getBytes());
LabCommScanner scanner = new LabCommScanner(in);
LabCommParser parser = new LabCommParser();
Collection errors = new LinkedList();
InRAMCompiler irc = null;
try {
Specification p = (Specification)parser.parse(scanner);
p.errorCheck(errors);
if (errors.isEmpty()) {
ast = p;
} else {
System.out.println("*** Errors:");
for (Iterator iter = errors.iterator(); iter.hasNext(); ) {
String s = (String)iter.next();
System.out.println(s);
}
}
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
if (ast != null) {
irc = handleAst(ast, handlers);
} else {
System.err.println("compilation failed");
}
return irc;
}
/** generate labcomm code and compile handlers
*
* @param lcAST - the AST of the labcomm declaration
* @param handlers - a map <name, source> of handlers for the types in ast
* @return an InRAMCompiler object containing the generated clases
*/
private static InRAMCompiler handleAst(Specification lcAST, HashMap<String, String> handlers) {
Map<String, String> genCode = new HashMap<String, String>();
try {
lcAST.J_gen(genCode, "labcomm.generated", 2014);
} catch (IOException e) {
e.printStackTrace();
}
// System.out.println("Generated labcomm code:");
InRAMCompiler irc = new InRAMCompilerJavax("labcomm.generated", TestLabcommGen.class.getClassLoader());
StringBuilder handlerClass = new StringBuilder();
StringBuilder handlerMethods = new StringBuilder();
handlerClass.append("package labcomm.generated;\n");
handlerClass.append("public class "+handlerClassName+" implements ");
String handlerAttributes = "Object context;\n";
String handlerConstr = "public "+handlerClassName+"(){super();}\n";
String handlerConstrCtxt = "public "+handlerClassName+"(Object context){ this.context=context;}\n";
Iterator<String> i = genCode.keySet().iterator();
try {
while(i.hasNext()){
final String sampleName = i.next();
final String src = genCode.get(sampleName);
String handleM = handlers.get(sampleName);
if(handleM != null) {
handlerClass.append(sampleName+".Handler");
if(i.hasNext()) {
handlerClass.append(", ");
}
handlerMethods.append(handleM);
handlerMethods.append("\n");
}
// System.out.println("***"+sampleName+"\n"+src);
irc.compile(sampleName, src); // while iterating, compile the labcomm generated code
}
handlerClass.append("{\n");
handlerClass.append(handlerAttributes);
handlerClass.append(handlerConstr);
handlerClass.append(handlerConstrCtxt);
handlerClass.append(handlerMethods.toString());
handlerClass.append("}\n");
System.out.println("-------------------------------------");
final String handlerSrc = handlerClass.toString();
System.out.println(handlerSrc);
irc.compile(handlerClassName, handlerSrc); // compile the generated handler class
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
System.out.println("================================");
return irc;
}
/** test method
*/
private void decodeTest(InRAMCompiler irc, HandlerContext ctxt, String tmpFile, String... sampleNames) {
try {
FileInputStream in = new FileInputStream(tmpFile);
DecoderChannel dec = new DecoderChannel(in);
Class handlerClass = irc.load(handlerClassName);
Constructor hcc = handlerClass.getDeclaredConstructor(Object.class);
Object handler = hcc.newInstance(ctxt);
for (String sampleName : sampleNames) {
System.out.println("registering handler for "+sampleName);
Class sampleClass = irc.load(sampleName);
Class handlerInterface = irc.load(sampleName+"$Handler");
Method reg = sampleClass.getDeclaredMethod("register", Decoder.class, handlerInterface);
reg.invoke(sampleClass, dec, handler);
}
try{
System.out.println("*** decoding:");
dec.run();
} catch(EOFException e) {
System.out.println("*** reached EOF ***");
}
in.close();
} catch (Throwable e) {
e.printStackTrace();
}
}
/** test encoding
*/
private void encodeTest(InRAMCompiler irc, HandlerContext ctxt, String tmpFile) {
try {
Class fc = irc.load(SAMPLE_NAME_FOO);
Class bc = irc.load(SAMPLE_NAME_BAR);
Class ft; // hack for both cases with and w/o typedef
try {
ft = irc.load(TYPE_NAME_FOO);
} catch (ClassNotFoundException e) {
System.out.println("** encodeTest: defaulting to sample==type");
ft = fc;
}
/* create sample class and instance objects */
Object fv = ft.newInstance();
Field x = ft.getField("x");
Field y = ft.getField("y");
Field z = ft.getField("z");
x.setInt(fv, ctxt.x);
y.setInt(fv, ctxt.y);
z.setInt(fv, ctxt.z);
FileOutputStream out = new FileOutputStream(tmpFile);
EncoderChannel enc = new EncoderChannel(out);
/* register and send foo */
Method regFoo = fc.getDeclaredMethod("register", Encoder.class);
regFoo.invoke(fc, enc);
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", Encoder.class);
regBar.invoke(bc, enc);
Method doEncodeBar = bc.getDeclaredMethod("encode", Encoder.class, Integer.TYPE);
doEncodeBar.invoke(bc, enc, ctxt.bar);
out.close();
} catch (Throwable e) {
e.printStackTrace();
}
}
/** dummy test creating instances of sample and handler, and calling handle*/
private static void dummyTest(InRAMCompiler irc) {
try {
Class hc = irc.load(handlerClassName);
Constructor hcc = hc.getDeclaredConstructor(Object.class);
// Object h = hc.newInstance();
Object h = hcc.newInstance(new HandlerContext());
Class ft = irc.load(TYPE_NAME_FOO);
Object f = ft.newInstance();
Field x = ft.getDeclaredField("x");
Field y = ft.getDeclaredField("y");
Field z = ft.getDeclaredField("z");
x.setInt(f, 10);
y.setInt(f, 11);
z.setInt(f, 12);
Method m;
try {
m = hc.getDeclaredMethod("handle_"+SAMPLE_NAME_FOO, ft);
m.invoke(h, f);
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchFieldException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
examples/dynamic/test/HandlerContext.java 0 → 100644
View file @ d3921882
package test;
public class HandlerContext {
public final String str="HandlerContext";
public int x, y, z, bar;
}
examples/dynamic/InRAMCompiler.java → examples/dynamic/test/InRAMCompiler.java
View file @ d3921882
package test;
import java.lang.reflect.InvocationTargetException;
......@@ -24,4 +24,4 @@ public interface InRAMCompiler {
*/
public Class<?> load(String className) throws ClassNotFoundException;
}
\ No newline at end of file
}
examples/dynamic/InRAMCompilerJavax.java → examples/dynamic/test/InRAMCompilerJavax.java
View file @ d3921882
package test;
import java.io.ByteArrayInputStream;
......@@ -48,6 +48,8 @@ import javax.tools.ToolProvider;
public class InRAMCompilerJavax implements InRAMCompiler {
private boolean debug;
// Source for both test classes. They go in package
// "just.generated"
......@@ -127,6 +129,18 @@ public class InRAMCompilerJavax implements InRAMCompiler {
createNewClassLoader(providedClassLoader);
}
/**
*
* @param pkgName - The package for the generated classes. The source code must only contain classes in this package.
* @param cl - An optional (i.e., may be null) classloader that is also searched
*
* @param debug - set to true to turn on debug output
*/
public InRAMCompilerJavax(String pkgName, ClassLoader cl, boolean debug) {
this(pkgName, cl);
this.debug = debug;
}
/* (non-Javadoc)
* @see se.lth.cs.sven.rosettaTest.cc.InRAMCompiler#deleteClass(java.lang.String)
......@@ -202,7 +216,9 @@ public class InRAMCompilerJavax implements InRAMCompiler {
jfm.isCompiling(false);
// Traces the classes now found in the cache
System.out.println("\nInRAMCompiler: generated classes = " + output.keySet());
if(debug) {
System.out.println("\nInRAMCompiler: generated classes = " + output.keySet());
}
}
/* (non-Javadoc)
......@@ -378,7 +394,9 @@ trick:
RAMClassLoader(Map<String, JavaFileObject> output, ClassLoader cl) {
this.output = output;
this.classLoader = cl;
testGetResources();
if(debug) {
testGetResources();
}
}
private void testGetResources() {
......@@ -395,8 +413,10 @@ trick:
try {
//XXX This is a hack! Look in "parent" class loader first, to find correct Service instances.
if(classLoader != null) {
System.out.println("RAMClassLoader.findClass: getResource (package): "+classLoader.getResource("se/lth/cs/sven/rosettaTest"));
System.out.println("RAMClassLoader.findClass: getResource: "+classLoader.getResource("se/lth/cs/sven/rosettaTest/Constraint.class"));
if(debug) {
System.out.println("RAMClassLoader.findClass: getResource (package): "+classLoader.getResource("se/lth/cs/sven/rosettaTest"));
System.out.println("RAMClassLoader.findClass: getResource: "+classLoader.getResource("se/lth/cs/sven/rosettaTest/Constraint.class"));
}
try {
Class<?> c = classLoader.loadClass(name);
......
examples/dynamic/test/StaticDecoder.java 0 → 100644
View file @ d3921882
package test;
import gen.foo;
import gen.bar;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import se.lth.control.labcomm2014.DecoderChannel;
public class StaticDecoder implements foo.Handler, bar.Handler
{
DecoderChannel decoder;
public StaticDecoder(InputStream in) throws Exception {
decoder = new DecoderChannel(in);
foo.register(decoder, this);
bar.register(decoder, this);
}
public void run() throws Exception {
try {
System.out.println("Running decoder.");
decoder.run();
} catch (java.io.EOFException e) {
System.out.println("Decoder reached end of file.");
}
}
public void handle_foo(foo d) throws java.io.IOException {
System.out.println("Got foo, x="+d.x+", y="+d.y+", z="+d.z);
}
public void handle_bar(int d) throws java.io.IOException {
System.out.println("Got bar: "+d);
}
public static void main(String[] arg) throws Exception {
FileInputStream fis = new FileInputStream(new File(arg[0]));
StaticDecoder dec = new StaticDecoder(fis);
dec.run();
fis.close();
}
}
examples/dynamic/test/StaticEncoder.java 0 → 100644
View file @ d3921882
package test;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStream;
import se.lth.control.labcomm2014.EncoderChannel;
import gen.foo;
import gen.bar;
public class StaticEncoder {
EncoderChannel encoder;
public StaticEncoder(OutputStream out)
throws Exception
{
encoder = new EncoderChannel(out);
foo.register(encoder);
bar.register(encoder);
}
public void doEncode() throws java.io.IOException {
foo f = new foo();
f.x = 17;
f.y = 42;
f.z = 37;
int b = 13;
System.out.println("Encoding foo, x="+f.x+", y="+f.y+", z="+f.z);
foo.encode(encoder, f);
System.out.println("Encoding bar: "+b);
bar.encode(encoder, b);
}
public static void main(String[] arg) throws Exception {
FileOutputStream fos = new FileOutputStream(arg[0]);
StaticEncoder enc = new StaticEncoder(fos);
enc.doEncode();
fos.close();
}
}
examples/dynamic/test/TestHandlerGen.java 0 → 100644
View file @ d3921882
package test;
import java.io.ByteArrayInputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.nio.CharBuffer;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;
public class TestHandlerGen {
static class HandlerSrc {
private String sampleName;
private String param;
private String body;
private final String proto = "public void handle_";
public HandlerSrc(String sampleName, String param, String body) {
this.sampleName = sampleName;
this.param = param;
this.body = body;
}
public String getSrc() {
String res = proto+sampleName+"("+param+")"+body;
return res;
}
}
/**
* @param args
*/
public static void main(String[] args) {
/* input data: */
FileReader fr;
int len=0;;
CharBuffer buf = CharBuffer.allocate(1024);
try {
fr = new FileReader(args[0]);
len = fr.read(buf);
buf.rewind();
} catch (Throwable e) {
e.printStackTrace();
System.exit(1);
}
String srcStr = buf.toString().substring(0, len);
/* read declarations */
int pos = 0;
while(pos < srcStr.length()) {
System.out.println("--------");
int nameEnd = srcStr.indexOf(':', pos);
String name = srcStr.substring(pos,nameEnd);
System.out.println("Name="+name);
pos=nameEnd+1;
String par = "";
final String handler_decl = "handler(";
if(srcStr.startsWith(handler_decl, pos)) {
int endPar = srcStr.indexOf(')', pos);
par = srcStr.substring(pos+handler_decl.length(), endPar);
System.out.println("param="+par);
pos = endPar+1;
} else {
System.out.println("expeced handler decl:");
}
int bodyEnd = srcStr.indexOf('}', pos); // HERE BE DRAGONS! too brittle
System.out.println("pos="+pos+", bodyEnd="+bodyEnd);
String body = srcStr.substring(pos, bodyEnd+1);
pos = bodyEnd+2;
System.out.println("body:");
System.out.println(body);
System.out.println("**** generates:");
HandlerSrc s = new HandlerSrc(name, par, body);
System.out.println(s.getSrc());
}
}
}
examples/dynamic/TestLabCommCompiler.java → examples/dynamic/test/TestLabCommCompiler.java
View file @ d3921882
package test;
import java.io.ByteArrayInputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.nio.CharBuffer;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;
import AST.LabCommParser;
import AST.LabCommScanner;
import AST.Program;
import se.lth.control.labcomm2014.Decoder;
import se.lth.control.labcomm2014.DecoderChannel;
import se.lth.control.labcomm2014.Encoder;
import se.lth.control.labcomm2014.EncoderChannel;
import AST.Parser;
import AST.Scanner;
import AST.Specification;
import beaver.Parser.Exception;
public class TestLabCommCompiler {
public class TestCompiler {
private static final String BAR = "bar";
private static final String FOO = "foo";
/**
* @param args
......@@ -25,53 +38,127 @@ public class TestLabCommCompiler {
public static void main(String[] args) {
/* input data: */
String prg ="sample struct { int x; int y; int z;}foo; sample int bar;";
FileReader fr;
int len=0;;
CharBuffer buf = CharBuffer.allocate(1024);
try {
fr = new FileReader(args[0]);
len = fr.read(buf);
buf.rewind();
} catch (Throwable e) {
e.printStackTrace();
System.exit(1);
}
String labcommStr = buf.toString().substring(0, len-1);
HashMap <String, String> handlers = new HashMap<String, String>();
handlers.put("foo", "public void handle_foo(foo value) {\nSystem.out.println(value.x);\nSystem.out.println(value.y);\nSystem.out.println(value.z);}");
handlers.put("bar", "public void handle_bar(int value) {System.out.println(value);}");
generateCode(prg, handlers);
handlers.put(FOO, "public void handle_"+FOO+"("+FOO+" value) {\nSystem.out.println(value.x);\nSystem.out.println(value.y);\nSystem.out.println(value.z);}");
handlers.put(BAR, "public void handle_"+BAR+"(int value) {System.out.println(value);}");
InRAMCompiler irc = generateCode(labcommStr, handlers);
if(irc != null) {
System.out.println("*** Testing instantiation and invocation of Handler ");
dummyTest(irc);
// String tmpFile = "/tmp/lcctest";
String tmpFile = args[1];
System.out.println("*** Testing writing and reading file "+tmpFile);
encodeTest(irc, tmpFile);
decodeTest(irc, tmpFile);
}
}
private static void decodeTest(InRAMCompiler irc, String tmpFile) {
try {
FileInputStream in = new FileInputStream(tmpFile);
DecoderChannel dec = new DecoderChannel(in);
Class fc = irc.load(FOO);
Class hc = irc.load("gen_"+FOO+"Handler");
Class hi = irc.load(FOO+"$Handler");
Object h = hc.newInstance();
Method reg = fc.getDeclaredMethod("register", Decoder.class, hi);
reg.invoke(fc, dec, h);
dec.runOne();
in.close();
} catch (Throwable e) {
e.printStackTrace();
}
}
public static void generateCode(String prg, HashMap<String, String> handlers) {
Program ast = null;
InputStream in = new ByteArrayInputStream(prg.getBytes());
LabCommScanner scanner = new LabCommScanner(in);
LabCommParser parser = new LabCommParser();
private static void encodeTest(InRAMCompiler irc, String tmpFile) {
Class<?> hc;
try {
hc = irc.load("gen_"+FOO+"Handler");
Object h = hc.newInstance();
Class fc = irc.load(FOO);
Object f = fc.newInstance();
Field x = fc.getDeclaredField("x");
Field y = fc.getDeclaredField("y");
Field z = fc.getDeclaredField("z");
x.setInt(f, 10);
y.setInt(f, 11);
z.setInt(f, 12);
FileOutputStream out = new FileOutputStream(tmpFile);
EncoderChannel enc = new EncoderChannel(out);
Method reg = fc.getDeclaredMethod("register", Encoder.class);
reg.invoke(fc, enc);
Method doEncode = fc.getDeclaredMethod("encode", Encoder.class, fc);
doEncode.invoke(fc, enc, f);
out.close();
} catch (Throwable e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static InRAMCompiler generateCode(String lcDecl, HashMap<String, String> handlers) {
Specification ast = null;
InputStream in = new ByteArrayInputStream(lcDecl.getBytes());
Scanner scanner = new Scanner(in);
Parser parser = new Parser();
Collection errors = new LinkedList();
InRAMCompiler irc = null;
try {
Program p = (Program)parser.parse(scanner);
Specification p = (Specification)parser.parse(scanner);
p.errorCheck(errors);
if (errors.isEmpty()) {
ast = p;
} else {
System.out.println("*** Errors:");
for (Iterator iter = errors.iterator(); iter.hasNext(); ) {
String s = (String)iter.next();
System.out.println(s);
}
}
if (errors.isEmpty()) {
ast = p;
} else {
System.out.println("*** Errors:");
for (Iterator iter = errors.iterator(); iter.hasNext(); ) {
String s = (String)iter.next();
System.out.println(s);
}
}
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
if (ast != null) {
InRAMCompiler irc = handleAst(ast, handlers);
dummyTest(irc);
irc = handleAst(ast, handlers);
} else {
System.err.println("compilation failed");
}
return irc;
}
/* dummy test creating instances of sample and handler, and calling handle*/
private static void dummyTest(InRAMCompiler irc) {
try {
Class hc = irc.load("gen_fooHandler");
Class hc = irc.load("gen_"+FOO+"Handler");
Object h = hc.newInstance();
Class fc = irc.load("foo");
Class fc = irc.load(FOO);
Object f = fc.newInstance();
Field x = fc.getDeclaredField("x");
Field y = fc.getDeclaredField("y");
......@@ -81,7 +168,7 @@ public class TestLabCommCompiler {
z.setInt(f, 12);
Method m;
try {
m = hc.getDeclaredMethod("handle_foo", fc);
m = hc.getDeclaredMethod("handle_"+FOO, fc);
m.invoke(h, f);
} catch (SecurityException e) {
// TODO Auto-generated catch block
......@@ -96,7 +183,7 @@ public class TestLabCommCompiler {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
......@@ -114,10 +201,16 @@ public class TestLabCommCompiler {
}
}
private static InRAMCompiler handleAst(Program ast, HashMap<String, String> handlers) {
Map<String, String> foo = new HashMap<String, String>();
/** generate labcomm code and compile handlers
*
* @param lcAST - the AST of the labcomm declaration
* @param handlers - a map <name, source> of handlers for the types in ast
* @return an InRAMCompiler object containing the generated clases
*/
private static InRAMCompiler handleAst(Specification lcAST, HashMap<String, String> handlers) {
Map<String, String> genCode = new HashMap<String, String>();
try {
ast.J_gen(foo, "labcomm.generated");
lcAST.J_gen(genCode, "labcomm.generated", 2013);
} catch (IOException e) {
e.printStackTrace();
}
......@@ -125,21 +218,21 @@ public class TestLabCommCompiler {
InRAMCompiler irc = new InRAMCompilerJavax("labcomm.generated", null);
Iterator<String> i = foo.keySet().iterator();
Iterator<String> i = genCode.keySet().iterator();
while(i.hasNext()){
final String name = i.next();
final String src = foo.get(name);
System.out.println("***"+name+"\n"+src);
final String sampleName = i.next();
final String src = genCode.get(sampleName);
System.out.println("***"+sampleName+"\n"+src);
StringBuilder sb = new StringBuilder();
sb.append("package labcomm.generated;\n");
sb.append("public class gen_"+name+"Handler implements "+name+".Handler {\n");
sb.append(handlers.get(name));
sb.append("public class gen_"+sampleName+"Handler implements "+sampleName+".Handler {\n");
sb.append(handlers.get(sampleName));
sb.append("}\n");
System.out.println("-------------------------------------");
System.out.println(sb.toString());
try {
irc.compile(name, src);
irc.compile("gen_"+name+"Handler", sb.toString());
irc.compile(sampleName, src);
irc.compile("gen_"+sampleName+"Handler", sb.toString());
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (SecurityException e) {
......
examples/dynamic/test/TestLabcommGen.java 0 → 100644
View file @ d3921882
package test;
import java.io.ByteArrayInputStream;
import java.io.EOFException;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.nio.CharBuffer;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;
import se.lth.control.labcomm2014.Decoder;
import se.lth.control.labcomm2014.DecoderChannel;
import se.lth.control.labcomm2014.Encoder;
import se.lth.control.labcomm2014.EncoderChannel;
import se.lth.control.labcomm2014.compiler.LabCommParser;
import se.lth.control.labcomm2014.compiler.LabCommScanner;
import se.lth.control.labcomm2014.compiler.Program;
import beaver.Parser.Exception;
public class TestLabcommGen {
private static final String TYPE_NAME_FOO = "foo_t";
private static final String SAMPLE_NAME_FOO = "foo";
private static final String SAMPLE_NAME_BAR = "bar";
static final String handlerClassName= "HandlerContainer";
static class HandlerSrc {
private String sampleName;
private String param;
private String body;
private final String proto = "public void handle_";
public HandlerSrc(String sampleName, String param, String body) {
this.sampleName = sampleName;
this.param = param;
this.body = body;
}
public String getSrc() {
String res = proto+sampleName+"("+param+")"+body;
return res;
}
}
/**
* @param args
*/
public static void main(String[] args) {
/* input data: */
String labcommStr = readLabcommDecl(args[0]);
String srcStr = readHandlerDecl(args[1]);
/*Map<sample name, handler code>*/
HashMap <String, String> handlers = new HashMap<String, String>();
generateHandlers(srcStr, handlers);
System.out.println("*** Generated handler source:");
handlers.keySet();
for (String n : handlers.keySet()) {
System.out.println(n+":");
System.out.println(handlers.get(n));
}
InRAMCompiler irc = generateCode(labcommStr, handlers);
if(irc != null) {
System.out.println("*** Testing instantiation and invocation of Handler ");
//dummyTest(irc);
String tmpFile = args[2];
System.out.println("*** Testing writing and reading file "+tmpFile);
encodeTest(irc, tmpFile);
decodeTest(irc, tmpFile, SAMPLE_NAME_FOO, SAMPLE_NAME_BAR);
}
}
public static void generateHandlers(String srcStr, HashMap<String,String> handlers) {
int pos = 0;
while(pos < srcStr.length()) {
// System.out.println("--------");
int nameEnd = srcStr.indexOf(':', pos);
if(nameEnd <0) break;
String name = srcStr.substring(pos,nameEnd);
// System.out.println("Name="+name);
pos=nameEnd+1;
String par = "";
final String handler_decl = "handler(";
if(srcStr.startsWith(handler_decl, pos)) {
int endPar = srcStr.indexOf(')', pos);
par = srcStr.substring(pos+handler_decl.length(), endPar);
// System.out.println("param="+par);
pos = endPar+1;
} else {
System.out.println("expeced handler decl:\n"+srcStr.substring(pos));
}
int bodyEnd = srcStr.indexOf("}###", pos); // HERE BE DRAGONS! a bit brittle
String body = srcStr.substring(pos, bodyEnd+1);
pos = bodyEnd+5;
// System.out.println("body:");
// System.out.println(body);
// System.out.println("**** generates:");
HandlerSrc s = new HandlerSrc(name, par, body);
final String genSrc = s.getSrc();
// System.out.println(genSrc);
handlers.put(name,genSrc);
}
}
public static String readHandlerDecl(String decl) {
FileReader fr;
int len=0;;
CharBuffer buf = CharBuffer.allocate(1024);
try {
fr = new FileReader(decl);
len = fr.read(buf);
buf.rewind();
} catch (Throwable e) {
e.printStackTrace();
System.exit(1);
}
String srcStr = buf.toString().substring(0, len);
return srcStr;
}
private static String readLabcommDecl(String lcfile) {
FileReader fr;
int len=0;;
CharBuffer buf = CharBuffer.allocate(1024);
try {
fr = new FileReader(lcfile);
len = fr.read(buf);
// buf.append((char) 0x04);
buf.rewind();
} catch (Throwable e) {
e.printStackTrace();
System.exit(1);
}
String labcommStr = buf.toString().substring(0, len-1);
return labcommStr;
}
public static InRAMCompiler generateCode(String lcDecl, HashMap<String, String> handlers) {
Specification ast = null;
InputStream in = new ByteArrayInputStream(lcDecl.getBytes());
LabCommScanner scanner = new LabCommScanner(in);
LabCommParser parser = new LabCommParser();
Collection errors = new LinkedList();
InRAMCompiler irc = null;
try {
Specification p = (Specification)parser.parse(scanner);
p.errorCheck(errors);
if (errors.isEmpty()) {
ast = p;
} else {
System.out.println("*** Errors:");
for (Iterator iter = errors.iterator(); iter.hasNext(); ) {
String s = (String)iter.next();
System.out.println(s);
}
}
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
if (ast != null) {
irc = handleAst(ast, handlers);
} else {
System.err.println("compilation failed");
}
return irc;
}
/** generate labcomm code and compile handlers
*
* @param lcAST - the AST of the labcomm declaration
* @param handlers - a map <name, source> of handlers for the types in ast
* @return an InRAMCompiler object containing the generated clases
*/
private static InRAMCompiler handleAst(Specification lcAST, HashMap<String, String> handlers) {
Map<String, String> genCode = new HashMap<String, String>();
try {
lcAST.J_gen(genCode, "labcomm.generated", 2014);
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("Generated labcomm code:");
InRAMCompiler irc = new InRAMCompilerJavax("labcomm.generated", TestLabcommGen.class.getClassLoader(), true);
StringBuilder handlerClass = new StringBuilder();
StringBuilder handlerMethods = new StringBuilder();
handlerClass.append("package labcomm.generated;\n");
handlerClass.append("import test.TestLabcommGen;\n");
handlerClass.append("public class "+handlerClassName+" implements ");
String handlerAttributes = "Object context;\n";
String handlerConstr = "public "+handlerClassName+"(){ super();}\n";
String handlerConstrCtxt = "public "+handlerClassName+"(Object context){ this.context=context;}\n";
Iterator<String> i = genCode.keySet().iterator();
try {
while(i.hasNext()){
final String sampleName = i.next();
System.out.println("sample: "+sampleName);
final String src = genCode.get(sampleName);
String hctmp = handlers.get(sampleName);
if(hctmp != null) {
handlerClass.append(sampleName+".Handler");
if(i.hasNext()) {
handlerClass.append(", ");
}
handlerMethods.append(hctmp);
handlerMethods.append("\n");
}
//System.out.println("FOOOO:"+sampleName+"++++"+hctmp);
//System.out.println("GOOO: "+sampleName+"----"+handlerMethods);
System.out.println("***"+sampleName+"\n"+src);
irc.compile(sampleName, src); // while iterating, compile the labcomm generated code
}
handlerClass.append("{\n");
if(handlerAttributes != null)
handlerClass.append(handlerAttributes);
if(handlerConstr != null)
handlerClass.append(handlerConstr);
if(handlerConstrCtxt != null)
handlerClass.append(handlerConstrCtxt);
if(handlerMethods != null)
handlerClass.append(handlerMethods.toString());
handlerClass.append("}\n");
System.out.println("--- generated code to compile -------"+ handlerClassName);
final String handlerSrc = handlerClass.toString();
System.out.println(handlerSrc);
irc.compile(handlerClassName, handlerSrc); // compile the generated handler class
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
System.out.println("================================");
return irc;
}
/** generate labcomm code and compile handlers. Version for separate handler classes
*
* @param lcAST - the AST of the labcomm declaration
* @param handlers - a map <name, source> of handlers for the types in ast
* @return an InRAMCompiler object containing the generated clases
*/
private static InRAMCompiler handleAstSeparate(Specification lcAST, HashMap<String, String> handlers) {
Map<String, String> genCode = new HashMap<String, String>();
try {
lcAST.J_gen(genCode, "labcomm.generated", 2013);
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("Generated labcomm code:");
InRAMCompiler irc = new InRAMCompilerJavax("labcomm.generated", null);
Iterator<String> i = genCode.keySet().iterator();
while(i.hasNext()){
final String sampleName = i.next();
final String src = genCode.get(sampleName);
System.out.println("***"+sampleName+"\n"+src);
StringBuilder sb = new StringBuilder();
sb.append("package labcomm.generated;\n");
sb.append("public class gen_"+sampleName+"Handler implements "+sampleName+".Handler {\n");
sb.append(handlers.get(sampleName));
sb.append("}\n");
System.out.println("--- foo -----------------------------");
System.out.println(sb.toString());
try {
irc.compile(sampleName, src);
irc.compile("gen_"+sampleName+"Handler", sb.toString());
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
System.out.println("================================");
}
return irc;
}
/** test method
*/
private static void decodeTest(InRAMCompiler irc, String tmpFile, String... sampleNames) {
try {
FileInputStream in = new FileInputStream(tmpFile);
DecoderChannel dec = new DecoderChannel(in);
Class handlerClass = irc.load(handlerClassName);
Constructor hcc = handlerClass.getDeclaredConstructor(Object.class);
// Object handler = handlerClass.newInstance();
HandlerContext ctxt = new HandlerContext();
Object handler = hcc.newInstance(ctxt);
for (String sampleName : sampleNames) {
System.out.println("registering handler for "+sampleName);
Class sampleClass = irc.load(sampleName);
Class handlerInterface = irc.load(sampleName+"$Handler");
Method reg = sampleClass.getDeclaredMethod("register", Decoder.class, handlerInterface);
reg.invoke(sampleClass, dec, handler);
}
try{
System.out.println("*** decoding:");
dec.run();
} catch(EOFException e) {
System.out.println("*** reached EOF ***");
}
in.close();
System.out.println("ctxt.x = "+ctxt.x);
System.out.println("ctxt.y = "+ctxt.y);
System.out.println("ctxt.z = "+ctxt.z);
} catch (Throwable e) {
e.printStackTrace();
}
}
/** test encoding
*/
private static void encodeTest(InRAMCompiler irc, String tmpFile) {
try {
Class ft;
Class fc = irc.load(SAMPLE_NAME_FOO);
Class bc = irc.load(SAMPLE_NAME_BAR);
try {
ft = irc.load(TYPE_NAME_FOO);
} catch (ClassNotFoundException e) {
System.out.println("encodeTest: defaulting to ft == fc");
ft = fc;
}
/* create sample class and instance objects */
Object f = ft.newInstance();
Field x = ft.getDeclaredField("x");
Field y = ft.getDeclaredField("y");
Field z = ft.getDeclaredField("z");
x.setInt(f, 10);
y.setInt(f, 11);
z.setInt(f, 12);
FileOutputStream out = new FileOutputStream(tmpFile);
EncoderChannel enc = new EncoderChannel(out);
/* register and send foo */
Method regFoo = fc.getDeclaredMethod("register", Encoder.class);
regFoo.invoke(fc, enc);
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", Encoder.class);
regBar.invoke(bc, enc);
Method doEncodeBar = bc.getDeclaredMethod("encode", Encoder.class, Integer.TYPE);
doEncodeBar.invoke(bc, enc, 42);
out.close();
} catch (Throwable e) {
e.printStackTrace();
}
}
/** dummy test creating instances of sample and handler, and calling handle*/
private static void dummyTest(InRAMCompiler irc) {
try {
Class hc = irc.load(handlerClassName);
Constructor hcc = hc.getDeclaredConstructor(Object.class);
// Object h = hc.newInstance();
Object h = hcc.newInstance(new HandlerContext());
Class fc = irc.load(SAMPLE_NAME_FOO);
Object f = fc.newInstance();
Field x = fc.getDeclaredField("x");
Field y = fc.getDeclaredField("y");
Field z = fc.getDeclaredField("z");
x.setInt(f, 10);
y.setInt(f, 11);
z.setInt(f, 12);
Method m;
try {
m = hc.getDeclaredMethod("handle_"+SAMPLE_NAME_FOO, fc);
m.invoke(h, f);
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchFieldException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/** test method
*/
private static void decodeTestSeparate(InRAMCompiler irc, String tmpFile, String... sampleNames) {
try {
FileInputStream in = new FileInputStream(tmpFile);
DecoderChannel dec = new DecoderChannel(in);
for (String sampleName : sampleNames) {
System.out.println("registering handler for "+sampleName);
Class sampleClass = irc.load(sampleName);
Class handlerClass = irc.load("gen_"+sampleName+"Handler");
Class handlerInterface = irc.load(sampleName+"$Handler");
Object handler = handlerClass.newInstance();
Method reg = sampleClass.getDeclaredMethod("register", Decoder.class, handlerInterface);
reg.invoke(sampleClass, dec, handler);
}
try{
System.out.println("*** decoding:");
dec.run();
} catch(EOFException e) {
System.out.println("*** reached EOF ***");
}
in.close();
} catch (Throwable e) {
e.printStackTrace();
}
}
/** dummy test creating instances of sample and handler, and calling handle*/
private static void dummyTestSeparate(InRAMCompiler irc) {
try {
Class hc = irc.load("gen_"+SAMPLE_NAME_FOO+"Handler");
Object h = hc.newInstance();
Class fc = irc.load(SAMPLE_NAME_FOO);
Object f = fc.newInstance();
Field x = fc.getDeclaredField("x");
Field y = fc.getDeclaredField("y");
Field z = fc.getDeclaredField("z");
x.setInt(f, 10);
y.setInt(f, 11);
z.setInt(f, 12);
Method m;
try {
m = hc.getDeclaredMethod("handle_"+SAMPLE_NAME_FOO, fc);
m.invoke(h, f);
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SecurityException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchFieldException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
examples/dynamic/test_type.sh 0 → 100644
View file @ d3921882
#dummy script to test the on-the-fly compilation
javac -cp .:../../compiler/labcomm2014_compiler.jar:../../lib/java/labcomm2014.jar:../../lib/tools/beaver.jar:../../lib/tools/beaver-rt.jar:../../lib/tools/jastadd2.jar:../../lib/tools/JFlex.jar:../../lib/tools/proj.jar test/TestLabcommGen.java
javac test/HandlerContext.java
java -cp .:../../compiler/labcomm2014_compiler.jar:../../lib/java/labcomm2014.jar:../../lib/tools/beaver.jar:../../lib/tools/beaver-rt.jar:../../lib/tools/jastadd2.jar:../../lib/tools/JFlex.jar:../../lib/tools/proj.jar test.TestLabcommGen simple_type.lc handlers_type.txt encoded_data
examples/jgrafchart/Makefile 0 → 100644
View file @ d3921882
LCDIR=../..
LABCOMM_JAR=../../compiler/labcomm2014_compiler.jar
LABCOMM=java -jar $(LABCOMM_JAR)
CLASSPATH=.:${LCDIR}/lib/java/labcomm2014.jar
JAVA_PKG=labcommTCPtest
SAMPLENAME=foo
LCLIBDIR=${LCDIR}/lib/c
LCFILE=jg
AUX=enc.c dec.c
TLCFILE=turtle1
TAUX=turtle_enc.c turtle_dec.c
${JAVA_PKG}/gen/foo.java: ${LCFILE}.lc
${LABCOMM} --javapackage=${JAVA_PKG}.gen --java=${JAVA_PKG}/gen $<
${JAVA_PKG}/gen/${SAMPLENAME}.class: ${JAVA_PKG}/gen/${SAMPLENAME}.java
javac -cp ${CLASSPATH} $<
${JAVA_PKG}/server/TestServer.class: ${JAVA_PKG}/server/TestServer.java ${JAVA_PKG}/gen/${SAMPLENAME}.class
javac -cp ${CLASSPATH} $<
${JAVA_PKG}/client/TestClient.class: ${JAVA_PKG}/client/TestClient.java ${JAVA_PKG}/gen/${SAMPLENAME}.class
javac -cp ${CLASSPATH} $<
.PHONY: runjavaserver
runjavaserver : ${JAVA_PKG}/server/TestServer.class
java -cp ${CLASSPATH} $(<:.class=)
.PHONY: runjavaclient
runjavaclient : ${JAVA_PKG}/client/TestClient.class
java -cp ${CLASSPATH} $(<:.class=)
client: client.c ${LCFILE}.c ${AUX} ${AUX:.c=.h}
${CC} -o $@ client.c ${AUX} ${LCFILE}.c -I${LCLIBDIR} -L${LCLIBDIR} -llabcomm
testserver: testserver.c ${LCFILE}.c ${AUX} ${AUX:.c=.h}
${CC} -o $@ testserver.c ${AUX} ${LCFILE}.c -I${LCLIBDIR} -L${LCLIBDIR} -llabcomm
turtleclient: turtleclient.c ${TLCFILE}.c ${TAUX} ${TAUX:.c=.h}
${CC} -o $@ turtleclient.c ${TAUX} ${TLCFILE}.c -I${LCLIBDIR} -L${LCLIBDIR} -llabcomm
${LCFILE}.c : ${LCFILE}.lc
${LABCOMM} -C ${LCFILE}.lc
${TLCFILE}.c : ${TLCFILE}.lc
${LABCOMM} -C ${TLCFILE}.lc
all: client testserver ${JAVA_PKG}/server/TestServer.class ${JAVA_PKG}/client/TestClient.class turtleclient
.PHONY: clean
clean :
rm -f ${LCFILE}.c ${LCFILE}.h client testserver turtleclient
rm -f ${JAVA_PKG}/server/*.class ${JAVA_PKG}/client/*.class
rm -f ${JAVA_PKG}/gen/*
.PHONY: distclean
distclean: clean
.PHONY: runclient
runclient : client
LD_LIBRARY_PATH=${LCLIBDIR} ./$< localhost 9999
.PHONY: runserver
runserver : testserver
LD_LIBRARY_PATH=${LCLIBDIR} ./$< 9999
.PHONY: runtclient
runtclient : turtleclient
LD_LIBRARY_PATH=${LCLIBDIR} ./$< localhost 8082
examples/jgrafchart/client.c 0 → 100644
View file @ d3921882
#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 "dec.h"
#include "enc.h"
void error(const char *msg)
{
perror(msg);
exit(0);
}
void do_labcomm(int sockfd)
{
void *enc = enc_init(sockfd);
void *dec = dec_init(sockfd, enc);
dec_run(dec);
dec_cleanup(dec);
enc_cleanup(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/jgrafchart/client_jg.xml 0 → 100644
View file @ d3921882
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<GCDocument color="-1" dimTicks="25" dpwsInterface="" dpwsPort="-1" height="599" horizontalScrollBar="1" modifiable="1" name="Client" saveVersion="7" scale="1.0" simulationMode="1" socketHost="" socketIsServer="0" socketPort="-1" socketSendMode="Changed" threadSpeed="40" tokenLuminance="0" verticalScrollBar="1" viewPositionX="0" viewPositionY="0" width="490" x="358" y="-1">
<LabCommObject height="60" isSocketServer="0" name="LabComm" socketHost="127.0.0.1" socketPort="9999" specification="sample struct {&#10; double b;&#10; int c;&#10; int d;&#10; string e;&#10; boolean f;&#10; short g;&#10; long h;&#10; float i;&#10;} foo;&#10;&#10;//sample int bar;&#10;" width="60" x="50" y="300"/>
<GCInitialStep actionBlockVisible="1" actionText="P b = LabComm.foo.b;" fileName="" height="70" id="d518e8b8-6b49-4af4-abcc-ec8024853580" name="" useIcon="0" width="200" x="140" y="65"/>
<IntegerVariable constant="0" exp="" height="45" initialValue="" name="b" updated="0" value="437" width="65" x="380" y="70"/>
</GCDocument>
examples/jgrafchart/dec.c 0 → 100644
View file @ d3921882
#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 "jg.h"
static struct labcomm_encoder *encoder;
static void handle_foo(jg_foo *v, void *context) {
printf("got foo: b=%f, e=%s, f=%d\n", v->b, v->e, v->f);
v->d = v->d+1;
labcomm_encode_jg_foo(encoder, v);
usleep(500000);
v->d = v->d+1;
labcomm_encode_jg_foo(encoder, v);
}
struct labcomm_decoder *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_jg_foo(decoder, handle_foo, context);
return decoder;
}
void dec_run(struct labcomm_decoder *decoder) {
printf("Decoding:\n");
labcomm_decoder_run(decoder);
printf("--- End Of File ---:\n");
}
void dec_cleanup(struct labcomm_decoder *decoder) {
labcomm_decoder_free(decoder);
}
examples/jgrafchart/dec.h 0 → 100644
View file @ d3921882
#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 * dec_init(int fd, struct labcomm_encoder *e) ;
void dec_run(struct labcomm_decoder *decoder) ;
void dec_cleanup(struct labcomm_decoder *decoder) ;
examples/jgrafchart/enc.c 0 → 100644
View file @ d3921882
#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 "jg.h"
#include <stdio.h>
struct labcomm_encoder *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_jg_foo(encoder);
return encoder;
}
void enc_run(struct labcomm_encoder *encoder, jg_foo *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
usleep(500000);
v->b += 42;
v->h += 42000000;
labcomm_encode_jg_foo(encoder, v);
}
void enc_cleanup(struct labcomm_encoder *encoder) {
labcomm_encoder_free(encoder);
}