.bzrignore

-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
-labcomm.dll
-labcomm.jar
-example.c
-example.h
-example.py
-examples/wiki_example/example.encoded
-example.encoded
-examples/simple/*.class
-examples/simple/encoded_data
-examples/simple/example_decoder
-examples/simple/example_encoder
-lib/c/test/test_labcomm_basic_type_encoding
-lib/c/test/test_labcomm_generated_encoding
-lib/java/se/lth/control/labcomm/WriterWrapper.class
-lib/c/liblabcomm.so.1
-lib/c/test/test_labcomm_pthread_scheduler
-lib/c/liblabcomm_plain_c.so.1
-lib/c/test/test_signature_plain_c
-test/test_signature_numbers
-lib/c/test/test_signature_numbers
-lib/c/test/test_labcomm

.gitignore

+*~
 *.class
 *.o
-lib/c/liblabcomm.a
-lib/c/liblabcomm.so
-lib/c/liblabcomm.so.1
-lib/c/liblabcomm2006.so.1
-lib/c/liblabcomm2006.so
-lib/c/liblabcomm2006.a
-lib/c/liblabcomm2014.so.1
-lib/c/liblabcomm2014.so
-lib/c/liblabcomm2014.a
-lib/c/test/test_labcomm
-lib/c/test/test_labcomm_basic_type_encoding
-lib/c/test/test_labcomm_copy
-lib/c/test/test_labcomm_generated_encoding
-lib/c/test/test_labcomm_pthread_scheduler
-lib/c/test/test_signature_numbers
-compiler/AST/
-compiler/labcomm_compiler.jar
-encoded_data
-encoded_data06
-gen
-gen06
 *.pyc
-examples/twoway/gen/
-lib/csharp/labcomm.dll
-lib/java/gen/
-lib/java/labcomm*.jar
-examples/simple/example_decoder
-examples/simple/example_decoder06
-examples/simple/example_encoder
-examples/simple/example_encoder06
+examples/dynamic/gen

LICENSE.rationale

+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. 
+

Makefile

-SUBDIRS=compiler lib test examples
-export LABCOMM_JAR=$(shell pwd)/compiler/labcomm_compiler.jar
+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
 
-all: $(SUBDIRS:%=make-%)
+UNAME_S=$(shell uname -s)
 
-.PHONY: make-compiler
-make-compiler:
-	cd compiler ; ant jar
+.PHONY: all
+all: $(SUBDIRS:%=all-%)
 
-.PHONY: make-%
-make-%:
-	LD_LIBRARY_PATH=`pwd`/lib/c $(MAKE) -C $* -e 
+.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-compiler
-test-compiler:
-	$(MAKE) -C test compiler_errors
-
 .PHONY: test-%
 test-%:
-	LD_LIBRARY_PATH=`pwd`/lib/c $(MAKE) -C $* -e 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-compiler
-clean-compiler:
-	cd compiler ; ant clean
-
 .PHONY: clean-%
 clean-%:
-	$(MAKE) -C $* -e clean
+	$(MAKE) -C $* clean
 
 .PHONY: distclean
-distclean: $(SUBDIRS:%=distclean-%)
-
-.PHONY: distclean-compiler
-distclean-compiler:
-	cd compiler ; ant clean
+distclean: clean $(SUBDIRS:%=distclean-%)
 
 .PHONY: distclean-%
 distclean-%:
-	$(MAKE) -C $* -e distclean
+	$(MAKE) -C $* distclean
+
+.PHONY: srpm
+srpm:
+	make -C packaging $@

compiler/.gitignore

+gen
+labcomm2006_compiler.jar
+labcomm2014_compiler.jar
+labcomm2014_compiler.jar

compiler/2014/Annotations.jrag

+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
+
+}
+

compiler/ArrayTypeRewrite.jrag → compiler/2014/ArrayTypeRewrite.jrag

@@ -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));
       }
     }
   }

compiler/2014/DeclNames.jrag

+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

+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);
+        }
+    }
+}

compiler/FlatSignature.jrag → compiler/2014/FlatSignature.jrag

 import java.util.*;
 
+aspect NoIntentionForTypeOrSampledefs {
+    inh boolean TypeInstance.addIntentions();
+    eq Decl.getTypeInstance().addIntentions() = false;
+    eq StructType.getField(int i).addIntentions() = true;
+}
+
 aspect FlatSignature {
 
   public SignatureList Decl.flatSignature(int version) {
@@ -14,11 +20,23 @@ aspect FlatSignature {
   }
 
   public void TypeDecl.flatSignature(SignatureList list) {
-    getType().flatSignature(list);
+    getTypeInstance().flatSignature(list);
   }
 
   public void SampleDecl.flatSignature(SignatureList list) {
-    getType().flatSignature(list);
+    getTypeInstance().flatSignature(list);
+  }
+
+//  public void SampleRefType.flatSignature(SignatureList list) {
+//    list.addInt(LABCOMM_SAMPLE_REF, "sample");
+//  }
+
+  public void 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) {
@@ -41,7 +59,7 @@ aspect FlatSignature {
     for (int i = 0 ; i < getNumExp() ; i++) {
       getExp(i).flatSignature(list);
     }
-    getType().flatSignature(list);
+    getDataType().flatSignature(list);
     list.unindent();
     list.add(null, "}");
   }
@@ -58,8 +76,10 @@ aspect FlatSignature {
   }
 
   public void Field.flatSignature(SignatureList list) {
-    list.addString(getName(), signatureComment());
-    getType().flatSignature(list);
+    debugAnnotations(this.getName()+".Field.flatSignature");
+    list.addIntentions(intentions(), "Field: "+getIntentionString());
+//    list.addString(getName(), signatureComment());
+    getDataType().flatSignature(list);
   }
 
   public void IntegerLiteral.flatSignature(SignatureList list) {
@@ -89,9 +109,13 @@ aspect FlatSignature {
   }
 
   public String Field.signatureComment() {
-    return getType().signatureComment() + " '" + getName() +"'";
+    return getDataType().signatureComment() + " '" + getName() +"'";
   }
 
+//  public String SampleRefType.signatureComment() {
+//    return "sample";
+//  }
+
   public String PrimType.signatureComment() {
     return getName();
   }

compiler/2014/GenerateTypedefs.jrag

+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;");
+        }
+    }
+
+}

compiler/2014/LabComm.ast

+Specification ::= Decl*;
+
+abstract Decl ::= TypeInstance /Signature/;
+
+TypeInstance ::= DataType Annotations;
+
+Annotations ::= Annotation*;
+Annotation ::= <Key:String> <Value:byte[]>;
+
+Intention : Annotation;
+DocString : Annotation;
+
+TypeDecl   : Decl;
+SampleDecl : Decl;
+
+//Signatures are in the abstract grammar, so that
+//they can be extended and refined by aspects.
+
+Signature                 ::= SignatureList FlatSignatureList:SignatureList;
+SignatureList             ::= SignatureLine*;
+abstract SignatureLine 	  ::= <Indent:int> <Comment:String>;
+abstract DataSignatureLine : SignatureLine;
+ByteArraySignatureLine     : DataSignatureLine ::= <Data:byte[]>;
+IntSignatureLine           : DataSignatureLine ::= <Data:int>;
+StringSignatureLine        : DataSignatureLine ::= <Data:String>;
+IntentionSignatureLine     : DataSignatureLine ::= Intention* ;
+TypeRefSignatureLine       : SignatureLine     ::= Decl;
+
+Field : TypeInstance;
+
+abstract DataType;
+VoidType           : DataType;
+//SampleRefType      : DataType;
+PrimType           : DataType ::= <Name:String> <Token:int>;
+UserType           : DataType ::= <Name:String>;
+StructType         : DataType ::= Field*;
+ParseArrayType     : DataType ::= DataType Dim*;
+abstract ArrayType : DataType ::= DataType Dim;
+VariableArrayType  : ArrayType;
+FixedArrayType     : ArrayType;
+
+Dim ::= Exp*;
+
+abstract Exp;
+IntegerLiteral : Exp ::= <Value:String>;
+VariableSize   : Exp;

compiler/LabComm.java → compiler/2014/LabComm.java

-import AST.*;
+package se.lth.control.labcomm2014.compiler;
+
 import java.io.*;
 import java.util.*;
 
@@ -13,7 +14,7 @@ public class LabComm {
     println("");
     println(" --help                  Shows this help text");
     println(" -v                      Be verbose");
-    println(" --ver=VERSION           Generate code for labcomm VERSION (=2006 or 2013)");
+    println(" --ver=VERSION           Generate code for labcomm VERSION (=2006 or 2014)");
     println("[ C options ]");
     println(" -C                      Generates C/H code in FILE.[ch]");
     println(" --cprefix=PREFIX        Prefixes C types with PREFIX");
@@ -33,21 +34,22 @@ public class LabComm {
     println("[ RAPID options ]");
     println(" --rapid                 Generates RAPID code in FILE.sys");
     println("[ Misc options ]");
-    println(" --pretty                Pretty prints on standard output");
+    println(" --pretty=PFILE          Pretty prints to PFILE");
     println(" --typeinfo=TIFILE       Generates typeinfo in TIFILE");
+    println(" --typedefs=TIFILE       Generates typedefs in TIFILE");
   }
 
   /** To be cleaned up.
    */
   private static void checkVersion(int v) {
-     if(! (v == 2006 || v == 2013) ) {
+     if(! (v == 2006 || v == 2014) ) {
 	System.err.println(" Unknown version: " + v);
-	System.err.println(" Supported versions: 2006, 2013 ");
+	System.err.println(" Supported versions: 2006, 2014 ");
 	System.exit(2);
      }
   }
 
-  private static void genH(Program p, String hName, 
+  private static void genH(Specification p, String hName,
 			   Vector cIncludes, String coreName, String prefix, int ver) {
     try {
       FileOutputStream f;
@@ -62,7 +64,7 @@ public class LabComm {
     }
   }
 
-  private static void genC(Program p, String cName, 
+  private static void genC(Specification p, String cName,
 			   Vector cIncludes, String coreName, String prefix, int ver) {
     try {
       FileOutputStream f;
@@ -77,7 +79,7 @@ public class LabComm {
     }
   }
 
-  private static void genCS(Program p, String csName, String csNamespace, int ver) {
+  private static void genCS(Specification p, String csName, String csNamespace, int ver) {
 //      throw new Error("C# generation currently disabled");
     try {
       p.CS_gen(csName, csNamespace, ver);
@@ -87,7 +89,7 @@ public class LabComm {
     }
   }
 
-  private static void genJava(Program p,  String dirName, String packageName, int ver) {
+  private static void genJava(Specification p,  String dirName, String packageName, int ver) {
     try {
       p.J_gen(dirName, packageName, ver);
     } catch (IOException e) {
@@ -96,7 +98,7 @@ public class LabComm {
     }
   }
 
-  private static void genPython(Program p, String filename, String prefix, int ver) {
+  private static void genPython(Specification p, String filename, String prefix, int ver) {
     try {
       FileOutputStream f;
       PrintStream out;
@@ -110,7 +112,7 @@ public class LabComm {
     }
   }
 
-  private static void genRAPID(Program p, String filename, String prefix, int ver) {
+  private static void genRAPID(Specification p, String filename, String prefix, int ver) {
     try {
       p.RAPID_gen(filename, prefix, ver);
     } catch (IOException e) {
@@ -126,7 +128,7 @@ public class LabComm {
     String coreName = null;
     String prefix = null;
     boolean verbose = false;
-    int ver = 2013; //Version 2013 as default
+    int ver = 2014; //Version 2014 as default
     String cFile = null;
     String hFile = null;
     Vector cIncludes = new Vector();
@@ -138,6 +140,7 @@ public class LabComm {
     String pythonFile = null;
     String prettyFile = null;
     String typeinfoFile = null;
+    String typedefsFile = null;
     String rapidFile = null;
     String fileName = null;
 
@@ -222,6 +225,8 @@ public class LabComm {
           prettyFile = args[i].substring(9);
         } else if (args[i].startsWith("--typeinfo=")) {
           typeinfoFile = args[i].substring(11);
+        } else if (args[i].startsWith("--typedefs=")) {
+          typedefsFile = args[i].substring(11);
         } else if (args[i].equals("--rapid")) {
           rapidFile = coreName + ".sys";
         } else if (i == args.length - 1) {
@@ -238,14 +243,14 @@ public class LabComm {
      }
    }
 
-   Program parseFile(){
-     Program ast = null;
+   Specification parseFile(){
+     Specification ast = null;
      try {
        // Check for errors
        LabCommScanner scanner = new LabCommScanner(
                                   new FileReader(fileName));
        LabCommParser parser = new LabCommParser();
-       Program p = (Program)parser.parse(scanner);
+       Specification p = (Specification)parser.parse(scanner);
        Collection errors = new LinkedList();
        p.errorCheck(errors);
 
@@ -267,7 +272,7 @@ public class LabComm {
      return ast;
    }
 
-   boolean generateC(Program ast) {
+   boolean generateC(Specification ast) {
      boolean wroteFile = false;
      Vector hIncludes = new Vector(cIncludes);
      if (hFile != null) {
@@ -286,7 +291,7 @@ public class LabComm {
      return wroteFile;
    }
 
-   boolean generateCS(Program ast) {
+   boolean generateCS(Specification ast) {
      boolean wroteFile = false;
      if (csFile != null) {
        printStatus("C#: " , csFile);
@@ -296,7 +301,7 @@ public class LabComm {
      return wroteFile;
    }
 
-   boolean generateJava(Program ast) {
+   boolean generateJava(Specification ast) {
      boolean wroteFile = false;
      if (javaDir != null) {
        printStatus("Java: " , javaDir);
@@ -306,7 +311,7 @@ public class LabComm {
      return wroteFile;
    }
 
-   boolean generatePython(Program ast) {
+   boolean generatePython(Specification ast) {
      boolean wroteFile = false;
      if (pythonFile != null) {
        printStatus("Python: " , pythonFile);
@@ -316,7 +321,7 @@ public class LabComm {
      return wroteFile;
    }
 
-   boolean generateRAPID(Program ast) {
+   boolean generateRAPID(Specification ast) {
      boolean wroteFile = false;
      if (rapidFile != null) {
        printStatus("RAPID: " , rapidFile);
@@ -325,7 +330,7 @@ public class LabComm {
      }
      return wroteFile;
    }
-   boolean generatePrettyPrint(Program ast) {
+   boolean generatePrettyPrint(Specification ast) {
      boolean wroteFile = false;
      if (prettyFile != null) {
        printStatus("Pretty: " , prettyFile);
@@ -342,7 +347,7 @@ public class LabComm {
      return wroteFile;
    }
 
-   boolean generateTypeinfo(Program ast) {
+   boolean generateTypeinfo(Specification ast) {
      boolean wroteFile = false;
      if (typeinfoFile != null) {
        printStatus("TypeInfo: " , typeinfoFile);
@@ -360,6 +365,22 @@ public class LabComm {
      return wroteFile;
     }
 
+   boolean generateTypedefs(Specification ast) {
+     boolean wroteFile = false;
+     if (typedefsFile != null) {
+       printStatus("Typedefs: " , typedefsFile);
+       try {
+         FileOutputStream f = new FileOutputStream(typedefsFile);
+         PrintStream out = new PrintStream(f);
+         ast.generateTypedefs(out, ver);
+         wroteFile = true;
+       } catch (IOException e) {
+         System.err.println("IOException: " + typedefsFile + " " + e);
+       }
+     }
+     return wroteFile;
+    }
+
     private void printStatus(String kind, String filename){
        if (verbose) {
          System.err.println("Generating "+kind+": " + filename);
@@ -375,7 +396,7 @@ public class LabComm {
       System.exit(1);
     } else {
       opts.processArgs();
-      Program ast =  opts.parseFile();
+      Specification ast =  opts.parseFile();
 
       if (ast != null) {
 
@@ -388,6 +409,7 @@ public class LabComm {
         fileWritten |= opts.generateRAPID(ast);
         fileWritten |= opts.generatePrettyPrint(ast);
         fileWritten |= opts.generateTypeinfo(ast);
+        fileWritten |= opts.generateTypedefs(ast);
 
         // if no output to files, prettyprint on stdout
 	if (!fileWritten) {

compiler/LabCommParser.parser → compiler/2014/LabCommParser.parser

 %header {:
- package AST;
+  package se.lth.control.labcomm2014.compiler;
+  import se.lth.control.labcomm2014.compiler.*;
 :};
 %embed {:
   public static class SourceError extends Error {
@@ -33,9 +34,9 @@
         }
 :};
 
-Program goal =
-     /* Empty program */               {: return new Program(); :}
-  |  decl_list.l                       {: return new Program(l); :}
+Specification goal =
+     /* Empty program */               {: return new Specification(); :}
+  |  decl_list.l                       {: return new Specification(l); :}
   ;
 
 List decl_list =
@@ -53,26 +54,40 @@ List var_decl_list =
   | var_decl_list.l var_decl.v      {: return l.add(v); :}
   ;
 
+Annotations annotations = 
+    /* empty list */  {: return new Annotations(); :}
+  |  annotation_list.l {: return new Annotations(l); :}
+  ;
+
+List annotation_list =
+    annotation.i                      {: return new List().add(i); :}
+  | annotation_list.l annotation.i     {: return l.add(i); :}
+  ;
+
+String key = IDENTIFIER;
+String stringliteral = IDENTIFIER | QUOTEDSTRING;
+
+Annotation annotation = intention.i | docstring.d;
+Annotation intention = LPAREN key.k COLON stringliteral.v RPAREN {: return new Intention(k,v.getBytes()); :};
+Annotation docstring = QUOTEDSTRING.s {: return new DocString(s.substring(1,s.length()-1).getBytes()); :};
+
+TypeInstance type_instance =
+    annotations.a type.t IDENTIFIER {: return new TypeInstance(t, IDENTIFIER, a); :}
+  | annotations.a type.t IDENTIFIER dim_list.d 
+    {: return new TypeInstance(new ParseArrayType(t, d), IDENTIFIER, a); :}
+  ;
+
 Field var_decl =
-    type.t IDENTIFIER SEMICOLON     {: return new Field(t, IDENTIFIER); :}
-  | type.t IDENTIFIER dim_list.d SEMICOLON
-    {: return new Field(new ParseArrayType(t, d), IDENTIFIER); :}
+    type_instance.t SEMICOLON     {: return new Field(t); :}
   ;
 
 TypeDecl type_decl =
-    TYPEDEF type.t IDENTIFIER SEMICOLON {: return new TypeDecl(t, IDENTIFIER); :}
-  | TYPEDEF type.t IDENTIFIER dim_list.d SEMICOLON
-    {: return new TypeDecl(new ParseArrayType(t, d), IDENTIFIER); :}
-  ;
+    TYPEDEF type_instance.t  SEMICOLON {: return new TypeDecl(t); :} ;
 
 SampleDecl sample_decl =
-    SAMPLE type.t IDENTIFIER SEMICOLON
-      {: return new SampleDecl(t, IDENTIFIER); :}
-  | SAMPLE type.t IDENTIFIER dim_list.d SEMICOLON
-      {: return new SampleDecl(new ParseArrayType(t, d), IDENTIFIER); :}
-  ;
+    SAMPLE type_instance.t SEMICOLON {: return new SampleDecl(t); :} ;
 
-Type type =
+DataType type =
     prim_type.p                     {: return p; :}
   | user_type.u                     {: return u; :}
   | struct_type.s                   {: return s; :}
@@ -96,6 +111,8 @@ PrimType prim_type =
       {: return new PrimType(DOUBLE, ASTNode.LABCOMM_DOUBLE); :}
   | STRING
       {: return new PrimType(STRING, ASTNode.LABCOMM_STRING); :}
+  | SAMPLE
+      {: return new PrimType(SAMPLE, ASTNode.LABCOMM_SAMPLE); :}
   ;
 
 UserType user_type =

compiler/LabCommScanner.flex → compiler/2014/LabCommScanner.flex

-package AST;
+package se.lth.control.labcomm2014.compiler;
 
 import beaver.Symbol;
 import beaver.Scanner;
-import AST.LabCommParser.Terminals;
+import se.lth.control.labcomm2014.compiler.LabCommParser.Terminals;
 
 %%
 
@@ -44,13 +44,16 @@ Comment = {TraditionalComment}
 TraditionalComment = "/*" [^*] ~"*/" | "/*" "*"+ "/" | "/*" "*"+ [^/*] ~"*/"
 EndOfLineComment = "//" {InputCharacter}* {LineTerminator}?
 
-Identifier = [:jletter:][:jletterdigit:]*
+Identifier = [[:letter:]_]([[:letter:]_[:digit:]])*
+StringLiteral = [:jletterdigit:]*
 
 DecimalNumeral = 0 | {NonZeroDigit} {Digits}?
 Digits = {Digit}+
 Digit = 0 | {NonZeroDigit}
 NonZeroDigit = [1-9]
 
+QuotedString = "\""~"\""
+
 %%
 
 <YYINITIAL> {
@@ -76,10 +79,14 @@ NonZeroDigit = [1-9]
   "}"                            { return sym(Terminals.RBRACE); }
   "["                            { return sym(Terminals.LBRACK); }
   "]"                            { return sym(Terminals.RBRACK); }
+  "("                            { return sym(Terminals.LPAREN); }
+  ")"                            { return sym(Terminals.RPAREN); }
   ";"                            { return sym(Terminals.SEMICOLON); }
+  ":"                            { return sym(Terminals.COLON); }
   ","                            { return sym(Terminals.COMMA); }
 
   {Identifier}                   { return sym(Terminals.IDENTIFIER); }
+  {QuotedString}                 { return sym(Terminals.QUOTEDSTRING); }
 }
 
 // fall through errors

compiler/LabCommTokens.jrag → compiler/2014/LabCommTokens.jrag

 aspect LabCommTokens {
 
   public static final int ASTNode.LABCOMM_VERSION =    0x01;  
-  public static final int ASTNode.LABCOMM_SAMPLE    =  0x02;  // The flat signature
+  public static final int ASTNode.LABCOMM_SAMPLE_DEF = 0x02;  // The flat signature
+  public static final int ASTNode.LABCOMM_SAMPLE_REF = 0x03;  
   public static final int ASTNode.LABCOMM_TYPE_DEF  =  0x03;  // and type declarations, hierarchically
+  public static final int ASTNode.LABCOMM_TYPE_BINDING=0x05;
 
   public static final int ASTNode.LABCOMM_ARRAY =      0x10;
   public static final int ASTNode.LABCOMM_STRUCT =     0x11;
@@ -15,5 +17,6 @@ aspect LabCommTokens {
   public static final int ASTNode.LABCOMM_FLOAT =      0x25;
   public static final int ASTNode.LABCOMM_DOUBLE =     0x26;
   public static final int ASTNode.LABCOMM_STRING =     0x27;
+  public static final int ASTNode.LABCOMM_SAMPLE =     0x28;
 
 }

compiler/NameAnalysis.jrag → compiler/2014/NameAnalysis.jrag

@@ -2,7 +2,7 @@
 aspect NameAnalysis {
 
   inh String Decl.lookupName(String name);
-  eq Program.getDecl(int index).lookupName(String name) {
+  eq Specification.getDecl(int index).lookupName(String name) {
     for (int i = 0; i < index; i++) {
       String s = getDecl(i).getName();
       if (s.equals(name)) {
@@ -24,7 +24,7 @@ aspect NameAnalysis {
 
   inh TypeDecl Decl.lookupType(String name);
   inh TypeDecl UserType.lookupType(String name);
-  eq Program.getDecl(int index).lookupType(String name) {
+  eq Specification.getDecl(int index).lookupType(String name) {
     for(int i = 0; i < index; i++) {
       Decl d = getDecl(i);  
       if(d instanceof TypeDecl && d.getName().equals(name)) {
@@ -34,9 +34,8 @@ aspect NameAnalysis {
     return null;
   }
 
-  //syn TypeDecl UserType.decl() = lookupType(getName());
-  syn TypeDecl Type.decl(); 
-  eq Type.decl() = null;
+  syn TypeDecl DataType.decl(); 
+  eq DataType.decl() = null;
   eq UserType.decl() = lookupType(getName());
   eq PrimType.decl() = null; //HERE BE DRAGONS XXX