Skip to content
Snippets Groups Projects

Compare revisions

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

Source

Select target project
No results found
Select Git revision
  • anders.blomdell
  • compiler-refactoring
  • labcomm2006
  • labcomm2013
  • labcomm2014
  • master
  • pragma
  • python_sig_hash
  • typedefs
  • typeref
  • v2006.0
  • v2013.0
  • v2014.0
  • v2014.1
  • v2014.2
  • v2014.3
  • v2014.4
  • v2014.5
  • v2014.6
  • v2015.0
20 results

Target

Select target project
  • anders_blomdell/labcomm
  • klaren/labcomm
  • tommyo/labcomm
  • erikj/labcomm
  • sven/labcomm
5 results
Select Git revision
  • anders.blomdell
  • compiler-refactoring
  • labcomm2013
  • master
  • pragma
  • typeref
  • v2013.0
  • v2014.0
  • v2014.1
9 results
Show changes
Showing
with 1245 additions and 1710 deletions
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 Program.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 Program.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 = getType().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;");
getType().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;");
getType().RAPID_AddEncodeInstr(env, stmts, "val", "st");
env.addProc("Encode_" + getName(), params, stmts);
}
public String Type.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.getType().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 = getType().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 Type.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).getType().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++) {
getType().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 Type.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).getType().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++) {
getType().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());
}
}
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);
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.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) {
throw new Error(this.getClass().getName() +
".genSigLineForDecl(SignatureList list)" +
" not declared");
}
public void TypeDecl.genSigLineForDecl(SignatureList list, boolean decl) {
//System.out.println("************ TypeDecl.genSigLine("+decl+").... for "+getName());
if(decl){
getType().genSigLineForDecl(list, decl);
}else{
list.addTypeRef(this, "//TODO (from list.addTypeRef)");
}
}
public void SampleDecl.genSigLineForDecl(SignatureList list, boolean decl) {
//System.out.println("************ SampleDecl.genSigLine("+decl+").... for "+getName());
getType().genSigLineForDecl(list, decl);
}
public void VoidType.genSigLineForDecl(SignatureList list, boolean decl) {
list.addInt(LABCOMM_STRUCT, "void");
list.addInt(0, null);
}
public void SampleRefType.genSigLineForDecl(SignatureList list, boolean decl) {
list.addInt(LABCOMM_SAMPLE_REF, "sample");
}
public void PrimType.genSigLineForDecl(SignatureList list, boolean decl) {
list.addInt(getToken(), null);
}
public void UserType.genSigLineForDecl(SignatureList list, boolean decl) {
if(decl){
//System.out.println("************ UserType.genSigLine("+decl+").... for "+getName());
TypeDecl thet=lookupType(getName());
//System.out.println("************ thet: "+thet.getName() +":"+thet.getType());
thet.genSigLineForDecl(list, decl);
}else{
//System.out.println("************ UserType.genSigLine("+decl+").... for "+getName());
TypeDecl thet = lookupType(getName());
// System.out.println("************ thet: "+thet.getName() +":"+thet.getType());
list.addTypeRef(thet, null);
}
}
public void ArrayType.genSigLineForDecl(SignatureList list, boolean decl) {
list.addInt(LABCOMM_ARRAY, signatureComment());
list.indent();
list.addInt(getNumExp(), null);
for (int i = 0 ; i < getNumExp() ; i++) {
getExp(i).genSigLineForDecl(list, false);
}
getType().genSigLineForDecl(list, false);
list.unindent();
list.add(null, "}");
}
public void StructType.genSigLineForDecl(SignatureList list, boolean decl) {
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);
}
list.unindent();
list.add(null, "}");
}
public void Field.genSigLineForDecl(SignatureList list, boolean decl) {
list.addString(getName(), signatureComment());
getType().genSigLineForDecl(list, decl);
}
public void IntegerLiteral.genSigLineForDecl(SignatureList list, boolean decl) {
list.addInt(Integer.parseInt(getValue()), null);
}
public void VariableSize.genSigLineForDecl(SignatureList list, boolean decl) {
list.addInt(0, null);
}
}
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 Type.isNull();
eq Type.isNull() = false;
eq VoidType.isNull() = true;
eq UserType.isNull() = decl().isNull();
syn boolean TypeDecl.isNull();
eq TypeDecl.isNull() = getType().isNull();
public void ASTNode.nullTypeCheck() {}
public void Field.nullTypeCheck() {
if(getType().isNull()) {
error("field " + getName() + " of struct "+ declName()+ " may not be of type void");
}
}
public void ParseArrayType.nullTypeCheck() {
if(getType().isNull()) {
error("elements of array "+declName()+" may not be of type void");
}
}
public void ArrayType.nullTypeCheck() {
if(getType().isNull()) {
error("elements of array "+declName()+" may not be of type void");
}
}
}
aspect User_Types {
syn String Type.getTypeName();
eq Type.getTypeName() = getClass().getName();
eq PrimType.getTypeName() = getName();
eq UserType.getTypeName() = getName();
syn boolean Type.isUserType();
eq Type.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)getType()).decl()
when parentDecl() != null && getType().isUserType()
to Decl.type_dependencies()
for parentDecl();
UserType contributes decl()
when parentDecl() != null
to Decl.type_dependencies()
for parentDecl();
/*
Field contributes getType().decl()
when parentDecl() != null && getType().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();
}
aspect Version {
/* An auxilliary class for handling naming and prefixes connected
* to the LabComm version
*/
class LabCommVersion {
public static String versionString(int version) {
return (version == 2006) ? "2006" : "";
}
public static boolean versionHasPragma(int version) {
return version != 2006;
}
}
}
aspect Annotations {
syn boolean TypeInstance.hasAnnotations() = getAnnotations().getNumAnnotation()>0;
syn boolean TypeInstance.hasIntentions() = ! intentionSet().isEmpty();
syn String Annotations.getName() = new String(lookup(""));
syn byte[] Annotations.lookup(String key) {
for(Annotation a: getAnnotations()) {
byte[] res = a.lookup(key);
if(res != null) return res;
}
return null;
}
syn byte[] Annotation.lookup(String key) = (getKey().equals(key) ? getValue() : null);
syn boolean Annotation.isIntention() = false;
eq Intention.isIntention() = true;
inh TypeInstance Annotation.parentInstance();
eq TypeInstance.getAnnotations().parentInstance() = this;
coll Set<Intention> TypeInstance.intentionSet() [new HashSet<Intention>()] with add;
Intention contributes this
to TypeInstance.intentionSet()
for parentInstance();
}
aspect SigAnnotations {
inh Decl TypeInstance.parentDecl();
coll Set Decl.allAnnotations() [new HashSet()] with add;
TypeInstance contributes getAnnotationString()
to Decl.allAnnotations()
for parentDecl();
// Helper attribute to get the "outermost" intentions for Decls
syn byte[] TypeInstance.intentionBytes() = getIntentionBytes(sortedIntentions());
syn byte[] Decl.getIntentionBytes() = getTypeInstance().intentionBytes();
static Comparator TypeInstance.intentionComp =
new Comparator<Intention>() {
public int compare(Intention i1, Intention i2) {
return i1.getKey().compareTo(i2.getKey());
}
};
syn int Decl.getNumIntentions() = getTypeInstance().sortedIntentions().getNumChild();
syn List<Intention> TypeInstance.sortedIntentions() {
List<Intention> res = new List<Intention>();
//TODO: refactor out creation of sorted list of intentions
java.util.ArrayList<Intention> sorted = new ArrayList(intentionSet());
java.util.Collections.sort(sorted, intentionComp);
for(Intention i : sorted) {
res.add(i);
}
return res;
}
public DocString.DocString(byte[] bs) {
super("DOCSTRING", bs);
}
public DocString.DocString(String s) {
super("DOCSTRING", s.getBytes());
}
public String Intention.toString() {
return "("+getKey() + ":"+new String(getValue())+")";
}
public String DocString.toString() {
return "\""+new String(getValue())+"\"";
}
/// TESTING
syn String Decl.getAnnotationString() {
StringBuilder sb = new StringBuilder();
Iterator<String> iti = allAnnotations().iterator();
while(iti.hasNext()) {
//Annotation i = iti.next();
//sb.append("("+i.getKey()+" : "+i.getValue()+") ");
String i = iti.next();
sb.append(i);
}
return sb.toString();
}
syn int TypeInstance.fooHash() {
List<Annotation> ints = getAnnotations().getAnnotationList();
int result=0;
for(Annotation i : ints) {
if(i.isIntention()) {
result += i.toString().hashCode();
}
}
return result;
}
syn String TypeInstance.getAnnotationString() {
StringBuilder sb = new StringBuilder();
List<Annotation> ints = getAnnotations().getAnnotationList();
for(Annotation i : ints) {
sb.append(i.toString());
}
return sb.toString();
}
public void Decl.debugAnnotations() {
getTypeInstance().debugAnnotations(getName());
}
public void TypeInstance.debugAnnotations(String context) {
if(hasAnnotations()){
System.out.println(context+".annotations: " + fooHash() + " : " + getAnnotationString());
} else {
//System.out.println(context + " : " + fooHash() + " : " + ": NO ANNOTATIONS ");
}
}
// TESTING END
}
......@@ -13,29 +13,29 @@ aspect ArrayRewrite {
when (! getDim(0).isVariable())
to FixedArrayType {
if (getNumDim() == 1) {
return new FixedArrayType(getType(),
getDim(0).getExpList());
return new FixedArrayType(getDataType(),
getDim(0));
} else {
List l = new List();
for (int i = 1 ; i < getNumDim() ; i++) {
l.add(getDim(i));
}
return new FixedArrayType(new ParseArrayType(getType(), l),
getDim(0).getExpList());
return new FixedArrayType(new ParseArrayType(getDataType(), l),
getDim(0));
}
}
when (getDim(0).isVariable())
to VariableArrayType {
if (getNumDim() == 1) {
return new VariableArrayType(getType(),
getDim(0).getExpList());
return new VariableArrayType(getDataType(),
getDim(0));
} else {
List l = new List();
for (int i = 1 ; i < getNumDim() ; i++) {
l.add(getDim(i));
}
return new VariableArrayType(new ParseArrayType(getType(), l),
getDim(0).getExpList());
return new VariableArrayType(new ParseArrayType(getDataType(), l),
getDim(0));
}
}
}
......
......@@ -6,145 +6,42 @@ aspect CS_CodeGenEnv {
// Environment wrapper for CS-code generation
// handles indentation, file writing,
public class CS_env {
public class CS_env extends PrintEnv {
public final int version;
public final String verStr;
private int indent;
private int depth;
private CS_printer printer;
private HashMap unique = new HashMap();
final private static class CS_printer {
private boolean newline = true;
private File file;
private PrintStream out;
private IOException exception;
final private static class CS_printer extends PrintEnv.FilePrinter {
public CS_printer(File f) {
file = f;
File parentFile = f.getParentFile();
if(parentFile != null) {
parentFile.mkdirs();
}
super(f);
}
public CS_printer(PrintStream out) {
this.out = out;
super(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(CS_env env, String s) {
checkOpen();
if (newline) {
newline = false;
for (int i = 0 ; i < env.indent ; i++) {
out.print(" ");
}
}
out.print(s);
}
public void println(CS_env env, String s) {
checkOpen();
print(env, s);
out.println();
newline = true;
}
}
private CS_env(int indent, CS_printer printer, int version) {
this.version = version;
this.indent = indent;
this.printer = printer;
this.verStr = LabCommVersion.versionString(version);
}
public CS_env(File f, int version) {
this(0, new CS_printer(f), version);
super(0, new CS_printer(f), version);
}
public CS_env(PrintStream out, int version) {
this(0, new CS_printer(out), version);
}
public void close() throws IOException {
printer.close();
}
public PrintStream getPrintStream() {
return printer.getPrintStream();
}
public void indent(int amount) {
indent += amount;
super(0, new CS_printer(out), version);
}
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 int getDepth() {
return depth;
}
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("}");
}
......@@ -159,15 +56,6 @@ aspect CS_CodeGenEnv {
println("}");
}
public String getUnique(Object o) {
String result = (String)unique.get(o);
if (result == null) {
result = "_" + (unique.size() + 1) + "_";
}
unique.put(o, result);
return result;
}
}
}
......@@ -175,12 +63,12 @@ aspect CS_CodeGenEnv {
aspect CS_StructName {
inh int Decl.CS_Depth();
inh int Type.CS_Depth();
eq Program.getDecl(int i).CS_Depth() = 0;
inh int DataType.CS_Depth();
eq Specification.getDecl(int i).CS_Depth() = 0;
eq StructType.getField(int i).CS_Depth() = CS_Depth() + 1;
inh String Type.CS_structName();
eq Program.getDecl(int i).CS_structName() = getDecl(i).getName();
inh String DataType.CS_structName();
eq Specification.getDecl(int i).CS_structName() = getDecl(i).getName();
eq StructType.getField(int i).CS_structName() {
if (CS_Depth() == 0) {
return "struct_" + getField(i).getName();
......@@ -192,16 +80,16 @@ aspect CS_StructName {
aspect CS_Void {
syn boolean Decl.CS_isVoid() = getType().CS_isVoid();
syn boolean Decl.CS_isVoid() = getDataType().CS_isVoid();
syn boolean UserType.CS_isVoid() = decl().CS_isVoid();
syn boolean Type.CS_isVoid() = false;
syn boolean DataType.CS_isVoid() = false;
syn boolean VoidType.CS_isVoid() = true;
}
aspect CS_CodeGen {
public void Program.CS_gen(String file,
public void Specification.CS_gen(String file,
String namespace, int version) throws IOException {
// Registration class
CS_env env = new CS_env(new File(file), version);
......@@ -210,7 +98,7 @@ aspect CS_CodeGen {
env.indent();
}
env.println("using System;");
env.println("using se.lth.control.labcomm;");
env.println("using se.lth.control.labcomm2014;");
for (int i = 0; i < getNumDecl(); i++) {
Decl d = getDecl(i);
try {
......@@ -230,7 +118,7 @@ aspect CS_CodeGen {
aspect CS_Register {
public void Program.CS_emitTypeRegister(CS_env env) {
public void Specification.CS_emitTypeRegister(CS_env env) {
}
public void Decl.CS_emitTypeRegister(CS_env env) {
......@@ -273,7 +161,7 @@ aspect CS_Class {
Decl t = it.next();
t.CS_emitUserTypeDeps(env, t.getName(), outputCode);
if( outputCode && t.getType().isUserType() ) {
if( outputCode && t.getDataType().isUserType() ) {
env.println(t.getName()+".register(e);");
} else { // Just output a comment
String refpath = (via == null) ? "directly" : "indirectly via "+via;
......@@ -329,7 +217,7 @@ aspect CS_Class {
}
public void TypeDecl.CS_emitClass(CS_env env) {
if (getType().CS_needInstance()) {
if (getDataType().CS_needInstance()) {
// Hackish prettyprint preamble
env.println("/* ");
pp(env.getPrintStream());
......@@ -338,7 +226,7 @@ aspect CS_Class {
env.println("public class " + getName() + " : SampleType {");
env.println();
env.indent();
getType().CS_emitInstance(env);
getDataType().CS_emitInstance(env);
if( isReferenced()) {
CS_emitRegisterEncoder(env);
CS_emitDispatcher(env,false);
......@@ -359,11 +247,11 @@ aspect CS_Class {
env.println("public class " + getName() + " : Sample {");
env.println();
env.indent();
getType().CS_emitInstance(env);
getDataType().CS_emitInstance(env);
env.println("public interface Handler : SampleHandler {");
env.print(" void handle(");
if (!isVoid()) {
getType().CS_emitType(env);
getDataType().CS_emitType(env);
env.print(" value");
}
env.println(");");
......@@ -377,6 +265,7 @@ aspect CS_Class {
CS_emitSignature(env);
env.println("}");
env.unindent();
}
public void Decl.CS_emitSignature(CS_env env) {
......@@ -425,12 +314,6 @@ aspect CS_Class {
env.println("private class Dispatcher : SampleDispatcher {");
env.indent();
env.println();
env.println("public Type getSampleClass() {");
env.indent();
env.println("return typeof(" + getName() + ");");
env.unindent();
env.println("}");
env.println();
env.println("public String getName() {");
env.indent();
env.println("return \"" + getName() + "\";");
......@@ -459,21 +342,6 @@ aspect CS_Class {
env.unindent();
env.println("}");
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 encodeSignatureMetadata(Encoder e, int index){");
// env.indent();
// env.println("e.encodePacked32(Constant.TYPE_DEF);");
// env.println("e.encodePacked32(index);");
// env.println("e.encodeString(getName());");
// env.println("emitSignature(e);");
// env.unindent();
// env.println("}");
// env.println();
env.println("public bool canDecodeAndHandle() {");
env.indent();
env.println("return "+isSample+";");
......@@ -499,19 +367,18 @@ aspect CS_Class {
env.unindent();
env.println("}");
env.println("");
} //TODO, fix above method
public void TypeDecl.CS_emitEncoder(CS_env env) {
env.print("public static void encode(Encoder e");
if (!isVoid()) {
env.print(", ");
getType().CS_emitType(env);
getDataType().CS_emitType(env);
env.print(" value");
}
env.println(") {");
env.indent();
getType().CS_emitEncoder(env, "value");
getDataType().CS_emitEncoder(env, "value");
env.unindent();
env.println("}");
env.println();
......@@ -521,20 +388,20 @@ aspect CS_Class {
env.print("public static void encode(Encoder e");
if (!isVoid()) {
env.print(", ");
getType().CS_emitType(env);
getDataType().CS_emitType(env);
env.print(" value");
}
env.println(") {");
env.indent();
env.println("e.begin(typeof(" + getName() + "));");
getType().CS_emitEncoder(env, "value");
env.println("e.end(typeof(" + getName() + "));");
env.println("e.begin(dispatcher);");
getDataType().CS_emitEncoder(env, "value");
env.println("e.end(dispatcher);");
env.unindent();
env.println("}");
env.println();
}
public void Type.CS_emitEncoder(CS_env env, String name) {
public void DataType.CS_emitEncoder(CS_env env, String name) {
throw new Error(this.getClass().getName() +
".CS_emitEncoder(CS_env env, String name)" +
" not declared");
......@@ -575,7 +442,7 @@ aspect CS_Class {
index = index + ", " + env.print_for_begin(limit);
}
}
getType().CS_emitEncoder(env, name + "[" + index + "]");
getDataType().CS_emitEncoder(env, name + "[" + index + "]");
for (int i = 0 ; i < getNumExp() ; i++) {
env.print_for_end();
}
......@@ -600,7 +467,7 @@ aspect CS_Class {
public void StructType.CS_emitEncoder(CS_env env, String name) {
for (int i = 0 ; i < getNumField() ; i++) {
Field f = getField(i);
f.getType().CS_emitEncoder(env, name + "." + f.getName());
f.getDataType().CS_emitEncoder(env, name + "." + f.getName());
}
}
......@@ -608,19 +475,19 @@ aspect CS_Class {
if (CS_needInstance()) {
env.println(getName() + ".encode(e, " + name + ");");
} else {
decl().getType().CS_emitEncoder(env, name);
decl().getDataType().CS_emitEncoder(env, name);
}
}
public void Decl.CS_emitDecoder(CS_env env) {
env.print("public static ");
getType().CS_emitType(env);
getDataType().CS_emitType(env);
env.println(" decode(Decoder d) {");
env.indent();
if (!isVoid()) {
getType().CS_emitType(env);
getDataType().CS_emitType(env);
env.println(" result;");
getType().CS_emitDecoder(env, "result");
getDataType().CS_emitDecoder(env, "result");
env.println("return result;");
}
env.unindent();
......@@ -628,7 +495,7 @@ aspect CS_Class {
env.println();
}
public void Type.CS_emitDecoder(CS_env env, String name) {
public void DataType.CS_emitDecoder(CS_env env, String name) {
throw new Error(this.getClass().getName() +
".CS_emitDecoder(CS_env env, String name)" +
" not declared");
......@@ -666,7 +533,7 @@ aspect CS_Class {
env.println(";");
}
env.print(name + " = new ");
getType().CS_emitTypePrefix(env);
getDataType().CS_emitTypePrefix(env);
env.print("[");
for (int i = 0 ; i < getNumExp() ; i++) {
if (i > 0) {
......@@ -675,7 +542,7 @@ aspect CS_Class {
env.print("i_" + (baseDepth + i) + "_max");
}
env.print("]");
getType().CS_emitTypeSuffix(env);
getDataType().CS_emitTypeSuffix(env);
env.println(";");
String index = null;
......@@ -687,7 +554,7 @@ aspect CS_Class {
index = index + ", " + env.print_for_begin(limit);
}
}
getType().CS_emitDecoder(env, name + "[" + index + "]");
getDataType().CS_emitDecoder(env, name + "[" + index + "]");
for (int i = 0 ; i < getNumExp() ; i++) {
env.print_for_end();
}
......@@ -715,7 +582,7 @@ aspect CS_Class {
env.println("();");
for (int i = 0 ; i < getNumField() ; i++) {
Field f = getField(i);
f.getType().CS_emitDecoder(env, name + "." + f.getName());
f.getDataType().CS_emitDecoder(env, name + "." + f.getName());
}
}
......@@ -723,11 +590,11 @@ aspect CS_Class {
if (CS_needInstance()) {
env.println(name + " = " + getName() + ".decode(d);");
} else {
decl().getType().CS_emitDecoder(env, name);
decl().getDataType().CS_emitDecoder(env, name);
}
}
public void Type.CS_emitTypePrefix(CS_env env) {
public void DataType.CS_emitTypePrefix(CS_env env) {
throw new Error(this.getClass().getName() +
".CS_emitTypePrefix(CS_env env)" +
" not declared");
......@@ -736,7 +603,7 @@ aspect CS_Class {
public void PrimType.CS_emitTypePrefix(CS_env env) {
switch (getToken()) {
case LABCOMM_STRING: { env.print("String"); } break;
case LABCOMM_SAMPLE: { env.print("Type"); } break;
case LABCOMM_SAMPLE: { env.print("SampleDispatcher"); } break;
default: { env.print(getName()); } break;
}
}
......@@ -745,24 +612,24 @@ aspect CS_Class {
if (CS_needInstance()) {
env.print(getName());
} else {
decl().getType().CS_emitTypePrefix(env);
decl().getDataType().CS_emitTypePrefix(env);
}
}
public void ArrayType.CS_emitTypePrefix(CS_env env){
getType().CS_emitTypePrefix(env);
getDataType().CS_emitTypePrefix(env);
}
public void StructType.CS_emitTypePrefix(CS_env env){
env.print(CS_structName());
}
public void Type.CS_emitTypeSuffix(CS_env env) {
public void DataType.CS_emitTypeSuffix(CS_env env) {
}
public void UserType.CS_emitTypeSuffix(CS_env env) {
if (! CS_needInstance()) {
decl().getType().CS_emitTypeSuffix(env);
decl().getDataType().CS_emitTypeSuffix(env);
}
}
......@@ -772,10 +639,10 @@ aspect CS_Class {
env.print(",");
}
env.print("]");
getType().CS_emitTypeSuffix(env);
getDataType().CS_emitTypeSuffix(env);
}
public boolean Type.CS_needInstance() {
public boolean DataType.CS_needInstance() {
throw new Error(this.getClass().getName() +
".CS_needInstance()" +
" not declared");
......@@ -790,7 +657,7 @@ aspect CS_Class {
}
public boolean UserType.CS_needInstance() {
return decl().getType().CS_needInstance();
return decl().getDataType().CS_needInstance();
}
public boolean StructType.CS_needInstance() {
......@@ -798,10 +665,10 @@ aspect CS_Class {
}
public boolean ArrayType.CS_needInstance() {
return getType().CS_needInstance();
return getDataType().CS_needInstance();
}
public boolean Type.CS_isPrimitive() {
public boolean DataType.CS_isPrimitive() {
return false;
}
......@@ -809,7 +676,7 @@ aspect CS_Class {
return true;
}
public void Type.CS_emitInstance(CS_env env) {
public void DataType.CS_emitInstance(CS_env env) {
throw new Error(this.getClass().getName() +
".CS_emitInstance(CS_env env)" +
" not declared");
......@@ -822,7 +689,7 @@ aspect CS_Class {
}
public void ArrayType.CS_emitInstance(CS_env env) {
getType().CS_emitInstance(env);
getDataType().CS_emitInstance(env);
}
public void StructType.CS_emitInstance(CS_env env) {
......@@ -831,7 +698,7 @@ aspect CS_Class {
env.indent();
}
for (int i = 0 ; i < getNumField() ; i++) {
getField(i).getType().CS_emitInstance(env);
getField(i).getDataType().CS_emitInstance(env);
}
for (int i = 0 ; i < getNumField() ; i++) {
getField(i).CS_emitField(env);
......@@ -848,11 +715,11 @@ aspect CS_Class {
public void Field.CS_emitField(CS_env env) {
env.print("public ");
getType().CS_emitType(env);
getDataType().CS_emitType(env);
env.println(" " + getName() + ";");
}
public void Type.CS_emitType(CS_env env) {
public void DataType.CS_emitType(CS_env env) {
throw new Error(this.getClass().getName() +
".CS_emitType(CS_env env)" +
" not declared");
......@@ -866,23 +733,23 @@ aspect CS_Class {
switch (getToken()) {
case LABCOMM_STRING: { env.print("String"); } break;
case LABCOMM_BOOLEAN: { env.print("bool"); } break;
case LABCOMM_SAMPLE: { env.print("Type"); } break;
case LABCOMM_SAMPLE: { env.print("SampleDispatcher"); } break;
default: { env.print(getName()); } break;
}
}
public void UserType.CS_emitType(CS_env env) {
decl().getType().CS_emitType(env);
decl().getDataType().CS_emitType(env);
}
public void ArrayType.CS_emitType(CS_env env){
getType().CS_emitTypePrefix(env);
getDataType().CS_emitTypePrefix(env);
env.print("[");
for (int i = 1 ; i < getNumExp() ; i++) {
env.print(",");
}
env.print("]");
getType().CS_emitTypeSuffix(env);
getDataType().CS_emitTypeSuffix(env);
}
public void StructType.CS_emitType(CS_env env){
......@@ -902,7 +769,7 @@ aspect CS_Signature {
public void TypeRefSignatureLine.CS_emitSignature(CS_env env, boolean isDecl){
env.print(getIndentString());
env.println("e.encodePacked32(e.getTypeId( typeof("+decl.getName()+")));");
env.println("e.encodePacked32(e.getDataTypeId( typeof("+decl.getName()+")));");
}
public void DataSignatureLine.CS_emitSignature(CS_env env, boolean decl){
......@@ -935,7 +802,7 @@ aspect CS_Signature {
aspect CS_Info {
public void Program.CS_info(PrintStream out, String namespace, int version) {
public void Specification.CS_info(PrintStream out, String namespace, int version) {
CS_env env = new CS_env(out, version);
if (namespace == null) {
namespace = "";
......@@ -955,14 +822,14 @@ aspect CS_Info {
public void TypeDecl.CS_info(CS_env env, String namespace) {
env.print(";C#;typedef;" + namespace + getName() + ";");
getType().CS_emitType(env) ;
getDataType().CS_emitType(env) ;
env.print(";not_applicable_for_C#");
env.println();
}
public void SampleDecl.CS_info(CS_env env, String namespace) {
env.print(";C#;sample;" + namespace + getName() + ";");
getType().CS_emitType(env);
getDataType().CS_emitType(env);
env.print(";not_applicable_for_C#");
env.println();
}
......
......@@ -6,57 +6,27 @@ aspect C_CodeGenEnv {
// handles qualid nesting, indentation, file writing and
// prefix propagation
public class C_env {
final private static class C_printer {
private boolean newline = true;
private PrintStream out;
public class C_env extends PrintEnv {
final private static class C_printer extends PrintEnv.Printer {
public C_printer(PrintStream out) {
this.out = out;
}
public void print(C_env env, String s) {
if (newline) {
newline = false;
for (int i = 0 ; i < env.indent ; i++) {
out.print(" ");
}
}
out.print(s);
}
public void println(C_env env, String s) {
print(env, s);
out.println();
newline = true;
super(out);
}
}
public final int version; //labcomm version (2006 or 2014)
public final String verStr; // version suffix to append (currently _2006 and empty string)
public final String qualid;
public final String lcName;
public final String rawPrefix;
public final String prefix;
private int indent;
public final int depth;
private C_printer printer;
public final int nestedLevel;
private boolean rootIsPointer;
private int rootLevel;
public boolean versionHasMetaData() {
return version != 2006;
}
private C_env(String qualid, String lcName, String rawPrefix,
int indent, int depth, C_printer printer,
int nestedLevel, int version)
{
this.version = version;
this.verStr = LabCommVersion.versionString(version);
super(indent, printer, version, depth);
this.qualid = qualid;
this.lcName = lcName;
this.rawPrefix = rawPrefix;
......@@ -68,9 +38,6 @@ aspect C_CodeGenEnv {
} else {
this.prefix = rawPrefix + "_";
}
this.indent = indent;
this.depth = depth;
this.printer = printer;
this.nestedLevel = nestedLevel;
}
......@@ -87,38 +54,18 @@ aspect C_CodeGenEnv {
public C_env nestArray(String suffix) {
return new C_env(qualid + suffix, lcName, rawPrefix,
indent, depth + 1, printer, nestedLevel + 1, version);
getIndent(), getDepth() + 1, (C_printer)getPrinter(), nestedLevel + 1, version);
}
public C_env nestStruct(String suffix) {
return new C_env(qualid + suffix, lcName, rawPrefix,
indent, depth, printer, nestedLevel + 1, version);
}
public void indent() {
indent++;
}
public void unindent() {
indent--;
getIndent(), getDepth(), (C_printer)getPrinter(), nestedLevel + 1, version);
}
public String prefix() {
return rawPrefix;
}
public void print(String s) {
printer.print(this, s);
}
public void println() {
printer.println(this, "");
}
public void println(String s) {
printer.println(this, s);
}
public C_env setPointer() {
rootIsPointer = true;
rootLevel = nestedLevel;
......@@ -143,41 +90,39 @@ aspect C_CodeGenEnv {
public C_env FixedArrayType.C_Nest(C_env env) {
String index = env.memberAccessor() + "a";
for (int i = 0 ; i < getNumExp() ; i++) {
index += "[i_" + env.depth + "_" + i + "]";
index += "[i_" + env.getDepth() + "_" + i + "]";
}
return env.nestArray(index);
}
public C_env VariableArrayType.C_Nest(C_env env) {
return env.nestArray(env.memberAccessor() + "a[i_" + env.depth + "]");
return env.nestArray(env.memberAccessor() + "a[i_" + env.getDepth() + "]");
}
}
aspect C_IsDynamic {
// Determine if a type has dynamically allocated data
syn boolean Decl.C_isDynamic() = getType().C_isDynamic();
syn boolean Type.C_isDynamic() = false;
syn boolean Decl.C_isDynamic() = getDataType().C_isDynamic();
syn boolean DataType.C_isDynamic() = false;
syn boolean PrimType.C_isDynamic() = getToken() == LABCOMM_STRING;
syn boolean UserType.C_isDynamic() =
lookupType(getName()).getType().C_isDynamic();
lookupType(getName()).getDataType().C_isDynamic();
syn boolean StructType.C_isDynamic() {
for (int i = 0 ; i < getNumField() ; i++) {
if (getField(i).getType().C_isDynamic()) {
if (getField(i).getDataType().C_isDynamic()) {
return true;
}
}
return false;
}
syn boolean FixedArrayType.C_isDynamic() = getType().C_isDynamic();
syn boolean FixedArrayType.C_isDynamic() = getDataType().C_isDynamic();
syn boolean VariableArrayType.C_isDynamic() = true;
}
aspect C_CodeGen {
public void Program.C_genH(PrintStream out, Vector includes,
public void Specification.C_genH(PrintStream out, Vector includes,
String lcName, String prefix, int version) {
C_env env = new C_env("", lcName, prefix, out, version);
......@@ -192,7 +137,7 @@ aspect C_CodeGen {
env.println("");
// Include
env.println("#include \"labcomm"+env.verStr+".h\"");
env.println("#include \"labcomm2014.h\"");
for (int i = 0 ; i < includes.size() ; i++) {
env.println("#include \"" + includes.get(i) + "\"");
}
......@@ -203,13 +148,13 @@ aspect C_CodeGen {
env.println("#endif");
}
public void Program.C_genC(PrintStream out, Vector includes,
public void Specification.C_genC(PrintStream out, Vector includes,
String lcName, String prefix, int version) {
C_env env = new C_env("", lcName, prefix, out, version);
// Include
env.println("#include \"labcomm"+env.verStr+".h\"");
env.println("#include \"labcomm"+env.verStr+"_private.h\"");
env.println("#include \"labcomm2014.h\"");
env.println("#include \"labcomm2014_private.h\"");
for (int i = 0 ; i < includes.size() ; i++) {
env.println("#include \"" + includes.get(i) + "\"");
}
......@@ -219,7 +164,7 @@ aspect C_CodeGen {
C_emitC(env);
}
public void Program.C_emitH(C_env env) {
public void Specification.C_emitH(C_env env) {
for (int i = 0; i < getNumDecl(); i++) {
getDecl(i).C_emitType(env);
getDecl(i).C_emitDecoderDeclaration(env);
......@@ -233,7 +178,7 @@ aspect C_CodeGen {
C_emitForAll(env);
}
public void Program.C_emitC(C_env env) {
public void Specification.C_emitC(C_env env) {
for (int i = 0; i < getNumDecl(); i++) {
getDecl(i).C_emitSignature(env);
getDecl(i).C_emitDecoder(env);
......@@ -255,7 +200,7 @@ aspect C_Common {
public void ArrayType.C_emitLoopVariables(C_env env) {
for (int i = 0 ; i < getNumExp() ; i++) {
env.println("int i_" + env.depth + "_" + i + ";");
env.println("int i_" + env.getDepth() + "_" + i + ";");
}
}
......@@ -270,25 +215,27 @@ aspect C_Type {
}
public void TypeDecl.C_emitType(C_env env) {
env.println("#ifndef PREDEFINED_" + env.prefix + getName());
env.println("#ifndef LABCOMM_DEFINED_" + env.prefix + getName());
env.print("typedef ");
getType().C_emitType(env, env.prefix + getName());
getDataType().C_emitType(env, env.prefix + getName());
env.println(";");
env.println("#define LABCOMM_DEFINED_" + env.prefix + getName());
env.println("#endif");
}
public void SampleDecl.C_emitType(C_env env) {
env.println("#ifndef PREDEFINED_" + env.prefix + getName());
env.println("#ifndef LABCOMM_DEFINED_" + env.prefix + getName());
env.print("typedef ");
getType().C_emitType(env, env.prefix + getName());
getDataType().C_emitType(env, env.prefix + getName());
env.println(";");
env.println("#define LABCOMM_DEFINED_" + env.prefix + getName());
env.println("#endif");
env.println("extern const struct labcomm"+env.verStr+"_signature " +
"*labcomm"+env.verStr+"_signature_" + env.prefix + getName() +
env.println("extern const struct labcomm2014_signature " +
"*labcomm2014_signature_" + env.prefix + getName() +
";");
}
public void Type.C_emitType(C_env env, String name) {
public void DataType.C_emitType(C_env env, String name) {
throw new Error(this.getClass().getName() +
".C_emitType(C_env env, String name)" +
" not declared");
......@@ -309,7 +256,7 @@ aspect C_Type {
case LABCOMM_DOUBLE: { env.print("double"); } break;
case LABCOMM_STRING: { env.print("char*"); } break;
case LABCOMM_SAMPLE: {
env.print("const struct labcomm_signature *");
env.print("const struct labcomm2014_sample_ref *");
} break;
}
env.print(" " + name);
......@@ -331,7 +278,7 @@ aspect C_Type {
}
public void Field.C_emitType(C_env env) {
getType().C_emitType(env, getName());
getDataType().C_emitType(env, getName());
}
public void FixedArrayType.C_emitType(C_env env, String name) {
......@@ -341,7 +288,7 @@ aspect C_Type {
for (int i = 0 ; i < getNumExp() ; i++) {
index.append("[" + getExp(i).C_getValue() + "]");
}
getType().C_emitType(env, index.toString());
getDataType().C_emitType(env, index.toString());
env.println(";");
env.unindent();
env.print("} " + name);
......@@ -357,7 +304,7 @@ aspect C_Type {
env.println("// n_" + i + "=" + getExp(i).C_getValue());
}
}
getType().C_emitType(env, "*a");
getDataType().C_emitType(env, "*a");
env.println(";");
env.unindent();
env.print("} " + name);
......@@ -381,10 +328,10 @@ aspect C_Declarations {
}
public void SampleDecl.C_emitDecoderDeclaration(C_env env) {
env.println("int labcomm"+env.verStr+"_decoder_register_" +
env.println("int labcomm2014_decoder_register_" +
env.prefix + getName() + "(");
env.indent();
env.println("struct labcomm"+env.verStr+"_decoder *d,");
env.println("struct labcomm2014_decoder *d,");
env.println("void (*handler)(");
env.indent();
env.println(env.prefix + getName() + " *v,");
......@@ -395,9 +342,9 @@ aspect C_Declarations {
env.unindent();
env.println(");");
env.println("int labcomm"+env.verStr+"_decoder_ioctl_" + env.prefix + getName() + "(");
env.println("int labcomm2014_decoder_ioctl_" + env.prefix + getName() + "(");
env.indent();
env.println("struct labcomm"+env.verStr+"_decoder *d,");
env.println("struct labcomm2014_decoder *d,");
env.println("int ioctl_action,");
env.println("...");
env.unindent();
......@@ -406,26 +353,26 @@ aspect C_Declarations {
public void Decl.C_emitEncoderDeclaration(C_env env) {
}
//
public void SampleDecl.C_emitEncoderDeclaration(C_env env) {
env.println("int labcomm"+env.verStr+"_encoder_register_" +
env.println("int labcomm2014_encoder_register_" +
env.prefix + getName() + "(");
env.indent();
env.println("struct labcomm"+env.verStr+"_encoder *e);");
env.println("struct labcomm2014_encoder *e);");
env.unindent();
env.println("int labcomm"+env.verStr+"_encode_" + env.prefix + getName() + "(");
env.println("int labcomm2014_encode_" + env.prefix + getName() + "(");
env.indent();
env.println("struct labcomm"+env.verStr+"_encoder *e");
env.println("struct labcomm2014_encoder *e");
if(!isVoid() ) {
env.println(", "+env.prefix + getName() + " *v");
}
env.unindent();
env.println(");");
env.println("int labcomm"+env.verStr+"_encoder_ioctl_" + env.prefix + getName() + "(");
env.println("int labcomm2014_encoder_ioctl_" + env.prefix + getName() + "(");
env.indent();
env.println("struct labcomm"+env.verStr+"_encoder *e,");
env.println("struct labcomm2014_encoder *e,");
env.println("int ioctl_action,");
env.println("...");
env.unindent();
......@@ -458,9 +405,9 @@ aspect C_Index {
}
public void VariableArrayType.C_emitCalcIndex(C_env env) {
env.print("int i_" + env.depth + " = ");
env.print("int i_" + env.getDepth() + " = ");
String i_prefix = "i_" + env.depth + "_";
String i_prefix = "i_" + env.getDepth() + "_";
String expr = i_prefix + "0";
for (int i = 1 ; i < getNumExp() ; i++) {
expr = "(" + expr + ") * " +
......@@ -487,7 +434,7 @@ aspect C_Decoder {
env = env.nestStruct("v");
env.println("static void decode_" + env.prefix + getName() + "(");
env.indent();
env.println("struct labcomm"+env.verStr+"_reader *r,");
env.println("struct labcomm2014_reader *r,");
env.println("void (*handle)(");
env.indent();
env.println(env.prefix + getName() + " *v,");
......@@ -500,12 +447,12 @@ aspect C_Decoder {
env.println("{");
env.indent();
env.println(env.prefix + getName() + " v;");
getType().C_emitDecoder(env);
getDataType().C_emitDecoder(env);
env.println("handle(&v, context);");
if (C_isDynamic()) {
env.println("{");
env.indent();
getType().C_emitDecoderDeallocation(env);
getDataType().C_emitDecoderDeallocation(env);
env.unindent();
env.println("}");
}
......@@ -513,7 +460,7 @@ aspect C_Decoder {
env.println("}");
}
public void Type.C_emitDecoder(C_env env) {
public void DataType.C_emitDecoder(C_env env) {
throw new Error(this.getClass().getName() +
".C_emitDecoder(C_env env)" +
" not declared");
......@@ -526,17 +473,17 @@ aspect C_Decoder {
env.print(env.qualid + " = ");
switch (getToken()) {
case LABCOMM_SAMPLE: {
env.println("labcomm_internal_decoder_index_to_signature(" +
"r->decoder, labcomm"+env.verStr+"_read_int(r));");
env.println("r->decoder->index_to_sample_ref(" +
"r->decoder, labcomm2014_read_int(r));");
} break;
default: {
env.println("labcomm"+env.verStr+"_read_" + getName() + "(r);");
env.println("labcomm2014_read_" + getName() + "(r);");
}; break;
}
}
public void UserType.C_emitDecoder(C_env env) {
lookupType(getName()).getType().C_emitDecoder(env);
lookupType(getName()).getDataType().C_emitDecoder(env);
}
public void StructType.C_emitDecoder(C_env env) {
......@@ -552,7 +499,7 @@ aspect C_Decoder {
env.indent();
C_emitLoopVariables(env);
for (int i = 0 ; i < getNumExp() ; i++) {
String iterator = "i_" + env.depth + "_" + i;
String iterator = "i_" + env.getDepth() + "_" + i;
env.println("for (" + iterator + " = 0" +
" ; " +
iterator + " < " + getExp(i).C_getLimit(env, i) +
......@@ -561,7 +508,7 @@ aspect C_Decoder {
env.indent();
}
C_emitCalcIndex(env);
getType().C_emitDecoder(C_Nest(env));
getDataType().C_emitDecoder(C_Nest(env));
for (int i = getNumExp() - 1 ; i >= 0 ; i--) {
env.unindent();
env.println("}");
......@@ -571,14 +518,14 @@ aspect C_Decoder {
}
public void Field.C_emitDecoder(C_env env) {
getType().C_emitDecoder(env.nestStruct("." + getName()));
getDataType().C_emitDecoder(env.nestStruct("." + getName()));
}
public void Exp.C_emitDecoderDecodeLimit(C_env env, int i) {
}
public void VariableSize.C_emitDecoderDecodeLimit(C_env env, int i) {
env.println(env.qualid + ".n_" + i + " = labcomm"+env.verStr+"_read_packed32(r);");
env.println(env.qualid + ".n_" + i + " = labcomm2014_read_packed32(r);");
}
public void ArrayType.C_emitDecoderDecodeLimit(C_env env) {
......@@ -592,7 +539,7 @@ aspect C_Decoder {
public void VariableArrayType.C_emitDecoderArrayAllocate(C_env env) {
env.print(env.qualid +
".a = labcomm"+env.verStr+"_memory_alloc(r->memory, 1, sizeof(" +
".a = labcomm2014_memory_alloc(r->memory, 1, sizeof(" +
env.qualid + ".a[0])");
for (int i = 0 ; i < getNumExp() ; i++) {
env.print(" * " + getExp(i).C_getLimit(env, i));
......@@ -602,7 +549,7 @@ aspect C_Decoder {
// Code for deallocation of dynamically allocated data
public void Type.C_emitDecoderDeallocation(C_env env) {
public void DataType.C_emitDecoderDeallocation(C_env env) {
throw new Error(this.getClass().getName() +
".C_emitDecoderDeallocation(C_env env)" +
" not declared");
......@@ -610,14 +557,14 @@ aspect C_Decoder {
public void PrimType.C_emitDecoderDeallocation(C_env env) {
if (C_isDynamic()) {
env.println("labcomm"+env.verStr+"_memory_free(r->memory, 1, " +
env.println("labcomm2014_memory_free(r->memory, 1, " +
env.qualid + ");");
}
}
public void UserType.C_emitDecoderDeallocation(C_env env) {
if (C_isDynamic()) {
lookupType(getName()).getType().C_emitDecoderDeallocation(env);
lookupType(getName()).getDataType().C_emitDecoderDeallocation(env);
}
}
......@@ -630,12 +577,12 @@ aspect C_Decoder {
}
public void ArrayType.C_emitDecoderDeallocation(C_env env) {
if (getType().C_isDynamic()) {
if (getDataType().C_isDynamic()) {
env.println("{");
env.indent();
C_emitLoopVariables(env);
for (int i = 0 ; i < getNumExp() ; i++) {
String iterator = "i_" + env.depth + "_" + i;
String iterator = "i_" + env.getDepth() + "_" + i;
env.println("for (" + iterator + " = 0" +
" ; " +
iterator + " < " + getExp(i).C_getLimit(env, i) +
......@@ -644,7 +591,7 @@ aspect C_Decoder {
env.indent();
}
C_emitCalcIndex(env);
getType().C_emitDecoderDeallocation(C_Nest(env));
getDataType().C_emitDecoderDeallocation(C_Nest(env));
for (int i = 0 ; i < getNumExp() ; i++) {
env.unindent();
env.println("}");
......@@ -656,12 +603,12 @@ aspect C_Decoder {
public void VariableArrayType.C_emitDecoderDeallocation(C_env env) {
super.C_emitDecoderDeallocation(env);
env.println("labcomm"+env.verStr+"_memory_free(r->memory, 1, " +
env.println("labcomm2014_memory_free(r->memory, 1, " +
env.qualid + ".a);");
}
public void Field.C_emitDecoderDeallocation(C_env env) {
getType().C_emitDecoderDeallocation(env.nestStruct("." + getName()));
getDataType().C_emitDecoderDeallocation(env.nestStruct("." + getName()));
}
public void Decl.C_emitDecoderRegisterHandler(C_env env) {
......@@ -674,10 +621,10 @@ aspect C_Decoder {
}
public void SampleDecl.C_emitDecoderRegisterHandler(C_env env) {
env.println("int labcomm"+env.verStr+"_decoder_register_" +
env.println("int labcomm2014_decoder_register_" +
env.prefix + getName() + "(");
env.indent();
env.println("struct labcomm"+env.verStr+"_decoder *d,");
env.println("struct labcomm2014_decoder *d,");
env.println("void (*handler)(");
env.indent();
env.println(env.prefix + getName() + " *v,");
......@@ -689,12 +636,12 @@ aspect C_Decoder {
env.println(")");
env.println("{");
env.indent();
env.println("return labcomm"+env.verStr+"_internal_decoder_register(");
env.println("return d->sample_register(");
env.indent();
env.println("d,");
env.println("&signature_" + env.prefix + getName() + ",");
env.println("(labcomm"+env.verStr+"_decoder_function)decode_" + env.prefix + getName() + ",");
env.println("(labcomm"+env.verStr+"_handler_function)handler,");
env.println("(labcomm2014_decoder_function)decode_" + env.prefix + getName() + ",");
env.println("(labcomm2014_handler_function)handler,");
env.println("context");
env.unindent();
env.println(");");
......@@ -709,10 +656,10 @@ aspect C_copy {
private void SampleDecl.C_emitCopyFunctionParam(C_env env, String src,
String dst)
{
env.println("void labcomm" + env.verStr + "_copy_" +
env.println("void labcomm2014_copy_" +
env.prefix + getName() + "(");
env.indent();
env.println("struct labcomm" + env.verStr + "_memory *mem,");
env.println("struct labcomm2014_memory *mem,");
env.println(env.prefix + getName() + " *" + dst + ",");
env.println(env.prefix + getName() + " *" + src);
env.unindent();
......@@ -746,12 +693,12 @@ aspect C_copy {
env_src.println("");
env_src.println("{");
env_src.indent();
getType().C_emitCopy(env_src, env_dst);
getDataType().C_emitCopy(env_src, env_dst);
env_src.unindent();
env_src.println("}");
}
public void Type.C_emitCopy(C_env env_src, C_env env_dst) {
public void DataType.C_emitCopy(C_env env_src, C_env env_dst) {
throw new Error(this.getClass().getName() +
".C_emitCopy(C_env env)" +
" not declared");
......@@ -763,9 +710,8 @@ aspect C_copy {
public void PrimType.C_emitCopy(C_env env_src, C_env env_dst) {
if (C_isDynamic()) {
env_src.println(String.format(
"%s%s = labcomm%s_memory_alloc(mem, 1, strlen(%s%s)+1);",
"%s%s = labcomm2014_memory_alloc(mem, 1, strlen(%s%s)+1);",
env_dst.accessor(), env_dst.qualid,
env_src.verStr,
env_src.accessor(), env_src.qualid));
env_src.println(String.format(
"memcpy(%s%s, %s%s, strlen(%s%s)+1);",
......@@ -779,7 +725,7 @@ aspect C_copy {
}
public void UserType.C_emitCopy(C_env env_src, C_env env_dst) {
lookupType(getName()).getType().C_emitCopy(env_src, env_dst);
lookupType(getName()).getDataType().C_emitCopy(env_src, env_dst);
}
public void StructType.C_emitCopy(C_env env_src, C_env env_dst) {
......@@ -795,7 +741,7 @@ aspect C_copy {
env_src.indent();
C_emitLoopVariables(env_src);
for (int i = 0 ; i < getNumExp() ; i++) {
String iterator = "i_" + env_src.depth + "_" + i;
String iterator = "i_" + env_src.getDepth() + "_" + i;
env_src.println("for (" + iterator + " = 0" +
" ; " +
iterator + " < " + getExp(i).C_getLimit(env_src, i) +
......@@ -804,7 +750,7 @@ aspect C_copy {
env_src.indent();
}
C_emitCalcIndex(env_src);
getType().C_emitCopy(C_Nest(env_src), C_Nest(env_dst));
getDataType().C_emitCopy(C_Nest(env_src), C_Nest(env_dst));
for (int i = getNumExp() - 1 ; i >= 0 ; i--) {
env_src.unindent();
env_src.println("}");
......@@ -815,7 +761,7 @@ aspect C_copy {
public void Field.C_emitCopy(C_env env_src, C_env env_dst) {
String fnam = env_src.memberAccessor() + getName();
getType().C_emitCopy(env_src.nestStruct(fnam), env_dst.nestStruct(fnam));
getDataType().C_emitCopy(env_src.nestStruct(fnam), env_dst.nestStruct(fnam));
}
public void Exp.C_emitCopyDecodeLimit(C_env env_src, C_env env_dst, int i) {
......@@ -841,8 +787,7 @@ aspect C_copy {
C_env env_dst)
{
env_src.print(env_dst.qualid + env_dst.memberAccessor() +
"a = labcomm" + env_src.verStr +
"_memory_alloc(mem, 1, sizeof(" +
"a = labcomm2014_memory_alloc(mem, 1, sizeof(" +
env_src.qualid + env_src.memberAccessor() + "a[0])");
for (int i = 0 ; i < getNumExp() ; i++) {
env_src.print(" * " + getExp(i).C_getLimit(env_src, i));
......@@ -855,10 +800,10 @@ aspect C_copy {
private void SampleDecl.C_emitCopyDeallocationFunctionParam(C_env env,
String par)
{
env.println("void labcomm" + env.verStr + "_copy_free_" +
env.println("void labcomm2014_copy_free_" +
env.prefix + getName() + "(");
env.indent();
env.println("struct labcomm" + env.verStr + "_memory *mem,");
env.println("struct labcomm2014_memory *mem,");
env.println(env.prefix + getName() + " *" + par);
env.unindent();
env.print(")");
......@@ -889,12 +834,12 @@ aspect C_copy {
env.println("");
env.println("{");
env.indent();
getType().C_emitCopyDeallocation(env);
getDataType().C_emitCopyDeallocation(env);
env.unindent();
env.println("}");
}
public void Type.C_emitCopyDeallocation(C_env env) {
public void DataType.C_emitCopyDeallocation(C_env env) {
throw new Error(this.getClass().getName() +
".C_emitCopyDeallocation(C_env env)" +
" not declared");
......@@ -905,14 +850,14 @@ aspect C_copy {
public void PrimType.C_emitCopyDeallocation(C_env env) {
if (C_isDynamic()) {
env.println("labcomm" + env.verStr + "_memory_free(mem, 1, " +
env.println("labcomm2014_memory_free(mem, 1, " +
env.accessor() + env.qualid + ");");
}
}
public void UserType.C_emitCopyDeallocation(C_env env) {
if (C_isDynamic()) {
lookupType(getName()).getType().C_emitCopyDeallocation(env);
lookupType(getName()).getDataType().C_emitCopyDeallocation(env);
}
}
......@@ -925,12 +870,12 @@ aspect C_copy {
}
public void ArrayType.C_emitCopyDeallocation(C_env env) {
if (getType().C_isDynamic()) {
if (getDataType().C_isDynamic()) {
env.println("{");
env.indent();
C_emitLoopVariables(env);
for (int i = 0 ; i < getNumExp() ; i++) {
String iterator = "i_" + env.depth + "_" + i;
String iterator = "i_" + env.getDepth() + "_" + i;
env.println("for (" + iterator + " = 0" +
" ; " +
iterator + " < " + getExp(i).C_getLimit(env, i) +
......@@ -939,7 +884,7 @@ aspect C_copy {
env.indent();
}
C_emitCalcIndex(env);
getType().C_emitCopyDeallocation(C_Nest(env));
getDataType().C_emitCopyDeallocation(C_Nest(env));
for (int i = 0 ; i < getNumExp() ; i++) {
env.unindent();
env.println("}");
......@@ -951,12 +896,12 @@ aspect C_copy {
public void VariableArrayType.C_emitCopyDeallocation(C_env env) {
super.C_emitCopyDeallocation(env);
env.println("labcomm" + env.verStr + "_memory_free(mem, 1, " +
env.println("labcomm2014_memory_free(mem, 1, " +
env.qualid + env.memberAccessor() + "a);");
}
public void Field.C_emitCopyDeallocation(C_env env) {
getType().C_emitCopyDeallocation(env.nestStruct(env.memberAccessor()
getDataType().C_emitCopyDeallocation(env.nestStruct(env.memberAccessor()
+ getName()));
}
}
......@@ -973,9 +918,9 @@ aspect C_DecoderIoctl {
}
public void SampleDecl.C_emitDecoderIoctl(C_env env) {
env.println("int labcomm"+env.verStr+"_decoder_ioctl_" + env.prefix + getName() + "(");
env.println("int labcomm2014_decoder_ioctl_" + env.prefix + getName() + "(");
env.indent();
env.println("struct labcomm"+env.verStr+"_decoder *d,");
env.println("struct labcomm2014_decoder *d,");
env.println("int ioctl_action,");
env.println("...");
env.unindent();
......@@ -985,7 +930,7 @@ aspect C_DecoderIoctl {
env.println("int result;");
env.println("va_list va;");
env.println("va_start(va, ioctl_action);");
env.println("result = labcomm"+env.verStr+"_internal_decoder_ioctl(");
env.println("result = d->ioctl(");
env.indent();
env.println("d, &signature_" + env.prefix + getName() + ", ");
env.println("ioctl_action, va);");
......@@ -1014,7 +959,7 @@ aspect C_Encoder {
env = env.nestStruct("(*v)");
env.println("static int encode_" + env.prefix + getName() + "(");
env.indent();
env.println("struct labcomm"+env.verStr+"_writer *w");
env.println("struct labcomm2014_writer *w");
if(!isVoid() ) {
env.println(", "+env.prefix + getName() + " *v");
}
......@@ -1023,14 +968,15 @@ aspect C_Encoder {
env.println("{");
env.indent();
env.println("int result = 0;");
getType().C_emitEncoder(env);
getDataType().C_emitEncoder(env);
env.println("return result;");
env.unindent();
env.println("}");
// Typesafe encode wrapper
env.println("int labcomm"+env.verStr+"_encode_" + env.prefix + getName() + "(");
env.println("struct labcomm"+env.verStr+"_encoder *e");
env.println("int labcomm2014_encode_" + env.prefix + getName() + "(");
env.indent();
env.println("struct labcomm2014_encoder *e");
if(!isVoid() ) {
env.println(", "+env.prefix + getName() + " *v");
}
......@@ -1038,16 +984,16 @@ aspect C_Encoder {
env.println(")");
env.println("{");
env.indent();
env.println("return labcomm"+env.verStr+"_internal_encode(e, &signature_" +
env.println("return e->encode(e, &signature_" +
env.prefix + getName() +
", (labcomm"+env.verStr+"_encoder_function)encode_" +
", (labcomm2014_encoder_function)encode_" +
env.prefix + getName() +
(!isVoid()?", v":", NULL")+");");
env.unindent();
env.println("}");
}
public void Type.C_emitEncoder(C_env env) {
public void DataType.C_emitEncoder(C_env env) {
throw new Error(this.getClass().getName() +
".C_emitEncoder(C_env env)" +
" not declared");
......@@ -1061,12 +1007,12 @@ aspect C_Encoder {
env.print("result = ");
switch (getToken()) {
case LABCOMM_SAMPLE: {
env.println("labcomm"+env.verStr+"_write_int(w, " +
"labcomm_internal_encoder_signature_to_index(w->encoder, " +
env.println("labcomm2014_write_int(w, " +
"w->encoder->sample_ref_to_index(w->encoder, " +
env.qualid + "));");
} break;
default: {
env.println("labcomm"+env.verStr+"_write_" + getName() +
env.println("labcomm2014_write_" + getName() +
"(w, " + env.qualid + ");");
} break;
}
......@@ -1074,7 +1020,7 @@ aspect C_Encoder {
}
public void UserType.C_emitEncoder(C_env env) {
decl().getType().C_emitEncoder(env);
decl().getDataType().C_emitEncoder(env);
}
public void StructType.C_emitEncoder(C_env env) {
......@@ -1089,7 +1035,7 @@ aspect C_Encoder {
env.indent();
C_emitLoopVariables(env);
for (int i = 0 ; i < getNumExp() ; i++) {
String iterator = "i_" + env.depth + "_" + i;
String iterator = "i_" + env.getDepth() + "_" + i;
env.println("for (" + iterator + " = 0" +
" ; " +
iterator + " < " + getExp(i).C_getLimit(env, i) +
......@@ -1098,7 +1044,7 @@ aspect C_Encoder {
env.indent();
}
C_emitCalcIndex(env);
getType().C_emitEncoder(C_Nest(env));
getDataType().C_emitEncoder(C_Nest(env));
for (int i = getNumExp() - 1 ; i >= 0 ; i--) {
env.unindent();
env.println("}");
......@@ -1108,14 +1054,14 @@ aspect C_Encoder {
}
public void Field.C_emitEncoder(C_env env) {
getType().C_emitEncoder(env.nestStruct("." + getName()));
getDataType().C_emitEncoder(env.nestStruct("." + getName()));
}
public void Exp.C_emitEncoderEncodeLimit(C_env env, int i) {
}
public void VariableSize.C_emitEncoderEncodeLimit(C_env env, int i) {
env.println("labcomm"+env.verStr+"_write_packed32(w, " + env.qualid + ".n_" + i + ");");
env.println("labcomm2014_write_packed32(w, " + env.qualid + ".n_" + i + ");");
}
public void ArrayType.C_emitEncoderEncodeLimit(C_env env) {
......@@ -1130,15 +1076,43 @@ aspect C_Encoder {
" not declared");
}
protected void Decl.C_emitEncoderTypeRegister(C_env env) {
env.println("int labcomm2014_encoder_type_register_" +
env.prefix + getName() + "(");
env.indent();
env.println("struct labcomm2014_encoder *e");
env.unindent();
env.println(")");
env.println("{");
env.indent();
env.println("//TODO: add error handling for dependencies");
C_emitUserTypeDeps(env, null, true);
if(!isSampleDecl() || hasDependencies()) {
env.println("return e->type_register(");
env.indent();
env.println("e,");
env.println("&signature_" + env.prefix + getName() + "");
env.unindent();
env.println(");");
} else {
env.println("// the type has no dependencies, do nothing");
env.println("return 0;");
}
env.unindent();
env.println("}");
}
public void TypeDecl.C_emitEncoderRegisterHandler(C_env env) {
// do nothing for type decls
C_emitEncoderTypeRegister(env);
}
public void SampleDecl.C_emitEncoderRegisterHandler(C_env env) {
env.println("int labcomm"+env.verStr+"_encoder_register_" +
C_emitEncoderTypeRegister(env);
env.println("int labcomm2014_encoder_register_" +
env.prefix + getName() + "(");
env.indent();
env.println("struct labcomm"+env.verStr+"_encoder *e");
env.println("struct labcomm2014_encoder *e");
env.unindent();
env.println(")");
env.println("{");
......@@ -1146,17 +1120,28 @@ aspect C_Encoder {
C_emitUserTypeDeps(env, null, false); //XXX HERE BE DRAGONS
//currently set to false to turn off
//outputting of code
env.println("return labcomm"+env.verStr+"_internal_encoder_register(");
env.println("int result = e->sample_register(");
env.indent();
env.println("e,");
env.println("&signature_" + env.prefix + getName() + ",");
env.println("(labcomm"+env.verStr+"_encoder_function)encode_" + env.prefix + getName());
env.println("(labcomm2014_encoder_function)encode_" + env.prefix + getName());
env.unindent();
env.println(");");
env.println("if(result >= 0) {\n");
env.indent();
env.println("labcomm2014_encoder_type_register_" + env.prefix + getName()+"(e);");
env.println("e->type_bind(");
env.indent();
env.println("e,");
env.println("&signature_" + env.prefix + getName() + ",");
env.println( (hasDependencies() ? "1" : "0") + ");");
env.unindent();
env.println("}");
env.unindent();
env.println("return result;");
env.unindent();
env.println("}");
}
}
aspect C_EncoderIoctl {
......@@ -1171,9 +1156,9 @@ aspect C_EncoderIoctl {
}
public void SampleDecl.C_emitEncoderIoctl(C_env env) {
env.println("int labcomm"+env.verStr+"_encoder_ioctl_" + env.prefix + getName() + "(");
env.println("int labcomm2014_encoder_ioctl_" + env.prefix + getName() + "(");
env.indent();
env.println("struct labcomm"+env.verStr+"_encoder *e,");
env.println("struct labcomm2014_encoder *e,");
env.println("int ioctl_action,");
env.println("...");
env.unindent();
......@@ -1183,7 +1168,7 @@ aspect C_EncoderIoctl {
env.println("int result;");
env.println("va_list va;");
env.println("va_start(va, ioctl_action);");
env.println("result = labcomm"+env.verStr+"_internal_encoder_ioctl(");
env.println("result = e->ioctl(");
env.indent();
env.println("e, &signature_" + env.prefix + getName() + ", ");
env.println("ioctl_action, va);");
......@@ -1205,8 +1190,7 @@ aspect C_TypeDependencies {
t.C_emitUserTypeDeps(env, t.getName(), outputCode);
if(outputCode) {
System.out.println("Decl.C_emitUserTypeDeps registering "+t.getName());
env.println("labcomm"+env.verStr+"_encoder_register_"+env.prefix + t.getName()+"(e);");
env.println("labcomm2014_encoder_type_register_"+env.prefix + t.getName()+"(e);");
} else { // Just output a comment
String refpath = (via == null) ? "directly" : "indirectly via "+via;
env.println(" //Depends ("+refpath+") on "+t.getName() );
......@@ -1214,6 +1198,7 @@ aspect C_TypeDependencies {
}
}
}
public void Decl.C_emitUserTypeRefs(C_env env, String via, boolean outputCode) {
if( isReferenced() ) {
Iterator<Decl> it = type_references().iterator();
......@@ -1222,7 +1207,7 @@ aspect C_TypeDependencies {
t.C_emitUserTypeRefs(env, t.getName(), outputCode);
if(outputCode) {
env.println("labcomm"+env.verStr+"_encoder_register_"+env.prefix + t.getName()+"(e);");
env.println("labcomm2014_encoder_type_register_"+env.prefix + t.getName()+"(e);");
} else { // Just output a comment
String refpath = (via == null) ? "directly" : "indirectly via "+via;
env.println(" //Is referenced ("+refpath+") by "+t.getName() );
......@@ -1245,26 +1230,15 @@ aspect C_Signature {
eq TypeDecl.C_DeclTypeString() = "LABCOMM_TYPEDEF";
public void Decl.C_emitSignature(C_env env) {
if( (true || isReferenced() || isSampleDecl())){
Signature signature = getSignature();
signature.C_emitSignature(env, !isSampleDecl());
C_emitFlatSignature(env);
//
// if( false && (isReferenced() || isSampleDecl())){
// Signature signature = getSignature();
// signature.C_emitSignature(env, !isSampleDecl());
// } else {
// env.println("// not emitting signature for "+getName()+isReferenced()+isSampleDecl());
// }
// if(env.versionHasMetaData()) {
// if(isReferenced() || isSampleDecl()){
// env.println("(int (*)(void *))labcomm"+env.verStr+"_signature_" +
// env.prefix + getName() + "_emit_signature");
// } else {
// env.println("NULL"); // HERE BE DRAGONS! Is it worth the size saving to skip emitting the emit_signature function for unused types?
// // The code won't likely end up in a target system anyway?
// }
// }
// env.unindent();
// env.println(" };");
//
} else {
env.println("// not emitting signature for " + getName() +
"referenced=" + isReferenced() +
"sampledecl=" + isSampleDecl());
}
}
public void ASTNode.C_emitFlatSignature(C_env env) {
......@@ -1273,7 +1247,25 @@ aspect C_Signature {
" not declared");
}
public void Decl.C_emitFlatSignature(C_env env) {
public void TypeDecl.C_emitFlatSignature(C_env env) {
C_emitSizeofValue(env);
env.println("static struct labcomm2014_signature " +
"signature_" + env.prefix + getName() + " = {");
env.indent();
env.println("\"" + getName() + "\",");
//env.println("sizeof_" + env.prefix + getName() + ",");
//HERE BE DRAGONS? do we need sizeof for typedefs?
env.println("NULL,");
env.println("0,");
env.println("NULL,");
env.println("0,"); // index
env.println("sizeof(signature_tree_" + env.prefix + getName() + "),");
env.println("signature_tree_" + env.prefix + getName() + "");
env.unindent();
env.println(" };");
env.println("const struct labcomm2014_signature " +
"*labcomm2014_signature_" + env.prefix + getName() +
" = &signature_" + env.prefix + getName() + ";");
}
public void SampleDecl.C_emitFlatSignature(C_env env){
......@@ -1297,18 +1289,20 @@ aspect C_Signature {
env.println("};");
C_emitSizeofValue(env);
env.println("static struct labcomm"+env.verStr+"_signature " +
env.println("static struct labcomm2014_signature " +
"signature_" + env.prefix + getName() + " = {");
env.indent();
env.println("\"" + getName() + "\",");
env.println("sizeof_" + env.prefix + getName() + ",");
env.println("sizeof(signature_bytes_" + env.prefix + getName() + "),");
env.println("signature_bytes_" + env.prefix + getName() + ",");
env.println("0");
env.println("0,"); // index
env.println("sizeof(signature_tree_" + env.prefix + getName() + "),");
env.println("signature_tree_" + env.prefix + getName() + "");
env.unindent();
env.println(" };");
env.println("const struct labcomm"+env.verStr+"_signature " +
"*labcomm"+env.verStr+"_signature_" + env.prefix + getName() +
env.println("const struct labcomm2014_signature " +
"*labcomm2014_signature_" + env.prefix + getName() +
" = &signature_" + env.prefix + getName() + ";");
}
......@@ -1319,28 +1313,29 @@ aspect C_Signature {
public abstract void SignatureLine.C_emitSignature(C_env env, boolean decl);
public void TypeRefSignatureLine.C_emitSignature(C_env env, boolean isDecl){
//env.print(getIndentString());
//env.println("LABCOMM_SIGDEF_SIGNATURE(labcomm"+env.verStr+"_signature_" + env.prefix + decl.getName() +"),");
env.print(getIndentString());
// env.println("LABCOMM_SIGDEF_SIGNATURE(labcomm2014_signature_" + env.prefix + decl.getName() +"),");
env.println("LABCOMM_SIGDEF_SIGNATURE(signature_" + env.prefix + decl.getName() +"),");
}
public void DataSignatureLine.C_emitSignature(C_env env, boolean decl){
// String comment = getComment();
// if (comment != null && comment.length() > 0) {
// env.println(getIndentString() + "// " + comment);
// }
// byte[] data = getData(env.version);
// if (data != null && data.length > 0) {
// env.print(getIndentString());
// env.print("LABCOMM_SIGDEF_BYTES("+data.length+", \"");
// for (int j = 0 ; j < data.length ; j++) {
// byte d = data[j];
// //if(d>='a'&&d<='z' || d>='A'&&d<='Z'|| d>='0'&&d<='9' )
// // env.print(""+(char)d);
// //else
// env.print("\\x"+Integer.toHexString(d));
// }
// env.println("\"),");
// }
String comment = getComment();
if (comment != null && comment.length() > 0) {
env.println(getIndentString() + "// " + comment);
}
byte[] data = getData(env.version);
if (data != null && data.length > 0) {
env.print(getIndentString());
env.print("LABCOMM_SIGDEF_BYTES("+data.length+", \"");
for (int j = 0 ; j < data.length ; j++) {
byte d = data[j];
//if(d>='a'&&d<='z' || d>='A'&&d<='Z'|| d>='0'&&d<='9' )
// env.print(""+(char)d);
//else
env.print("\\x"+Integer.toHexString(d));
}
env.println("\"),");
}
}
//
//
......@@ -1348,8 +1343,8 @@ aspect C_Signature {
// if (data != null) {
// for (int j = 0 ; j < data.length ; j++) {
// env.print(getIndentString());
// //env.print("printf(\"labcomm"+env.verStr+"_write_byte( w, (unsigned char)"+ String.format("0x%02X ", data[j]) +")\\n\"); ");
// env.print("labcomm"+env.verStr+"_write_byte( w, (unsigned char)"+ String.format("0x%02X ", data[j]) +"); ");
// //env.print("printf(\"labcomm2014_write_byte( w, (unsigned char)"+ String.format("0x%02X ", data[j]) +")\\n\"); ");
// env.print("labcomm2014_write_byte( w, (unsigned char)"+ String.format("0x%02X ", data[j]) +"); ");
// env.println("if (result != 0) { return result; }");
// }
// env.println();
......@@ -1357,18 +1352,18 @@ aspect C_Signature {
//
//}
public void SignatureList.C_emitSignature(C_env env, boolean decl) {
// env.println("static struct labcomm_signature_data signature_tree_" +
// env.prefix + parentDecl().getName() + "[] = {");
// env.indent();
// for (int i = 0 ; i < size() ; i++) {
// SignatureLine l = getSignatureLine(i);
// l.C_emitSignature(env, decl);
// }
//
// env.println("LABCOMM_SIGDEF_END");
// env.println("};");
// env.unindent();
// env.println();
env.println("static struct labcomm2014_signature_data signature_tree_" +
env.prefix + parentDecl().getName() + "[] = {");
env.indent();
for (int i = 0 ; i < size() ; i++) {
SignatureLine l = getSignatureLine(i);
l.C_emitSignature(env, decl);
}
env.println("LABCOMM_SIGDEF_END");
env.println("};");
env.unindent();
env.println();
}
......@@ -1392,11 +1387,11 @@ aspect C_Signature {
// }
// }
// env.println("};");
// env.println("struct labcomm"+env.verStr+"_signature labcomm"+env.verStr+"_signature_" +
// env.println("struct labcomm2014_signature labcomm2014_signature_" +
// env.prefix + getName() + " = {");
// env.indent();
// env.println("LABCOMM_SAMPLE, \"" + getName() + "\",");
// env.println("(int (*)(struct labcomm"+env.verStr+"_signature *, void *))labcomm"+env.verStr+"_sizeof_" +
// env.println("(int (*)(struct labcomm2014_signature *, void *))labcomm2014_sizeof_" +
// env.prefix + getName() + ",");
// env.println("sizeof(signature_bytes_" + env.prefix + getName() + "),");
// env.println("signature_bytes_" + env.prefix + getName() + ",");
......@@ -1413,7 +1408,7 @@ aspect C_Constructor {
" not declared");
}
public void Program.C_emitConstructor(C_env env) {
public void Specification.C_emitConstructor(C_env env) {
env.println("LABCOMM_CONSTRUCTOR void init_" +
env.prefix + "_signatures(void)");
env.println("{");
......@@ -1431,11 +1426,15 @@ aspect C_Constructor {
env.println("}");
}
public void Decl.C_emitConstructor(C_env env) {
public void TypeDecl.C_emitConstructor(C_env env) {
if (isReferenced()) {
env.println("labcomm2014_set_local_index(&signature_" +
env.prefix + getName() + ");");
}
}
//XXX
public void SampleDecl.C_emitConstructor(C_env env) {
env.println("labcomm"+env.verStr+"_set_local_index(&signature_" +
env.println("labcomm2014_set_local_index(&signature_" +
env.prefix + getName() + ");");
}
......@@ -1446,23 +1445,24 @@ aspect C_Constructor {
" not declared");
}
public void Program.C_emitConstructorDeclaration(C_env env) {
public void Specification.C_emitConstructorDeclaration(C_env env) {
env.println("void init_" + env.prefix + "_signatures(void);");
}
}
aspect C_Sizeof {
public void Decl.C_emitSizeofDeclaration(C_env env) {
}
public void SampleDecl.C_emitSizeofDeclaration(C_env env) {
env.println("extern int labcomm"+env.verStr+"_sizeof_" + env.prefix + getName() +
"(" + env.prefix + getName() + " *v);");
env.println("extern int labcomm2014_sizeof_" + env.prefix + getName() +
"( const struct labcomm2014_signature *sig, " + env.prefix + getName() + " *v);");
}
public int Decl.C_fixedSizeof() {
return getType().C_fixedSizeof();
return getDataType().C_fixedSizeof();
}
public void Decl.C_emitSizeof(C_env env) {
......@@ -1470,18 +1470,18 @@ aspect C_Sizeof {
public void SampleDecl.C_emitSizeof(C_env env) {
env = env.nestStruct("(*v)");
env.println("int labcomm"+env.verStr+"_sizeof_" + env.prefix + getName() +
"(" + env.prefix + getName() + " *v)");
env.println("int labcomm2014_sizeof_" + env.prefix + getName() +
"( const struct labcomm2014_signature *sig, " + env.prefix + getName() + " *v)");
env.println("{");
env.indent();
env.println("return labcomm"+env.verStr+"_internal_sizeof(" +
env.println("return labcomm2014_internal_sizeof(" +
"&signature_" + env.prefix + getName() +
", v);");
env.unindent();
env.println("}");
}
public int Type.C_fixedSizeof() {
public int DataType.C_fixedSizeof() {
throw new Error(this.getClass().getName() +
".C_fixedSizeof()" +
" not declared");
......@@ -1510,13 +1510,13 @@ aspect C_Sizeof {
}
public int UserType.C_fixedSizeof() {
return lookupType(getName()).getType().C_fixedSizeof();
return lookupType(getName()).getDataType().C_fixedSizeof();
}
public int StructType.C_fixedSizeof() {
int result = 0;
for (int i = 0 ; i < getNumField() ; i++) {
result += getField(i).getType().C_fixedSizeof();
result += getField(i).getDataType().C_fixedSizeof();
}
return result;
}
......@@ -1527,7 +1527,7 @@ aspect C_Sizeof {
int n = Integer.parseInt(((IntegerLiteral)getExp(i)).getValue());
elements = elements * n;
}
return getType().C_fixedSizeof() * elements;
return getDataType().C_fixedSizeof() * elements;
}
public void Decl.C_emitSizeofValue(C_env env) {
......@@ -1535,13 +1535,13 @@ aspect C_Sizeof {
public void SampleDecl.C_emitSizeofValue(C_env env) {
env = env.nestStruct("(*v)");
env.println("static int sizeof_" + env.prefix + getName() + "(void *vv)");
env.println("static int sizeof_" + env.prefix + getName() + "( const struct labcomm2014_signature *sig, void *vv)");
env.println("{");
env.indent();
env.println("int result = 0;");
if (C_isDynamic()) {
env.println(env.prefix + getName() + " *v = vv;");
getType().C_emitSizeof(env);
getDataType().C_emitSizeof(env);
} else {
env.println("result += " + C_fixedSizeof() + ";");
}
......@@ -1550,7 +1550,7 @@ aspect C_Sizeof {
env.println("}");
}
public void Type.C_emitSizeof(C_env env) {
public void DataType.C_emitSizeof(C_env env) {
throw new Error(this.getClass().getName() +
".C_emitSizeof(C_env env)" +
" not declared");
......@@ -1560,7 +1560,7 @@ aspect C_Sizeof {
switch (getToken()) {
case LABCOMM_STRING: {
env.print("{ int l = strlen(" + env.qualid + "); ");
env.println("result += labcomm"+env.verStr+"_size_packed32(l) + l; }");
env.println("result += labcomm2014_size_packed32(l) + l; }");
} break;
default: {
throw new Error(this.getClass().getName() +
......@@ -1571,17 +1571,17 @@ aspect C_Sizeof {
}
public void UserType.C_emitSizeof(C_env env) {
lookupType(getName()).getType().C_emitSizeof(env);
lookupType(getName()).getDataType().C_emitSizeof(env);
}
public void StructType.C_emitSizeof(C_env env) {
int fixed = 0;
for (int i = 0 ; i < getNumField() ; i++) {
if (getField(i).getType().C_isDynamic()) {
getField(i).getType().C_emitSizeof(
if (getField(i).getDataType().C_isDynamic()) {
getField(i).getDataType().C_emitSizeof(
env.nestStruct("." + getField(i).getName()));
} else {
fixed += getField(i).getType().C_fixedSizeof();
fixed += getField(i).getDataType().C_fixedSizeof();
}
}
if (fixed > 0) {
......@@ -1589,13 +1589,24 @@ aspect C_Sizeof {
}
}
public void Exp.C_emitSizeof(C_env env, int i) {
}
public void VariableSize.C_emitSizeof(C_env env, int i) {
env.println("result += labcomm2014_size_packed32(" +
env.qualid + env.memberAccessor() + "n_" + i + ");");
}
public void ArrayType.C_emitSizeof(C_env env) {
if (getType().C_isDynamic()) {
for (int i = 0 ; i < getNumExp() ; i++) {
getExp(i).C_emitSizeof(env, i);
}
if (getDataType().C_isDynamic()) {
env.println("{");
env.indent();
C_emitLoopVariables(env);
for (int i = 0 ; i < getNumExp() ; i++) {
String iterator = "i_" + env.depth + "_" + i;
String iterator = "i_" + env.getDepth() + "_" + i;
env.println("for (" + iterator + " = 0" +
" ; " +
iterator + " < " + getExp(i).C_getLimit(env, i) +
......@@ -1604,7 +1615,7 @@ aspect C_Sizeof {
env.indent();
}
C_emitCalcIndex(env);
getType().C_emitSizeof(C_Nest(env));
getDataType().C_emitSizeof(C_Nest(env));
for (int i = 0 ; i < getNumExp() ; i++) {
env.unindent();
env.println("}");
......@@ -1612,11 +1623,7 @@ aspect C_Sizeof {
env.unindent();
env.println("}");
} else {
for (int i = 0 ; i < getNumExp() ; i++) {
env.println("result += labcomm"+env.verStr+"_size_packed32(" +
getExp(i).C_getLimit(env, i) + ");");
}
env.print("result += " + getType().C_fixedSizeof());
env.print("result += " + getDataType().C_fixedSizeof());
for (int i = 0 ; i < getNumExp() ; i++) {
env.print(" * " + getExp(i).C_getLimit(env, i));
}
......@@ -1627,7 +1634,7 @@ aspect C_Sizeof {
aspect C_forAll {
public void Program.C_emitForAll(C_env env) {
public void Specification.C_emitForAll(C_env env) {
env.print("#define LABCOMM_FORALL_SAMPLES_" + env.lcName +
"(func, sep)");
env.indent();
......@@ -1657,7 +1664,7 @@ aspect C_forAll {
aspect C_Info {
public void Program.C_info(PrintStream out, String prefix, int version) {
public void Specification.C_info(PrintStream out, String prefix, int version) {
C_env env = new C_env("", "", prefix, out, version);
for (int i = 0; i < getNumDecl(); i++) {
getDecl(i).C_info(env);
......
aspect DeclNames {
inh String Type.declName();
eq Decl.getType().declName() = getName();
inh String DataType.declName();
eq Decl.getTypeInstance().declName() = getName();
inh String Field.declName();
eq StructType.getField(int i).declName() = declName();
//TODO: aspect should be renamed to parent-something
inh Decl Type.parentDecl();
inh Decl DataType.parentDecl();
inh Decl Field.parentDecl();
eq Decl.getType().parentDecl() = this;
eq Decl.getTypeInstance().parentDecl() = this;
eq StructType.getField(int i).parentDecl() = parentDecl();
}
......@@ -27,5 +27,4 @@ aspect ErrorCheck {
getChild(i).errorCheck(collection);
}
}
}
import java.util.*;
aspect NoIntentionForTypeOrSampledefs {
inh boolean TypeInstance.addIntentions();
eq Decl.getTypeInstance().addIntentions() = false;
eq StructType.getField(int i).addIntentions() = true;
}
aspect FlatSignature {
public SignatureList Decl.flatSignature(int version) {
......@@ -14,15 +20,23 @@ aspect FlatSignature {
}
public void TypeDecl.flatSignature(SignatureList list) {
getType().flatSignature(list);
getTypeInstance().flatSignature(list);
}
public void SampleDecl.flatSignature(SignatureList list) {
getType().flatSignature(list);
getTypeInstance().flatSignature(list);
}
public void SampleRefType.flatSignature(SignatureList list) {
list.addInt(LABCOMM_SAMPLE_REF, "sample");
// public void SampleRefType.flatSignature(SignatureList list) {
// list.addInt(LABCOMM_SAMPLE_REF, "sample");
// }
public void TypeInstance.flatSignature(SignatureList list) {
if(addIntentions()) {
debugAnnotations(this.getName()+".TypeInstance.flatSignature");
list.addIntentions(intentions(), "intentions: "+getIntentionString());
}
getDataType().flatSignature(list);
}
public void VoidType.flatSignature(SignatureList list) {
......@@ -45,7 +59,7 @@ aspect FlatSignature {
for (int i = 0 ; i < getNumExp() ; i++) {
getExp(i).flatSignature(list);
}
getType().flatSignature(list);
getDataType().flatSignature(list);
list.unindent();
list.add(null, "}");
}
......@@ -62,8 +76,10 @@ aspect FlatSignature {
}
public void Field.flatSignature(SignatureList list) {
list.addString(getName(), signatureComment());
getType().flatSignature(list);
debugAnnotations(this.getName()+".Field.flatSignature");
list.addIntentions(intentions(), "Field: "+getIntentionString());
// list.addString(getName(), signatureComment());
getDataType().flatSignature(list);
}
public void IntegerLiteral.flatSignature(SignatureList list) {
......@@ -93,12 +109,12 @@ aspect FlatSignature {
}
public String Field.signatureComment() {
return getType().signatureComment() + " '" + getName() +"'";
return getDataType().signatureComment() + " '" + getName() +"'";
}
public String SampleRefType.signatureComment() {
return "sample";
}
// public String SampleRefType.signatureComment() {
// return "sample";
// }
public String PrimType.signatureComment() {
return getName();
......
aspect TypeDefGen {
public void Specification.generateTypedefs(PrintStream out, int ver) {
for(Decl d : getDecls()) {
d.generateTypedefs(out);
}
}
public void Decl.generateTypedefs(PrintStream out) {
}
public void Decl.generateDepTypedefs(PrintStream out){
Iterator<Decl> it = type_dependencies().iterator();
while(it.hasNext()) {
Decl d = it.next();
d.generateDepTypedefs(out);
}
pp(out);
}
public void SampleDecl.generateTypedefs(PrintStream out){
if(hasDependencies()) {
out.println("sample "+getName()+"_def {");
out.println(" sample sample;");
out.println(" string typedef = <<EOL");
for(Decl d : type_dependencies()) {
d.generateDepTypedefs(out);
}
pp(out);
out.println("EOL;");
}
}
}
......@@ -6,148 +6,40 @@ aspect Java_CodeGenEnv {
// Environment wrapper for Java-code generation
// handles indentation, file writing,
public class Java_env {
public class Java_env extends PrintEnv {
public final int version; //labcomm version to generate code for
public final String verStr;
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();
}
}
final private static class Java_printer extends PrintEnv.FilePrinter {
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);
super(out);
}
public void println(Java_env env, String s) {
checkOpen();
print(env, s);
out.println();
newline = true;
}
}
private Java_env(int version, int indent) {
this.version = version;
this.verStr = LabCommVersion.versionString(version);
this.indent = indent;
public Java_printer(File f) {
super(f);
}
private Java_env(int version, Java_printer printer) {
this(version, 0);
this.printer = printer;
}
public Java_env(int version, File f) {
this(version, 0);
this.printer = new Java_printer(f);
super(0, new Java_printer(f), version);
}
public Java_env(int version, PrintStream out) {
this(version, 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 void println(String s) {
printer.println(this, s);
}
public void println() {
printer.println(this, "");
}
public int getDepth() {
return depth;
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("}");
}
......@@ -178,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();
......@@ -195,16 +87,16 @@ aspect Java_StructName {
aspect Java_Void {
syn boolean Decl.isVoid() = getType().isVoid();
syn boolean Decl.isVoid() = getDataType().isVoid();
syn boolean UserType.isVoid() = decl().isVoid();
syn boolean Type.isVoid() = false;
syn boolean DataType.isVoid() = false;
syn boolean VoidType.isVoid() = true;
}
aspect Java_CodeGen {
public void Program.J_gen(PrintStream ps, String pack, int version) throws IOException {
public void Specification.J_gen(PrintStream ps, String pack, int version) throws IOException {
Java_env env;
env = new Java_env(version, ps);
for (int i = 0; i < getNumDecl(); i++) {
......@@ -219,7 +111,7 @@ aspect Java_CodeGen {
env.close();
}
public void Program.J_gen(String dir, String pack, int version) throws IOException {
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);
......@@ -236,7 +128,7 @@ aspect Java_CodeGen {
/** Experimental method for generating code to a map <classname, source>
*/
public void Program.J_gen(Map<String,String> src, String pack, int version) throws IOException {
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++) {
Decl d = getDecl(i);
......@@ -275,6 +167,55 @@ aspect Java_Class {
}
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)
......@@ -295,7 +236,7 @@ aspect Java_Class {
Decl t = it.next();
t.Java_emitUserTypeDeps(env, t.getName(), outputCode);
if( outputCode){// && t.getType().isUserType() ) {
if( outputCode){// && t.getDataType().isUserType() ) {
env.println(t.getName()+".register(e);");
} else { // Just output a comment
String refpath = (via == null) ? "directly" : "indirectly via "+via;
......@@ -335,7 +276,8 @@ aspect Java_Class {
env.println();
env.println("public static void register(Encoder e, boolean sendMetaData) throws IOException {");
env.indent();
Java_emitUserTypeDeps(env, null, true);
// Java_emitUserTypeDeps(env, null, true);
env.println("dispatcher.registerTypeDeps(e);");
env.println("e.register(dispatcher);");
env.unindent();
env.println("}");
......@@ -345,6 +287,12 @@ aspect Java_Class {
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) {
......@@ -355,15 +303,19 @@ aspect Java_Class {
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 (getType().Java_needInstance() || hasDependencies() || isReferenced()) {
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 (getType().Java_needInstance()) {
// if (getDataType().Java_needInstance()) {
env.println("import java.io.IOException;");
env.println("import se.lth.control.labcomm"+env.verStr+".Decoder;");
}
......@@ -374,14 +326,14 @@ aspect Java_Class {
env.println();
env.indent();
if (getType().Java_needInstance()) {
getType().Java_emitInstance(env);
if (getDataType().Java_needInstance()) {
getDataType().Java_emitInstance(env);
Java_emitEncoder(env);
Java_emitDecoder(env);
}
//if(hasDependencies() || isReferenced()) {
//if( getType().isUserType() && isReferenced()) {
//if( getDataType().isUserType() && isReferenced()) {
if( isReferenced()) {
Java_emitRegisterEncoder(env);
Java_emitDispatcher(env, false);
......@@ -408,23 +360,27 @@ aspect Java_Class {
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.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(getType().isUserType()) {
// env.print(" extends "+getType().getTypeName());
// if(getDataType().isUserType()) {
// env.print(" extends "+getDataType().getTypeName());
// }
env.println(" implements Sample {");
env.println();
env.indent();
getType().Java_emitInstance(env);
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;");
......@@ -454,21 +410,37 @@ aspect Java_Class {
env.println();
}
//public void TypeDecl.Java_emitSignature(Java_env env) {
// Signature signature = getSignature();
// signature.Java_emitSignature(env, true);
//}
public void TypeDecl.Java_emitSignature(Java_env env) {
Signature signature = getSignature();
signature.Java_emitSignature(env, true);
}
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()){
// Signature signature = getSignature();
// signature.Java_emitSignature(env, !isSampleDecl());
//}
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();
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){
......@@ -491,24 +463,124 @@ aspect Java_Class {
}
env.unindent();
env.println("};");
env.unindent();
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()+">":"";
env.println("private static Dispatcher dispatcher = new Dispatcher();");
// 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("private static class Dispatcher implements SampleDispatcher "+genericStr+"{");
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;");
......@@ -544,16 +616,42 @@ aspect Java_Class {
env.println("return "+isSample+";");
env.unindent();
env.println("}");
// env.println("public boolean hasStaticSignature() {");
// env.indent();
// env.println("return "+!hasDependencies()+";");
// 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();
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("/** return the outermost intentions. */");
env.println("public byte[] getIntentionBytes() {");
env.indent();
if(isSample) {
env.println("return intentions;");
} else {
env.println("return new byte[0];");
}
env.unindent();
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();
......@@ -563,15 +661,16 @@ aspect Java_Class {
// env.unindent();
// env.println("}");
// env.println();
// env.println("public void encodeSignatureMetadata(Encoder e, int index) throws IOException{");
// env.indent();
// env.println("e.encodePacked32(Constant.TYPE_DEF);");
// env.println("e.encodePacked32(index);");
// env.println("e.encodeString(getName());");
// env.println("emitSignature(e);");
// env.unindent();
// env.println("}");
// env.println();
env.println("public void encodeTypeDef(Encoder e, int index) throws IOException{");
env.indent();
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("public boolean canDecodeAndHandle() {");
env.indent();
env.println("return "+isSample+";");
......@@ -605,12 +704,12 @@ aspect Java_Class {
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();
......@@ -620,20 +719,20 @@ aspect Java_Class {
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) {
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");
......@@ -642,6 +741,39 @@ aspect Java_Class {
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;
......@@ -670,7 +802,7 @@ 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();
......@@ -695,7 +827,7 @@ aspect Java_Class {
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());
}
}
......@@ -703,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);
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();
......@@ -723,7 +855,7 @@ aspect Java_Class {
env.println();
}
public void Type.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");
......@@ -763,7 +895,7 @@ aspect Java_Class {
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();
}
......@@ -791,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());
}
}
......@@ -799,11 +931,11 @@ 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) {
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");
......@@ -811,15 +943,15 @@ aspect Java_Class {
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) {
public void DataType.Java_emitTypePrefix(Java_env env) {
throw new Error(this.getClass().getName() +
".Java_emitTypePrefix(Java_env env)" +
" not declared");
......@@ -837,35 +969,35 @@ 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() {
public boolean DataType.Java_needInstance() {
throw new Error(this.getClass().getName() +
".Java_needInstance()" +
" not declared");
......@@ -880,7 +1012,7 @@ aspect Java_Class {
}
public boolean UserType.Java_needInstance() {
return decl().getType().Java_needInstance();
return decl().getDataType().Java_needInstance();
}
public boolean StructType.Java_needInstance() {
......@@ -888,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;
}
......@@ -899,7 +1031,7 @@ aspect Java_Class {
return true;
}
public void Type.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");
......@@ -912,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) {
......@@ -921,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);
......@@ -938,11 +1070,11 @@ aspect Java_Class {
public void Field.Java_emitField(Java_env env) {
env.print("public ");
getType().Java_emitType(env);
getDataType().Java_emitType(env);
env.println(" " + getName() + ";");
}
public void Type.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");
......@@ -961,11 +1093,11 @@ aspect Java_Class {
}
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("[]");
}
......@@ -1026,7 +1158,7 @@ aspect Java_Signature {
aspect Java_Info {
public void Program.Java_info(PrintStream out, int version) {
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);
......@@ -1041,14 +1173,14 @@ aspect Java_Info {
public void TypeDecl.Java_info(Java_env env) {
env.print(",Java,typedef," + getName() + ",");
getType().Java_emitType(env);
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);
getDataType().Java_emitType(env);
env.print(",not_applicable_for_Java");
env.println();
}
......
Program ::= Decl*;
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.
//TODO: Add signatures to the abstract grammar, so that
//they can be extended and refined by more than one aspect.
//sketch:
Signature ::= SignatureList FlatSignatureList:SignatureList;
SignatureList ::= SignatureLine*;
abstract SignatureLine ::= <Indent:int> <Comment:String>;
......@@ -10,25 +23,19 @@ abstract DataSignatureLine : SignatureLine;
ByteArraySignatureLine : DataSignatureLine ::= <Data:byte[]>;
IntSignatureLine : DataSignatureLine ::= <Data:int>;
StringSignatureLine : DataSignatureLine ::= <Data:String>;
IntentionSignatureLine : DataSignatureLine ::= Intention* ;
TypeRefSignatureLine : SignatureLine ::= Decl;
Field : TypeInstance;
//abstract Decl ::= Type <Name:String>;
// the signature list be defined as a non-terminal attribute:
abstract Decl ::= Type <Name:String> /Signature/;
TypeDecl : Decl;
SampleDecl : Decl;
Field ::= Type <Name:String>;
abstract Type;
VoidType : Type;
SampleRefType : Type;
PrimType : Type ::= <Name:String> <Token:int>;
UserType : Type ::= <Name:String>;
StructType : Type ::= Field*;
ParseArrayType : Type ::= Type Dim*;
abstract ArrayType :Type ::= Type Exp*;
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;
......
......@@ -14,7 +14,7 @@ public class LabComm {
println("");
println(" --help Shows this help text");
println(" -v Be verbose");
println(" --ver=VERSION Generate code for labcomm VERSION (=2006 or 2013)");
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");
......@@ -36,6 +36,7 @@ public class LabComm {
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.
......@@ -48,7 +49,7 @@ public class LabComm {
}
}
private static void genH(Program p, String hName,
private static void genH(Specification p, String hName,
Vector cIncludes, String coreName, String prefix, int ver) {
try {
FileOutputStream f;
......@@ -63,7 +64,7 @@ public class LabComm {
}
}
private static void genC(Program p, String cName,
private static void genC(Specification p, String cName,
Vector cIncludes, String coreName, String prefix, int ver) {
try {
FileOutputStream f;
......@@ -78,7 +79,7 @@ public class LabComm {
}
}
private static void genCS(Program p, String csName, String csNamespace, int ver) {
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);
......@@ -88,7 +89,7 @@ public class LabComm {
}
}
private static void genJava(Program p, String dirName, String packageName, int ver) {
private static void genJava(Specification p, String dirName, String packageName, int ver) {
try {
p.J_gen(dirName, packageName, ver);
} catch (IOException e) {
......@@ -97,7 +98,7 @@ public class LabComm {
}
}
private static void genPython(Program p, String filename, String prefix, int ver) {
private static void genPython(Specification p, String filename, String prefix, int ver) {
try {
FileOutputStream f;
PrintStream out;
......@@ -111,7 +112,7 @@ public class LabComm {
}
}
private static void genRAPID(Program p, String filename, String prefix, int ver) {
private static void genRAPID(Specification p, String filename, String prefix, int ver) {
try {
p.RAPID_gen(filename, prefix, ver);
} catch (IOException e) {
......@@ -127,7 +128,7 @@ public class LabComm {
String coreName = null;
String prefix = null;
boolean verbose = false;
int ver = 2013; //Version 2013 as default
int ver = 2014; //Version 2014 as default
String cFile = null;
String hFile = null;
Vector cIncludes = new Vector();
......@@ -139,6 +140,7 @@ public class LabComm {
String pythonFile = null;
String prettyFile = null;
String typeinfoFile = null;
String typedefsFile = null;
String rapidFile = null;
String fileName = null;
......@@ -223,6 +225,8 @@ public class LabComm {
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) {
......@@ -239,14 +243,14 @@ public class LabComm {
}
}
Program parseFile(){
Program ast = null;
Specification parseFile(){
Specification ast = null;
try {
// Check for errors
LabCommScanner scanner = new LabCommScanner(
new FileReader(fileName));
LabCommParser parser = new LabCommParser();
Program p = (Program)parser.parse(scanner);
Specification p = (Specification)parser.parse(scanner);
Collection errors = new LinkedList();
p.errorCheck(errors);
......@@ -268,7 +272,7 @@ public class LabComm {
return ast;
}
boolean generateC(Program ast) {
boolean generateC(Specification ast) {
boolean wroteFile = false;
Vector hIncludes = new Vector(cIncludes);
if (hFile != null) {
......@@ -287,7 +291,7 @@ public class LabComm {
return wroteFile;
}
boolean generateCS(Program ast) {
boolean generateCS(Specification ast) {
boolean wroteFile = false;
if (csFile != null) {
printStatus("C#: " , csFile);
......@@ -297,7 +301,7 @@ public class LabComm {
return wroteFile;
}
boolean generateJava(Program ast) {
boolean generateJava(Specification ast) {
boolean wroteFile = false;
if (javaDir != null) {
printStatus("Java: " , javaDir);
......@@ -307,7 +311,7 @@ public class LabComm {
return wroteFile;
}
boolean generatePython(Program ast) {
boolean generatePython(Specification ast) {
boolean wroteFile = false;
if (pythonFile != null) {
printStatus("Python: " , pythonFile);
......@@ -317,7 +321,7 @@ public class LabComm {
return wroteFile;
}
boolean generateRAPID(Program ast) {
boolean generateRAPID(Specification ast) {
boolean wroteFile = false;
if (rapidFile != null) {
printStatus("RAPID: " , rapidFile);
......@@ -326,7 +330,7 @@ public class LabComm {
}
return wroteFile;
}
boolean generatePrettyPrint(Program ast) {
boolean generatePrettyPrint(Specification ast) {
boolean wroteFile = false;
if (prettyFile != null) {
printStatus("Pretty: " , prettyFile);
......@@ -343,7 +347,7 @@ public class LabComm {
return wroteFile;
}
boolean generateTypeinfo(Program ast) {
boolean generateTypeinfo(Specification ast) {
boolean wroteFile = false;
if (typeinfoFile != null) {
printStatus("TypeInfo: " , typeinfoFile);
......@@ -361,6 +365,22 @@ public class LabComm {
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);
......@@ -376,7 +396,7 @@ public class LabComm {
System.exit(1);
} else {
opts.processArgs();
Program ast = opts.parseFile();
Specification ast = opts.parseFile();
if (ast != null) {
......@@ -389,6 +409,7 @@ public class LabComm {
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) {
......
......@@ -34,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 =
......@@ -54,26 +54,40 @@ List var_decl_list =
| var_decl_list.l var_decl.v {: return l.add(v); :}
;
Annotations annotations =
/* empty list */ {: return new Annotations(); :}
| annotation_list.l {: return new Annotations(l); :}
;
List annotation_list =
annotation.i {: return new List().add(i); :}
| annotation_list.l annotation.i {: return l.add(i); :}
;
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); :}
;
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); :}
type_instance.t SEMICOLON {: return new Field(t); :}
;
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); :}
;
TYPEDEF type_instance.t SEMICOLON {: return new TypeDecl(t); :} ;
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 type_instance.t SEMICOLON {: return new SampleDecl(t); :} ;
Type type =
DataType type =
prim_type.p {: return p; :}
| user_type.u {: return u; :}
| struct_type.s {: return s; :}
......
......@@ -44,13 +44,16 @@ Comment = {TraditionalComment}
TraditionalComment = "/*" [^*] ~"*/" | "/*" "*"+ "/" | "/*" "*"+ [^/*] ~"*/"
EndOfLineComment = "//" {InputCharacter}* {LineTerminator}?
Identifier = [:jletter:][:jletterdigit:]*
Identifier = [[:letter:]_]([[:letter:]_[:digit:]])*
StringLiteral = [:jletterdigit:]*
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
......
......@@ -3,7 +3,8 @@ 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 = 0x04; // and type declarations, hierarchically
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;
......
......@@ -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,8 +34,8 @@ aspect NameAnalysis {
return null;
}
syn TypeDecl Type.decl();
eq Type.decl() = null;
syn TypeDecl DataType.decl();
eq DataType.decl() = null;
eq UserType.decl() = lookupType(getName());
eq PrimType.decl() = null; //HERE BE DRAGONS XXX
......