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

Target

Select target project
  • anders_blomdell/labcomm
  • klaren/labcomm
  • tommyo/labcomm
  • erikj/labcomm
  • sven/labcomm
5 results
Show changes
Hide whitespace changes
Inline Side-by-side
Showing
with 3408 additions and 54 deletions
Java_CodeGen.jrag → compiler/2014/Java_CodeGen.jrag
View file @ d3921882
......@@ -4,142 +4,42 @@ import java.util.*;
aspect Java_CodeGenEnv {
// Environment wrapper for Java-code generation
// handles indentation, file writing,
// handles indentation, file writing,
public class Java_env {
public class Java_env extends PrintEnv {
private int indent;
private int depth;
private Java_printer printer;
private HashMap unique = new HashMap();
final private class Java_printer {
private boolean newline = true;
private File file;
private PrintStream out;
private IOException exception;
public Java_printer(File f) {
file = f;
File parentFile = f.getParentFile();
if(parentFile != null) {
parentFile.mkdirs();
}
}
public Java_printer(PrintStream out) {
this.out = out;
}
public void close() throws IOException {
if (out != null) {
out.close();
}
if (exception != null) {
throw exception;
}
}
public PrintStream getPrintStream() {
return(out);
}
public void checkOpen() {
if (out == null && exception == null) {
try {
out = new PrintStream(new FileOutputStream(file));
} catch (IOException e) {
exception = e;
}
}
}
public void print(Java_env env, String s) {
checkOpen();
if (newline) {
newline = false;
for (int i = 0 ; i < env.indent ; i++) {
out.print(" ");
}
}
out.print(s);
final private static class Java_printer extends PrintEnv.FilePrinter {
public Java_printer(PrintStream out) {
super(out);
}
public void println(Java_env env, String s) {
checkOpen();
print(env, s);
out.println();
newline = true;
public Java_printer(File f) {
super(f);
}
}
private Java_env(int indent, Java_printer printer) {
this.indent = indent;
this.printer = printer;
}
public Java_env(File f) {
this.indent = 0;
this.printer = new Java_printer(f);
}
public Java_env(PrintStream out) {
this.indent = 0;
this.printer = new Java_printer(out);
}
public void close() throws IOException {
printer.close();
}
public PrintStream getPrintStream() {
return printer.getPrintStream();
}
public void indent(int amount) {
indent += amount;
}
public void indent() {
indent(1);
}
public void unindent(int amount) {
indent -= amount;
}
public void unindent() {
unindent(1);
}
public void print(String s) {
printer.print(this, s);
public Java_env(int version, File f) {
super(0, new Java_printer(f), version);
}
public void println(String s) {
printer.println(this, s);
}
public void println() {
printer.println(this, "");
}
public int getDepth() {
return depth;
public Java_env(int version, PrintStream out) {
super(0, new Java_printer(out), version);
}
public String print_for_begin(String limit) {
int depth = getDepth();
print("for (int i_" + depth + " = 0 ; ");
print("i_" + depth + " < " + limit + " ; ");
println("i_" + depth + "++) {");
indent();
depth++;
return "[i_" + (depth - 1) + "]";
incDepth();
return "[i_" + (depth) + "]";
}
public void print_for_end() {
depth--;
decDepth();
unindent();
println("}");
}
......@@ -170,12 +70,12 @@ aspect Java_CodeGenEnv {
aspect Java_StructName {
inh int Decl.Java_Depth();
inh int Type.Java_Depth();
eq Program.getDecl(int i).Java_Depth() = 0;
inh int DataType.Java_Depth();
eq Specification.getDecl(int i).Java_Depth() = 0;
eq StructType.getField(int i).Java_Depth() = Java_Depth() + 1;
inh String Type.Java_structName();
eq Program.getDecl(int i).Java_structName() = getDecl(i).getName();
inh String DataType.Java_structName();
eq Specification.getDecl(int i).Java_structName() = getDecl(i).getName();
eq StructType.getField(int i).Java_structName() {
if (Java_Depth() == 0) {
return "struct_" + getField(i).getName();
......@@ -187,35 +87,36 @@ aspect Java_StructName {
aspect Java_Void {
syn boolean Decl.isVoid() = getType().isVoid();
syn boolean Type.isVoid() = false;
syn boolean Decl.isVoid() = getDataType().isVoid();
syn boolean UserType.isVoid() = decl().isVoid();
syn boolean DataType.isVoid() = false;
syn boolean VoidType.isVoid() = true;
}
aspect Java_CodeGen {
public void Program.J_gen(String dir, String pack) throws IOException {
public void Specification.J_gen(PrintStream ps, String pack, int version) throws IOException {
Java_env env;
/*
// Registration class
env = new Java_env(new File(dir, "LabCommRegister.java"));
if (pack != null && pack.length() > 0) {
env.println("package " + pack + ";");
env = new Java_env(version, ps);
for (int i = 0; i < getNumDecl(); i++) {
Decl d = getDecl(i);
try {
d.Java_emitClass(env, pack);
} catch (Error e) {
System.err.println(d.getName());
throw e;
}
}
env.println("public class LabCommRegister {");
env.println();
env.indent();
Java_emitTypeRegister(env);
env.unindent();
env.println();
env.println("}");
env.close();
*/
}
public void Specification.J_gen(String dir, String pack, int version) throws IOException {
Java_env env;
for (int i = 0; i < getNumDecl(); i++) {
Decl d = getDecl(i);
try {
env = new Java_env(new File(dir, d.getName() + ".java"));
env = new Java_env(version, new File(dir, d.getName() + ".java"));
d.Java_emitClass(env, pack);
env.close();
} catch (Error e) {
......@@ -225,35 +126,24 @@ aspect Java_CodeGen {
}
}
}
aspect Java_Register {
public void Program.Java_emitTypeRegister(Java_env env) {
/*
env.println("static void register(LabCommChannel c) {");
env.indent();
/** Experimental method for generating code to a map <classname, source>
*/
public void Specification.J_gen(Map<String,String> src, String pack, int version) throws IOException {
Java_env env;
for (int i = 0; i < getNumDecl(); i++) {
getDecl(i).Java_emitTypeRegister(env);
Decl d = getDecl(i);
try {
ByteArrayOutputStream bs = new ByteArrayOutputStream();
PrintStream out = new PrintStream(bs);
env = new Java_env(version, out);
d.Java_emitClass(env, pack);
env.close();
src.put(d.getName(), bs.toString());
} catch (Error e) {
System.err.println(d.getName());
throw e;
}
}
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
}
}
......@@ -261,185 +151,629 @@ aspect Java_Register {
aspect Java_Class {
public void Decl.Java_emitClass(Java_env env, String pack) {
throw new Error(this.getClass().getName() +
".Java_emitClass(Java_env env, String pack)" +
throw new Error(this.getClass().getName() +
".Java_emitClass(Java_env env, String pack)" +
" not declared");
}
public void TypeDecl.Java_emitClass(Java_env env, String pack) {
if (getType().Java_needInstance()) {
public void Decl.Java_emitDeclPP(Java_env env) {
// Hackish prettyprint preamble
env.println("/* ");
pp(env.getPrintStream());
Java_emitUserTypeDeps(env, null, false);
Java_emitUserTypeRefs(env, null, false);
env.println("*/");
}
private void Decl.Java_declareUserTypeDeps(Java_env env) {
int numDeps = type_dependencies().size();
int i=0;
env.println("private static DataType dataType;");
env.println("static {");
env.indent();
Java_emitTypeTree(env);
env.unindent();
env.println("}");
env.println("private Set<SampleDispatcher> typeDependencies = new HashSet<SampleDispatcher>();");
env.println("public Dispatcher(){");
env.indent();
Iterator<Decl> it = type_dependencies().iterator();
while(it.hasNext()) {
Decl t = it.next();
//env.println("deps["+(i++)+"] = "+t.getName()+";");
env.println("typeDependencies.add("+t.getName()+".dispatcher);");
}
env.unindent();
env.println("}");
env.println("public DataType getDataType(){");
env.indent();
env.println("return dataType;");
env.unindent();
env.println("}");
env.println("public Iterator<SampleDispatcher> getDependencyIterator(){");
env.indent();
env.println("return typeDependencies.iterator();");
env.unindent();
env.println("}");
env.println("public void registerTypeDeps(Encoder e) throws IOException {");
env.indent();
// env.println("for (SampleDispatcher d : typeDependencies) {");
env.println("Iterator<SampleDispatcher> it = typeDependencies.iterator();");
env.println("while (it.hasNext()) {");
env.indent();
env.println("SampleDispatcher d = it.next();");
env.println("d.registerTypeDeps(e);");
env.println("e.register(d);");
env.unindent();
env.println("}");
env.unindent();
env.println("}");
}
public void Decl.Java_emitUserTypeDeps(Java_env env, String via, boolean outputCode) {
// XXX TODO will generate unnecessary recursion for types. fix this per commented out code
// XXX but ensure that types with references actually register themselves.. (i.e., add "nested" argument)
//public abstract void Decl.Java_emitUserTypeDeps(Java_env env, String via, boolean outputCode);
//public void TypeDecl.Java_emitUserTypeDeps(Java_env env, String via, boolean outputCode) {
// // do nothing for type decls; sampledecl iterates over all dependencies and outputs
// // all type decls
//}
//public void SampleDecl.Java_emitUserTypeDeps(Java_env env, String via, boolean outputCode) {
// if(env.versionHasMetaData() && hasDependencies() || isReferenced() ) {
// if(env.versionHasMetaData() && isSampleDecl() && outputCode) {
// env.println("if(sendMetaData){");
// env.indent();
// }
Iterator<Decl> it = type_dependencies().iterator();
while(it.hasNext()) {
Decl t = it.next();
t.Java_emitUserTypeDeps(env, t.getName(), outputCode);
if( outputCode){// && t.getDataType().isUserType() ) {
env.println(t.getName()+".register(e);");
} else { // Just output a comment
String refpath = (via == null) ? "directly" : "indirectly via "+via;
env.println(" //Depends ("+refpath+") on "+t.getName() );
}
}
// if(env.versionHasMetaData() && isSampleDecl() && outputCode) {
// env.unindent();
// env.println("}");
// }
// }
}
public void Decl.Java_emitUserTypeRefs(Java_env env, String via, boolean outputCode) {
if( isReferenced() ) {
Iterator<Decl> it = type_references().iterator();
while(it.hasNext()) {
Decl t = it.next();
t.Java_emitUserTypeRefs(env, t.getName(), outputCode);
if(outputCode) {
env.println(t.getName()+".register(e);");
} else { // Just output a comment
String refpath = (via == null) ? "directly" : "indirectly via "+via;
env.println(" //Is referenced ("+refpath+") by "+t.getName() );
}
}
}
}
public void Decl.Java_emitRegisterEncoder(Java_env env) {
env.println("public static void register(Encoder e) throws IOException {");
env.indent();
env.println("register(e, true);");
env.unindent();
env.println("}");
env.println();
env.println("public static void register(Encoder e, boolean sendMetaData) throws IOException {");
env.indent();
// Java_emitUserTypeDeps(env, null, true);
env.println("dispatcher.registerTypeDeps(e);");
env.println("e.register(dispatcher);");
env.unindent();
env.println("}");
env.println("public static void registerSampleRef(Encoder e) throws IOException{");
env.indent();
env.println("e.registerSampleRef(dispatcher);");
env.unindent();
env.println("}");
env.println();
env.println("public static DataType getDataType(){");
env.indent();
env.println("return dispatcher.getDataType();");
env.unindent();
env.println("}");
env.println();
}
public void TypeDecl.Java_emitClass(Java_env env, String pack) {
Java_emitDeclPP(env);
if (pack != null && pack.length() > 0) {
env.println("package " + pack + ";");
env.println("package " + pack + ";");
}
env.println("import java.io.IOException;");
env.println("import se.lth.control.labcomm.LabCommType;");
env.println("import se.lth.control.labcomm.LabCommEncoder;");
env.println("import se.lth.control.labcomm.LabCommDecoder;");
env.println();
env.println("public class " + getName() + " implements LabCommType {");
env.println("import se.lth.control.labcomm"+env.verStr+".Constant;");
env.println("import se.lth.control.labcomm"+env.verStr+".SampleType;");
env.println("import se.lth.control.labcomm"+env.verStr+".*;");
if (getDataType().Java_needInstance() || hasDependencies() || isReferenced()) {
env.println("import se.lth.control.labcomm"+env.verStr+".Encoder;");
env.println("import se.lth.control.labcomm"+env.verStr+".SampleDispatcher;");
env.println("import se.lth.control.labcomm"+env.verStr+".SampleHandler;");
env.println("import java.util.Set;");
env.println("import java.util.HashSet;");
env.println("import java.util.Iterator;");
// env.println();
// }
//
// if (getDataType().Java_needInstance()) {
env.println("import java.io.IOException;");
env.println("import se.lth.control.labcomm"+env.verStr+".Decoder;");
}
// For types without type_dependencies and not needing an instance,
// currently just an empty class is generated
env.println("public class " + getName() + " implements SampleType {");
env.println();
env.indent();
getType().Java_emitInstance(env);
Java_emitEncoder(env);
Java_emitDecoder(env);
env.unindent();
if (getDataType().Java_needInstance()) {
getDataType().Java_emitInstance(env);
Java_emitEncoder(env);
Java_emitDecoder(env);
}
//if(hasDependencies() || isReferenced()) {
//if( getDataType().isUserType() && isReferenced()) {
if( isReferenced()) {
Java_emitRegisterEncoder(env);
Java_emitDispatcher(env, false);
}
Java_emitSignature(env);
env.println("}");
}
env.unindent();
env.println();
}
public void SampleDecl.Java_emitClass(Java_env env, String pack) {
env.println("/* ");
pp(env.getPrintStream());
env.println("*/");
Java_emitDeclPP(env);
if (pack != null && pack.length() > 0) {
env.println("package " + pack + ";");
}
env.println("import java.io.IOException;");
env.println("import se.lth.control.labcomm.LabCommDecoder;");
env.println("import se.lth.control.labcomm.LabCommDispatcher;");
env.println("import se.lth.control.labcomm.LabCommEncoder;");
env.println("import se.lth.control.labcomm.LabCommHandler;");
env.println("import se.lth.control.labcomm.LabCommSample;");
env.println("import se.lth.control.labcomm"+env.verStr+".Constant;");
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("import se.lth.control.labcomm"+env.verStr+".*;");
env.println("import java.util.Set;");
env.println("import java.util.HashSet;");
env.println("import java.util.Iterator;");
env.println();
env.println("public class " + getName() + " implements LabCommSample {");
env.print("public class " + getName());
// TODO: ?
// Code for making samples of user types extend their type
// currently commented out. Is this a good idea or not?
//
// if(getDataType().isUserType()) {
// env.print(" extends "+getDataType().getTypeName());
// }
env.println(" implements Sample {");
env.println();
env.indent();
getType().Java_emitInstance(env);
env.println("public interface Handler extends LabCommHandler {");
getDataType().Java_emitInstance(env);
env.println("public interface Handler extends SampleHandler {");
env.print(" public void handle_" + getName() + "(");
if (!isVoid()) {
getType().Java_emitType(env);
getDataType().Java_emitType(env);
env.print(" value");
}
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, Handler h) throws IOException {");
env.indent();
env.println("d.register(dispatcher, h);");
env.unindent();
env.println("}");
env.println("public static void registerSampleRef(Decoder d) throws IOException {");
env.indent();
env.println("d.register(new Dispatcher(), h);");
env.println("d.registerSampleRef(dispatcher);");
env.unindent();
env.println("}");
env.println();
env.println("public static void register(LabCommEncoder e) throws IOException {");
env.indent();
env.println("e.register(new Dispatcher());");
Java_emitRegisterEncoder(env);
Java_emitDispatcher(env, true);
Java_emitEncoder(env);
Java_emitDecoder(env);
Java_emitSignature(env);
env.unindent();
env.println("}");
env.println();
env.println();
}
public void TypeDecl.Java_emitSignature(Java_env env) {
Signature signature = getSignature();
signature.Java_emitSignature(env, true);
}
env.println("private static class Dispatcher implements LabCommDispatcher {");
public void Decl.Java_emitSignature(Java_env env) {
//always emit the flat signature, as it is needed
//for matching at the decoder side (which cannot know
//the type_ids of dependent types. Therefore, flat sigs
//are used for matching
Java_emitIntentions(env);
Java_emitFlatSignature(env);
if(isReferenced() || (isSampleDecl() && hasDependencies() )){
Signature signature = getSignature();
signature.Java_emitSignature(env, !isSampleDecl());
}
}
public void Decl.Java_emitIntentions(Java_env env){
env.println("private static int numIntentions = " +getNumIntentions() +";");
env.println("private static byte[] intentions = new byte[] {");
env.indent();
env.println();
env.println("public Class getSampleClass() {");
byte[] data = getIntentionBytes();
if (data != null) {
for (int j = 0 ; j < data.length ; j++) {
env.print(data[j] + ", ");
}
}
env.unindent();
env.println("};");
env.println();
}
public void Decl.Java_emitFlatSignature(Java_env env){
env.println("private static byte[] signature = new byte[] {");
env.indent();
SignatureList signature = flatSignature(env.version);
for (int i = 0 ; i < signature.size() ; i++) {
String comment = signature.getComment(i);
if (comment != null) {
env.println(signature.getIndent(i) + "// " + comment);
}
byte[] data = signature.getData(i, env.version);
if (data != null) {
env.print(signature.getIndent(i));
for (int j = 0 ; j < data.length ; j++) {
env.print(data[j] + ", ");
}
env.println();
}
}
env.unindent();
env.println("};");
env.println();
}
public void TypeInstance.Java_emitAnnotationComment(Java_env env) {
if(hasAnnotations()) {
env.println("// "+getAnnotationString());
}
}
public void TypeInstance.Java_emitTypeTree(Java_env env, String varName) {
getDataType().Java_emitTypeTree(env, varName);
}
public void TypeInstance.Java_emitTypeField(Java_env env, String struct, String name) {
getDataType().Java_emitTypeField(env, struct, name);
}
public abstract void DataType.Java_emitTypeTree(Java_env env, String name);
public abstract void DataType.Java_emitTypeField(Java_env env, String struct, String name);
public void PrimType.Java_emitTypeTree(Java_env env, String name) {
env.println("// "+name+"="+getName() + " : " + getToken());
env.println(name+" = new SigPrimitiveType("+getToken()+");");
}
public void PrimType.Java_emitTypeField(Java_env env, String struct, String name) {
//env.println("// "+struct+".addField("+name+ ", "+getName()+");");
env.println(struct+".addField(\""+name+ "\", new SigPrimitiveType("+getToken()+"));");
}
public void VoidType.Java_emitTypeTree(Java_env env, String name) {
env.println(name+"= new VoidType();");
}
public void VoidType.Java_emitTypeField(Java_env env, String struct, String name) {
throw new Error("Void may not be field");
}
public void ParseArrayType.Java_emitTypeTree(Java_env env, String name) {
String elementType = name + "_element";
env.println("DataType "+elementType+";");
getDataType().Java_emitTypeTree(env, elementType);
env.println("// "+name+"= array("+elementType+");");
}
syn String Exp.dimArrayPart();
eq IntegerLiteral.dimArrayPart() = getValue();
eq VariableSize.dimArrayPart() = "-1";
syn String Dim.dimArrayString() {
StringBuilder sb = new StringBuilder();
sb.append("new int[] {");
for(int i=0; i<getNumExp(); i++) {
sb.append(getExp(i).dimArrayPart());
if(i < getNumExp()-1) {
sb.append(", ");
}
}
sb.append("}");
return sb.toString();
}
public void ArrayType.Java_emitTypeTree(Java_env env, String name) {
String elementType = name + "_element";
StringBuilder dim = new StringBuilder();
dim.append("new int[] {");
env.println("DataType "+elementType+";");
getDataType().Java_emitTypeTree(env, elementType);
env.println(name+"= new SigArrayType("+elementType+","+getDim().dimArrayString()+");");
}
public void ParseArrayType.Java_emitTypeField(Java_env env, String struct, String name) {
env.println("// field "+name+ " = array("+getDataType().Java_getTypeName()); }
public void ArrayType.Java_emitTypeField(Java_env env, String struct, String name) {
String innerName = struct+"_"+name;
env.println("DataType "+innerName+";");
Java_emitTypeTree(env, innerName);
env.println(struct+".addField(\""+name+ "\", "+innerName+");");
//env.println(struct+".addField(\""+name+ "\", new UserType(\""+getName()+"\"));");
}
public void StructType.Java_emitTypeTree(Java_env env, String name) {
env.println(name+" = new SigStructType();");
for(Field f : getFields()) {
f.Java_emitTypeField(env, name, f.getName());
}
}
public void StructType.Java_emitTypeField(Java_env env, String struct, String name) {
String innerName = struct+"_"+name;
env.println("SigStructType "+innerName+" = new SigStructType();");
for(Field f : getFields()) {
f.Java_emitTypeField(env, innerName, f.getName());
}
env.println(struct+".addField(\""+name+ "\", "+innerName+");");
}
public void UserType.Java_emitTypeTree(Java_env env, String name) {
env.println(name+" = new SigUserType(\""+getName()+"\");");
}
public void UserType.Java_emitTypeField(Java_env env, String struct, String name) {
env.println(struct+".addField(\""+name+ "\", new SigUserType(\""+getName()+"\"));");
}
public void Decl.Java_emitTypeTree(Java_env env) {
getTypeInstance().Java_emitTypeTree(env, "dataType");
}
//XXX TODO: refactor: split into a static class ("TypeDefSingleton"?)and a (smaller) dispatcher
public void Decl.Java_emitDispatcher(Java_env env, boolean isSample) {
// String genericStr = ""; //env.versionHasMetaData()?"<"+getName()+">":"";
String genericStr = "<"+getName()+">";
env.println("static Dispatcher dispatcher = new Dispatcher();");
env.println();
getTypeInstance().Java_emitAnnotationComment(env);
env.println("public SampleDispatcher getDispatcher() {");
env.indent();
env.println("return dispatcher;");
env.unindent();
env.println("}");
env.println();
env.println("static class Dispatcher implements SampleDispatcher "+genericStr+"{");
env.indent();
env.println();
Java_declareUserTypeDeps(env);
env.println("public Class"+genericStr+" getSampleClass() {");
env.indent();
env.println("return " + getName() + ".class;");
env.unindent();
env.println("}");
env.println();
env.println();
env.println("public String getName() {");
env.indent();
env.println("return \"" + getName() + "\";");
env.unindent();
env.println("}");
env.println();
env.println();
env.println("public byte getTypeDeclTag() {");
env.indent();
if(env.version == 2006) {
if(isSample) {
env.println("return Constant.SAMPLE;");
} else {
env.println("return Constant.TYPEDEF;");
}
} else {
if(isSample) {
env.println("return Constant.SAMPLE_DEF;");
} else {
env.println("return Constant.TYPE_DEF;");
}
}
env.unindent();
env.println("}");
env.println();
env.println("public boolean isSample() {");
env.indent();
env.println("return "+isSample+";");
env.unindent();
env.println("}");
env.println("public boolean hasDependencies() {");
env.indent();
env.println("return "+hasDependencies()+";");
env.unindent();
env.println("}");
env.println();
env.println("/** return the flat signature. */");
env.println("public byte[] getSignature() {");
env.indent();
env.println("return signature;");
if(isSample) {
env.println("return signature;");
} else {
env.println("throw new Error(\"a TYPE_DEF has no flat signature\");");
}
env.unindent();
env.println("}");
env.println();
env.println("public void decodeAndHandle(LabCommDecoder d,");
env.println(" LabCommHandler h) throws Exception {");
env.println();
env.println("/** return the outermost intentions. */");
env.println("public byte[] getIntentionBytes() {");
env.indent();
if (isVoid()) {
env.println(getName() + ".decode(d);");
env.println("((Handler)h).handle_" + getName() + "();");
if(isSample) {
env.println("return intentions;");
} else {
env.println("((Handler)h).handle_" + getName() + "(" + getName() + ".decode(d));");
env.println("return new byte[0];");
}
env.unindent();
env.println("}");
env.println("");
env.println();
env.println("/** return the number of intentions. */");
env.println("public int getNumIntentions() {");
env.indent();
if(isSample) {
env.println("return numIntentions;");
} else {
env.println("return 0;");
}
env.unindent();
env.println("}");
env.println("");
Java_emitEncoder(env);
Java_emitDecoder(env);
env.println("private static byte[] signature = new byte[] {");
env.println();
// env.println("public void encodeSignature(Encoder e) throws IOException{");
// env.indent();
// env.println("emitSignature(e);");
// env.unindent();
// env.println("}");
// env.println();
env.println("public void encodeTypeDef(Encoder e, int index) throws IOException{");
env.indent();
SignatureList signature = signature();
for (int i = 0 ; i < signature.size() ; i++) {
String comment = signature.getComment(i);
if (comment != null) {
env.println(signature.getIndent(i) + "// " + comment);
}
byte[] data = signature.getData(i);
if (data != null) {
env.print(signature.getIndent(i));
for (int j = 0 ; j < data.length ; j++) {
env.print(data[j] + ", ");
}
env.println();
}
if(!isSample || hasDependencies()) {
env.println("emitSignature(e);");
} else {
env.println("// the type has no dependencies, do nothing");
}
env.unindent();
env.println("};");
env.println("}");
env.println();
env.println("public boolean canDecodeAndHandle() {");
env.indent();
env.println("return "+isSample+";");
env.unindent();
env.println("}");
env.println();
env.println("public void decodeAndHandle(Decoder d,");
env.println(" SampleHandler h) throws Exception {");
env.indent();
if( isSample) {
if (isVoid()) {
env.println(getName() + ".decode(d);");
env.println("((Handler)h).handle_" + getName() + "();");
} else {
env.println("((Handler)h).handle_" + getName() + "(" + getName() + ".decode(d));");
}
} else {
env.println("throw new Exception(\"A typedef has no handler, the corresponding method on the sample class should be called.\");");
}
env.unindent();
env.println("}");
}
env.println("");
env.unindent();
env.println("}");
env.println("");
}
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);
getDataType().Java_emitType(env);
env.print(" value");
}
env.println(") throws IOException {");
env.indent();
getType().Java_emitEncoder(env, "value");
getDataType().Java_emitEncoder(env, "value");
env.unindent();
env.println("}");
env.println();
}
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);
getDataType().Java_emitType(env);
env.print(" value");
}
env.println(") throws IOException {");
env.indent();
env.println("e.begin(" + getName() + ".class);");
getType().Java_emitEncoder(env, "value");
getDataType().Java_emitEncoder(env, "value");
env.println("e.end(" + getName() + ".class);");
env.unindent();
env.println("}");
env.println();
}
public void Type.Java_emitEncoder(Java_env env, String name) {
throw new Error(this.getClass().getName() +
".Java_emitEncoder(Java_env env, String name)" +
public void DataType.Java_emitEncoder(Java_env env, String name) {
throw new Error(this.getClass().getName() +
".Java_emitEncoder(Java_env env, String name)" +
" not declared");
}
public void VoidType.Java_emitEncoder(Java_env env, String name) {
}
public abstract String DataType.Java_getTypeName();
public String UserType.Java_getTypeName() {
return "UserType";
}
public String VoidType.Java_getTypeName() {
return "VoidType";
}
public String ArrayType.Java_getTypeName() {
return "SigArrayType";
}
public String ParseArrayType.Java_getTypeName() {
throw new Error("should not be called");
//return "ParseArrayType";
}
public String StructType.Java_getTypeName() {
return "SigStructType";
}
public String PrimType.Java_getTypeName() {
switch (getToken()) {
case LABCOMM_BOOLEAN: { return "BooleanType"; }
case LABCOMM_BYTE: { return "ByteType"; }
case LABCOMM_SHORT: { return "ShortType"; }
case LABCOMM_INT: { return "IntType"; }
case LABCOMM_LONG: { return "LongType"; }
case LABCOMM_FLOAT: { return "FloatType"; }
case LABCOMM_DOUBLE: { return "DoubleType"; }
case LABCOMM_STRING: { return "StringType"; }
case LABCOMM_SAMPLE: { return "SampleRefType"; }
}
throw new Error( "unknown primitive type ("+getToken()+")");
}
public void PrimType.Java_emitEncoder(Java_env env, String name) {
switch (getToken()) {
case LABCOMM_BOOLEAN: { env.print("e.encodeBoolean"); } break;
......@@ -450,6 +784,7 @@ aspect Java_Class {
case LABCOMM_FLOAT: { env.print("e.encodeFloat"); } break;
case LABCOMM_DOUBLE: { env.print("e.encodeDouble"); } break;
case LABCOMM_STRING: { env.print("e.encodeString"); } break;
case LABCOMM_SAMPLE: { env.print("e.encodeSampleRef"); } break;
}
env.println("(" + name + ");");
}
......@@ -467,16 +802,16 @@ aspect Java_Class {
String limit = "i_" + (baseDepth + i) + "_max";
name = name + env.print_for_begin(limit);
}
getType().Java_emitEncoder(env, name);
getDataType().Java_emitEncoder(env, name);
for (int i = 0 ; i < getNumExp() ; i++) {
env.print_for_end();
env.print_block_end();
}
}
public String Exp.Java_emitEncoder(Java_env env, String name) {
throw new Error(this.getClass().getName() +
".Java_emitEncoder(Java_env env, String name)" +
throw new Error(this.getClass().getName() +
".Java_emitEncoder(Java_env env, String name)" +
" not declared");
}
......@@ -485,14 +820,14 @@ aspect Java_Class {
}
public String VariableSize.Java_emitEncoder(Java_env env, String name) {
env.println("e.encodeInt(" + name + ".length);");
env.println("e.encodePacked32(" + name + ".length);");
return name + ".length";
}
public void StructType.Java_emitEncoder(Java_env env, String name) {
for (int i = 0 ; i < getNumField() ; i++) {
Field f = getField(i);
f.getType().Java_emitEncoder(env, name + "." + f.getName());
f.getDataType().Java_emitEncoder(env, name + "." + f.getName());
}
}
......@@ -500,19 +835,19 @@ aspect Java_Class {
if (Java_needInstance()) {
env.println(getName() + ".encode(e, " + name + ");");
} else {
decl().getType().Java_emitEncoder(env, name);
decl().getDataType().Java_emitEncoder(env, name);
}
}
public void Decl.Java_emitDecoder(Java_env env) {
env.print("public static ");
getType().Java_emitType(env);
env.println(" decode(LabCommDecoder d) throws IOException {");
getDataType().Java_emitType(env);
env.println(" decode(Decoder d) throws IOException {");
env.indent();
if (!isVoid()) {
getType().Java_emitType(env);
getDataType().Java_emitType(env);
env.println(" result;");
getType().Java_emitDecoder(env, "result");
getDataType().Java_emitDecoder(env, "result");
env.println("return result;");
}
env.unindent();
......@@ -520,9 +855,9 @@ aspect Java_Class {
env.println();
}
public void Type.Java_emitDecoder(Java_env env, String name) {
throw new Error(this.getClass().getName() +
".Java_emitDecoder(Java_env env, String name)" +
public void DataType.Java_emitDecoder(Java_env env, String name) {
throw new Error(this.getClass().getName() +
".Java_emitDecoder(Java_env env, String name)" +
" not declared");
}
......@@ -540,6 +875,7 @@ aspect Java_Class {
case LABCOMM_FLOAT: { env.println("d.decodeFloat();"); } break;
case LABCOMM_DOUBLE: { env.println("d.decodeDouble();"); } break;
case LABCOMM_STRING: { env.println("d.decodeString();"); } break;
case LABCOMM_SAMPLE: { env.println("d.decodeSampleRef();"); } break;
}
}
......@@ -554,12 +890,12 @@ aspect Java_Class {
}
for (int i = 0 ; i < getNumExp() ; i++) {
String limit = "i_" + (baseDepth + i) + "_max";
env.print(name + " = ");
env.print(name + " = ");
Java_emitNew(env, limit, getNumExp() - i);
env.println(";");
name = name + env.print_for_begin(limit);
}
getType().Java_emitDecoder(env, name);
getDataType().Java_emitDecoder(env, name);
for (int i = 0 ; i < getNumExp() ; i++) {
env.print_for_end();
}
......@@ -568,8 +904,8 @@ aspect Java_Class {
}
public void Exp.Java_emitDecoder(Java_env env) {
throw new Error(this.getClass().getName() +
".Java_emitDecoder(Java_env env)" +
throw new Error(this.getClass().getName() +
".Java_emitDecoder(Java_env env)" +
" not declared");
}
......@@ -578,7 +914,7 @@ aspect Java_Class {
}
public void VariableSize.Java_emitDecoder(Java_env env) {
env.print("d.decodeInt()");
env.print("d.decodePacked32()");
}
public void StructType.Java_emitDecoder(Java_env env, String name) {
......@@ -587,7 +923,7 @@ aspect Java_Class {
env.println("();");
for (int i = 0 ; i < getNumField() ; i++) {
Field f = getField(i);
f.getType().Java_emitDecoder(env, name + "." + f.getName());
f.getDataType().Java_emitDecoder(env, name + "." + f.getName());
}
}
......@@ -595,35 +931,36 @@ aspect Java_Class {
if (Java_needInstance()) {
env.println(name + " = " + getName() + ".decode(d);");
} else {
decl().getType().Java_emitDecoder(env, name);
decl().getDataType().Java_emitDecoder(env, name);
}
}
public void Type.Java_emitNew(Java_env env, String size) {
throw new Error(this.getClass().getName() +
".Java_emitNew(Java_env env, String size)" +
public void DataType.Java_emitNew(Java_env env, String size) {
throw new Error(this.getClass().getName() +
".Java_emitNew(Java_env env, String size)" +
" not declared");
}
public void ArrayType.Java_emitNew(Java_env env, String size, int depth) {
env.print("new ");
getType().Java_emitTypePrefix(env);
getDataType().Java_emitTypePrefix(env);
env.print("[" + size + "]");
getType().Java_emitTypeSuffix(env);
getDataType().Java_emitTypeSuffix(env);
for (int i = 1 ; i < depth ; i++) {
env.print("[]");
}
}
public void Type.Java_emitTypePrefix(Java_env env) {
throw new Error(this.getClass().getName() +
".Java_emitTypePrefix(Java_env env)" +
public void DataType.Java_emitTypePrefix(Java_env env) {
throw new Error(this.getClass().getName() +
".Java_emitTypePrefix(Java_env env)" +
" not declared");
}
public void PrimType.Java_emitTypePrefix(Java_env env) {
switch (getToken()) {
case LABCOMM_STRING: { env.print("String"); } break;
case LABCOMM_SAMPLE: { env.print("Class"); } break;
default: { env.print(getName()); } break;
}
}
......@@ -632,46 +969,50 @@ aspect Java_Class {
if (Java_needInstance()) {
env.print(getName());
} else {
decl().getType().Java_emitTypePrefix(env);
}
decl().getDataType().Java_emitTypePrefix(env);
}
}
public void ArrayType.Java_emitTypePrefix(Java_env env){
getType().Java_emitTypePrefix(env);
getDataType().Java_emitTypePrefix(env);
}
public void StructType.Java_emitTypePrefix(Java_env env){
env.print(Java_structName());
}
public void Type.Java_emitTypeSuffix(Java_env env) {
public void DataType.Java_emitTypeSuffix(Java_env env) {
}
public void UserType.Java_emitTypeSuffix(Java_env env) {
if (! Java_needInstance()) {
decl().getType().Java_emitTypeSuffix(env);
}
decl().getDataType().Java_emitTypeSuffix(env);
}
}
public void ArrayType.Java_emitTypeSuffix(Java_env env){
getType().Java_emitTypeSuffix(env);
getDataType().Java_emitTypeSuffix(env);
for (int i = 0 ; i < getNumExp() ; i++) {
env.print("[]");
}
}
public boolean Type.Java_needInstance() {
throw new Error(this.getClass().getName() +
".Java_needInstance()" +
public boolean DataType.Java_needInstance() {
throw new Error(this.getClass().getName() +
".Java_needInstance()" +
" not declared");
}
public boolean VoidType.Java_needInstance() {
return false;
}
public boolean PrimType.Java_needInstance() {
return false;
}
public boolean UserType.Java_needInstance() {
return decl().getType().Java_needInstance();
return decl().getDataType().Java_needInstance();
}
public boolean StructType.Java_needInstance() {
......@@ -679,10 +1020,10 @@ aspect Java_Class {
}
public boolean ArrayType.Java_needInstance() {
return getType().Java_needInstance();
return getDataType().Java_needInstance();
}
public boolean Type.Java_isPrimitive() {
public boolean DataType.Java_isPrimitive() {
return false;
}
......@@ -690,9 +1031,9 @@ aspect Java_Class {
return true;
}
public void Type.Java_emitInstance(Java_env env) {
throw new Error(this.getClass().getName() +
".Java_emitInstance(Java_env env)" +
public void DataType.Java_emitInstance(Java_env env) {
throw new Error(this.getClass().getName() +
".Java_emitInstance(Java_env env)" +
" not declared");
}
......@@ -703,7 +1044,7 @@ aspect Java_Class {
}
public void ArrayType.Java_emitInstance(Java_env env) {
getType().Java_emitInstance(env);
getDataType().Java_emitInstance(env);
}
public void StructType.Java_emitInstance(Java_env env) {
......@@ -712,7 +1053,7 @@ aspect Java_Class {
env.indent();
}
for (int i = 0 ; i < getNumField() ; i++) {
getField(i).getType().Java_emitInstance(env);
getField(i).getDataType().Java_emitInstance(env);
}
for (int i = 0 ; i < getNumField() ; i++) {
getField(i).Java_emitField(env);
......@@ -729,13 +1070,13 @@ aspect Java_Class {
public void Field.Java_emitField(Java_env env) {
env.print("public ");
getType().Java_emitType(env);
env.println(" " + getName() + ";");
getDataType().Java_emitType(env);
env.println(" " + getName() + ";");
}
public void Type.Java_emitType(Java_env env) {
throw new Error(this.getClass().getName() +
".Java_emitType(Java_env env)" +
public void DataType.Java_emitType(Java_env env) {
throw new Error(this.getClass().getName() +
".Java_emitType(Java_env env)" +
" not declared");
}
......@@ -746,16 +1087,17 @@ aspect Java_Class {
public void PrimType.Java_emitType(Java_env env) {
switch (getToken()) {
case LABCOMM_STRING: { env.print("String"); } break;
case LABCOMM_SAMPLE: { env.print("Class"); } break;
default: { env.print(getName()); } break;
}
}
public void UserType.Java_emitType(Java_env env) {
decl().getType().Java_emitType(env);
decl().getDataType().Java_emitType(env);
}
public void ArrayType.Java_emitType(Java_env env){
getType().Java_emitType(env);
getDataType().Java_emitType(env);
for (int i = 0 ; i < getNumExp() ; i++) {
env.print("[]");
}
......@@ -764,33 +1106,82 @@ aspect Java_Class {
public void StructType.Java_emitType(Java_env env){
env.print(Java_structName());
}
}
aspect Java_Signature {
public void Signature.Java_emitSignature(Java_env env, boolean decl){
// XXX should sendOnlyFlatSignatures be kept somewhere?
//SignatureList sl = (parentDecl().sendOnlyFlatSignatures(env)) ? getFlatSignatureList() : getSignatureList();
SignatureList sl = getSignatureList();
sl.Java_emitSignature(env, decl);
}
// public void Signature.Java_emitHierarchicalSignature(Java_env env, boolean decl){
// SignatureList sl = getSignatureList();
// sl.Java_emitSignature(env, decl);
// }
//
public abstract void SignatureLine.Java_emitSignature(Java_env env, boolean decl);
public void TypeRefSignatureLine.Java_emitSignature(Java_env env, boolean isDecl){
env.print(getIndentString());
env.println("e.encodePacked32(e.getTypeId("+decl.getName()+".class));");
}
public void DataSignatureLine.Java_emitSignature(Java_env env, boolean decl){
byte[] data = getData(env.version);
if (data != null) {
env.print(getIndentString());
for (int j = 0 ; j < data.length ; j++) {
//env.print("e.encodeByte((byte)"+data[j]+");");
env.print("e.encodeByte((byte)"+ String.format("0x%02X ", data[j]) +"); ");
}
env.println();
}
}
public void SignatureList.Java_emitSignature(Java_env env, boolean decl) {
env.println("private static void emitSignature(Encoder e) throws IOException{");
env.indent();
for (int i = 0 ; i < size() ; i++) {
String comment = getComment(i);
if (comment != null && comment.length() > 0) {
env.println(getIndent(i) + "// " + comment);
}
SignatureLine l = getSignatureLine(i);
l.Java_emitSignature(env, decl);
}
env.println("}");
env.unindent();
}
}
aspect Java_Info {
public void Program.Java_info(PrintStream out) {
Java_env env = new Java_env(out);
public void Specification.Java_info(PrintStream out, int version) {
Java_env env = new Java_env(version, out);
for (int i = 0; i < getNumDecl(); i++) {
getDecl(i).Java_info(env);
}
}
public void Decl.Java_info(Java_env env) {
throw new Error(this.getClass().getName() +
".Java_info(Java_env env)" +
throw new Error(this.getClass().getName() +
".Java_info(Java_env env)" +
" not declared");
}
public void TypeDecl.Java_info(Java_env env) {
env.print("Java,typedef," + getName() + ",");
getType().Java_emitType(env);
env.print(",Java,typedef," + getName() + ",");
getDataType().Java_emitType(env);
env.print(",not_applicable_for_Java");
env.println();
}
public void SampleDecl.Java_info(Java_env env) {
env.print("Java,sample," + getName() + ",");
getType().Java_emitType(env);
env.print(",Java,sample," + getName() + ",");
getDataType().Java_emitType(env);
env.print(",not_applicable_for_Java");
env.println();
}
......
compiler/2014/LabComm.ast 0 → 100644
View file @ d3921882
Specification ::= Decl*;
abstract Decl ::= TypeInstance /Signature/;
TypeInstance ::= DataType Annotations;
Annotations ::= Annotation*;
Annotation ::= <Key:String> <Value:byte[]>;
Intention : Annotation;
DocString : Annotation;
TypeDecl : Decl;
SampleDecl : Decl;
//Signatures are in the abstract grammar, so that
//they can be extended and refined by aspects.
Signature ::= SignatureList FlatSignatureList:SignatureList;
SignatureList ::= SignatureLine*;
abstract SignatureLine ::= <Indent:int> <Comment:String>;
abstract DataSignatureLine : SignatureLine;
ByteArraySignatureLine : DataSignatureLine ::= <Data:byte[]>;
IntSignatureLine : DataSignatureLine ::= <Data:int>;
StringSignatureLine : DataSignatureLine ::= <Data:String>;
IntentionSignatureLine : DataSignatureLine ::= Intention* ;
TypeRefSignatureLine : SignatureLine ::= Decl;
Field : TypeInstance;
abstract DataType;
VoidType : DataType;
//SampleRefType : DataType;
PrimType : DataType ::= <Name:String> <Token:int>;
UserType : DataType ::= <Name:String>;
StructType : DataType ::= Field*;
ParseArrayType : DataType ::= DataType Dim*;
abstract ArrayType : DataType ::= DataType Dim;
VariableArrayType : ArrayType;
FixedArrayType : ArrayType;
Dim ::= Exp*;
abstract Exp;
IntegerLiteral : Exp ::= <Value:String>;
VariableSize : Exp;
compiler/2014/LabComm.java 0 → 100644
View file @ d3921882
package se.lth.control.labcomm2014.compiler;
import java.io.*;
import java.util.*;
public class LabComm {
private static void println(String s) {
System.out.println(s);
}
private static void print_help() {
println("\n Usage: java -jar labcom.jar [options*] FILE");
println("");
println(" --help Shows this help text");
println(" -v Be verbose");
println(" --ver=VERSION Generate code for labcomm VERSION (=2006 or 2014)");
println("[ C options ]");
println(" -C Generates C/H code in FILE.[ch]");
println(" --cprefix=PREFIX Prefixes C types with PREFIX");
println(" --cinclude=FILE Include FILE in generated .c");
println(" --c=CFILE Generates C code in CFILE");
println(" --h=HFILE Generates H code in HFILE");
println("[ C# options]");
println(" --cs Generates C# code in FILE.cs");
println(" --cs=CSFILE Generates C# code in CSFILE");
println(" --csnamespace=NAMESPACE Place C# classes in NAMESPACE");
println("[ Java options ]");
println(" --java=JDIR Generates Java files in JDIR");
println(" --javapackage=PACKAGE Place Java classes in PACKAGE");
println("[ Python options ]");
println(" -P Generates Python code in FILE.py");
println(" --python=PFILE Generates Python code in PFILE");
println("[ RAPID options ]");
println(" --rapid Generates RAPID code in FILE.sys");
println("[ Misc options ]");
println(" --pretty=PFILE Pretty prints to PFILE");
println(" --typeinfo=TIFILE Generates typeinfo in TIFILE");
println(" --typedefs=TIFILE Generates typedefs in TIFILE");
}
/** To be cleaned up.
*/
private static void checkVersion(int v) {
if(! (v == 2006 || v == 2014) ) {
System.err.println(" Unknown version: " + v);
System.err.println(" Supported versions: 2006, 2014 ");
System.exit(2);
}
}
private static void genH(Specification p, String hName,
Vector cIncludes, String coreName, String prefix, int ver) {
try {
FileOutputStream f;
PrintStream out;
f = new FileOutputStream(hName);
out = new PrintStream(f);
p.C_genH(out, cIncludes, coreName, prefix, ver);
out.close();
} catch (IOException e) {
System.err.println("IOException: " + hName + " " + e);
}
}
private static void genC(Specification p, String cName,
Vector cIncludes, String coreName, String prefix, int ver) {
try {
FileOutputStream f;
PrintStream out;
f = new FileOutputStream(cName);
out = new PrintStream(f);
p.C_genC(out, cIncludes, coreName, prefix, ver);
out.close();
} catch (IOException e) {
System.err.println("IOException: " + cName + " " + e);
}
}
private static void genCS(Specification p, String csName, String csNamespace, int ver) {
// throw new Error("C# generation currently disabled");
try {
p.CS_gen(csName, csNamespace, ver);
} catch (IOException e) {
System.err.println("IOException: " + csName + " " +
csNamespace + " " + e);
}
}
private static void genJava(Specification p, String dirName, String packageName, int ver) {
try {
p.J_gen(dirName, packageName, ver);
} catch (IOException e) {
System.err.println("IOException: " + dirName + " " +
packageName + " " + e);
}
}
private static void genPython(Specification p, String filename, String prefix, int ver) {
try {
FileOutputStream f;
PrintStream out;
f = new FileOutputStream(filename);
out = new PrintStream(f);
p.Python_gen(out, prefix, ver);
out.close();
} catch (IOException e) {
System.err.println("IOException: " + filename + " " + e);
}
}
private static void genRAPID(Specification p, String filename, String prefix, int ver) {
try {
p.RAPID_gen(filename, prefix, ver);
} catch (IOException e) {
System.err.println("IOException: " + filename + " " + e);
}
}
/** Helper class to contain command line options
and their associated behaviour
**/
private static class Opts {
final String[] args;
String coreName = null;
String prefix = null;
boolean verbose = false;
int ver = 2014; //Version 2014 as default
String cFile = null;
String hFile = null;
Vector cIncludes = new Vector();
String cPrefix; // gets default value (prefix) in processFilename
String csFile = null;
String csNamespace = null;
String javaDir = null;
String javaPackage = "";
String pythonFile = null;
String prettyFile = null;
String typeinfoFile = null;
String typedefsFile = null;
String rapidFile = null;
String fileName = null;
Opts(String[] args) {
this.args = args;
}
private static String getCoreName(String s) {
int i = s.lastIndexOf('.');
return s.substring(0, i > 0 ? i : s.length());
}
private static String getFileName(String s) {
return s.substring(s.lastIndexOf('/') + 1, s.length());
}
private static String getBaseName(String s) {
s = getFileName(s);
int i = s.lastIndexOf('.');
return s.substring(0, i > 0 ? i : s.length());
}
private static String getPrefix(String s) {
return s.substring(s.lastIndexOf('/') + 1, s.length());
}
boolean processFilename(){
// Scan for first non-option
for (int i = 0 ; i < args.length ; i++) {
if (! args[i].startsWith("-")) {
fileName = args[i];
break;
}
}
if (fileName != null) {
coreName = getBaseName(fileName);
prefix = getPrefix(coreName);
cPrefix = prefix;
}
return fileName != null;
}
void processArgs(){
for (int i = 0 ; i < args.length ; i++) {
if (fileName == null ||
args[i].equals("-help") ||
args[i].equals("-h") ||
args[i].equals("--help")) {
print_help();
System.exit(0);
} else if (args[i].equals("-v")) {
verbose=true;
} else if (args[i].startsWith("--ver=")) {
ver = Integer.parseInt(args[i].substring(6));
checkVersion(ver);
} else if (args[i].equals("-C")) {
cFile = coreName + ".c";
hFile = coreName + ".h";
} else if (args[i].startsWith("--cinclude=")) {
cIncludes.add(args[i].substring(11));
} else if (args[i].startsWith("--cprefix=")) {
cPrefix = args[i].substring(10);
} else if (args[i].startsWith("--c=")) {
cFile = args[i].substring(4);
} else if (args[i].startsWith("--h=")) {
hFile = args[i].substring(4);
} else if (args[i].equals("--cs")) {
csFile = coreName + ".cs";
} else if (args[i].startsWith("--cs=")) {
csFile = args[i].substring(5);
} else if (args[i].startsWith("--csnamespace=")) {
csNamespace = args[i].substring(14);
} else if (args[i].startsWith("--java=")) {
javaDir = args[i].substring(7);
} else if (args[i].startsWith("--javapackage=")) {
javaPackage = args[i].substring(14);
} else if (args[i].equals("-P")) {
pythonFile = coreName + ".py";
} else if (args[i].startsWith("--python=")) {
pythonFile = args[i].substring(9);
} else if (args[i].startsWith("--pretty=")) {
prettyFile = args[i].substring(9);
} else if (args[i].startsWith("--typeinfo=")) {
typeinfoFile = args[i].substring(11);
} else if (args[i].startsWith("--typedefs=")) {
typedefsFile = args[i].substring(11);
} else if (args[i].equals("--rapid")) {
rapidFile = coreName + ".sys";
} else if (i == args.length - 1) {
fileName = args[i];
} else {
System.err.println(" Unknown argument " + args[i]);
print_help();
System.exit(2);
}
}
if(prefix==null){
System.err.println(" WARNING! prefix==null");
prefix="";
}
}
Specification parseFile(){
Specification ast = null;
try {
// Check for errors
LabCommScanner scanner = new LabCommScanner(
new FileReader(fileName));
LabCommParser parser = new LabCommParser();
Specification p = (Specification)parser.parse(scanner);
Collection errors = new LinkedList();
p.errorCheck(errors);
if (errors.isEmpty()) {
ast = p;
} else {
for (Iterator iter = errors.iterator(); iter.hasNext(); ) {
String s = (String)iter.next();
System.out.println(s);
}
}
} catch (FileNotFoundException e) {
System.err.println("Could not find file: " + fileName);
} catch (IOException e) {
System.err.println("IOException: " + fileName + " " + e);
} catch (beaver.Parser.Exception e) {
System.err.println(e.getMessage());
}
return ast;
}
boolean generateC(Specification ast) {
boolean wroteFile = false;
Vector hIncludes = new Vector(cIncludes);
if (hFile != null) {
cIncludes.add(hFile);
}
if (cFile != null) {
printStatus("C: " , cFile);
genC(ast, cFile, cIncludes, coreName, cPrefix, ver);
wroteFile = true;
}
if (hFile != null) {
printStatus("H: " , hFile);
genH(ast, hFile, hIncludes, coreName, cPrefix, ver);
wroteFile = true;
}
return wroteFile;
}
boolean generateCS(Specification ast) {
boolean wroteFile = false;
if (csFile != null) {
printStatus("C#: " , csFile);
genCS(ast, csFile, csNamespace, ver);
wroteFile = true;
}
return wroteFile;
}
boolean generateJava(Specification ast) {
boolean wroteFile = false;
if (javaDir != null) {
printStatus("Java: " , javaDir);
genJava(ast, javaDir, javaPackage, ver);
wroteFile = true;
}
return wroteFile;
}
boolean generatePython(Specification ast) {
boolean wroteFile = false;
if (pythonFile != null) {
printStatus("Python: " , pythonFile);
genPython(ast, pythonFile, prefix, ver);
wroteFile = true;
}
return wroteFile;
}
boolean generateRAPID(Specification ast) {
boolean wroteFile = false;
if (rapidFile != null) {
printStatus("RAPID: " , rapidFile);
genRAPID(ast, rapidFile, coreName, ver);
wroteFile = true;
}
return wroteFile;
}
boolean generatePrettyPrint(Specification ast) {
boolean wroteFile = false;
if (prettyFile != null) {
printStatus("Pretty: " , prettyFile);
try {
FileOutputStream f = new FileOutputStream(prettyFile);
PrintStream out = new PrintStream(f);
ast.pp(out);
out.close();
wroteFile = true;
} catch (IOException e) {
System.err.println("IOException: " + prettyFile + " " + e);
}
}
return wroteFile;
}
boolean generateTypeinfo(Specification ast) {
boolean wroteFile = false;
if (typeinfoFile != null) {
printStatus("TypeInfo: " , typeinfoFile);
try {
FileOutputStream f = new FileOutputStream(typeinfoFile);
PrintStream out = new PrintStream(f);
ast.C_info(out, cPrefix, ver);
ast.Java_info(out, ver);
ast.CS_info(out, csNamespace, ver);
wroteFile = true;
} catch (IOException e) {
System.err.println("IOException: " + typeinfoFile + " " + e);
}
}
return wroteFile;
}
boolean generateTypedefs(Specification ast) {
boolean wroteFile = false;
if (typedefsFile != null) {
printStatus("Typedefs: " , typedefsFile);
try {
FileOutputStream f = new FileOutputStream(typedefsFile);
PrintStream out = new PrintStream(f);
ast.generateTypedefs(out, ver);
wroteFile = true;
} catch (IOException e) {
System.err.println("IOException: " + typedefsFile + " " + e);
}
}
return wroteFile;
}
private void printStatus(String kind, String filename){
if (verbose) {
System.err.println("Generating "+kind+": " + filename);
}
}
}
public static void main(String[] args) {
Opts opts = new Opts(args);
if(!opts.processFilename()) {
print_help();
System.exit(1);
} else {
opts.processArgs();
Specification ast = opts.parseFile();
if (ast != null) {
boolean fileWritten = false;
fileWritten |= opts.generateC(ast);
fileWritten |= opts.generateCS(ast);
fileWritten |= opts.generateJava(ast);
fileWritten |= opts.generatePython(ast);
fileWritten |= opts.generateRAPID(ast);
fileWritten |= opts.generatePrettyPrint(ast);
fileWritten |= opts.generateTypeinfo(ast);
fileWritten |= opts.generateTypedefs(ast);
// if no output to files, prettyprint on stdout
if (!fileWritten) {
ast.pp(System.out);
}
} else {
// Catch-all for compilation errors
System.err.println("Error in specification");
System.exit(3);
}
}
}
}
LabCommParser.parser → compiler/2014/LabCommParser.parser
View file @ d3921882
%header {:
package AST;
package se.lth.control.labcomm2014.compiler;
import se.lth.control.labcomm2014.compiler.*;
:};
%embed {:
public static class SourceError extends Error {
......@@ -14,7 +15,7 @@
s.append(" *** Syntactic error: unexpected token " + Terminals.NAMES[token.getId()]);
throw new SourceError(s.toString());
//super.syntaxError(token);
//throw new RuntimeException(token.getLine(token.getStart()) + ", " +
//throw new RuntimeException(token.getLine(token.getStart()) + ", " +
// token.getColumn(token.getStart()) + ": Syntax Error");
}
public void scannerError(Scanner.Exception e) {
......@@ -33,9 +34,9 @@
}
:};
Program goal =
/* Empty program */ {: return new Program(); :}
| decl_list.l {: return new Program(l); :}
Specification goal =
/* Empty program */ {: return new Specification(); :}
| decl_list.l {: return new Specification(l); :}
;
List decl_list =
......@@ -53,53 +54,68 @@ List var_decl_list =
| var_decl_list.l var_decl.v {: return l.add(v); :}
;
Field var_decl =
type.t IDENTIFIER SEMICOLON {: return new Field(t, IDENTIFIER); :}
| type.t IDENTIFIER dim_list.d SEMICOLON
{: return new Field(new ParseArrayType(t, d), IDENTIFIER); :}
Annotations annotations =
/* empty list */ {: return new Annotations(); :}
| annotation_list.l {: return new Annotations(l); :}
;
TypeDecl type_decl =
TYPEDEF type.t IDENTIFIER SEMICOLON {: return new TypeDecl(t, IDENTIFIER); :}
| TYPEDEF type.t IDENTIFIER dim_list.d SEMICOLON
{: return new TypeDecl(new ParseArrayType(t, d), IDENTIFIER); :}
List annotation_list =
annotation.i {: return new List().add(i); :}
| annotation_list.l annotation.i {: return l.add(i); :}
;
SampleDecl sample_decl =
SAMPLE type.t IDENTIFIER SEMICOLON
{: return new SampleDecl(t, IDENTIFIER); :}
| SAMPLE type.t IDENTIFIER dim_list.d SEMICOLON
{: return new SampleDecl(new ParseArrayType(t, d), IDENTIFIER); :}
| SAMPLE VOID IDENTIFIER SEMICOLON
{: return new SampleDecl(new VoidType(), IDENTIFIER); :}
String key = IDENTIFIER;
String stringliteral = IDENTIFIER | QUOTEDSTRING;
Annotation annotation = intention.i | docstring.d;
Annotation intention = LPAREN key.k COLON stringliteral.v RPAREN {: return new Intention(k,v.getBytes()); :};
Annotation docstring = QUOTEDSTRING.s {: return new DocString(s.substring(1,s.length()-1).getBytes()); :};
TypeInstance type_instance =
annotations.a type.t IDENTIFIER {: return new TypeInstance(t, IDENTIFIER, a); :}
| annotations.a type.t IDENTIFIER dim_list.d
{: return new TypeInstance(new ParseArrayType(t, d), IDENTIFIER, a); :}
;
Type type =
Field var_decl =
type_instance.t SEMICOLON {: return new Field(t); :}
;
TypeDecl type_decl =
TYPEDEF type_instance.t SEMICOLON {: return new TypeDecl(t); :} ;
SampleDecl sample_decl =
SAMPLE type_instance.t SEMICOLON {: return new SampleDecl(t); :} ;
DataType type =
prim_type.p {: return p; :}
| user_type.u {: return u; :}
| struct_type.s {: return s; :}
| void_type.v {: return v; :}
;
PrimType prim_type =
BOOLEAN
PrimType prim_type =
BOOLEAN
{: return new PrimType(BOOLEAN, ASTNode.LABCOMM_BOOLEAN); :}
| BYTE
| BYTE
{: return new PrimType(BYTE, ASTNode.LABCOMM_BYTE); :}
| SHORT
| SHORT
{: return new PrimType(SHORT, ASTNode.LABCOMM_SHORT); :}
| INT
| INT
{: return new PrimType(INT, ASTNode.LABCOMM_INT); :}
| LONG
| LONG
{: return new PrimType(LONG, ASTNode.LABCOMM_LONG); :}
| FLOAT
| FLOAT
{: return new PrimType(FLOAT, ASTNode.LABCOMM_FLOAT); :}
| DOUBLE
| DOUBLE
{: return new PrimType(DOUBLE, ASTNode.LABCOMM_DOUBLE); :}
| STRING
| STRING
{: return new PrimType(STRING, ASTNode.LABCOMM_STRING); :}
| SAMPLE
{: return new PrimType(SAMPLE, ASTNode.LABCOMM_SAMPLE); :}
;
UserType user_type =
UserType user_type =
IDENTIFIER {: return new UserType(IDENTIFIER); :}
;
......@@ -107,6 +123,10 @@ StructType struct_type =
STRUCT LBRACE var_decl_list.l RBRACE {: return new StructType(l); :}
;
VoidType void_type =
VOID {: return new VoidType(); :}
;
List dim_list =
dim.d {: return new List().add(d); :}
| dim_list.l dim.d {: return l.add(d); :}
......@@ -121,7 +141,7 @@ List exp_list =
| exp_list.l COMMA exp.e {: return l.add(e); :}
;
Exp exp =
Exp exp =
INTEGER_LITERAL {: return new IntegerLiteral(INTEGER_LITERAL); :}
| UNDERSCORE {: return new VariableSize(); :}
;
LabCommScanner.flex → compiler/2014/LabCommScanner.flex
View file @ d3921882
package AST;
package se.lth.control.labcomm2014.compiler;
import beaver.Symbol;
import beaver.Scanner;
import AST.LabCommParser.Terminals;
import se.lth.control.labcomm2014.compiler.LabCommParser.Terminals;
%%
%public
%final
%public
%final
%class LabCommScanner
%extends Scanner
%type Symbol
%function nextToken
%type Symbol
%function nextToken
%yylexthrow Scanner.Exception
%unicode
......@@ -44,13 +44,16 @@ Comment = {TraditionalComment}
TraditionalComment = "/*" [^*] ~"*/" | "/*" "*"+ "/" | "/*" "*"+ [^/*] ~"*/"
EndOfLineComment = "//" {InputCharacter}* {LineTerminator}?
Identifier = [:jletter:][:jletterdigit:]*
Identifier = [[:letter:]_]([[:letter:]_[:digit:]])*
StringLiteral = [:jletterdigit:]*
DecimalNumeral = 0 | {NonZeroDigit} {Digits}?
DecimalNumeral = 0 | {NonZeroDigit} {Digits}?
Digits = {Digit}+
Digit = 0 | {NonZeroDigit}
NonZeroDigit = [1-9]
QuotedString = "\""~"\""
%%
<YYINITIAL> {
......@@ -76,10 +79,14 @@ NonZeroDigit = [1-9]
"}" { return sym(Terminals.RBRACE); }
"[" { return sym(Terminals.LBRACK); }
"]" { return sym(Terminals.RBRACK); }
"(" { return sym(Terminals.LPAREN); }
")" { return sym(Terminals.RPAREN); }
";" { return sym(Terminals.SEMICOLON); }
":" { return sym(Terminals.COLON); }
"," { return sym(Terminals.COMMA); }
{Identifier} { return sym(Terminals.IDENTIFIER); }
{QuotedString} { return sym(Terminals.QUOTEDSTRING); }
}
// fall through errors
......
compiler/2014/LabCommTokens.jrag 0 → 100644
View file @ d3921882
aspect LabCommTokens {
public static final int ASTNode.LABCOMM_VERSION = 0x01;
public static final int ASTNode.LABCOMM_SAMPLE_DEF = 0x02; // The flat signature
public static final int ASTNode.LABCOMM_SAMPLE_REF = 0x03;
public static final int ASTNode.LABCOMM_TYPE_DEF = 0x03; // and type declarations, hierarchically
public static final int ASTNode.LABCOMM_TYPE_BINDING=0x05;
public static final int ASTNode.LABCOMM_ARRAY = 0x10;
public static final int ASTNode.LABCOMM_STRUCT = 0x11;
public static final int ASTNode.LABCOMM_BOOLEAN = 0x20;
public static final int ASTNode.LABCOMM_BYTE = 0x21;
public static final int ASTNode.LABCOMM_SHORT = 0x22;
public static final int ASTNode.LABCOMM_INT = 0x23;
public static final int ASTNode.LABCOMM_LONG = 0x24;
public static final int ASTNode.LABCOMM_FLOAT = 0x25;
public static final int ASTNode.LABCOMM_DOUBLE = 0x26;
public static final int ASTNode.LABCOMM_STRING = 0x27;
public static final int ASTNode.LABCOMM_SAMPLE = 0x28;
}
NameAnalysis.jrag → compiler/2014/NameAnalysis.jrag
View file @ d3921882
......@@ -2,7 +2,7 @@
aspect NameAnalysis {
inh String Decl.lookupName(String name);
eq Program.getDecl(int index).lookupName(String name) {
eq Specification.getDecl(int index).lookupName(String name) {
for (int i = 0; i < index; i++) {
String s = getDecl(i).getName();
if (s.equals(name)) {
......@@ -24,7 +24,7 @@ aspect NameAnalysis {
inh TypeDecl Decl.lookupType(String name);
inh TypeDecl UserType.lookupType(String name);
eq Program.getDecl(int index).lookupType(String name) {
eq Specification.getDecl(int index).lookupType(String name) {
for(int i = 0; i < index; i++) {
Decl d = getDecl(i);
if(d instanceof TypeDecl && d.getName().equals(name)) {
......@@ -34,7 +34,10 @@ aspect NameAnalysis {
return null;
}
syn TypeDecl UserType.decl() = lookupType(getName());
syn TypeDecl DataType.decl();
eq DataType.decl() = null;
eq UserType.decl() = lookupType(getName());
eq PrimType.decl() = null; //HERE BE DRAGONS XXX
public void ASTNode.nameCheck() {
......
PrettyPrint.jrag → compiler/2014/PrettyPrint.jrag
View file @ d3921882
......@@ -6,7 +6,7 @@ aspect PPIndentation {
inh String Field.pp_indent();
inh String StructType.pp_indent();
eq StructType.getField(int index).pp_indent() = pp_indent() + " ";
eq Program.getDecl(int index).pp_indent() = "";
eq Specification.getDecl(int index).pp_indent() = "";
}
......@@ -18,7 +18,7 @@ aspect PrettyPrint {
" not declared");
}
public void Program.pp(PrintStream out) {
public void Specification.pp(PrintStream out) {
for(int i = 0; i < getNumDecl(); i++) {
getDecl(i).pp(out);
}
......@@ -27,24 +27,24 @@ aspect PrettyPrint {
// Pretty print declarations
public void TypeDecl.pp(PrintStream out) {
out.print("typedef ");
getType().ppIdentifier(out, getName());
getDataType().ppIdentifier(out, getName());
out.println(";");
}
public void SampleDecl.pp(PrintStream out) {
out.print("sample ");
getType().ppIdentifier(out, getName());
getDataType().ppIdentifier(out, getName());
out.println(";");
}
public void Field.pp(PrintStream out) {
out.print(pp_indent());
getType().ppIdentifier(out, getName());
getDataType().ppIdentifier(out, getName());
out.println(";");
}
// Pretty print variable of a given type
public void Type.ppIdentifier(PrintStream out, String id) {
public void DataType.ppIdentifier(PrintStream out, String id) {
ppPrefix(out);
out.print(" ");
out.print(id);
......@@ -58,7 +58,7 @@ aspect PrettyPrint {
}
// PrettyPrint prefix type info
public void Type.ppPrefix(PrintStream out) {
public void DataType.ppPrefix(PrintStream out) {
throw new Error(this.getClass().getName() +
".ppPrefix(PrintStream out)" +
" not declared");
......@@ -68,6 +68,10 @@ aspect PrettyPrint {
out.print("void");
}
// public void SampleRefType.ppPrefix(PrintStream out) {
// out.print("sample");
// }
public void PrimType.ppPrefix(PrintStream out) {
out.print(getName());
}
......@@ -77,7 +81,7 @@ aspect PrettyPrint {
}
public void ArrayType.ppPrefix(PrintStream out) {
getType().ppPrefix(out);
getDataType().ppPrefix(out);
}
public void StructType.ppPrefix(PrintStream out) {
......@@ -90,7 +94,7 @@ aspect PrettyPrint {
}
// PrettyPrint suffix type info (array dimensions)
public void Type.ppSuffix(PrintStream out) { }
public void DataType.ppSuffix(PrintStream out) { }
public void ArrayType.ppSuffix(PrintStream out) {
out.print("[");
......@@ -99,7 +103,7 @@ aspect PrettyPrint {
getExp(i).pp(out);
}
out.print("]");
getType().ppSuffix(out);
getDataType().ppSuffix(out);
}
public void IntegerLiteral.pp(PrintStream out) {
......
compiler/2014/Python_CodeGen.jrag 0 → 100644
View file @ d3921882
aspect Python_CodeGenEnv {
// Environment wrapper for Python code generation
// handles qualid nesting, indentation, file writing and
// prefix propagation
public class Python_env extends PrintEnv {
final private class Python_printer extends PrintEnv.Printer {
// public C_printer(PrintStream out) {
// super(out, " ");
// }
}
public Python_env(PrintStream out) {
super(out);
}
}
}
aspect Python_CodeGen {
public void Specification.Python_gen(PrintStream out, String baseName, int version) {
Python_env env = new Python_env(out);
env.println("#!/usr/bin/python");
env.println("# Auto generated " + baseName);
env.println();
env.println("import labcomm2014");
env.println();
Python_genTypes(env);
env.println("typedef = tuple([");
env.indent();
for (int i = 0 ; i < getNumDecl() ; i++) {
getDecl(i).Python_genTypedefListEntry(env);
}
env.unindent();
env.println("])");
env.println("sample = tuple([");
env.indent();
for (int i = 0 ; i < getNumDecl() ; i++) {
getDecl(i).Python_genSampleListEntry(env);
}
env.unindent();
env.println("])");
}
}
aspect PythonTypes {
public void Specification.Python_genTypes(Python_env env) {
for (int i = 0 ; i < getNumDecl() ; i++) {
getDecl(i).Python_genSignatureAndTypedef(env);
}
}
public void Decl.Python_genSignatureAndTypedef(Python_env env) {
throw new Error(this.getClass().getName() +
".Python_genSignatureAndTypedef(Python_env env)" +
" not declared");
}
public void TypeDecl.Python_genSignatureAndTypedef(Python_env env) {
env.println("class " + getName() + "(object):");
env.indent();
env.print("typedef = labcomm2014.typedef(");
Python_genIntentions(env);
env.println(",");
env.indent();
getTypeInstance().Python_genTypedef(env);
env.unindent();
env.println(")");
env.unindent();
env.println();
}
public void SampleDecl.Python_genSignatureAndTypedef(Python_env env) {
env.println("class " + getName() + "(object):");
env.indent();
env.print("signature = labcomm2014.sample(");
Python_genIntentions(env);
env.println(",");
env.indent();
getDataType().Python_genSignature(env);
env.unindent();
env.println(")");
env.print("typedef = labcomm2014.sample(");
Python_genIntentions(env);
env.println(",");
env.indent();
getTypeInstance().Python_genTypedef(env);
env.unindent();
env.println(")");
env.unindent();
env.println();
}
public void Decl.Python_genIntentions(Python_env env) {
getTypeInstance().Python_genIntentions(env);
}
public void TypeInstance.Python_genIntentions(Python_env env) {
// env.print("{");
// for(Intention i : sortedIntentions()) {
// env.print("'"+i.getKey()+"':'"+new String(i.getValue())+"', ");
// }
// env.print("}");
env.print("tuple((");
for(Intention i : sortedIntentions()) {
env.print("('"+i.getKey()+"','"+new String(i.getValue())+"'), ");
}
env.print("))");
}
public void TypeInstance.Python_genTypedef(Python_env env) {
getDataType().Python_genTypedef(env);
}
public void UserType.Python_genSignature(Python_env env) {
lookupType(getName()).getDataType().Python_genSignature(env);
}
public void DataType.Python_genSignature(Python_env env) {
throw new Error(this.getClass().getName() +
".Python_genSignature(Python_env env)" +
" not declared");
}
public void PrimType.Python_genSignature(Python_env env) {
switch (getToken()) {
case LABCOMM_BOOLEAN: { env.print("labcomm2014.BOOLEAN()"); } break;
case LABCOMM_BYTE: { env.print("labcomm2014.BYTE()"); } break;
case LABCOMM_SHORT: { env.print("labcomm2014.SHORT()"); } break;
case LABCOMM_INT: { env.print("labcomm2014.INTEGER()"); } break;
case LABCOMM_LONG: { env.print("labcomm2014.LONG()"); } break;
case LABCOMM_FLOAT: { env.print("labcomm2014.FLOAT()"); } break;
case LABCOMM_DOUBLE: { env.print("labcomm2014.DOUBLE()"); } break;
case LABCOMM_STRING: { env.print("labcomm2014.STRING()"); } break;
case LABCOMM_SAMPLE: { env.print("labcomm2014.SAMPLE()"); } break;
}
}
public void ArrayType.Python_genSignature(Python_env env) {
env.print("labcomm2014.array([");
for (int i = 0 ; i < getNumExp() ; i++) {
if (i > 0) { env.print(", "); }
env.print(getExp(i).Python_getValue());
}
env.println("],");
env.indent();
getDataType().Python_genSignature(env);
env.print(")");
env.unindent();
}
public void StructType.Python_genSignature(Python_env env) {
env.println("labcomm2014.struct([");
env.indent();
for (int i = 0 ; i < getNumField() ; i++) {
if (i > 0) { env.println(","); }
getField(i).Python_genSignature(env);
}
env.print("])");
env.unindent();
}
public void VoidType.Python_genSignature(Python_env env) {
env.println("labcomm2014.struct([])");
}
public void Field.Python_genSignature(Python_env env) {
env.print("(");
Python_genIntentions(env);
env.print(", ");
getDataType().Python_genSignature(env);
env.print(")");
}
public void UserType.Python_genTypedef(Python_env env) {
env.println(getName() + ".typedef");
}
public void DataType.Python_genTypedef(Python_env env) {
throw new Error(this.getClass().getName() +
".Python_genTypedef(Python_env env)" +
" not declared");
}
public void PrimType.Python_genTypedef(Python_env env) {
switch (getToken()) {
case LABCOMM_BOOLEAN: { env.print("labcomm2014.BOOLEAN()"); } break;
case LABCOMM_BYTE: { env.print("labcomm2014.BYTE()"); } break;
case LABCOMM_SHORT: { env.print("labcomm2014.SHORT()"); } break;
case LABCOMM_INT: { env.print("labcomm2014.INTEGER()"); } break;
case LABCOMM_LONG: { env.print("labcomm2014.LONG()"); } break;
case LABCOMM_FLOAT: { env.print("labcomm2014.FLOAT()"); } break;
case LABCOMM_DOUBLE: { env.print("labcomm2014.DOUBLE()"); } break;
case LABCOMM_STRING: { env.print("labcomm2014.STRING()"); } break;
case LABCOMM_SAMPLE: { env.print("labcomm2014.SAMPLE()"); } break;
}
}
public void ArrayType.Python_genTypedef(Python_env env) {
env.print("labcomm2014.array([");
for (int i = 0 ; i < getNumExp() ; i++) {
if (i > 0) { env.print(", "); }
env.print(getExp(i).Python_getValue());
}
env.println("],");
env.indent();
getDataType().Python_genTypedef(env);
env.print(")");
env.unindent();
}
public void StructType.Python_genTypedef(Python_env env) {
env.println("labcomm2014.struct([");
env.indent();
for (int i = 0 ; i < getNumField() ; i++) {
if (i > 0) { env.println(","); }
getField(i).Python_genTypedef(env);
}
env.print("])");
env.unindent();
}
public void VoidType.Python_genTypedef(Python_env env) {
env.println("labcomm2014.struct([])");
}
public void Field.Python_genTypedef(Python_env env) {
env.print("(");
Python_genIntentions(env);
env.print(", ");
getDataType().Python_genTypedef(env);
env.print(")");
}
public void Decl.Python_genTypedefListEntry(Python_env env) {
}
public void TypeDecl.Python_genTypedefListEntry(Python_env env) {
env.println(getName() + ",");
}
public void Decl.Python_genSampleListEntry(Python_env env) {
}
public void SampleDecl.Python_genSampleListEntry(Python_env env) {
env.println(getName()+ ",");
}
public String Exp.Python_getValue() {
throw new Error(this.getClass().getName() +
".Python_getValue()" +
" not declared");
}
public String IntegerLiteral.Python_getValue() {
return getValue();
}
public String VariableSize.Python_getValue() {
return "0";
}
}
compiler/2014/RAPID_CodeGen.jrag 0 → 100644
View file @ d3921882
aspect RAPID_env {
public class RAPID_env {
public final int version;
private String prefix;
private StringBuilder types;
private StringBuilder constants;
private StringBuilder procedures;
private PrintStream ps;
public RAPID_env(PrintStream ps, String prefix, int version)
{
this.version = version;
this.types = new StringBuilder();
this.constants = new StringBuilder();
this.procedures = new StringBuilder();
this.prefix = prefix;
this.ps = ps;
}
public String prefix() { return this.prefix; }
public String addRecord(String name, java.util.List<String> components)
{
String recordName = this.prefix + "_" + name;
types.append("\tRECORD " + recordName);
types.append("\n");
for (String c : components) {
types.append("\t\t" + c + "\n");
}
types.append("\tENDRECORD");
types.append("\n\n");
return recordName;
}
public void addConstant(String type, String name, String value) {
this.constants.append("\tLOCAL CONST " + type + " " + name +
" := " + value + ";\n");
}
public void addProc(String name, java.util.List<String> params,
java.util.List<String> stmts)
{
this.procedures.append("\tLOCAL PROC " + name + "(");
for (int i = 0; i < params.size(); i++) {
this.procedures.append(params.get(i));
if (i < params.size() - 1) {
this.procedures.append(", ");
}
}
this.procedures.append(")\n");
for (String stmt : stmts) {
this.procedures.append("\t\t" + stmt + "\n");
}
this.procedures.append("\tERROR\n\t\tRAISE ;\n\tENDPROC\n\n");
}
public void flush()
{
ps.println("MODULE " + prefix() + "(SYSMODULE)");
ps.println();
ps.print(types.toString());
ps.println();
ps.println("\tLOCAL CONST string prefix:=\"" + this.prefix + "\";");
ps.print(constants.toString());
ps.println();
ps.print(procedures.toString());
ps.println();
ps.print("ENDMODULE");
}
}
}
aspect RAPID_CodeGen {
public void ASTNode.RAPID_gen(RAPID_env env) {
throw new UnsupportedOperationException();
}
public void Specification.RAPID_gen(String file, String prefix, int version)
throws IOException
{
PrintStream ps = new PrintStream(new FileOutputStream(new File(file)));
RAPID_env env = new RAPID_env(ps, prefix, version);
RAPID_gen(env);
}
public void Specification.RAPID_gen(RAPID_env env)
{
for (int i = 0; i < getNumDecl(); i++) {
getDecl(i).RAPID_gen(env);
}
env.flush();
}
public void Decl.RAPID_gen(RAPID_env env) {
throw new UnsupportedOperationException("RAPID code generation (currently) does not support "+getClass().getSimpleName());
}
public void TypeDecl.RAPID_gen(RAPID_env env) {
System.out.println("***WARNING! TypeDecl.RapidGen(.) a NOP after sig reorganization.");
System.out.println(" (Tell a developer to) remove this warning when tested");
}
public void Decl.RAPID_emitFlatSignature(RAPID_env env, String sig_len_name, String sig_name) {
System.out.println("***WARNING! Code not tested after reorganization of signatures.");
System.out.println(" (Tell a developer to) remove this warning when tested");
SignatureList sig = flatSignature(env.version);
StringBuilder sb = new StringBuilder();
sb.append("[");
byte[] d = null;
int sig_len = 0;
for (int i = 0; i < sig.size(); i++) {
d = sig.getData(i, env.version);
for (int j = 0; d != null && j < d.length; j++) {
sb.append(d[j] + ",");
sig_len++;
}
}
sb.delete(sb.length() - 1, sb.length());
sb.append("]");
env.addConstant("num", sig_len_name, "" + sig_len);
env.addConstant("byte", sig_name + "{" + sig_len_name + "}",
sb.toString());
}
public void SampleDecl.RAPID_gen(RAPID_env env) {
// Add type declarations
String fullName = getDataType().RAPID_AddType(env, getName());
// Add signature constants
String sig_len_name = "signature_len_" + getName();
String sig_name = "signature_" + getName();
RAPID_emitFlatSignature(env, sig_len_name, sig_name);
// Add decode procedures
ArrayList<String> params = new ArrayList<String>();
ArrayList<String> stmts = new ArrayList<String>();
params.add("VAR LabComm_Decoder_Sample s");
params.add("string handler");
stmts.add("s.prefix := prefix;");
stmts.add("s.name := \"" + getName() + "\";");
stmts.add("s.handler := handler;");
env.addProc("Dec_Reg_" + getName(), params, stmts);
params.clear();
stmts.clear();
params.add("VAR LabComm_Decoder_Sample s");
params.add("VAR rawbytes sig");
params.add("num user_id");
stmts.add("VAR byte tmp_sig{" + sig_len_name + "};");
stmts.add("IF RawBytesLen(sig)<>" + sig_len_name + " THEN");
stmts.add("\tRETURN;");
stmts.add("ENDIF");
stmts.add("FOR i FROM 1 TO " + sig_len_name + " DO");
stmts.add("\tUnpackRawBytes sig, i, tmp_sig{i}, \\Hex1;");
stmts.add("ENDFOR");
stmts.add("IF tmp_sig<>" + sig_name + " THEN");
stmts.add("\tRETURN;");
stmts.add("ENDIF");
stmts.add("s.user_id := user_id;");
env.addProc("Reg_If_Signature_Of_" + getName(), params, stmts);
params.clear();
stmts.clear();
params.add("VAR Decoder d");
params.add("VAR LabComm_Stream st");
params.add("VAR LabComm_Decoder_Sample s");
stmts.add("VAR " + fullName + " tmp;");
getDataType().RAPID_AddDecodeInstr(env, stmts, "tmp", "st");
stmts.add("% s.handler % tmp;");
env.addProc("Decode_And_Handle_" + getName(), params, stmts);
params.clear();
stmts.clear();
params.add("VAR Encoder e");
params.add("VAR LabComm_Stream st");
params.add("VAR LabComm_Encoder_Sample s");
stmts.add("s.prefix := prefix;");
stmts.add("s.name := \"" + getName() + "\";");
stmts.add("Encoder_Register_Sample e, st, s;");
env.addProc("Enc_Reg_" + getName(), params, stmts);
params.clear();
stmts.clear();
params.add("VAR Encoder e");
params.add("VAR LabComm_Stream s");
stmts.add("VAR rawbytes buffer;");
stmts.add("FOR i FROM 1 TO " + sig_len_name + " DO");
stmts.add("\tPackRawBytes " + sig_name +
"{i}, buffer, \\Network, i, \\Hex1;");
stmts.add("ENDFOR");
stmts.add("SocketSend s.soc, \\RawData:=buffer, \\NoOfBytes:=" +
sig_len_name + ";");
env.addProc("Encode_Signature_" + getName(), params, stmts);
params.clear();
stmts.clear();
params.add("VAR Encoder e");
params.add("VAR LabComm_Stream st");
params.add("VAR LabComm_Encoder_Sample s");
params.add("VAR " + fullName + " val");
stmts.add("Encode_Packed st, s.user_id;");
getDataType().RAPID_AddEncodeInstr(env, stmts, "val", "st");
env.addProc("Encode_" + getName(), params, stmts);
}
public String DataType.RAPID_AddType(RAPID_env env, String name) {
throw new UnsupportedOperationException("RAPID code generation does (currently) not support "+getClass().getSimpleName());
}
public String StructType.RAPID_AddType(RAPID_env env, String name) {
ArrayList<String> components = new ArrayList<String>();
for (int i = 0; i < getNumField(); i++) {
Field f = getField(i);
components.add(
f.getDataType().RAPID_AddType(env, name + "_" + f.getName()) +
" " + f.getName() + ";");
}
String typeName = env.addRecord(name, components);
return typeName;
}
public String FixedArrayType.RAPID_AddType(RAPID_env env, String name) {
String typeName = getDataType().RAPID_AddType(env, name + "_e");
if (getNumExp() > 1) {
throw new UnsupportedOperationException("RAPID generation only (currently) supports one-dimensional arrays");
}
ArrayList<String> components = new ArrayList<String>();
for (int i = 1; i <= getExp(0).RAPID_getValue(); i++) {
components.add(typeName + " e" + i + ";");
}
String completeName = env.addRecord("list_" + name, components);
return completeName;
}
public String PrimType.RAPID_AddType(RAPID_env env, String name) {
if (getToken() == LABCOMM_SHORT ||
getToken() == LABCOMM_FLOAT ||
getToken() == LABCOMM_INT) {
return "num";
} else if (getToken() == LABCOMM_LONG) {
return "dnum";
} else if (getToken() == LABCOMM_STRING) {
return "string";
} else if (getToken() == LABCOMM_BOOLEAN) {
return "bool";
} else if (getToken() == LABCOMM_BYTE) {
return "byte";
}
throw new UnsupportedOperationException("RAPID code generation does not (currently) support "+getName());
}
public void DataType.RAPID_AddDecodeInstr(RAPID_env env,
java.util.List<String> instrs,
String var_name, String stream_name) {
throw new UnsupportedOperationException("RAPID code generation does not (currently) support "+getClass().getSimpleName());
}
public void StructType.RAPID_AddDecodeInstr(RAPID_env env,
java.util.List<String> instrs,
String var_name, String stream_name) {
for (int i = 0; i < getNumField(); i++) {
getField(i).getDataType().RAPID_AddDecodeInstr(env, instrs,
var_name + "." + getField(i).getName(), stream_name);
}
}
public void FixedArrayType.RAPID_AddDecodeInstr(RAPID_env env,
java.util.List<String> instrs,
String var_name, String stream_name) {
for (int i = 1; i <= getExp(0).RAPID_getValue(); i++) {
getDataType().RAPID_AddDecodeInstr(env, instrs,
var_name + ".e" + i, stream_name);
}
}
public void PrimType.RAPID_AddDecodeInstr(RAPID_env env,
java.util.List<String> instrs,
String var_name, String stream_name) {
switch(getToken()) {
case LABCOMM_BYTE:
instrs.add("Decode_Byte " + stream_name + "," + var_name + ";");
break;
case LABCOMM_BOOLEAN:
instrs.add("Decode_Bool " + stream_name + "," + var_name + ";");
break;
case LABCOMM_SHORT:
instrs.add("Decode_Short " + stream_name + "," + var_name + ";");
break;
case LABCOMM_INT:
instrs.add("Decode_Int " + stream_name + "," + var_name + ";");
break;
case LABCOMM_LONG:
instrs.add("Decode_Long " + stream_name + "," + var_name + ";");
break;
case LABCOMM_FLOAT:
instrs.add("Decode_Float " + stream_name + "," + var_name + ";");
break;
case LABCOMM_STRING:
instrs.add("Decode_String " + stream_name + "," + var_name + ";");
break;
default:
throw new UnsupportedOperationException("RAPID code generation does not (currently) support "+getName());
}
}
public void DataType.RAPID_AddEncodeInstr(RAPID_env env,
java.util.List<String> instrs,
String var_name, String stream_name) {
throw new UnsupportedOperationException("RAPID code generation does not (currently) support "+getClass().getSimpleName());
}
public void StructType.RAPID_AddEncodeInstr(RAPID_env env,
java.util.List<String> instrs,
String var_name, String stream_name) {
for (int i = 0; i < getNumField(); i++) {
getField(i).getDataType().RAPID_AddEncodeInstr(env, instrs,
var_name + "." + getField(i).getName(), stream_name);
}
}
public void FixedArrayType.RAPID_AddEncodeInstr(RAPID_env env,
java.util.List<String> instrs,
String var_name, String stream_name) {
for (int i = 1; i <= getExp(0).RAPID_getValue(); i++) {
getDataType().RAPID_AddEncodeInstr(env, instrs,
var_name + ".e" + i, stream_name);
}
}
public void PrimType.RAPID_AddEncodeInstr(RAPID_env env,
java.util.List<String> instrs,
String var_name, String stream_name) {
switch(getToken()) {
case LABCOMM_BYTE:
instrs.add("Encode_Byte " + stream_name + "," + var_name + ";");
break;
case LABCOMM_BOOLEAN:
instrs.add("Encode_Bool " + stream_name + "," + var_name + ";");
break;
case LABCOMM_SHORT:
instrs.add("Encode_Short " + stream_name + "," + var_name + ";");
break;
case LABCOMM_INT:
instrs.add("Encode_Int " + stream_name + "," + var_name + ";");
break;
case LABCOMM_LONG:
instrs.add("Encode_Long " + stream_name + "," + var_name + ";");
break;
case LABCOMM_FLOAT:
instrs.add("Encode_Float " + stream_name + "," + var_name + ";");
break;
case LABCOMM_STRING:
instrs.add("Encode_String " + stream_name + "," + var_name + ";");
break;
default:
throw new UnsupportedOperationException("RAPID code generation does not (currently) support "+getName());
}
}
public int Exp.RAPID_getValue() {
throw new UnsupportedOperationException("RAPID code generation does not (currently) support "+getClass().getSimpleName());
}
public int IntegerLiteral.RAPID_getValue() {
return Integer.parseInt(getValue());
}
}
compiler/2014/Refactoring.jrag 0 → 100644
View file @ d3921882
/* Temporary aspect with forwarding methods */
aspect Refactoring {
syn int ArrayType.getNumExp() = getDim().getNumExp();
syn Exp ArrayType.getExp(int i) = getDim().getExp(i);
syn String Decl.getName() = getTypeInstance().getName();
syn DataType Decl.getDataType() = getTypeInstance().getDataType();
syn String TypeInstance.getName() = getAnnotations().getName();
public Annotations Annotations.addName(String n) {
//XXX TODO: check if name already exists
addAnnotation(new Intention("",n.getBytes()));
return this;
}
public Field.Field(TypeInstance t) {
this(t.getDataType(), t.getAnnotations());
}
public TypeInstance.TypeInstance(DataType t, String n, Annotations a) {
this(t, a.addName(n));
}
public TypeInstance.TypeInstance(DataType t, String n) {
this(t, new Annotations().addName(n));
System.out.println("WARNING! TypeInstance(DataType, String) ignoring intention list");
}
syn Annotation TypeInstance.getAnnotation(int i) = getAnnotations().getAnnotation(i);
}
compiler/2014/Signature.jrag 0 → 100644
View file @ d3921882
import java.util.*;
aspect Signature {
syn boolean Decl.isSampleDecl();
eq TypeDecl.isSampleDecl() = false;
eq SampleDecl.isSampleDecl() = true;
syn boolean Decl.sendOnlyFlatSignatures(Java_env env) = (env.version==2006);
eq Decl.getSignature().parentDecl() = this;
eq Signature.getSignatureList().parentDecl() = parentDecl();
inh Decl Signature.parentDecl();
inh Decl SignatureList.parentDecl();
syn nta Signature Decl.getSignature() {
SignatureList sl = new SignatureList();
genSigLineForDecl(sl, true, this);
SignatureList fsl = new SignatureList();
flatSignature(fsl);
Signature sig = new Signature();
sig.setSignatureList(sl);
sig.setFlatSignatureList(fsl);
setSignature(sig);
return sig;
}
public String SignatureLine.getIndentString() {
StringBuffer result = new StringBuffer();
int indent = getIndent();
for (int i = 0 ; i < indent ; i++) {
result.append(" ");
}
return result.toString();
}
syn byte[] SignatureLine.getData(int version) = null;
// return new byte[0];
private Decl TypeRefSignatureLine.decl;
public TypeRefSignatureLine.TypeRefSignatureLine(int indent, Decl decl, String comment) {
super(indent, comment);
this.decl = decl;
}
public void SignatureList.addTypeRef(Decl type, String comment) {
addSignatureLine(new TypeRefSignatureLine(indent, type, comment));
}
public ByteArraySignatureLine.ByteArraySignatureLine(int indent, byte[] data, String comment) {
super(indent, comment);
setData(data);
}
public IntSignatureLine.IntSignatureLine(int indent, int data, String comment) {
super(indent, comment);
setData(data);
}
public void SignatureList.add(byte[] data, String comment) {
addSignatureLine(new ByteArraySignatureLine(indent, data, comment));
}
public void SignatureList.addInt(int data, String comment) {
addSignatureLine(new IntSignatureLine(indent, data, comment));
}
protected byte[] DataSignatureLine.getIntBytes(int value, int version) {
byte data[];
switch(version) {
case 2006: // Use old encoding with 32 bit integers
data = new byte[4];
for (int i = 0 ; i < 4 ; i++) {
data[3 - i] = (byte)((value >> (8 * i)) & 0xff);
}
//add(data, comment);
break;
case 2014: // Use new encoding with varints
byte[] tmp = new byte[5];
long v = value & 0xffffffff;
int i, j;
for (i = 0 ; i == 0 || v != 0 ; i++, v = (v >> 7)) {
tmp[i] = (byte)(v & 0x7f);
}
byte[] packed = new byte[i];
for (i = i - 1, j = 0 ; i >= 0 ; i--, j++) {
packed[j] = (byte)(tmp[i] | (i!=0?0x80:0x00));
}
//add(packed, comment);
data = packed;
break;
default:
throw new RuntimeException("Unsupported version = "+version+". This should never happen.");
}
return data;
}
eq IntSignatureLine.getData(int version) {
return getIntBytes(getData(), version);
}
public void SignatureList.addIntentions(Set<Intention> data, String comment) {
//addString(TypeInstance.getIntentionString(data), comment);
//create IntenionSignatureLine
IntentionSignatureLine line = new IntentionSignatureLine(indent, comment, new List());
//TODO: refactor out creation of sorted list of intentions
java.util.ArrayList<Intention> sorted = new ArrayList(data);
java.util.Collections.sort(sorted, TypeInstance.intentionComp);
for(Intention i : sorted) {
line.addIntention(i);
}
addSignatureLine(line);
}
eq IntentionSignatureLine.getData(int version) {
//String tmpString = TypeInstance.getIntentionString(getIntentions());
byte[] bs = TypeInstance.getIntentionBytes(getIntentions());
return bs;
}
public void SignatureList.addString(String data, String comment) {
addSignatureLine(new StringSignatureLine(indent, comment, data));
}
eq StringSignatureLine.getData(int version) {
byte[] lenBytes = getIntBytes(getData().length(), version);
byte[] data = new byte[lenBytes.length+getData().length()];
// first add the encoded length
for (int i = 0 ; i < lenBytes.length ; i++) {
data[i] = lenBytes[i];
}
// and then the actual chars
for (int i = 0 ; i < getData().length() ; i++) {
int idx = lenBytes.length + i;
data[idx] = (byte)(getData().charAt(i) & 0xff);
}
return data;
}
public int SignatureList.size() {
return getNumSignatureLine();
}
public String SignatureList.getIndent(int i) {
StringBuffer result = new StringBuffer();
int indent = getSignatureLine(i).getIndent();
for (i = 0 ; i < indent ; i++) {
result.append(" ");
}
return result.toString();
}
public byte[] SignatureList.getData(int i, int version) {
return getSignatureLine(i).getData(version);
}
public String SignatureList.getComment(int i) {
return getSignatureLine(i).getComment();
}
private int SignatureList.indent;
public void SignatureList.indent() {
indent++;
}
public void SignatureList.unindent() {
indent--;
}
public void ASTNode.genSigLineForDecl(SignatureList list, boolean decl, ASTNode inst) {
throw new Error(this.getClass().getName() +
".genSigLineForDecl(SignatureList list)" +
" not declared");
}
public String TypeInstance.getIntentionString() {
return getIntentionString(intentions());
}
public static String TypeInstance.getIntentionString(List<Intention> intentions) {
if(intentions==null) return "";
Iterator<Intention> it = intentions.iterator();
return getIntentionString(it);
}
public static String TypeInstance.getIntentionString(Set<Intention> intentions) {
if(intentions==null) return "";
Iterator<Intention> it = intentions.iterator();
return getIntentionString(it);
}
public static String TypeInstance.getIntentionString(Iterator<Intention> it) {
StringBuilder sb = new StringBuilder();
while(it.hasNext()) {
Intention i = it.next();
sb.append(i.toString());
}
return sb.toString();
}
syn byte[] Intention.keyBytes() = getKey().getBytes();
syn byte[] Intention.valBytes() = getValue();
syn byte[] Intention.toByteArray() {
byte[] k = keyBytes();
byte[] v = valBytes();
int klen = Utilities.size_packed32(k.length);
int vlen = Utilities.size_packed32(v.length);
int tlen = k.length + v.length + Utilities.size_packed32(klen) + Utilities.size_packed32(vlen);
//int size = Utilities.size_packed32(tlen)+tlen;
byte result[] = new byte[tlen];
int pos=0;
// pos = Utilities.encodePacked32(tlen, result, pos, Utilities.size_packed32(tlen));
pos = Utilities.encodePacked32(k.length, result, pos, klen);
for(byte kb : k) {
result[pos++] = kb;
}
pos = Utilities.encodePacked32(v.length, result, pos, vlen);
for(byte vb : v) {
result[pos++] = vb;
}
return result;
}
public byte[] TypeInstance.getIntentionBytes() {
return getIntentionBytes(intentions());
}
public static byte[] TypeInstance.getIntentionBytes(List<Intention> intentions) {
if(intentions==null) return new byte[0];
Iterator<Intention> it = intentions.iterator();
return getIntentionBytes(it);
}
public static byte[] TypeInstance.getIntentionBytes(Set<Intention> intentions) {
if(intentions==null) return new byte[0];
Iterator<Intention> it = intentions.iterator();
return getIntentionBytes(it);
}
public static byte[] TypeInstance.getIntentionBytes(Iterator<Intention> it) {
java.util.ArrayList<byte[]> tmp = new java.util.ArrayList<byte[]>();
int tmpLen=0;
int numIntentions=0;
while(it.hasNext()) {
Intention i = it.next();
byte[] bs = i.toByteArray();
tmp.add(bs);
tmpLen+=bs.length;
numIntentions++;
}
byte result[] = new byte[tmpLen + Utilities.size_packed32(numIntentions)];
int pos = 0;
pos = Utilities.encodePacked32(numIntentions, result, 0, Utilities.size_packed32(numIntentions));
for(byte[] bs : tmp) {
for(byte b : bs) {
result[pos++] = b;
}
}
return result;
}
syn Set<Intention> Specification.emptyIntentions() = new HashSet<Intention>();
inh Set<Intention> ASTNode.noIntentions();
eq Specification.getChild(int i).noIntentions() = emptyIntentions();
syn Set<Intention> ASTNode.intentions();
eq ASTNode.intentions() = noIntentions();
eq TypeInstance.intentions() = intentionSet();
public void TypeInstance.genSigLineForDecl(SignatureList list, boolean decl, ASTNode inst) {
// debugAnnotations(this.getName());
// list.addString(inst.getIntentionString(), "intention string");
if(addIntentions()) {
list.addIntentions(intentionSet(), "intentions");
}
getDataType().genSigLineForDecl(list, decl, this);
}
public void TypeDecl.genSigLineForDecl(SignatureList list, boolean decl, ASTNode inst) {
//TODO intent
if(decl){
getTypeInstance().genSigLineForDecl(list, decl, this);
}else{
list.addTypeRef(this, "//TODO (from list.addTypeRef)");
}
}
public void SampleDecl.genSigLineForDecl(SignatureList list, boolean decl, ASTNode inst) {
//TODO intent
getTypeInstance().genSigLineForDecl(list, decl, this);
}
public void VoidType.genSigLineForDecl(SignatureList list, boolean decl, ASTNode inst) {
list.addInt(LABCOMM_STRUCT, "void");
list.addInt(0, null);
}
// public void SampleRefType.genSigLineForDecl(SignatureList list, boolean decl, ASTNode inst) {
// list.addInt(LABCOMM_SAMPLE_REF, "sample");
// }
public void PrimType.genSigLineForDecl(SignatureList list, boolean decl, ASTNode inst) {
list.addInt(getToken(), null);
}
/* For UserType, the decl parameter is ignored, as a UserType
* will always be a TypeRef
*/
public void UserType.genSigLineForDecl(SignatureList list, boolean decl, ASTNode inst) {
TypeDecl thet = lookupType(getName());
list.addTypeRef(thet, null);
}
public void ArrayType.genSigLineForDecl(SignatureList list, boolean decl, ASTNode inst) {
list.addInt(LABCOMM_ARRAY, signatureComment());
list.indent();
list.addInt(getNumExp(), null);
for (int i = 0 ; i < getNumExp() ; i++) {
getExp(i).genSigLineForDecl(list, false, null);
}
getDataType().genSigLineForDecl(list, false, null);
list.unindent();
list.add(null, "}");
}
public void StructType.genSigLineForDecl(SignatureList list, boolean decl, ASTNode inst) {
list.addInt(LABCOMM_STRUCT, "struct { " + getNumField() + " fields");
list.indent();
list.addInt(getNumField(), null);
for (int i = 0 ; i < getNumField() ; i++) {
getField(i).genSigLineForDecl(list, false, inst);
}
list.unindent();
list.add(null, "}");
}
// public void Field.genSigLineForDecl(SignatureList list, boolean decl, ASTNode inst) {
// //XXX make intention
// list.addString(getName(), signatureComment());
// super.genSigLineForDecl(list, decl, inst);
// //TODOintent
// //getDataType().genSigLineForDecl(list, decl, inst);
// }
public void IntegerLiteral.genSigLineForDecl(SignatureList list, boolean decl, ASTNode inst) {
list.addInt(Integer.parseInt(getValue()), null);
}
public void VariableSize.genSigLineForDecl(SignatureList list, boolean decl, ASTNode inst) {
list.addInt(0, null);
}
}
compiler/2014/TypeCheck.jrag 0 → 100644
View file @ d3921882
aspect TypeCheck {
public void ASTNode.typeCheck() {
// calls to the different type checks to be performed
nullTypeCheck();
}
// void is not allowed as a field in a struct or an array element
syn boolean DataType.isNull();
eq DataType.isNull() = false;
eq VoidType.isNull() = true;
eq UserType.isNull() = decl().isNull();
syn boolean TypeDecl.isNull();
eq TypeDecl.isNull() = getDataType().isNull();
public void ASTNode.nullTypeCheck() {}
public void Field.nullTypeCheck() {
if(getDataType().isNull()) {
error("field " + getName() + " of struct "+ declName()+ " may not be of type void");
}
}
public void ParseArrayType.nullTypeCheck() {
if(getDataType().isNull()) {
error("elements of array "+declName()+" may not be of type void");
}
}
public void ArrayType.nullTypeCheck() {
if(getDataType().isNull()) {
error("elements of array "+declName()+" may not be of type void");
}
}
}
aspect AnnotationCheck {
refine TypeCheck void ASTNode.typeCheck() {
refined(); // similar to call to super
annotationCheck();
}
public void ASTNode.annotationCheck() {}
public void TypeDecl.annotationCheck() {
Iterator<Intention> it = getTypeInstance().intentions().iterator();;
while(it.hasNext()) {
if(!it.next().getKey().equals("")) {
error("TypeDecl " + getName() + " has intentions. (Not allowed for typedefs)");
}
}
}
}
compiler/2014/TypeReferences.jrag 0 → 100644
View file @ d3921882
aspect User_Types {
syn String DataType.getTypeName();
eq DataType.getTypeName() = getClass().getName();
eq PrimType.getTypeName() = getName();
eq UserType.getTypeName() = getName();
syn boolean DataType.isUserType();
eq DataType.isUserType() = false;
eq UserType.isUserType() = true;
}
aspect Type_References {
// The dependencies on other type declarations for a Decl.
coll Set<Decl> Decl.type_dependencies() [new HashSet<Decl>()] with add;
Field contributes ((UserType)getDataType()).decl()
when parentDecl() != null && getDataType().isUserType()
to Decl.type_dependencies()
for parentDecl();
UserType contributes decl()
when parentDecl() != null
to Decl.type_dependencies()
for parentDecl();
/*
Field contributes getDataType().decl()
when parentDecl() != null && getDataType().isLeafType()
to Decl.type_dependencies()
for parentDecl();
*/
// The references from other type declarations to a Decl.
coll Set<Decl> Decl.type_references() [new HashSet<Decl>()] with add;
Decl contributes this
to Decl.type_references()
for each type_dependencies();
syn boolean Decl.hasDependencies();
eq Decl.hasDependencies() = !type_dependencies().isEmpty();
syn boolean Decl.isReferenced();
eq Decl.isReferenced() = !type_references().isEmpty();
}
compiler/2014/Utilities.jadd 0 → 100644
View file @ d3921882
aspect Encoding {
public class Utilities {
/* Size of packed32 variable */
public static int size_packed32(long data)
{
long d = data & 0xffffffff;
int result = 0;
int i;
for (i = 0 ; i == 0 || d != 0; i++, d = (d >>> 7)) {
result++;
}
return result;
}
public static int encodePacked32(long value, byte[] buf, int start, int len) {
int pos = start;
byte[] tmp = new byte[5];
long v = value & 0xffffffff;
int i;
for (i = 0 ; i == 0 || v != 0 ; i++, v = (v >> 7)) {
tmp[i] = (byte)(v & 0x7f);
}
if(i != len) {
throw new Error("wrong length, was: "+i+", expected "+len);
}
for (i = i - 1 ; i >= 0 ; i--) {
buf[pos++] = (byte)(tmp[i] | (i!=0?0x80:0x00));
}
return pos;
}
}
}
aspect PrintEnv {
public abstract class PrintEnv {
protected static class Printer {
private final String indentString = " ";
private boolean newline = true; // last print ended with newline
protected PrintStream out;
private Printer printer;
/** dummy constructor motivated by the FilePrinter subclass */
protected Printer() {
this.out = null;
}
public Printer(PrintStream out) {
this.out = out;
}
public void print(PrintEnv env, String s) {
if (newline) {
newline = false;
for (int i = 0 ; i < env.getIndent() ; i++) {
out.print(indentString);
}
}
out.print(s);
}
public void println(PrintEnv env, String s) {
print(env, s);
out.println();
newline = true;
}
public void println(PrintEnv env) {
out.println();
newline = true;
}
public PrintStream getPrintStream() {
return(out);
}
public void close() throws IOException {
//do nothing
}
}
protected static class FilePrinter extends Printer {
private File file;
private IOException exception;
public FilePrinter(PrintStream out) {
super(out);
}
public FilePrinter(File f) {
file = f;
File parentFile = f.getParentFile();
if(parentFile != null) {
parentFile.mkdirs();
}
}
public void close() throws IOException {
if (out != null) {
out.close();
}
if (exception != null) {
throw exception;
}
}
public void checkOpen() {
if (out == null && exception == null) {
try {
out = new PrintStream(new FileOutputStream(file));
} catch (IOException e) {
exception = e;
}
}
}
public void print(PrintEnv env, String s) {
checkOpen();
super.print(env,s);
}
public void println(PrintEnv env, String s) {
checkOpen();
super.println(env, s);
}
}
public final int version; //labcomm version (2006 or 2014)
public final String verStr; // version suffix to append (currently _2006 and empty string)
private Printer printer;
private int indent;
private int depth;
protected PrintEnv(PrintStream out) {
this(new Printer(out));
}
protected PrintEnv(Printer printer) {
this(printer, 2014);
}
protected PrintEnv(Printer printer, int version) {
this(0, printer, version);
}
protected PrintEnv(int indent, Printer printer, int version) {
this(indent, printer, version, 0);
}
protected PrintEnv(int indent, Printer printer, int version, int depth) {
this.version = version;
this.indent = indent;
this.printer = printer;
this.verStr = LabCommVersion.versionString(version);
this.depth = depth;
}
public void close() throws IOException {
printer.close();
}
public PrintStream getPrintStream() {
return printer.getPrintStream();
}
public void indent(int amount) {
indent += amount;
}
public void indent() {
indent(1);
}
public void unindent(int amount) {
indent -= amount;
if (indent < 0) {
throw new Error("Negative indent level");
}
}
public void unindent() {
unindent(1);
}
public void print(String s) {
printer.print(this, s);
}
public void println(String s) {
printer.println(this, s);
}
public void println() {
printer.println(this, "");
}
public void incDepth() {
depth++;
}
public void decDepth() {
if(depth<=0) {
throw new RuntimeException("decDepth() called when depth = "+depth);
}
depth--;
}
public int getDepth() {
return depth;
}
public int getVersion() {
return version;
}
public int getIndent() {
return indent;
}
public Printer getPrinter() {
return printer;
}
public boolean versionHasMetaData() {
return version != 2006;
}
}
}
compiler/2014/Version.jrag 0 → 100644
View file @ d3921882
aspect Version {
/* An auxilliary class for handling naming and prefixes connected
* to the LabComm version
*/
class LabCommVersion {
public static String versionString(int version) {
switch(version) {
case 2006:
return "2006";
case 2014:
return "2014";
default:
throw new Error("no versionString for version "+version);
}
}
public static boolean versionHasPragma(int version) {
return version != 2006;
}
}
}
compiler/Makefile 0 → 100644
View file @ d3921882
.PHONY: all
all: ant-all
.PHONY: test
test: ant-test
.PHONY: clean
clean: ant-clean
rm -f *~
.PHONY: distclean
distclean: clean ant-distclean
.PHONY: ant-%
ant-%:
ant $*
compiler/build.xml 0 → 100644
View file @ d3921882
<!--
Targets for working from terminal window:
build (default) - generates java files and compiles them
clean - removes all generated files and class files
Targets for working from Eclipse:
gen - generates java files
cleanGen - removes all generated files and their class files
-->
<project name="LabComm" default="all" basedir=".">
<!-- "tools" is the directory where generators and libraries are located. -->
<property name="tools" value="tools"/>
<!-- "jflex" is an ant task class for the scanner generator in JFlex.jar -->
<taskdef name="jflex" classname="JFlex.anttask.JFlexTask" classpath="tools/JFlex.jar"/>
<!-- "beaver" is an ant task class for the parser generator in beaver.jar -->
<taskdef name="beaver" classname="beaver.comp.run.AntTask" classpath="tools/beaver-ant.jar"/>
<!-- "jastadd" is an ant task class in jastadd2.jar -->
<taskdef name="jastadd" classname="jastadd.JastAddTask"
classpath="tools/jastadd2.jar"/>
<target name="jastadd.cu">
<uptodate property="jastadd.u">
<srcfiles dir='.'>
<include name="${version}/*.ast"/>
<include name="${version}/*.jrag"/>
<include name="${version}/*.jadd"/>
</srcfiles>
<mapper type="merge"
to="${outdir}/${package_path}/jastadd.uptodate"/>
</uptodate>
</target>
<target name="jastadd" depends="jastadd.cu" unless="jastadd.u">
<echo message = "Running JastAdd"/>
<jastadd package="${package}" rewrite="true" beaver="true"
novisitcheck="true" lazyMaps="true" outdir="${outdir}">
<fileset dir=".">
<include name="${version}/*.ast"/>
<include name="${version}/*.jrag"/>
<include name="${version}/*.jadd"/>
</fileset>
</jastadd>
<touch file="${outdir}/${package_path}/jastadd.uptodate"/>
</target>
<target name="scanner.cu">
<uptodate property="scanner.u">
<srcfiles dir='.'>
<include name="${version}/LabCommScanner.flex"/>
<!--include name="${tools}/JFlex.jar"/-->
</srcfiles>
<mapper type="merge"
to="${outdir}/${package_path}/LabCommScanner.java"/>
</uptodate>
</target>
<target name="scanner" depends="scanner.cu" unless="scanner.u">
<echo message = "Generating scanner ${version}"/>
<echo message = "Running jflex -> ${package} ${outdir}/${package_path}"/>
<jflex file="${version}/LabCommScanner.flex"
outdir="${outdir}/${package_path}" nobak="yes"/>
</target>
<target name="parser.1.cu">
<uptodate property="parser.1.u">
<srcfiles dir='.'>
<include name="${version}/*.parser"/>
</srcfiles>
<mapper type="merge"
to="${outdir}/${package_path}/LabCommParser.all"/>
</uptodate>
</target>
<target name="parser.1" depends="parser.1.cu" unless="parser.1.u">
<!-- generate the parser phase 1, create a full .lalr specification
from fragments-->
<echo message = "Joining parser fragments"/>
<concat destfile="${outdir}/${package_path}/LabCommParser.all" binary="true">
<fileset dir=".">
<include name="${version}/*.parser"/>
</fileset>
</concat>
</target>
<target name="parser.2.cu">
<uptodate property="parser.2.u">
<srcfiles dir='.'>
<include name="${outdir}/${package_path}/LabCommParser.all"/>
</srcfiles>
<mapper type="merge"
to="${outdir}/${package_path}/LabCommParser.beaver"/>
</uptodate>
</target>
<target name="parser.2" depends="parser.1, parser.2.cu" unless="parser.2.u">
<!-- generate the parser phase 2, translating .lalr to .beaver -->
<echo message = "translating .lalr to .beaver"/>
<java fork="true" dir="${basedir}"
classpath="${tools}/proj.jar:${tools}/beaver-rt.jar" classname="Main">
<arg line="${outdir}/${package_path}/LabCommParser.all
${outdir}/${package_path}/LabCommParser.beaver"/>
</java>
</target>
<target name="parser.3.cu">
<uptodate property="parser.3.u">
<srcfiles dir='.'>
<include name="${outdir}/${package_path}/LabCommParser.beaver"/>
</srcfiles>
<mapper type="merge"
to="${outdir}/${package_path}/LabCommParser.java"/>
</uptodate>
</target>
<target name="parser.3" depends="parser.2, parser.3.cu" unless="parser.3.u">
<echo message = "translating .beaver to .java"/>
<beaver file="${outdir}/${package_path}/LabCommParser.beaver"
terminalNames="yes" compress="yes" useSwitch="yes"/>
</target>
<target name="all.version" depends="jastadd, scanner, parser.3">
</target>
<target name="compile.cu">
<uptodate property="compile.u">
<srcfiles dir='.'>
<include name="*.java"/>
<include name="2014/*.java"/>
<include name="${outdir}/**/*.java"/>
</srcfiles>
<mapper type="merge"
to="${outdir}/compile.uptodate"/>
</uptodate>
</target>
<target name="compile" depends="compile.cu" unless="compile.u">
<echo message = "compiling"/>
<javac debug="true" srcdir="." destdir="${outdir}"
includes="*.java 2014/*.java gen/**/*.java"
classpath="${outdir}:${tools}/beaver-rt.jar:${tools}/junit.jar"
includeantruntime="false"
fork="true" memoryMaximumSize="128M">
<!--compilerarg value="-Xlint"/-->
</javac>
<touch file="${outdir}/compile.uptodate"/>
</target>
<target name="jar.version.cu">
<uptodate property="jar.version.u">
<srcfiles dir=".">
<include name="${outdir}/${package_path}/*.class"/>
</srcfiles>
<mapper type="merge"
to="labcomm${version}_compiler.jar"/>
</uptodate>
</target>
<target name="jar.version" depends="jar.version.cu" unless="jar.version.u">
<echo message = "Generating labcomm${version}_compiler.jar"/>
<jar destfile="labcomm${version}_compiler.jar">
<fileset dir="${outdir}"
includes="${package_path}/*.class"/>
<zipfileset src="tools/beaver-rt.jar" includes="beaver/*.class"/>
<manifest>
<attribute name="Main-Class"
value="${package}.LabComm"/>
</manifest>
</jar>
</target>
<target name="do.version">
<!-- Wrapper that sets up package and package_path based on ${version} -->
<local name="package"/>
<local name="package_path"/>
<property name="package" value="se.lth.control.labcomm${version}.compiler"/>
<loadresource property="package_path">
<propertyresource name="package"/>
<filterchain>
<tokenfilter>
<filetokenizer/>
<replacestring from="." to="/"/>
</tokenfilter>
</filterchain>
</loadresource>
<echo>${do} ${version} ${outdir}</echo>
<mkdir dir="${outdir}"/>
<antcall target="${do}">
<param name="version" value="${version}"/>
<param name="outdir" value="${outdir}"/>
<param name="package" value="${package}"/>
<param name="package_path" value="${package_path}"/>
</antcall>
</target>
<target name="all">
<antcall target="do.version">
<param name="do" value="all.version"/>
<param name="version" value="2014"/>
<param name="outdir" value="gen"/>
</antcall>
<antcall target="compile">
<param name="outdir" value="gen"/>
</antcall>
<antcall target="do.version">
<param name="do" value="jar.version"/>
<param name="version" value="2014"/>
<param name="outdir" value="gen"/>
</antcall>
</target>
<target name="clean">
<delete dir="gen"/>
</target>
<target name="distclean" depends="clean">
<delete>
<fileset dir="." includes="labcomm*_compiler.jar"/>
</delete>
</target>
<target name="test">
<echo>No tests defined yet</echo>
</target>
</project>
compiler/labcomm2014 0 → 100755
View file @ d3921882
#!/bin/sh
java -jar /lib/labcomm2014_compiler.jar "$@"
tools/JFlex.jar → compiler/tools/JFlex.jar
View file @ d3921882
File moved