Skip to content
Snippets Groups Projects

Compare revisions

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

Source

Select target project
No results found
Select Git revision
Loading items

Target

Select target project
0 results Searching
Select Git revision
Loading items
Show changes

Commits on Source 609

509 additional commits have been omitted to prevent performance issues.
396 files
+ 30955
− 9525
Compare changes
  • Side-by-side
  • Inline

Files

.bzrignore

deleted100644 → 0
+0 −19
Original line number Original line Diff line number Diff line 
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

.gitignore

0 → 100644
+5 −0
Original line number Original line Diff line number Diff line 
*~

*.class

*.o

*.pyc

examples/dynamic/gen

ErrorCheck.jrag

deleted100644 → 0
+0 −30
Original line number Original line Diff line number Diff line 
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
+73 −0
Original line number Original line Diff line number Diff line 
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

deleted100644 → 0
+0 −23
Original line number Original line Diff line number Diff line 
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

deleted100644 → 0
+0 −295
Original line number Original line Diff line number Diff line 
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

deleted100644 → 0
+0 −18
Original line number Original line Diff line number Diff line 
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
+46 −0
Original line number Original line Diff line number Diff line 
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

deleted100644 → 0
+0 −193
Original line number Original line Diff line number Diff line 
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
+60 −0
Original line number Original line Diff line number Diff line 
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

deleted100644 → 0
+0 −104
Original line number Original line Diff line number Diff line 
<!--

 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/**" 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
+4 −0
Original line number Original line Diff line number Diff line 
gen

labcomm2006_compiler.jar

labcomm2014_compiler.jar

labcomm2014_compiler.jar

compiler/2014/Annotations.jrag

0 → 100644
+130 −0
Original line number Original line Diff line number Diff line 
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

+8 −8
Original line number Original line Diff line number Diff line
@@ -13,29 +13,29 @@ aspect ArrayRewrite { 
    when (! getDim(0).isVariable()) 

    when (! getDim(0).isVariable()) 

    to FixedArrayType  { 

    to FixedArrayType  { 

      if (getNumDim() == 1) {

      if (getNumDim() == 1) {

        return new FixedArrayType(getType(), 

        return new FixedArrayType(getDataType(), 

				  getDim(0).getExpList());

				  getDim(0));

      } else {

      } else {

        List l = new List();

        List l = new List();

        for (int i = 1 ; i < getNumDim() ; i++) {

        for (int i = 1 ; i < getNumDim() ; i++) {

	  l.add(getDim(i));

	  l.add(getDim(i));

        }

        }

        return new FixedArrayType(new ParseArrayType(getType(), l), 

        return new FixedArrayType(new ParseArrayType(getDataType(), l), 

				  getDim(0).getExpList());

				  getDim(0));

      }

      }

    }

    }

    when (getDim(0).isVariable()) 

    when (getDim(0).isVariable()) 

    to VariableArrayType  { 

    to VariableArrayType  { 

      if (getNumDim() == 1) {

      if (getNumDim() == 1) {

        return new VariableArrayType(getType(), 

        return new VariableArrayType(getDataType(), 

				     getDim(0).getExpList());

				     getDim(0));

      } else {

      } else {

        List l = new List();

        List l = new List();

        for (int i = 1 ; i < getNumDim() ; i++) {

        for (int i = 1 ; i < getNumDim() ; i++) {

	  l.add(getDim(i));

	  l.add(getDim(i));

        }

        }

        return new VariableArrayType(new ParseArrayType(getType(), l), 

        return new VariableArrayType(new ParseArrayType(getDataType(), l), 

				     getDim(0).getExpList());

				     getDim(0));

      }

      }

    }

    }

  }

  }

CS_CodeGen.jrag→compiler/2014/CS_CodeGen.jrag

+335 −297

File changed and moved.

Preview size limit exceeded, changes collapsed.

C_CodeGen.jrag→compiler/2014/C_CodeGen.jrag

+1701 −0

File changed and moved.

Preview size limit exceeded, changes collapsed.

compiler/2014/DeclNames.jrag

0 → 100644
+14 −0
Original line number Original line Diff line number Diff line 
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
+30 −0
Original line number Original line Diff line number Diff line 
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);

        }

    }

}