Skip to content
Snippets Groups Projects

Compare revisions

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

Source

Select target project
No results found

Target

Select target project
  • anders_blomdell/labcomm
  • klaren/labcomm
  • tommyo/labcomm
  • erikj/labcomm
  • sven/labcomm
5 results
Show changes
Commits on Source (602)
502 additional commits have been omitted to prevent performance issues.
Hide whitespace changes
Inline Side-by-side
Showing
with 2581 additions and 988 deletions
.bzrignore deleted 100644 → 0
View file @ ca5b4caf
AST
AST/*
LabComm.class
labComm.jar
lib/java/se/lth/control/labcomm/LabComm.class
lib/java/se/lth/control/labcomm/LabCommDecoderChannel.class
lib/java/se/lth/control/labcomm/LabCommDecoder.class
lib/java/se/lth/control/labcomm/LabCommDecoderRegistry.class
lib/java/se/lth/control/labcomm/LabCommDecoderRegistry$Entry.class
lib/java/se/lth/control/labcomm/LabCommDispatcher.class
lib/java/se/lth/control/labcomm/LabCommEncoderChannel.class
lib/java/se/lth/control/labcomm/LabCommEncoder.class
lib/java/se/lth/control/labcomm/LabCommEncoderRegistry.class
lib/java/se/lth/control/labcomm/LabCommEncoderRegistry$Entry.class
lib/java/se/lth/control/labcomm/LabCommHandler.class
lib/java/se/lth/control/labcomm/LabCommReader.class
lib/java/se/lth/control/labcomm/LabCommSample.class
lib/java/se/lth/control/labcomm/LabCommType.class
lib/java/se/lth/control/labcomm/LabCommWriter.class
gen
.gitignore 0 → 100644
View file @ d3921882
*~
*.class
*.o
*.pyc
examples/dynamic/gen
ErrorCheck.jrag deleted 100644 → 0
View file @ ca5b4caf
import java.util.Collection;
aspect ErrorCheck {
syn int ASTNode.lineNumber() = getLine(getStart());
protected String ASTNode.errors = null;
protected void ASTNode.error(String s) {
s = "Error at " + lineNumber() + ": " + s;
if(errors == null) {
errors = s;
} else {
errors = errors + "\n" + s;
}
}
protected boolean ASTNode.hasErrors() {
return errors != null;
}
public void ASTNode.errorCheck(Collection collection) {
nameCheck();
if(hasErrors())
collection.add(errors);
for(int i = 0; i < getNumChild(); i++) {
getChild(i).errorCheck(collection);
}
}
}
LICENSE.rationale 0 → 100644
View file @ d3921882
Rationale for the licensing choosen for LabComm
===============================================
Primary goal: the owners of systems with LabComm communication in it,
should have the liberty to replace the LabComm parts with
any software they see fit.
Secondary goal: it should be possible to release propreitary software
with LabComm.
Wanted software architecture
^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+------------------------------------------------------------+
| Propreitary software (any license) |
+------------------------------------------------------------+
| Labcomm glue (LGPL) |
+--------------+-----+--------------+ |
| Generated | | Generated | |
| encoder/ | | encoder/ | |
| decoder | * * | decoder | |
| ( GPLv3 + | | ( GPLv3 + | +---------------+
| permission) | | permission) | | Non-system |
+--------------+-----+--------------+--+ | library |
| LabComm library (GPLv3 + permission) | | (any license) |
+--------------------------------------+-----+----------+----+
| System library (any license) | |
+-------------------------------------------------------+ |
| OS (any license) |
+------------------------------------------------------------+
License considerations
^^^^^^^^^^^^^^^^^^^^^^
We need to allow linking to the LabComm library from the LGPL glue
(see http://www.gnu.org/licenses/gpl-faq.html#GPLIncompatibleLibs).
We can not set a license on generated code
(http://www.gnu.org/licenses/gpl-faq.html#GPLOutput),
but when used with the LabComm library we can force it
to be licensed under GPLv3.
Suggested license for all library files
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Copyright 2013 Anders Blomdell <anders.blomdell@control.lth.se>
This file is part of LabComm.
LabComm is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
LabComm is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Additional permission under GNU GPL version 3 section 7
If you modify this Program, or any covered work, by directly linking
any functionality of it, with the the exception of calls denoting the
boundary of encoded samples and calls encoding primitive datatypes,
with any software licensed under the GNU Lesser General Public License,
the licensors of this Program grant you additional permission to convey
the resulting work.
LabComm.ast deleted 100644 → 0
View file @ ca5b4caf
Program ::= Decl*;
abstract Decl ::= Type <Name:String>;
TypeDecl : Decl;
SampleDecl : Decl;
Field ::= Type <Name:String>;
abstract Type;
VoidType : Type;
PrimType : Type ::= <Name:String> <Token:int>;
UserType : Type ::= <Name:String>;
StructType : Type ::= Field*;
ParseArrayType : Type ::= Type Dim*;
abstract ArrayType : Type ::= Type Exp*;
VariableArrayType : ArrayType;
FixedArrayType : ArrayType;
Dim ::= Exp*;
abstract Exp;
IntegerLiteral : Exp ::= <Value:String>;
VariableSize : Exp;
LabComm.java deleted 100644 → 0
View file @ ca5b4caf
import AST.*;
import java.io.*;
import java.util.*;
public class LabComm {
private static void println(String s) {
System.out.println(s);
}
private static void print_help() {
println("\n Usage: java -jar labcom.jar [options*] FILE");
println("");
println(" --help Shows this help text");
println(" -v Be verbose");
println("[ C options ]");
println(" -C Generates C/H code in FILE.[ch]");
println(" --cprefix=PREFIX Prefixes C types with PREFIX");
println(" --cinclude=FILE Include FILE in generated .c");
println(" --c=CFILE Generates C code in CFILE");
println(" --h=HFILE Generates H code in HFILE");
println("[ C# options]");
println(" --cs Generates C# code in FILE.cs");
println(" --cs=CSFILE Generates C# code in CSFILE");
println(" --csnamespace=NAMESPACE Place C# classes in NAMESPACE");
println("[ Java options ]");
println(" --java=JDIR Generates Java files in JDIR");
println(" --javapackage=PACKAGE Place Java classes in PACKAGE");
println("[ Python options ]");
println(" -P Generates Python code in FILE.py");
println(" --python=PFILE Generates Python code in PFILE");
println("[ Misc options ]");
println(" --pretty Pretty prints on standard output");
println(" --typeinfo=TIFILE Generates typeinfo in TIFILE");
}
private static String getCoreName(String s) {
int i = s.lastIndexOf('.');
return s.substring(0, i > 0 ? i : s.length());
}
private static String getFileName(String s) {
return s.substring(s.lastIndexOf('/') + 1, s.length());
}
private static String getBaseName(String s) {
s = getFileName(s);
int i = s.lastIndexOf('.');
return s.substring(0, i > 0 ? i : s.length());
}
private static String getPrefix(String s) {
return s.substring(s.lastIndexOf('/') + 1, s.length());
}
public static void main(String[] args) {
String fileName = null;
// Scan for first non-option
for (int i = 0 ; i < args.length ; i++) {
if (! args[i].startsWith("-")) {
fileName = args[i];
break;
}
}
String coreName = null;
String prefix = null;
if (fileName != null) {
coreName = getBaseName(fileName);
prefix = getPrefix(coreName);
}
boolean verbose = false;
String cFile = null;
String hFile = null;
Vector cIncludes = new Vector();
String cPrefix = prefix;
String csFile = null;
String csNamespace = null;
String javaDir = null;
String javaPackage = "";
String pythonFile = null;
String prettyFile = null;
String typeinfoFile = null;
for (int i = 0 ; i < args.length ; i++) {
if (fileName == null ||
args[i].equals("-help") ||
args[i].equals("-h") ||
args[i].equals("--help")) {
print_help();
System.exit(0);
} else if (args[i].equals("-v")) {
verbose=true;
} else if (args[i].equals("-C")) {
cFile = coreName + ".c";
hFile = coreName + ".h";
} else if (args[i].startsWith("--cinclude=")) {
cIncludes.add(args[i].substring(11));
} else if (args[i].startsWith("--cprefix=")) {
cPrefix = args[i].substring(10);
} else if (args[i].startsWith("--c=")) {
cFile = args[i].substring(4);
} else if (args[i].startsWith("--h=")) {
hFile = args[i].substring(4);
} else if (args[i].equals("--cs")) {
csFile = coreName + ".cs";
} else if (args[i].startsWith("--cs=")) {
csFile = args[i].substring(5);
} else if (args[i].startsWith("--csnamespace=")) {
csNamespace = args[i].substring(14);
} else if (args[i].startsWith("--java=")) {
javaDir = args[i].substring(7);
} else if (args[i].startsWith("--javapackage=")) {
javaPackage = args[i].substring(14);
} else if (args[i].equals("-P")) {
pythonFile = coreName + ".py";
} else if (args[i].startsWith("--python=")) {
pythonFile = args[i].substring(9);
} else if (args[i].startsWith("--pretty=")) {
prettyFile = args[i].substring(9);
} else if (args[i].startsWith("--typeinfo=")) {
typeinfoFile = args[i].substring(11);
} else if (i == args.length - 1) {
fileName = args[i];
} else {
System.err.println(" Unknown argument " + args[i]);
print_help();
System.exit(2);
}
}
if (fileName == null) {
print_help();
System.exit(1);
} else {
Program ast = null;
try {
// Check for errors
LabCommScanner scanner = new LabCommScanner(new FileReader(fileName));
LabCommParser parser = new LabCommParser();
Program p = (Program)parser.parse(scanner);
Collection errors = new LinkedList();
p.errorCheck(errors);
if (errors.isEmpty()) {
ast = p;
} else {
for (Iterator iter = errors.iterator(); iter.hasNext(); ) {
String s = (String)iter.next();
System.out.println(s);
}
}
} catch (FileNotFoundException e) {
System.err.println("Could not find file: " + fileName);
} catch (IOException e) {
System.err.println("IOException: " + fileName + " " + e);
} catch (beaver.Parser.Exception e) {
System.err.println(e.getMessage());
}
if (ast != null) {
Vector hIncludes = new Vector(cIncludes);
if (hFile != null) {
cIncludes.add(hFile);
}
boolean prettyOnStdout = true;
if (cFile != null) {
if (verbose) { System.err.println("Generating C: " + cFile); }
genC(ast, cFile, cIncludes, coreName, cPrefix);
prettyOnStdout = false;
}
if (hFile != null) {
if (verbose) { System.err.println("Generating H: " + hFile); }
genH(ast, hFile, hIncludes, coreName, cPrefix);
prettyOnStdout = false;
}
if (csFile != null) {
if (verbose) { System.err.println("Generating C#: " + csFile); }
genCS(ast, csFile, csNamespace);
prettyOnStdout = false;
}
if (javaDir != null) {
if (verbose) { System.err.println("Generating Java: " + javaDir); }
genJava(ast, javaDir, javaPackage);
prettyOnStdout = false;
}
if (pythonFile != null) {
if (verbose) {
System.err.println("Generating Python: " + pythonFile);
}
genPython(ast, pythonFile, prefix);
prettyOnStdout = false;
}
if (prettyFile != null) {
if (verbose) {
System.err.println("Generating Pretty: " + prettyFile);
}
try {
FileOutputStream f = new FileOutputStream(prettyFile);
PrintStream out = new PrintStream(f);
ast.pp(out);
out.close();
prettyOnStdout = false;
} catch (IOException e) {
System.err.println("IOException: " + prettyFile + " " + e);
}
}
if (typeinfoFile != null) {
if (verbose) {
System.err.println("Generating TypeInfo: " + typeinfoFile);
}
try {
FileOutputStream f = new FileOutputStream(typeinfoFile);
PrintStream out = new PrintStream(f);
ast.C_info(out, cPrefix);
ast.Java_info(out);
ast.CS_info(out, csNamespace);
prettyOnStdout = false;
} catch (IOException e) {
System.err.println("IOException: " + typeinfoFile + " " + e);
}
}
if (prettyOnStdout) {
ast.pp(System.out);
}
}
}
}
private static void genH(Program p, String hName,
Vector cIncludes, String coreName, String prefix) {
try {
FileOutputStream f;
PrintStream out;
f = new FileOutputStream(hName);
out = new PrintStream(f);
p.C_genH(out, cIncludes, coreName, prefix);
out.close();
} catch (IOException e) {
System.err.println("IOException: " + hName + " " + e);
}
}
private static void genC(Program p, String cName,
Vector cIncludes, String coreName, String prefix) {
try {
FileOutputStream f;
PrintStream out;
f = new FileOutputStream(cName);
out = new PrintStream(f);
p.C_genC(out, cIncludes, coreName, prefix);
out.close();
} catch (IOException e) {
System.err.println("IOException: " + cName + " " + e);
}
}
private static void genCS(Program p, String csName, String csNamespace) {
try {
p.CS_gen(csName, csNamespace);
} catch (IOException e) {
System.err.println("IOException: " + csName + " " +
csNamespace + " " + e);
}
}
private static void genJava(Program p, String dirName, String packageName) {
try {
p.J_gen(dirName, packageName);
} catch (IOException e) {
System.err.println("IOException: " + dirName + " " +
packageName + " " + e);
}
}
private static void genPython(Program p, String filename, String prefix) {
try {
FileOutputStream f;
PrintStream out;
f = new FileOutputStream(filename);
out = new PrintStream(f);
p.Python_gen(out, prefix);
out.close();
} catch (IOException e) {
System.err.println("IOException: " + filename + " " + e);
}
}
}
LabCommmTokens.jrag deleted 100644 → 0
View file @ ca5b4caf
aspect LabCommTokens {
public static final int ASTNode.LABCOMM_TYPEDEF = 0x01;
public static final int ASTNode.LABCOMM_SAMPLE = 0x02;
public static final int ASTNode.LABCOMM_ARRAY = 0x10;
public static final int ASTNode.LABCOMM_STRUCT = 0x11;
public static final int ASTNode.LABCOMM_BOOLEAN = 0x20;
public static final int ASTNode.LABCOMM_BYTE = 0x21;
public static final int ASTNode.LABCOMM_SHORT = 0x22;
public static final int ASTNode.LABCOMM_INT = 0x23;
public static final int ASTNode.LABCOMM_LONG = 0x24;
public static final int ASTNode.LABCOMM_FLOAT = 0x25;
public static final int ASTNode.LABCOMM_DOUBLE = 0x26;
public static final int ASTNode.LABCOMM_STRING = 0x27;
}
\ No newline at end of file
Makefile 0 → 100644
View file @ d3921882
SUBDIRS=compiler lib test examples packaging
export LABCOMM_JAR=$(shell pwd)/compiler/labcomm2014_compiler.jar
export LABCOMM=java -jar $(LABCOMM_JAR)
export VALGRIND=valgrind --leak-check=full --error-exitcode=1
UNAME_S=$(shell uname -s)
.PHONY: all
all: $(SUBDIRS:%=all-%)
.PHONY: all-%
all-%:
ifeq ($(UNAME_S),Darwin)
DYLD_LIBRARY_PATH=`pwd`/lib/c $(MAKE) -C $*
else
LD_LIBRARY_PATH=`pwd`/lib/c $(MAKE) -C $*
endif
.PHONY: test
test: $(SUBDIRS:%=test-%)
.PHONY: test-%
test-%:
ifeq ($(UNAME_S),Darwin)
DYLD_LIBRARY_PATH=`pwd`/lib/c $(MAKE) -C $* test
else
LD_LIBRARY_PATH=`pwd`/lib/c $(MAKE) -C $* test
endif
.PHONY: clean
clean: $(SUBDIRS:%=clean-%)
.PHONY: clean-%
clean-%:
$(MAKE) -C $* clean
.PHONY: distclean
distclean: clean $(SUBDIRS:%=distclean-%)
.PHONY: distclean-%
distclean-%:
$(MAKE) -C $* distclean
.PHONY: srpm
srpm:
make -C packaging $@
Python_CodeGen.jrag deleted 100644 → 0
View file @ ca5b4caf
aspect Python_CodeGenEnv {
// Environment wrapper for Python code generation
// handles qualid nesting, indentation, file writing and
// prefix propagation
public class Python_env {
final private class Python_printer {
private boolean newline = true;
private PrintStream out;
public Python_printer(PrintStream out) {
this.out = out;
}
public void print(Python_env env, String s) {
if (newline) {
newline = false;
for (int i = 0 ; i < env.indent ; i++) {
out.print(" ");
}
}
out.print(s);
}
public void println(Python_env env, String s) {
print(env, s);
out.println();
newline = true;
}
public void println(Python_env env) {
out.println();
newline = true;
}
}
private int indent;
private Python_printer printer;
public Python_env(PrintStream out) {
this.indent = 0;
this.printer = new Python_printer(out);
}
public void indent() {
indent++;
}
public void unindent() {
indent--;
}
public void print(String s) {
printer.print(this, s);
}
public void println(String s) {
printer.println(this, s);
}
public void println() {
printer.println(this);
}
}
}
aspect Python_CodeGen {
public void Program.Python_gen(PrintStream out, String baseName) {
Python_env env = new Python_env(out);
env.println("#!/usr/bin/python");
env.println("# Auto generated " + baseName);
env.println();
env.println("import labcomm");
env.println();
Python_genTypes(env);
}
}
aspect PythonTypes {
public void Program.Python_genTypes(Python_env env) {
for (int i = 0 ; i < getNumDecl() ; i++) {
env.println("class " + getDecl(i).getName() + "(object):");
env.indent();
getDecl(i).Python_genSignature(env);
env.unindent();
env.println();
}
}
public void Decl.Python_genSignature(Python_env env) {
throw new Error(this.getClass().getName() +
".Python_genSignature(Python_env env)" +
" not declared");
}
public void TypeDecl.Python_genSignature(Python_env env) {
env.println("no_signature = labcomm.typedef('" + getName() + "',");
env.indent();
getType().Python_genSignature(env);
env.unindent();
env.println(")");
}
public void SampleDecl.Python_genSignature(Python_env env) {
env.println("signature = labcomm.sample('" + getName() + "', ");
env.indent();
getType().Python_genSignature(env);
env.unindent();
env.println(")");
}
public void UserType.Python_genSignature(Python_env env) {
lookupType(getName()).getType().Python_genSignature(env);
}
public void Type.Python_genSignature(Python_env env) {
throw new Error(this.getClass().getName() +
".Python_genSignature(Python_env env)" +
" not declared");
}
public void PrimType.Python_genSignature(Python_env env) {
switch (getToken()) {
case LABCOMM_BOOLEAN: { env.print("labcomm.BOOLEAN()"); } break;
case LABCOMM_BYTE: { env.print("labcomm.BYTE()"); } break;
case LABCOMM_SHORT: { env.print("labcomm.SHORT()"); } break;
case LABCOMM_INT: { env.print("labcomm.INTEGER()"); } break;
case LABCOMM_LONG: { env.print("labcomm.LONG()"); } break;
case LABCOMM_FLOAT: { env.print("labcomm.FLOAT()"); } break;
case LABCOMM_DOUBLE: { env.print("labcomm.DOUBLE()"); } break;
case LABCOMM_STRING: { env.print("labcomm.STRING()"); } break;
}
}
public void ArrayType.Python_genSignature(Python_env env) {
env.print("labcomm.array([");
for (int i = 0 ; i < getNumExp() ; i++) {
if (i > 0) { env.print(", "); }
env.print(getExp(i).Python_getValue());
}
env.println("],");
env.indent();
getType().Python_genSignature(env);
env.print(")");
env.unindent();
}
public void StructType.Python_genSignature(Python_env env) {
env.println("labcomm.struct([");
env.indent();
for (int i = 0 ; i < getNumField() ; i++) {
if (i > 0) { env.println(","); }
getField(i).Python_genSignature(env);
}
env.print("])");
env.unindent();
}
public void VoidType.Python_genSignature(Python_env env) {
env.println("labcomm.struct([])");
env.unindent();
}
public void Field.Python_genSignature(Python_env env) {
env.print("('" + getName() + "', ");
getType().Python_genSignature(env);
env.print(")");
}
public String Exp.Python_getValue() {
throw new Error(this.getClass().getName() +
".Python_getValue()" +
" not declared");
}
public String IntegerLiteral.Python_getValue() {
return getValue();
}
public String VariableSize.Python_getValue() {
return "0";
}
}
\ No newline at end of file
README 0 → 100644
View file @ d3921882
Embryo of documentation. More details on http://wiki.cs.lth.se/moin/LabComm
*** The LabComm data description language: ***
Primitive types
sample boolean a_boolean;
sample byte a_byte;
sample short a_short;
sample int an_int;
sample long a_long;
sample float a_float;
sample double a_double;
sample string a_string;
Arrays
sample int fixed_array[3];
sample int variable_array[_]; // Note 1
sample int fixed_array_of_array[3][4]; // Note 2
sample int fixed_rectangular_array[3, 4]; // Note 2
sample int variable_array_of_array[_][_]; // Notes 1 & 2
sample int variable_rectangular_array[_, _]; // Notes 1 & 2
1 In contrast to C, LabComm supports both fixed and variable (denoted by '_') sized arrays.
2 In contrast to Java, LabComm supports multidimensional arrays and not only arrays of arrays.
Structures
sample struct {
int an_int_field;
double a_double_field;
} a_struct;
User defined types
typedef struct {
int field_1;
byte field_2;
} user_type[_];
sample user_type a_user_type_instance;
sample user_type another_user_type_instance;
Example sample declaration (e.g. example.lc)
sample struct {
int sequence;
struct {
boolean last;
string data;
} line[_];
} log_message;
From an .lc file, the labcomm compiler can generate marshalling and demarshalling code
for C, Java, Python, and C#.
build.xml deleted 100644 → 0
View file @ ca5b4caf
<!--
Targets for working from terminal window:
build (default) - generates java files and compiles them
clean - removes all generated files and class files
Targets for working from Eclipse:
gen - generates java files
genClean - removes all generated files and their class files
-->
<project name="LabComm" default="build" basedir=".">
<!-- "package" is the directory where generated files will be stored -->
<property name="package" value="AST"/>
<!-- "tools" is the directory where generators and libraries are located. -->
<property name="tools" value="tools"/>
<!-- "test" is the directory where tests are located. -->
<property name="test" value="test"/>
<!-- "jflex" is an ant task class for the scanner generator in JFlex.jar -->
<taskdef name="jflex" classname="JFlex.anttask.JFlexTask" classpath="tools/JFlex.jar"/>
<!-- "beaver" is an ant task class for the parser generator in beaver.jar -->
<taskdef name="beaver" classname="beaver.comp.run.AntTask" classpath="tools/beaver.jar"/>
<!-- "jastadd" is an ant task class in jastadd2.jar -->
<taskdef name="jastadd" classname="jastadd.JastAddTask"
classpath="tools/jastadd2.jar"/>
<!-- compile sources -->
<target name="build" depends="gen">
<javac debug="true" nowarn="true" srcdir="." includes="**/*.java" excludes="test/** examples/**" classpath=".:${tools}/beaver-rt.jar:${tools}/junit.jar"
fork="true" memoryMaximumSize="128M"/>
</target>
<!-- generate compiler source files -->
<target name="gen">
<!-- create AST node types and weave aspect modules -->
<echo message = "Running JastAdd"/>
<jastadd package="${package}" rewrite="true" beaver="true" novisitcheck="true" lazyMaps="true" outdir="${basedir}">
<fileset dir=".">
<include name="**/*.ast"/>
<include name="**/*.jrag"/>
<include name="**/*.jadd"/>
</fileset>
</jastadd>
<!-- generate the scanner -->
<echo message = "Running jflex"/>
<jflex file="LabCommScanner.flex" outdir="AST" nobak="yes"/>
<!-- generate the parser phase 1, create a full .lalr specification from fragments-->
<echo message = "Running parser phase 1"/>
<concat destfile="AST/LabCommParser.all" binary="true">
<fileset dir=".">
<include name="*.parser"/>
</fileset>
</concat>
<!-- generate the parser phase 2, translating .lalr to .beaver -->
<java fork="true" dir="${basedir}" classpath="${tools}/proj.jar:${tools}/beaver-rt.jar" classname="Main">
<arg line="AST/LabCommParser.all AST/LabCommParser.beaver"/>
</java>
<!-- generate the parser phase 3, translating .beaver to .java -->
<beaver file="AST/LabCommParser.beaver" terminalNames="yes" compress="yes" useSwitch="yes"/>
</target>
<!-- compile sources -->
<target name="test" depends="jar">
<echo message = "Running tests"/>
<exec executable="./run" dir="test">
<env key="PYTHONPATH" value="../lib/python"/>
<!--arg value="hej"/-->
</exec>
</target>
<!-- remove generated source files and .class files -->
<target name="clean" depends="cleanGen">
<!-- delete all .class files recursively -->
<delete>
<fileset dir="." includes="**/*.class"/>
</delete>
</target>
<!-- remove generated source files and their .class files -->
<target name="cleanGen">
<delete dir="${package}"/>
</target>
<target name="jar" depends="build">
<jar destfile="labComm.jar">
<fileset dir="." includes="LabComm*.class"/>
<fileset dir="." includes="AST/*.class"/>
<zipfileset src="tools/beaver-rt.jar" includes="beaver/*.class"/>
<manifest>
<attribute name="Main-Class" value="LabComm"/>
</manifest>
</jar>
</target>
</project>
compiler/.gitignore 0 → 100644
View file @ d3921882
gen
labcomm2006_compiler.jar
labcomm2014_compiler.jar
labcomm2014_compiler.jar
compiler/2014/Annotations.jrag 0 → 100644
View file @ d3921882
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
}
ArrayTypeRewrite.jrag → compiler/2014/ArrayTypeRewrite.jrag
View file @ d3921882
......@@ -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));
}
}
}
......
CS_CodeGen.jrag → compiler/2014/CS_CodeGen.jrag
View file @ d3921882
......@@ -4,142 +4,44 @@ import java.util.*;
aspect CS_CodeGenEnv {
// Environment wrapper for CS-code generation
// handles indentation, file writing,
// handles indentation, file writing,
public class CS_env {
public class CS_env extends PrintEnv {
private int indent;
private int depth;
private CS_printer printer;
private HashMap unique = new HashMap();
final private class CS_printer {
private boolean newline = true;
private File file;
private PrintStream out;
private IOException exception;
public CS_printer(File f) {
file = f;
File parentFile = f.getParentFile();
if(parentFile != null) {
parentFile.mkdirs();
}
}
public CS_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(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) {
this.indent = indent;
this.printer = printer;
}
public CS_env(File f) {
this.indent = 0;
this.printer = new CS_printer(f);
}
public CS_env(PrintStream out) {
this.indent = 0;
this.printer = new CS_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);
}
final private static class CS_printer extends PrintEnv.FilePrinter {
public CS_printer(File f) {
super(f);
}
public void unindent(int amount) {
indent -= amount;
}
public void unindent() {
unindent(1);
}
public CS_printer(PrintStream out) {
super(out);
}
public void print(String s) {
printer.print(this, s);
}
public void println(String s) {
printer.println(this, s);
public CS_env(File f, int version) {
super(0, new CS_printer(f), version);
}
public void println() {
printer.println(this, "");
public CS_env(PrintStream out, int version) {
super(0, new CS_printer(out), version);
}
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("}");
}
......@@ -154,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;
}
}
}
......@@ -170,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();
......@@ -187,24 +80,25 @@ aspect CS_StructName {
aspect CS_Void {
syn boolean Decl.CS_isVoid() = getType().CS_isVoid();
syn boolean Type.CS_isVoid() = false;
syn boolean Decl.CS_isVoid() = getDataType().CS_isVoid();
syn boolean UserType.CS_isVoid() = decl().CS_isVoid();
syn boolean DataType.CS_isVoid() = false;
syn boolean VoidType.CS_isVoid() = true;
}
aspect CS_CodeGen {
public void Program.CS_gen(String file,
String namespace) throws IOException {
public void Specification.CS_gen(String file,
String namespace, int version) throws IOException {
// Registration class
CS_env env = new CS_env(new File(file));
CS_env env = new CS_env(new File(file), version);
if (namespace != null && namespace.length() > 0) {
env.println("namespace " + namespace + "{");
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 {
......@@ -224,22 +118,12 @@ aspect CS_CodeGen {
aspect CS_Register {
public void Program.CS_emitTypeRegister(CS_env env) {
/*
env.println("static void register(LabCommChannel c) {");
env.indent();
for (int i = 0; i < getNumDecl(); i++) {
getDecl(i).CS_emitTypeRegister(env);
}
env.unindent();
env.println("}");
*/
public void Specification.CS_emitTypeRegister(CS_env env) {
}
public void Decl.CS_emitTypeRegister(CS_env env) {
throw new Error(this.getClass().getName() +
".CS_emitTypeRegister(CS_env env)" +
throw new Error(this.getClass().getName() +
".CS_emitTypeRegister(CS_env env)" +
" not declared");
}
......@@ -256,22 +140,98 @@ aspect CS_Register {
aspect CS_Class {
public void Decl.CS_emitClass(CS_env env) {
throw new Error(this.getClass().getName() +
".CS_emitClass(CS_env env)" +
throw new Error(this.getClass().getName() +
".CS_emitClass(CS_env env)" +
" not declared");
}
public void Decl.CS_emitDeclPP(CS_env env){
env.println("/* ");
pp(env.getPrintStream());
CS_emitUserTypeDeps(env,null,false);
CS_emitUserTypeRefs(env,null,false);
env.println("*/");
}
public void Decl.CS_emitUserTypeDeps(CS_env env, String via, boolean outputCode){
Iterator<Decl> it = type_dependencies().iterator();
while(it.hasNext()) {
Decl t = it.next();
t.CS_emitUserTypeDeps(env, t.getName(), outputCode);
if( outputCode && t.getDataType().isUserType() ) {
env.println(t.getName()+".register(e);");
} else { // Just output a comment
String refpath = (via == null) ? "directly" : "indirectly via "+via;
env.println(" //Depends ("+refpath+") on "+t.getName() );
}
}
}
public void Decl.CS_emitUserTypeRefs(CS_env env, String via, boolean outputCode){
if( isReferenced() ) {
Iterator<Decl> it = type_references().iterator();
while(it.hasNext()) {
Decl t = it.next();
t.CS_emitUserTypeRefs(env, t.getName(), outputCode);
if(outputCode) {
env.println(t.getName()+".register(e);");
} else { // Just output a comment
String refpath = (via == null) ? "directly" : "indirectly via "+via;
env.println(" //Is referenced ("+refpath+") by "+t.getName() );
}
}
}
}
public void Decl.CS_emitRegisterEncoder(CS_env env) {
env.println("public static void register(Encoder e){");
env.indent();
env.println("e.register(dispatcher);");
env.unindent();
env.println("}");
env.println("public static void registerSampleRef(Encoder e) {");
env.indent();
env.println("e.registerSampleRef(dispatcher);");
env.unindent();
env.println("}");
env.println();
}
public void Decl.CS_emitRegisterDecoder(CS_env env) {
env.println("public static void register(Decoder d, Handler h) {");
env.indent();
env.println("d.register(dispatcher, h);");
env.unindent();
env.println("}");
env.println();
env.println("public static void registerSampleRef(Decoder d) {");
env.indent();
env.println("d.registerSampleRef(dispatcher);");
env.unindent();
env.println("}");
env.println();
}
public void TypeDecl.CS_emitClass(CS_env env) {
if (getType().CS_needInstance()) {
if (getDataType().CS_needInstance()) {
// Hackish prettyprint preamble
env.println("/* ");
pp(env.getPrintStream());
env.println("*/");
env.println();
env.println("public class " + getName() + " : LabCommType {");
env.println("public class " + getName() + " : SampleType {");
env.println();
env.indent();
getType().CS_emitInstance(env);
getDataType().CS_emitInstance(env);
if( isReferenced()) {
CS_emitRegisterEncoder(env);
CS_emitDispatcher(env,false);
}
CS_emitSignature(env);
CS_emitEncoder(env);
CS_emitDecoder(env);
env.unindent();
......@@ -284,130 +244,166 @@ aspect CS_Class {
pp(env.getPrintStream());
env.println("*/");
env.println();
env.println("public class " + getName() + " : LabCommSample {");
env.println("public class " + getName() + " : Sample {");
env.println();
env.indent();
getType().CS_emitInstance(env);
env.println("public interface Handler : LabCommHandler {");
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(");");
env.println("}");
env.println();
env.println("public static void register(LabCommDecoder d, Handler h) {");
CS_emitDispatcher(env,true);
CS_emitRegisterEncoder(env);
CS_emitRegisterDecoder(env);
CS_emitEncoder(env);
CS_emitDecoder(env);
CS_emitSignature(env);
env.println("}");
env.unindent();
}
public void Decl.CS_emitSignature(CS_env env) {
CS_emitFlatSignature(env);
// if(isReferenced() || isSampleDecl()){
// Signature signature = getSignature();
// signature.CS_emitSignature(env, !isSampleDecl());
// }
}
public void Decl.CS_emitFlatSignature(CS_env env){
env.println("private static byte[] signature = new byte[] {");
env.indent();
env.println("d.register(new Dispatcher(), h);");
SignatureList signature = flatSignature(env.version);
for (int i = 0 ; i < signature.size() ; i++) {
String comment = signature.getComment(i);
if (comment != null) {
env.println(signature.getIndent(i) + "// " + comment);
}
byte[] data = signature.getData(i, env.version);
if (data != null) {
env.print(signature.getIndent(i));
for (int j = 0 ; j < data.length ; j++) {
//env.print(data[j] + ", ");
env.print(String.format("0x%02X, ", data[j])) ;
}
env.println();
}
}
env.unindent();
env.println("}");
env.println("};");
env.println();
}
env.println("public static void register(LabCommEncoder e) {");
//XXX TODO: refactor: split into a static class ("TypeDefSingleton"?)and a (smaller) dispatcher
public void Decl.CS_emitDispatcher(CS_env env, boolean isSample) {
String genericStr = ""; //env.versionHasMetaData()?"<"+getName()+">":"";
env.println("private static Dispatcher dispatcher = new Dispatcher();");
env.println();
env.println("public SampleDispatcher getDispatcher() {");
env.indent();
env.println("e.register(new Dispatcher());");
env.println("return dispatcher;");
env.unindent();
env.println("}");
env.println();
env.println("private class Dispatcher : LabCommDispatcher {");
env.println();
env.println("private class Dispatcher : SampleDispatcher {");
env.indent();
env.println();
env.println("public Type getSampleClass() {");
env.println();
env.println("public String getName() {");
env.indent();
env.println("return typeof(" + getName() + ");");
env.println("return \"" + getName() + "\";");
env.unindent();
env.println("}");
env.println();
env.println("public String getName() {");
env.println();
env.println("public byte getTypeDeclTag() {");
env.indent();
env.println("return \"" + getName() + "\";");
if(isSample) {
env.println("return Constant.SAMPLE_DEF;");
} else {
env.println("return Constant.TYPE_DEF;");
}
env.unindent();
env.println("}");
env.println();
env.println("public byte[] getSignature() {");
env.println();
env.println("public bool isSample() {");
env.indent();
env.println("return signature;");
env.println("return "+isSample+";");
env.unindent();
env.println("}");
env.println();
env.println("public void decodeAndHandle(LabCommDecoder d, LabCommHandler h) {");
env.println("/** return the flat signature. */");
env.println("public byte[] getSignature() {");
env.indent();
if (isVoid()) {
env.println(getName() + ".decode(d);");
env.println("((Handler)h).handle();");
} else {
env.println("((Handler)h).handle(" + getName() + ".decode(d));");
}
env.println("return signature;");
env.unindent();
env.println("}");
env.println("");
env.println();
env.println("public bool canDecodeAndHandle() {");
env.indent();
env.println("return "+isSample+";");
env.unindent();
env.println("}");
env.println("");
CS_emitEncoder(env);
CS_emitDecoder(env);
env.println("private static byte[] signature = new byte[] {");
env.println();
env.println("public void decodeAndHandle(Decoder d,");
env.println(" SampleHandler h) {");
env.indent();
SignatureList signature = signature();
for (int i = 0 ; i < signature.size() ; i++) {
String comment = signature.getComment(i);
if (comment != null) {
env.println(signature.getIndent(i) + "// " + comment);
}
byte[] data = signature.getData(i);
if (data != null) {
env.print(signature.getIndent(i));
for (int j = 0 ; j < data.length ; j++) {
env.print(data[j] + ", ");
if( isSample) {
if (isVoid()) {
env.println(getName() + ".decode(d);");
env.println("((Handler)h).handle();");
} else {
env.println("((Handler)h).handle(" + getName() + ".decode(d));");
}
env.println();
}
} else {
env.println("throw new Exception(\"A typedef has no handler, the corresponding method on the sample class should be called.\");");
}
env.unindent();
env.println("};");
env.println("}");
env.println("");
env.unindent();
env.println();
env.println("}");
}
env.println("");
} //TODO, fix above method
public void TypeDecl.CS_emitEncoder(CS_env env) {
env.print("public static void encode(LabCommEncoder e");
env.print("public static void encode(Encoder e");
if (!isVoid()) {
env.print(", ");
getType().CS_emitType(env);
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();
}
public void SampleDecl.CS_emitEncoder(CS_env env) {
env.print("public static void encode(LabCommEncoder e");
env.print("public static void encode(Encoder e");
if (!isVoid()) {
env.print(", ");
getType().CS_emitType(env);
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) {
throw new Error(this.getClass().getName() +
".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");
}
......@@ -424,16 +420,17 @@ aspect CS_Class {
case LABCOMM_FLOAT: { env.print("e.encodeFloat"); } break;
case LABCOMM_DOUBLE: { env.print("e.encodeDouble"); } break;
case LABCOMM_STRING: { env.print("e.encodeString"); } break;
case LABCOMM_SAMPLE: { env.print("e.encodeSampleRef"); } break;
}
env.println("(" + name + ");");
}
public void ArrayType.CS_emitEncoder(CS_env env, String name) {
env.print_block_begin();
int baseDepth = env.getDepth();
for (int i = 0 ; i < getNumExp() ; i++) {
String limit = getExp(i).CS_emitEncoder(env,
String limit = getExp(i).CS_emitEncoder(env,
name + ".GetLength(" + i + ")");
env.print_block_begin();
env.println("int i_" + (baseDepth + i) + "_max = " + limit + ";");
}
String index = null;
......@@ -445,16 +442,16 @@ 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();
env.print_block_end();
}
env.print_block_end();
}
public String Exp.CS_emitEncoder(CS_env env, String name) {
throw new Error(this.getClass().getName() +
".CS_emitEncoder(CS_env env, String name)" +
throw new Error(this.getClass().getName() +
".CS_emitEncoder(CS_env env, String name)" +
" not declared");
}
......@@ -463,14 +460,14 @@ aspect CS_Class {
}
public String VariableSize.CS_emitEncoder(CS_env env, String name) {
env.println("e.encodeInt(" + name + ");");
env.println("e.encodePacked32(" + name + ");");
return name;
}
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());
}
}
......@@ -478,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);
env.println(" decode(LabCommDecoder d) {");
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();
......@@ -498,9 +495,9 @@ aspect CS_Class {
env.println();
}
public void Type.CS_emitDecoder(CS_env env, String name) {
throw new Error(this.getClass().getName() +
".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");
}
......@@ -518,6 +515,11 @@ aspect CS_Class {
case LABCOMM_FLOAT: { env.println("d.decodeFloat();"); } break;
case LABCOMM_DOUBLE: { env.println("d.decodeDouble();"); } break;
case LABCOMM_STRING: { env.println("d.decodeString();"); } break;
case LABCOMM_SAMPLE: { env.println("d.decodeSampleRef();"); } break;
default: {
throw new Error("PrimType.CS_emitDecoder(CS_env env, String name)" +
" unknown token type");
}
}
}
......@@ -530,8 +532,8 @@ aspect CS_Class {
getExp(i).CS_emitDecoder(env);
env.println(";");
}
env.print(name + " = new ");
getType().CS_emitTypePrefix(env);
env.print(name + " = new ");
getDataType().CS_emitTypePrefix(env);
env.print("[");
for (int i = 0 ; i < getNumExp() ; i++) {
if (i > 0) {
......@@ -539,10 +541,10 @@ aspect CS_Class {
}
env.print("i_" + (baseDepth + i) + "_max");
}
env.println("]");
getType().CS_emitTypeSuffix(env);
env.print("]");
getDataType().CS_emitTypeSuffix(env);
env.println(";");
String index = null;
for (int i = 0 ; i < getNumExp() ; i++) {
String limit = "i_" + (baseDepth + i) + "_max";
......@@ -552,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();
}
......@@ -561,8 +563,8 @@ aspect CS_Class {
}
public void Exp.CS_emitDecoder(CS_env env) {
throw new Error(this.getClass().getName() +
".CS_emitDecoder(CS_env env)" +
throw new Error(this.getClass().getName() +
".CS_emitDecoder(CS_env env)" +
" not declared");
}
......@@ -571,7 +573,7 @@ aspect CS_Class {
}
public void VariableSize.CS_emitDecoder(CS_env env) {
env.print("d.decodeInt()");
env.print("d.decodePacked32()");
}
public void StructType.CS_emitDecoder(CS_env env, String name) {
......@@ -580,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());
}
}
......@@ -588,35 +590,20 @@ 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_emitNew(CS_env env, String size) {
throw new Error(this.getClass().getName() +
".CS_emitNew(CS_env env, String size)" +
" not declared");
}
public void ArrayType.CS_emitNew(CS_env env, String size, int depth) {
env.print("new ");
getType().CS_emitTypePrefix(env);
env.print("[" + size + "]");
getType().CS_emitTypeSuffix(env);
for (int i = 1 ; i < depth ; i++) {
env.print("[]");
}
}
public void Type.CS_emitTypePrefix(CS_env env) {
throw new Error(this.getClass().getName() +
".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");
}
public void PrimType.CS_emitTypePrefix(CS_env env) {
switch (getToken()) {
case LABCOMM_STRING: { env.print("String"); } break;
case LABCOMM_SAMPLE: { env.print("SampleDispatcher"); } break;
default: { env.print(getName()); } break;
}
}
......@@ -625,48 +612,52 @@ 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);
}
}
public void ArrayType.CS_emitTypeSuffix(CS_env env){
getType().CS_emitTypeSuffix(env);
env.print("[");
for (int i = 1 ; i < getNumExp() ; i++) {
env.print(",");
}
env.print("]");
getDataType().CS_emitTypeSuffix(env);
}
public boolean Type.CS_needInstance() {
throw new Error(this.getClass().getName() +
".CS_needInstance()" +
public boolean DataType.CS_needInstance() {
throw new Error(this.getClass().getName() +
".CS_needInstance()" +
" not declared");
}
public boolean VoidType.CS_needInstance() {
return false;
}
public boolean PrimType.CS_needInstance() {
return false;
}
public boolean UserType.CS_needInstance() {
return decl().getType().CS_needInstance();
return decl().getDataType().CS_needInstance();
}
public boolean StructType.CS_needInstance() {
......@@ -674,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;
}
......@@ -685,9 +676,9 @@ aspect CS_Class {
return true;
}
public void Type.CS_emitInstance(CS_env env) {
throw new Error(this.getClass().getName() +
".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");
}
......@@ -698,16 +689,16 @@ 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) {
if (CS_Depth() > 0) {
env.println("public static class " + CS_structName() + " {");
env.println("public class " + CS_structName() + " {");
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);
......@@ -724,13 +715,13 @@ aspect CS_Class {
public void Field.CS_emitField(CS_env env) {
env.print("public ");
getType().CS_emitType(env);
env.println(" " + getName() + ";");
getDataType().CS_emitType(env);
env.println(" " + getName() + ";");
}
public void Type.CS_emitType(CS_env env) {
throw new Error(this.getClass().getName() +
".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");
}
......@@ -742,21 +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("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_emitType(env);
getDataType().CS_emitTypePrefix(env);
env.print("[");
for (int i = 1 ; i < getNumExp() ; i++) {
env.print(",");
}
env.print("]");
getDataType().CS_emitTypeSuffix(env);
}
public void StructType.CS_emitType(CS_env env){
......@@ -765,14 +758,56 @@ aspect CS_Class {
}
aspect CS_Signature {
public void Signature.CS_emitSignature(CS_env env, boolean decl){
SignatureList sl = getSignatureList();
sl.CS_emitSignature(env, decl);
}
public abstract void SignatureLine.CS_emitSignature(CS_env env, boolean decl);
public void TypeRefSignatureLine.CS_emitSignature(CS_env env, boolean isDecl){
env.print(getIndentString());
env.println("e.encodePacked32(e.getDataTypeId( typeof("+decl.getName()+")));");
}
public void DataSignatureLine.CS_emitSignature(CS_env env, boolean decl){
byte[] data = getData(env.version);
if (data != null) {
env.print(getIndentString());
for (int j = 0 ; j < data.length ; j++) {
//env.print("e.encodeByte((byte)"+data[j]+");");
env.print("e.encodeByte((byte)"+ String.format("0x%02X ", data[j]) +"); ");
}
env.println();
}
}
public void SignatureList.CS_emitSignature(CS_env env, boolean decl) {
env.println("private static void emitSignature(Encoder e){");
env.indent();
for (int i = 0 ; i < size() ; i++) {
String comment = getComment(i);
if (comment != null && comment.length() > 0) {
env.println(getIndent(i) + "// " + comment);
}
SignatureLine l = getSignatureLine(i);
l.CS_emitSignature(env, decl);
}
env.println("}");
env.unindent();
}
}
aspect CS_Info {
public void Program.CS_info(PrintStream out, String namespace) {
CS_env env = new CS_env(out);
public void Specification.CS_info(PrintStream out, String namespace, int version) {
CS_env env = new CS_env(out, version);
if (namespace == null) {
namespace = "";
namespace = "";
} else {
namespace = namespace + ".";
namespace = namespace + ".";
}
for (int i = 0; i < getNumDecl(); i++) {
getDecl(i).CS_info(env, namespace);
......@@ -780,21 +815,24 @@ aspect CS_Info {
}
public void Decl.CS_info(CS_env env, String namespace) {
throw new Error(this.getClass().getName() +
".CS_info(CS_env env)" +
throw new Error(this.getClass().getName() +
".CS_info(CS_env env)" +
" not declared");
}
public void TypeDecl.CS_info(CS_env env, String namespace) {
env.print("C#,typedef," + namespace + getName() + ",");
getType().CS_emitType(env);
env.print(";C#;typedef;" + namespace + getName() + ";");
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);
env.print(";C#;sample;" + namespace + getName() + ";");
getDataType().CS_emitType(env);
env.print(";not_applicable_for_C#");
env.println();
}
}
C_CodeGen.jrag → compiler/2014/C_CodeGen.jrag
View file @ d3921882
......@@ -6,30 +6,11 @@ aspect C_CodeGenEnv {
// handles qualid nesting, indentation, file writing and
// prefix propagation
public class C_env {
final private 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);
}
}
......@@ -37,110 +18,113 @@ aspect C_CodeGenEnv {
public final String lcName;
public final String rawPrefix;
public final String prefix;
private int indent;
public final int depth;
private C_printer printer;
private C_env(String qualid, String lcName, String rawPrefix,
int indent, int depth, C_printer printer) {
this.qualid = qualid;
this.lcName = lcName;
this.rawPrefix = rawPrefix;
this.prefix = rawPrefix + "_";
this.indent = indent;
this.depth = depth;
this.printer = printer;
}
public C_env(String qualid, String lcName, String rawPrefix,
PrintStream out) {
public final int nestedLevel;
private boolean rootIsPointer;
private int rootLevel;
private C_env(String qualid, String lcName, String rawPrefix,
int indent, int depth, C_printer printer,
int nestedLevel, int version)
{
super(indent, printer, version, depth);
this.qualid = qualid;
this.lcName = lcName;
this.rawPrefix = rawPrefix;
this.prefix = rawPrefix + "_";
this.depth = 0;
this.indent = 0;
this.printer = new C_printer(out);
if (rawPrefix == null) {
System.err.println("WARNING: prefix==null");
this.prefix = "";
} else if (rawPrefix.equals("")) {
this.prefix = rawPrefix;
} else {
this.prefix = rawPrefix + "_";
}
this.nestedLevel = nestedLevel;
}
public C_env nestArray(String suffix) {
return new C_env(qualid + suffix, lcName, rawPrefix,
indent, depth + 1, printer);
public C_env(String qualid, String lcName, String rawPrefix,
PrintStream out, int version)
{
this(qualid, lcName, rawPrefix, 0, 0, new C_printer(out), 0, version);
}
public C_env nestStruct(String suffix) {
return new C_env(qualid + suffix, lcName, rawPrefix,
indent, depth, printer);
public C_env(String qualid, String lcName, String rawPrefix,
int indent, int depth, C_printer printer, int version) {
this(qualid, lcName, rawPrefix, indent, depth, printer, 0, version);
}
public void indent() {
indent++;
public C_env nestArray(String suffix) {
return new C_env(qualid + suffix, lcName, rawPrefix,
getIndent(), getDepth() + 1, (C_printer)getPrinter(), nestedLevel + 1, version);
}
public void unindent() {
indent--;
public C_env nestStruct(String suffix) {
return new C_env(qualid + suffix, lcName, rawPrefix,
getIndent(), getDepth(), (C_printer)getPrinter(), nestedLevel + 1, version);
}
public String prefix() {
return rawPrefix;
}
public void print(String s) {
printer.print(this, s);
public C_env setPointer() {
rootIsPointer = true;
rootLevel = nestedLevel;
return this;
}
public void println(String s) {
printer.println(this, s);
public String memberAccessor() {
return (rootIsPointer && (nestedLevel == rootLevel)) ? "->" : ".";
}
public String accessor() {
return (rootIsPointer && (nestedLevel == rootLevel)) ? "*" : "";
}
}
public C_env ArrayType.C_Nest(C_env env) {
throw new Error(this.getClass().getName() +
".C_Nest(C_env env)" +
throw new Error(this.getClass().getName() +
".C_Nest(C_env env)" +
" not declared");
}
public C_env FixedArrayType.C_Nest(C_env env) {
String index = ".a";
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(".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();
syn boolean UserType.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,
String lcName, String prefix) {
C_env env = new C_env("", lcName, prefix, out);
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);
// Hackish prettyprint preamble
out.println("/* LabComm declarations:");
......@@ -148,12 +132,12 @@ aspect C_CodeGen {
out.println("*/");
env.println("");
env.println("");
env.println("#ifndef __LABCOMM_" + env.lcName + "_H__");
env.println("#ifndef __LABCOMM_" + env.lcName + "_H__");
env.println("#define __LABCOMM_" + env.lcName + "_H__");
env.println("");
// Include
env.println("#include \"labcomm.h\"");
env.println("#include \"labcomm2014.h\"");
for (int i = 0 ; i < includes.size() ; i++) {
env.println("#include \"" + includes.get(i) + "\"");
}
......@@ -164,52 +148,59 @@ aspect C_CodeGen {
env.println("#endif");
}
public void Program.C_genC(PrintStream out, Vector includes,
String lcName, String prefix) {
C_env env = new C_env("", lcName, prefix, out);
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.h\"");
env.println("#include \"labcomm_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) + "\"");
}
env.println("");
// Method Implementations
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_emitSignatureDeclaration(env);
getDecl(i).C_emitDecoderRegisterDeclaration(env);
getDecl(i).C_emitDecoderDeclaration(env);
getDecl(i).C_emitEncoderDeclaration(env);
getDecl(i).C_emitSizeofDeclaration(env);
getDecl(i).C_emitCopyDeclaration(env);
getDecl(i).C_emitCopyDeallocationDeclaration(env);
env.println("");
}
C_emitConstructorDeclaration(env);
C_emitForAll(env);
}
public void Program.C_emitC(C_env env) {
C_emitSignature(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);
getDecl(i).C_emitDecoderRegisterHandler(env);
getDecl(i).C_emitDecoderIoctl(env);
getDecl(i).C_emitEncoder(env);
getDecl(i).C_emitEncoderRegisterHandler(env);
getDecl(i).C_emitEncoderIoctl(env);
getDecl(i).C_emitSizeof(env);
getDecl(i).C_emitCopy(env);
getDecl(i).C_emitCopyDeallocation(env);
}
C_emitConstructor(env);
}
}
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 + ";");
}
}
......@@ -218,30 +209,35 @@ aspect C_Common {
aspect C_Type {
public void Decl.C_emitType(C_env env) {
throw new Error(this.getClass().getName() +
".C_emitType(C_env env)" +
throw new Error(this.getClass().getName() +
".C_emitType(C_env env)" +
" not declared");
}
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 labcomm2014_signature " +
"*labcomm2014_signature_" + env.prefix + getName() +
";");
}
public void Type.C_emitType(C_env env, String name) {
throw new Error(this.getClass().getName() +
".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");
}
......@@ -251,11 +247,17 @@ aspect C_Type {
public void PrimType.C_emitType(C_env env, String name) {
switch (getToken()) {
case LABCOMM_BOOLEAN: { env.print("unsigned char"); } break;
case LABCOMM_BYTE: { env.print("unsigned char"); } break;
case LABCOMM_BOOLEAN: { env.print("uint8_t"); } break;
case LABCOMM_BYTE: { env.print("uint8_t"); } break;
case LABCOMM_SHORT: { env.print("int16_t"); } break;
case LABCOMM_INT: { env.print("int32_t"); } break;
case LABCOMM_LONG: { env.print("int64_t"); } break;
case LABCOMM_FLOAT: { env.print("float"); } break;
case LABCOMM_DOUBLE: { env.print("double"); } break;
case LABCOMM_STRING: { env.print("char*"); } break;
case LABCOMM_LONG: { env.print("long long"); } break;
default: { env.print(getName()); } break;
case LABCOMM_SAMPLE: {
env.print("const struct labcomm2014_sample_ref *");
} break;
}
env.print(" " + name);
}
......@@ -276,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) {
......@@ -286,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);
......@@ -302,15 +304,15 @@ 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);
}
public String Exp.C_getValue() {
throw new Error(this.getClass().getName() +
".C_getValue()" +
throw new Error(this.getClass().getName() +
".C_getValue()" +
" not declared");
}
......@@ -322,14 +324,14 @@ aspect C_Type {
aspect C_Declarations {
public void Decl.C_emitDecoderRegisterDeclaration(C_env env) {
public void Decl.C_emitDecoderDeclaration(C_env env) {
}
public void SampleDecl.C_emitDecoderRegisterDeclaration(C_env env) {
env.println("void labcomm_decoder_register_" +
public void SampleDecl.C_emitDecoderDeclaration(C_env env) {
env.println("int labcomm2014_decoder_register_" +
env.prefix + getName() + "(");
env.indent();
env.println("struct labcomm_decoder *d,");
env.println("struct labcomm2014_decoder *d,");
env.println("void (*handler)(");
env.indent();
env.println(env.prefix + getName() + " *v,");
......@@ -339,22 +341,40 @@ aspect C_Declarations {
env.println("void *context");
env.unindent();
env.println(");");
env.println("int labcomm2014_decoder_ioctl_" + env.prefix + getName() + "(");
env.indent();
env.println("struct labcomm2014_decoder *d,");
env.println("int ioctl_action,");
env.println("...");
env.unindent();
env.println(");");
}
public void Decl.C_emitEncoderDeclaration(C_env env) {
}
public void SampleDecl.C_emitEncoderDeclaration(C_env env) {
env.println("void labcomm_encoder_register_" +
env.println("int labcomm2014_encoder_register_" +
env.prefix + getName() + "(");
env.indent();
env.println("struct labcomm_encoder *e);");
env.println("struct labcomm2014_encoder *e);");
env.unindent();
env.println("int labcomm2014_encode_" + env.prefix + getName() + "(");
env.indent();
env.println("struct labcomm2014_encoder *e");
if(!isVoid() ) {
env.println(", "+env.prefix + getName() + " *v");
}
env.unindent();
env.println(");");
env.println("void labcomm_encode_" + env.prefix + getName() + "(");
env.println("int labcomm2014_encoder_ioctl_" + env.prefix + getName() + "(");
env.indent();
env.println("struct labcomm_encoder *e,");
env.println(env.prefix + getName() + " *v");
env.println("struct labcomm2014_encoder *e,");
env.println("int ioctl_action,");
env.println("...");
env.unindent();
env.println(");");
}
......@@ -364,8 +384,8 @@ aspect C_Declarations {
aspect C_Limit {
public String Exp.C_getLimit(C_env env, int i) {
throw new Error(this.getClass().getName() +
".C_emitDecoderLimit(C_env env, int i)" +
throw new Error(this.getClass().getName() +
".C_emitDecoderLimit(C_env env, int i)" +
" not declared");
}
......@@ -374,9 +394,9 @@ aspect C_Limit {
}
public String VariableSize.C_getLimit(C_env env, int i) {
return env.qualid + ".n_" + i;
return env.qualid + env.memberAccessor() + "n_" + i;
}
}
aspect C_Index {
......@@ -385,13 +405,13 @@ 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 + ") * " +
getExp(i).C_getLimit(env, i) + " + " +
getExp(i).C_getLimit(env, i) + " + " +
i_prefix + i;
}
env.println(expr + ";");
......@@ -402,8 +422,8 @@ aspect C_Index {
aspect C_Decoder {
public void Decl.C_emitDecoder(C_env env) {
throw new Error(this.getClass().getName() +
".C_emitDecoder(C_env env)" +
throw new Error(this.getClass().getName() +
".C_emitDecoder(C_env env)" +
" not declared");
}
......@@ -412,9 +432,9 @@ aspect C_Decoder {
public void SampleDecl.C_emitDecoder(C_env env) {
env = env.nestStruct("v");
env.println("static void decode_" + getName() + "(");
env.println("static void decode_" + env.prefix + getName() + "(");
env.indent();
env.println("labcomm_decoder_t *d,");
env.println("struct labcomm2014_reader *r,");
env.println("void (*handle)(");
env.indent();
env.println(env.prefix + getName() + " *v,");
......@@ -427,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("}");
}
......@@ -440,9 +460,9 @@ aspect C_Decoder {
env.println("}");
}
public void Type.C_emitDecoder(C_env env) {
throw new Error(this.getClass().getName() +
".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");
}
......@@ -450,11 +470,20 @@ aspect C_Decoder {
}
public void PrimType.C_emitDecoder(C_env env) {
env.println(env.qualid + " = labcomm_decode_" + getName() + "(d);");
env.print(env.qualid + " = ");
switch (getToken()) {
case LABCOMM_SAMPLE: {
env.println("r->decoder->index_to_sample_ref(" +
"r->decoder, labcomm2014_read_int(r));");
} break;
default: {
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) {
......@@ -470,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) +
......@@ -479,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("}");
......@@ -489,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_decode_int(d);");
env.println(env.qualid + ".n_" + i + " = labcomm2014_read_packed32(r);");
}
public void ArrayType.C_emitDecoderDecodeLimit(C_env env) {
......@@ -509,30 +538,33 @@ aspect C_Decoder {
}
public void VariableArrayType.C_emitDecoderArrayAllocate(C_env env) {
env.print(env.qualid + ".a = malloc(sizeof(" + env.qualid + ".a[0])");
env.print(env.qualid +
".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));
}
env.println(");");
}
// Code for deallocation of dynamically allocated data
// Code for deallocation of dynamically allocated data
public void Type.C_emitDecoderDeallocation(C_env env) {
throw new Error(this.getClass().getName() +
".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");
}
public void PrimType.C_emitDecoderDeallocation(C_env env) {
if (C_isDynamic()) {
env.println("free(" + env.qualid + ");");
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);
}
}
......@@ -545,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) +
......@@ -559,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("}");
......@@ -571,16 +603,17 @@ aspect C_Decoder {
public void VariableArrayType.C_emitDecoderDeallocation(C_env env) {
super.C_emitDecoderDeallocation(env);
env.println("free(" + env.qualid + ".a);");
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) {
throw new Error(this.getClass().getName() +
".C_emitDecoderRegisterHandler(C_env env)" +
throw new Error(this.getClass().getName() +
".C_emitDecoderRegisterHandler(C_env env)" +
" not declared");
}
......@@ -588,10 +621,10 @@ aspect C_Decoder {
}
public void SampleDecl.C_emitDecoderRegisterHandler(C_env env) {
env.println("void labcomm_decoder_register_" +
env.println("int labcomm2014_decoder_register_" +
env.prefix + getName() + "(");
env.indent();
env.println("struct labcomm_decoder *d,");
env.println("struct labcomm2014_decoder *d,");
env.println("void (*handler)(");
env.indent();
env.println(env.prefix + getName() + " *v,");
......@@ -603,12 +636,12 @@ aspect C_Decoder {
env.println(")");
env.println("{");
env.indent();
env.println("labcomm_internal_decoder_register(");
env.println("return d->sample_register(");
env.indent();
env.println("d,");
env.println("&labcomm_signature_" + env.prefix + getName() + ",");
env.println("(labcomm_decoder_typecast_t)decode_" + getName() + ",");
env.println("(labcomm_handler_typecast_t)handler,");
env.println("&signature_" + env.prefix + getName() + ",");
env.println("(labcomm2014_decoder_function)decode_" + env.prefix + getName() + ",");
env.println("(labcomm2014_handler_function)handler,");
env.println("context");
env.unindent();
env.println(");");
......@@ -618,69 +651,376 @@ aspect C_Decoder {
}
aspect C_copy {
private void SampleDecl.C_emitCopyFunctionParam(C_env env, String src,
String dst)
{
env.println("void labcomm2014_copy_" +
env.prefix + getName() + "(");
env.indent();
env.println("struct labcomm2014_memory *mem,");
env.println(env.prefix + getName() + " *" + dst + ",");
env.println(env.prefix + getName() + " *" + src);
env.unindent();
env.print(")");
}
public void Decl.C_emitCopyDeclaration(C_env env) {
}
public void SampleDecl.C_emitCopyDeclaration(C_env env) {
C_emitCopyFunctionParam(env, "src", "dst");
env.println(";");
}
public void Decl.C_emitCopy(C_env env) {
throw new Error(this.getClass().getName() +
".C_emitCopy(C_env env)" +
" not declared");
}
public void TypeDecl.C_emitCopy(C_env env) {
}
public void SampleDecl.C_emitCopy(C_env env) {
final String dst = "dst";
final String src = "src";
C_env env_src = env.nestStruct(src).setPointer();
C_env env_dst = env.nestStruct(dst).setPointer();
C_emitCopyFunctionParam(env_src, src, dst);
env_src.println("");
env_src.println("{");
env_src.indent();
getDataType().C_emitCopy(env_src, env_dst);
env_src.unindent();
env_src.println("}");
}
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");
}
public void VoidType.C_emitCopy(C_env env_src, C_env env_dst) {
}
public void PrimType.C_emitCopy(C_env env_src, C_env env_dst) {
if (C_isDynamic()) {
env_src.println(String.format(
"%s%s = labcomm2014_memory_alloc(mem, 1, strlen(%s%s)+1);",
env_dst.accessor(), env_dst.qualid,
env_src.accessor(), env_src.qualid));
env_src.println(String.format(
"memcpy(%s%s, %s%s, strlen(%s%s)+1);",
env_dst.accessor(), env_dst.qualid,
env_src.accessor(), env_src.qualid,
env_src.accessor(), env_src.qualid));
} else {
env_src.println(env_dst.accessor() + env_dst.qualid + " = " +
env_src.accessor() + env_src.qualid + ";");
}
}
public void UserType.C_emitCopy(C_env env_src, C_env env_dst) {
lookupType(getName()).getDataType().C_emitCopy(env_src, env_dst);
}
public void StructType.C_emitCopy(C_env env_src, C_env env_dst) {
for (int i = 0 ; i < getNumField() ; i++) {
getField(i).C_emitCopy(env_src, env_dst);
}
}
public void ArrayType.C_emitCopy(C_env env_src, C_env env_dst) {
C_emitCopyDecodeLimit(env_src, env_dst);
C_emitCopyArrayAllocate(env_src, env_dst);
env_src.println("{");
env_src.indent();
C_emitLoopVariables(env_src);
for (int i = 0 ; i < getNumExp() ; i++) {
String iterator = "i_" + env_src.getDepth() + "_" + i;
env_src.println("for (" + iterator + " = 0" +
" ; " +
iterator + " < " + getExp(i).C_getLimit(env_src, i) +
" ; " +
iterator + "++) {");
env_src.indent();
}
C_emitCalcIndex(env_src);
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("}");
}
env_src.unindent();
env_src.println("}");
}
public void Field.C_emitCopy(C_env env_src, C_env env_dst) {
String fnam = env_src.memberAccessor() + getName();
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) {
// Ordinary array has no length-member.
}
public void VariableSize.C_emitCopyDecodeLimit(C_env env_src, C_env env_dst, int i) {
String src = env_src.qualid + env_src.memberAccessor() + "n_" + i;
String dst = env_dst.qualid + env_dst.memberAccessor() + "n_" + i;
env_src.println(dst + " = " + src + ";");
}
public void ArrayType.C_emitCopyDecodeLimit(C_env env_src, C_env env_dst) {
for (int i = 0 ; i < getNumExp() ; i++) {
getExp(i).C_emitCopyDecodeLimit(env_src, env_dst, i);
}
}
public void ArrayType.C_emitCopyArrayAllocate(C_env env_src, C_env env_dst) {
}
public void VariableArrayType.C_emitCopyArrayAllocate(C_env env_src,
C_env env_dst)
{
env_src.print(env_dst.qualid + env_dst.memberAccessor() +
"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));
}
env_dst.println(");");
}
// Code for deallocation of dynamically allocated data in a copy.
private void SampleDecl.C_emitCopyDeallocationFunctionParam(C_env env,
String par)
{
env.println("void labcomm2014_copy_free_" +
env.prefix + getName() + "(");
env.indent();
env.println("struct labcomm2014_memory *mem,");
env.println(env.prefix + getName() + " *" + par);
env.unindent();
env.print(")");
}
public void Decl.C_emitCopyDeallocationDeclaration(C_env env) {
}
public void SampleDecl.C_emitCopyDeallocationDeclaration(C_env env) {
C_emitCopyDeallocationFunctionParam(env, "c");
env.println(";");
}
public void Decl.C_emitCopyDeallocation(C_env env) {
throw new Error(this.getClass().getName() +
".C_emitCopy(C_env env)" +
" not declared");
}
public void TypeDecl.C_emitCopyDeallocation(C_env env) {
}
public void SampleDecl.C_emitCopyDeallocation(C_env env) {
String par = "par";
env = env.nestStruct(par).setPointer();
C_emitCopyDeallocationFunctionParam(env, par);
env.println("");
env.println("{");
env.indent();
getDataType().C_emitCopyDeallocation(env);
env.unindent();
env.println("}");
}
public void DataType.C_emitCopyDeallocation(C_env env) {
throw new Error(this.getClass().getName() +
".C_emitCopyDeallocation(C_env env)" +
" not declared");
}
public void VoidType.C_emitCopyDeallocation(C_env env) {
}
public void PrimType.C_emitCopyDeallocation(C_env env) {
if (C_isDynamic()) {
env.println("labcomm2014_memory_free(mem, 1, " +
env.accessor() + env.qualid + ");");
}
}
public void UserType.C_emitCopyDeallocation(C_env env) {
if (C_isDynamic()) {
lookupType(getName()).getDataType().C_emitCopyDeallocation(env);
}
}
public void StructType.C_emitCopyDeallocation(C_env env) {
if (C_isDynamic()) {
for (int i = 0 ; i < getNumField() ; i++) {
getField(i).C_emitCopyDeallocation(env);
}
}
}
public void ArrayType.C_emitCopyDeallocation(C_env env) {
if (getDataType().C_isDynamic()) {
env.println("{");
env.indent();
C_emitLoopVariables(env);
for (int i = 0 ; i < getNumExp() ; i++) {
String iterator = "i_" + env.getDepth() + "_" + i;
env.println("for (" + iterator + " = 0" +
" ; " +
iterator + " < " + getExp(i).C_getLimit(env, i) +
" ; " +
iterator + "++) {");
env.indent();
}
C_emitCalcIndex(env);
getDataType().C_emitCopyDeallocation(C_Nest(env));
for (int i = 0 ; i < getNumExp() ; i++) {
env.unindent();
env.println("}");
}
env.unindent();
env.println("}");
}
}
public void VariableArrayType.C_emitCopyDeallocation(C_env env) {
super.C_emitCopyDeallocation(env);
env.println("labcomm2014_memory_free(mem, 1, " +
env.qualid + env.memberAccessor() + "a);");
}
public void Field.C_emitCopyDeallocation(C_env env) {
getDataType().C_emitCopyDeallocation(env.nestStruct(env.memberAccessor()
+ getName()));
}
}
aspect C_DecoderIoctl {
public void Decl.C_emitDecoderIoctl(C_env env) {
throw new Error(this.getClass().getName() +
".C_emitDecoderIoctl(C_env env)" +
" not declared");
}
public void TypeDecl.C_emitDecoderIoctl(C_env env) {
}
public void SampleDecl.C_emitDecoderIoctl(C_env env) {
env.println("int labcomm2014_decoder_ioctl_" + env.prefix + getName() + "(");
env.indent();
env.println("struct labcomm2014_decoder *d,");
env.println("int ioctl_action,");
env.println("...");
env.unindent();
env.println(")");
env.println("{");
env.indent();
env.println("int result;");
env.println("va_list va;");
env.println("va_start(va, ioctl_action);");
env.println("result = d->ioctl(");
env.indent();
env.println("d, &signature_" + env.prefix + getName() + ", ");
env.println("ioctl_action, va);");
env.unindent();
env.println("va_end(va);");
env.println("return result;");
env.unindent();
env.println("}");
}
}
aspect C_Encoder {
public void Decl.C_emitEncoder(C_env env) {
throw new Error(this.getClass().getName() +
".C_emitEncoder()" +
" not declared");
throw new Error(this.getClass().getName() +
".C_emitEncoder()" +
" not declared");
}
public void TypeDecl.C_emitEncoder(C_env env) {
// do nothing for type decls
}
public void SampleDecl.C_emitEncoder(C_env env) {
env = env.nestStruct("(*v)");
env.println("static void encode_" + getName() + "(");
env.println("static int encode_" + env.prefix + getName() + "(");
env.indent();
env.println("labcomm_encoder_t *e,");
env.println(env.prefix + getName() + " *v");
env.println("struct labcomm2014_writer *w");
if(!isVoid() ) {
env.println(", "+env.prefix + getName() + " *v");
}
env.unindent();
env.println(")");
env.println("{");
env.indent();
env.println("e->writer.write(&e->writer, labcomm_writer_start);");
env.println("labcomm_encode_type_index(e, &labcomm_signature_" +
env.prefix + getName() + ");");
env.println("{");
env.indent();
getType().C_emitEncoder(env);
env.unindent();
env.println("}");
env.println("e->writer.write(&e->writer, labcomm_writer_end);");
env.println("int result = 0;");
getDataType().C_emitEncoder(env);
env.println("return result;");
env.unindent();
env.println("}");
// Typesafe encode wrapper
env.println("void labcomm_encode_" + env.prefix + getName() + "(");
env.println("labcomm_encoder_t *e,");
env.println(env.prefix + getName() + " *v");
env.println("int labcomm2014_encode_" + env.prefix + getName() + "(");
env.indent();
env.println("struct labcomm2014_encoder *e");
if(!isVoid() ) {
env.println(", "+env.prefix + getName() + " *v");
}
env.unindent();
env.println(")");
env.println("{");
env.indent();
env.println("labcomm_internal_encode(e, &labcomm_signature_" +
env.prefix + getName() + ", v);");
env.println("return e->encode(e, &signature_" +
env.prefix + getName() +
", (labcomm2014_encoder_function)encode_" +
env.prefix + getName() +
(!isVoid()?", v":", NULL")+");");
env.unindent();
env.println("}");
}
public void Type.C_emitEncoder(C_env env) {
throw new Error(this.getClass().getName() +
".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");
}
public void VoidType.C_emitEncoder(C_env env) {
env.println("result = 0;");
}
public void PrimType.C_emitEncoder(C_env env) {
env.println("labcomm_encode_" + getName() + "(e, " + env.qualid + ");");
env.print("result = ");
switch (getToken()) {
case LABCOMM_SAMPLE: {
env.println("labcomm2014_write_int(w, " +
"w->encoder->sample_ref_to_index(w->encoder, " +
env.qualid + "));");
} break;
default: {
env.println("labcomm2014_write_" + getName() +
"(w, " + env.qualid + ");");
} break;
}
env.println("if (result != 0) { return result; }");
}
public void UserType.C_emitEncoder(C_env env) {
lookupType(getName()).getType().C_emitEncoder(env);
decl().getDataType().C_emitEncoder(env);
}
public void StructType.C_emitEncoder(C_env env) {
......@@ -695,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) +
......@@ -704,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("}");
......@@ -714,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_encode_int(e, " + env.qualid + ".n_" + i + ");");
env.println("labcomm2014_write_packed32(w, " + env.qualid + ".n_" + i + ");");
}
public void ArrayType.C_emitEncoderEncodeLimit(C_env env) {
......@@ -731,65 +1071,213 @@ aspect C_Encoder {
}
public void Decl.C_emitEncoderRegisterHandler(C_env env) {
throw new Error(this.getClass().getName() +
".C_emitEncoderRegisterHandler(C_env env)" +
" not declared");
throw new Error(this.getClass().getName() +
".C_emitEncoderRegisterHandler(C_env env)" +
" 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) {
C_emitEncoderTypeRegister(env);
}
public void SampleDecl.C_emitEncoderRegisterHandler(C_env env) {
env.println("void labcomm_encoder_register_" +
C_emitEncoderTypeRegister(env);
env.println("int labcomm2014_encoder_register_" +
env.prefix + getName() + "(");
env.indent();
env.println("struct labcomm_encoder *e");
env.println("struct labcomm2014_encoder *e");
env.unindent();
env.println(")");
env.println("{");
env.indent();
env.println("labcomm_internal_encoder_register(");
C_emitUserTypeDeps(env, null, false); //XXX HERE BE DRAGONS
//currently set to false to turn off
//outputting of code
env.println("int result = e->sample_register(");
env.indent();
env.println("e,");
env.println("&labcomm_signature_" + env.prefix + getName() + ",");
env.println("(labcomm_encode_typecast_t)encode_" + getName());
env.println("&signature_" + 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 {
public void Decl.C_emitEncoderIoctl(C_env env) {
throw new Error(this.getClass().getName() +
".C_emitEncoderIoctl()" +
" not declared");
}
public void TypeDecl.C_emitEncoderIoctl(C_env env) {
}
public void SampleDecl.C_emitEncoderIoctl(C_env env) {
env.println("int labcomm2014_encoder_ioctl_" + env.prefix + getName() + "(");
env.indent();
env.println("struct labcomm2014_encoder *e,");
env.println("int ioctl_action,");
env.println("...");
env.unindent();
env.println(")");
env.println("{");
env.indent();
env.println("int result;");
env.println("va_list va;");
env.println("va_start(va, ioctl_action);");
env.println("result = e->ioctl(");
env.indent();
env.println("e, &signature_" + env.prefix + getName() + ", ");
env.println("ioctl_action, va);");
env.unindent();
env.println("va_end(va);");
env.println("return result;");
env.unindent();
env.println("}");
}
}
aspect C_TypeDependencies {
public void Decl.C_emitUserTypeDeps(C_env env, String via, boolean outputCode) {
if( hasDependencies() ) {
Iterator<Decl> it = type_dependencies().iterator();
while(it.hasNext()) {
Decl t = it.next();
t.C_emitUserTypeDeps(env, t.getName(), outputCode);
if(outputCode) {
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() );
}
}
}
}
public void Decl.C_emitUserTypeRefs(C_env env, String via, boolean outputCode) {
if( isReferenced() ) {
Iterator<Decl> it = type_references().iterator();
while(it.hasNext()) {
Decl t = it.next();
t.C_emitUserTypeRefs(env, t.getName(), outputCode);
if(outputCode) {
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() );
}
}
}
}
}
aspect C_Signature {
public void ASTNode.C_emitSignature(C_env env) {
throw new Error(this.getClass().getName() +
".C_emitSignature(C_env env)" +
throw new Error(this.getClass().getName() +
".C_emitSignature(C_env env)" +
" not declared");
}
public void Program.C_emitSignature(C_env env) {
for (int i = 0; i < getNumDecl(); i++) {
getDecl(i).C_emitSignature(env);
syn String Decl.C_DeclTypeString();
eq SampleDecl.C_DeclTypeString() = "LABCOMM_SAMPLE";
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);
} else {
env.println("// not emitting signature for " + getName() +
"referenced=" + isReferenced() +
"sampledecl=" + isSampleDecl());
}
}
public void Decl.C_emitSignature(C_env env) {
public void ASTNode.C_emitFlatSignature(C_env env) {
throw new Error(this.getClass().getName() +
".C_emitFlatSignature(C_env env)" +
" not declared");
}
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_emitSignature(C_env env) {
env.println("static unsigned char signature_bytes_" +
getName() + "[] = {");
// C_genFlatSignature(env);
SignatureList signature = signature();
public void SampleDecl.C_emitFlatSignature(C_env env){
env.println("static unsigned char signature_bytes_" +
env.prefix + getName() + "[] = {");
SignatureList signature = flatSignature(env.version);
for (int i = 0 ; i < signature.size() ; i++) {
String comment = signature.getComment(i);
if (comment != null) {
env.println(signature.getIndent(i) + "// " + comment);
}
byte[] data = signature.getData(i);
byte[] data = signature.getData(i, env.version);
if (data != null) {
env.print(signature.getIndent(i));
for (int j = 0 ; j < data.length ; j++) {
......@@ -799,97 +1287,166 @@ aspect C_Signature {
}
}
env.println("};");
env.println("labcomm_signature_t labcomm_signature_" +
env.prefix + getName() + " = {");
C_emitSizeofValue(env);
env.println("static struct labcomm2014_signature " +
"signature_" + env.prefix + getName() + " = {");
env.indent();
env.println("LABCOMM_SAMPLE, \"" + getName() + "\",");
env.println("(int (*)(void *))labcomm_sizeof_" +
env.prefix + getName() + ",");
env.println("sizeof(signature_bytes_" + getName() + "),");
env.println("signature_bytes_"+ getName());
env.println("\"" + getName() + "\",");
env.println("sizeof_" + env.prefix + getName() + ",");
env.println("sizeof(signature_bytes_" + env.prefix + getName() + "),");
env.println("signature_bytes_" + env.prefix + getName() + ",");
env.println("0,"); // 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 ASTNode.C_genFlatSignature(C_env env) {
throw new Error(this.getClass().getName() +
".C_genFlatSignature(C_env env)" +
" not declared");
}
public void Signature.C_emitSignature(C_env env, boolean decl){
getSignatureList().C_emitSignature(env, decl);
}
public void TypeDecl.C_genFlatSignature(C_env env) {
getType().C_genFlatSignature(env);
}
public abstract void SignatureLine.C_emitSignature(C_env env, boolean decl);
public void SampleDecl.C_genFlatSignature(C_env env) {
getType().C_genFlatSignature(env);
}
public void TypeRefSignatureLine.C_emitSignature(C_env env, boolean isDecl){
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 PrimType.C_genFlatSignature(C_env env) {
C_genFlatSignature(env, getToken());
env.println("// " + 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("\"),");
}
}
//
//
// byte[] data = getData(env.version);
// if (data != null) {
// for (int j = 0 ; j < data.length ; j++) {
// env.print(getIndentString());
// //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();
// }
//
//}
public void SignatureList.C_emitSignature(C_env env, boolean decl) {
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();
}
// public void SampleDecl.C_emitSignature(C_env env) {
// env.println("static unsigned char signature_bytes_" +
// env.prefix + getName() + "[] = {");
// SignatureList signature = signature(env.version);
// for (int i = 0 ; i < signature.size() ; i++) {
// String comment = signature.getComment(i);
// if (comment != null) {
// env.println(signature.getIndent(i) + "// " + comment);
// }
// byte[] data = signature.getData(i);
// if (data != null) {
// env.print(signature.getIndent(i));
// for (int j = 0 ; j < data.length ; j++) {
// env.print(data[j] + ", ");
// }
// env.println("");
// }
// }
// env.println("};");
// env.println("struct labcomm2014_signature labcomm2014_signature_" +
// env.prefix + getName() + " = {");
// env.indent();
// env.println("LABCOMM_SAMPLE, \"" + getName() + "\",");
// 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() + ",");
// env.println("0");
// env.unindent();
// env.println(" };");
// }
public void UserType.C_genFlatSignature(C_env env) {
lookupType(getName()).C_genFlatSignature(env);
}
aspect C_Constructor {
public void ASTNode.C_emitConstructor(C_env env) {
throw new Error(this.getClass().getName() +
".C_emitConstructor(C_env env)" +
" not declared");
}
public void ArrayType.C_genFlatSignature(C_env env) {
C_genFlatSignature(env, LABCOMM_ARRAY);
env.println("// LABCOMM_ARRAY");
C_genFlatSignature(env, getNumExp());
env.println("// # of dimensions");
for (int i = 0 ; i < getNumExp() ; i++) {
getExp(i).C_genFlatSignature(env);
env.println("");
public void Specification.C_emitConstructor(C_env env) {
env.println("LABCOMM_CONSTRUCTOR void init_" +
env.prefix + "_signatures(void)");
env.println("{");
env.indent();
env.println("static int initialized = 0;");
env.println("if (initialized == 0) {");
env.indent();
env.println("initialized = 1;");
for (int i = 0; i < getNumDecl(); i++) {
getDecl(i).C_emitConstructor(env);
}
getType().C_genFlatSignature(env);
env.unindent();
env.println("}");
env.unindent();
env.println("}");
}
public void StructType.C_genFlatSignature(C_env env) {
C_genFlatSignature(env, LABCOMM_STRUCT);
env.println("// LABCOMM_STRUCT");
C_genFlatSignature(env, getNumField());
env.println("// # of fields");
for (int i = 0 ; i < getNumField() ; i++) {
getField(i).C_genFlatSignature(env);
public void TypeDecl.C_emitConstructor(C_env env) {
if (isReferenced()) {
env.println("labcomm2014_set_local_index(&signature_" +
env.prefix + getName() + ");");
}
}
public void Field.C_genFlatSignature(C_env env) {
C_genFlatSignature(env, getName());
env.println("");
getType().C_genFlatSignature(env);
public void SampleDecl.C_emitConstructor(C_env env) {
env.println("labcomm2014_set_local_index(&signature_" +
env.prefix + getName() + ");");
}
public void IntegerLiteral.C_genFlatSignature(C_env env) {
C_genFlatSignature(env, Integer.parseInt(getValue()));
env.print("// " + getValue());
}
public void VariableSize.C_genFlatSignature(C_env env) {
C_genFlatSignature(env, 0);
env.print("// _");
public void ASTNode.C_emitConstructorDeclaration(C_env env) {
throw new Error(this.getClass().getName() +
".C_emitConstructorDeclaration(C_env env)" +
" not declared");
}
public void ASTNode.C_genFlatSignature(C_env env, int value) {
env.print(" ");
for (int i = 24 ; i >= 0 ; i -= 8) {
env.print("0x");
String hex = Integer.toHexString((value >> i) & 0xff);
if (hex.length() == 1) { env.print("0"); }
env.print(hex);
env.print(", ");
}
}
public void ASTNode.C_genFlatSignature(C_env env, String value) {
C_genFlatSignature(env, value.length());
env.println("");
env.print(" ");
for (int i = 0 ; i < value.length() ; i++) {
env.print("'" + value.charAt(i) +"', ");
}
public void Specification.C_emitConstructorDeclaration(C_env env) {
env.println("void init_" + env.prefix + "_signatures(void);");
}
}
......@@ -900,18 +1457,34 @@ aspect C_Sizeof {
}
public void SampleDecl.C_emitSizeofDeclaration(C_env env) {
env.println("extern int labcomm_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 int Type.C_fixedSizeof() {
throw new Error(this.getClass().getName() +
".C_fixedSizeof()" +
" not declared");
public void Decl.C_emitSizeof(C_env env) {
}
public void SampleDecl.C_emitSizeof(C_env env) {
env = env.nestStruct("(*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 labcomm2014_internal_sizeof(" +
"&signature_" + env.prefix + getName() +
", v);");
env.unindent();
env.println("}");
}
public int DataType.C_fixedSizeof() {
throw new Error(this.getClass().getName() +
".C_fixedSizeof()" +
" not declared");
}
public int VoidType.C_fixedSizeof() {
......@@ -920,29 +1493,30 @@ aspect C_Sizeof {
public int PrimType.C_fixedSizeof() {
switch (getToken()) {
case LABCOMM_BOOLEAN: { return 1; }
case LABCOMM_BYTE: { return 1; }
case LABCOMM_SHORT: { return 2; }
case LABCOMM_INT: { return 4; }
case LABCOMM_BOOLEAN: { return 1; }
case LABCOMM_BYTE: { return 1; }
case LABCOMM_SHORT: { return 2; }
case LABCOMM_INT: { return 4; }
case LABCOMM_LONG: { return 8; }
case LABCOMM_FLOAT: { return 4; }
case LABCOMM_DOUBLE: { return 8; }
default: {
throw new Error(this.getClass().getName() +
".C_fixedSizeof()" +
" unknown size (" + getName() + ")");
}
case LABCOMM_SAMPLE: { return 4; }
default: {
throw new Error(this.getClass().getName() +
".C_fixedSizeof()" +
" unknown size (" + getName() + ")");
}
}
}
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;
}
......@@ -953,60 +1527,61 @@ 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_emitSizeof(C_env env) {
public void Decl.C_emitSizeofValue(C_env env) {
}
public void SampleDecl.C_emitSizeof(C_env env) {
public void SampleDecl.C_emitSizeofValue(C_env env) {
env = env.nestStruct("(*v)");
env.println("int labcomm_sizeof_" + env.prefix + getName() +
"(" + env.prefix + getName() + " *v)");
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("int result = 4;");
getType().C_emitSizeof(env);
env.println("return result;");
env.println(env.prefix + getName() + " *v = vv;");
getDataType().C_emitSizeof(env);
} else {
env.println("return " + (4 + C_fixedSizeof()) + ";");
}
env.println("result += " + C_fixedSizeof() + ";");
}
env.println("return result;");
env.unindent();
env.println("}");
}
public void Type.C_emitSizeof(C_env env) {
throw new Error(this.getClass().getName() +
".C_emitSizeof(C_env env)" +
" not declared");
public void DataType.C_emitSizeof(C_env env) {
throw new Error(this.getClass().getName() +
".C_emitSizeof(C_env env)" +
" not declared");
}
public void PrimType.C_emitSizeof(C_env env) {
switch (getToken()) {
case LABCOMM_STRING: {
env.println("result += 4 + strlen(" + env.qualid + ");");
case LABCOMM_STRING: {
env.print("{ int l = strlen(" + env.qualid + "); ");
env.println("result += labcomm2014_size_packed32(l) + l; }");
} break;
default: {
throw new Error(this.getClass().getName() +
".C_emitSizeof(C_env env)" +
" known size (" + getName() + ")");
}
default: {
throw new Error(this.getClass().getName() +
".C_emitSizeof(C_env env)" +
" known size (" + getName() + ")");
}
}
}
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(
env.nestStruct("." + getField(i).getName()));
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) {
......@@ -1014,43 +1589,53 @@ 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;
env.println("for (" + iterator + " = 0" +
" ; " +
iterator + " < " + getExp(i).C_getLimit(env, i) +
" ; " +
iterator + "++) {");
env.indent();
String iterator = "i_" + env.getDepth() + "_" + i;
env.println("for (" + iterator + " = 0" +
" ; " +
iterator + " < " + getExp(i).C_getLimit(env, i) +
" ; " +
iterator + "++) {");
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("}");
env.unindent();
env.println("}");
}
env.unindent();
env.println("}");
} else {
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));
env.print(" * " + getExp(i).C_getLimit(env, i));
}
env.println(";");
env.println(";");
}
}
}
aspect C_forAll {
public void Program.C_emitForAll(C_env env) {
env.print("#define LABCOMM_FORALL_SAMPLES_" + env.lcName +
public void Specification.C_emitForAll(C_env env) {
env.print("#define LABCOMM_FORALL_SAMPLES_" + env.lcName +
"(func, sep)");
env.indent();
boolean needSeparator = false;
......@@ -1066,7 +1651,7 @@ aspect C_forAll {
env.println("");
env.unindent();
}
public String Decl.C_forAll(C_env env) {
return null;
}
......@@ -1079,25 +1664,38 @@ aspect C_forAll {
aspect C_Info {
public void Program.C_info(PrintStream out, String prefix) {
C_env env = new C_env("", "", prefix, out);
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);
}
}
public void Decl.C_info(C_env env) {
throw new Error(this.getClass().getName() +
".C_info((C_env env)" +
throw new Error(this.getClass().getName() +
".C_info((C_env env)" +
" not declared");
}
public void TypeDecl.C_info(C_env env) {
env.println("C,typedef," + getName() + "," + getName());
env.println(",C,typedef," + env.prefix + getName() + "," +
env.prefix + getName() + "," +
C_info_type_or_void(env.prefix));
}
public void SampleDecl.C_info(C_env env) {
env.println("C,sample," + getName() + "," + getName());
env.println(",C,sample," + env.prefix + getName() + "," +
env.prefix + getName() + "," +
C_info_type_or_void(env.prefix));
}
// make void types explicitly as they require special treatment
// in encoder/decoder calls
protected String Decl.C_info_type_or_void(String prefix) {
if(isVoid() ) {
return "void";
} else {
return prefix + getName() ;
}
}
}
compiler/2014/DeclNames.jrag 0 → 100644
View file @ d3921882
aspect DeclNames {
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 DataType.parentDecl();
inh Decl Field.parentDecl();
eq Decl.getTypeInstance().parentDecl() = this;
eq StructType.getField(int i).parentDecl() = parentDecl();
}
compiler/2014/ErrorCheck.jrag 0 → 100644
View file @ d3921882
import java.util.Collection;
aspect ErrorCheck {
syn int ASTNode.lineNumber() = getLine(getStart());
protected String ASTNode.errors = null;
protected void ASTNode.error(String s) {
s = "Error at " + lineNumber() + ": " + s;
if(errors == null) {
errors = s;
} else {
errors = errors + "\n" + s;
}
}
protected boolean ASTNode.hasErrors() {
return errors != null;
}
public void ASTNode.errorCheck(Collection collection) {
nameCheck();
typeCheck();
if(hasErrors())
collection.add(errors);
for(int i = 0; i < getNumChild(); i++) {
getChild(i).errorCheck(collection);
}
}
}
Signature.jrag → compiler/2014/FlatSignature.jrag
View file @ d3921882
import java.util.*;
aspect Signature {
public class SignatureLine {
private int indent;
private byte[] data;
private String comment;
public SignatureLine(int indent, byte[] data, String comment) {
this.indent = indent;
this.data = data;
this.comment = comment;
}
public int getIndent() {
return indent;
}
public byte[] getData() {
return data;
}
public String getComment() {
return comment;
}
}
public class SignatureList {
aspect NoIntentionForTypeOrSampledefs {
inh boolean TypeInstance.addIntentions();
eq Decl.getTypeInstance().addIntentions() = false;
eq StructType.getField(int i).addIntentions() = true;
}
private int indent;
private ArrayList list = new ArrayList();
public void add(byte[] data, String comment) {
list.add(new SignatureLine(indent, data, comment));
}
public void addInt(int value, String comment) {
byte[] data = new byte[4];
for (int i = 0 ; i < 4 ; i++) {
data[3 - i] = (byte)((value >> (8 * i)) & 0xff);
}
add(data, comment);
}
public void addString(String value, String comment) {
addInt(value.length(), comment);
byte[] data = new byte[value.length()];
for (int i = 0 ; i < value.length() ; i++) {
data[i] = (byte)(value.charAt(i) & 0xff);
}
add(data, null);
}
public int size() {
return list.size();
}
aspect FlatSignature {
public String getIndent(int i) {
StringBuffer result = new StringBuffer();
int indent = ((SignatureLine)list.get(i)).getIndent();
for (i = 0 ; i < indent ; i++) {
result.append(" ");
}
return result.toString();
}
public byte[] getData(int i) {
return ((SignatureLine)list.get(i)).getData();
}
public String getComment(int i) {
return ((SignatureLine)list.get(i)).getComment();
}
public void indent() {
indent++;
}
public void unindent() {
indent--;
}
}
public SignatureList Decl.signature() {
SignatureList result = new SignatureList();
flatSignature(result);
public SignatureList Decl.flatSignature(int version) {
SignatureList result = getSignature().getFlatSignatureList();
return result;
}
public void ASTNode.flatSignature(SignatureList list) {
throw new Error(this.getClass().getName() +
".flatSignature(SignatureList list)" +
throw new Error(this.getClass().getName() +
".flatSignature(SignatureList list)" +
" not declared");
}
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 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) {
......@@ -125,7 +59,7 @@ aspect Signature {
for (int i = 0 ; i < getNumExp() ; i++) {
getExp(i).flatSignature(list);
}
getType().flatSignature(list);
getDataType().flatSignature(list);
list.unindent();
list.add(null, "}");
}
......@@ -142,8 +76,10 @@ aspect Signature {
}
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) {
......@@ -158,7 +94,7 @@ aspect Signature {
StringBuffer result = new StringBuffer("array [");
for (int i = 0 ; i < getNumExp() ; i++) {
if (i > 0) {
result.append(", ");
result.append(", ");
}
result.append(getExp(i).signatureComment());
}
......@@ -167,15 +103,19 @@ aspect Signature {
}
public String ASTNode.signatureComment() {
throw new Error(this.getClass().getName() +
".signatureComment()" +
throw new Error(this.getClass().getName() +
".signatureComment()" +
" not declared");
}
public String Field.signatureComment() {
return getType().signatureComment() + " '" + getName() +"'";
return getDataType().signatureComment() + " '" + getName() +"'";
}
// public String SampleRefType.signatureComment() {
// return "sample";
// }
public String PrimType.signatureComment() {
return getName();
}
......@@ -196,4 +136,4 @@ aspect Signature {
return "_";
}
}
\ No newline at end of file
}
compiler/2014/GenerateTypedefs.jrag 0 → 100644
View file @ d3921882
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;");
}
}
}