Merge lp:~danilovesky/workcraft/trunk-verilog-export-translate into lp:workcraft

[Danil Sokolov]

=== modified file 'CircuitPlugin/src/org/workcraft/plugins/circuit/CircuitSettings.java'
--- CircuitPlugin/src/org/workcraft/plugins/circuit/CircuitSettings.java	2015-10-29 18:40:12 +0000
+++ CircuitPlugin/src/org/workcraft/plugins/circuit/CircuitSettings.java	2015-11-09 09:38:45 +0000
@@ -21,6 +21,7 @@
 	private static final String keyWireWidth  = prefix + ".wireWidth";
 	private static final String keySimplifyStg = prefix + ".simplifyStg";
 	private static final String keyGateLibrary = prefix + ".gateLibrary";
+	private static final String keySubstitutionLibrary = prefix + ".substitutionLibrary";
 	private static final String keyOpenSynthesisResult = prefix + ".openSynthesisResult";
 
 	private static final boolean defaultShowContacts = false;
@@ -30,6 +31,7 @@
 	private static final Double defaultWireWidth = 0.04;
 	private static final boolean defaultSimplifyStg = true;
 	private static final String defaultGateLibrary = "tools/petrify/petrify.lib";
+	private static final String defaultSubstitutionLibrary = "";
 	private static final boolean defaultOpenSynthesisResult = true;
 
 	private static boolean showContacts = defaultShowContacts;
@@ -39,6 +41,7 @@
 	private static Double wireWidth = defaultWireWidth;
 	private static boolean simplifyStg = defaultSimplifyStg;
 	private static String gateLibrary = defaultGateLibrary;
+	private static String substitutionLibrary = defaultSubstitutionLibrary;
 	private static boolean openSynthesisResult = defaultOpenSynthesisResult;
 	
 	public CircuitSettings() {
@@ -112,6 +115,16 @@
 			}
 		});
 
+		properties.add(new PropertyDeclaration<CircuitSettings, String>(
+				this, "Substitution rules for export", String.class, true, false, false) {
+			protected void setter(CircuitSettings object, String value) {
+				setSubstitutionLibrary(value);
+			}
+			protected String getter(CircuitSettings object) {
+				return getSubstitutionLibrary();
+			}
+		});
+
 		properties.add(new PropertyDeclaration<CircuitSettings, Boolean>(
 				this, "Import synthesis result", Boolean.class, true, false, false) {
 			protected void setter(CircuitSettings object, Boolean value) {
@@ -147,6 +160,7 @@
 		setWireWidth(config.getDouble(keyWireWidth, defaultWireWidth));
 		setSimplifyStg(config.getBoolean(keySimplifyStg, defaultSimplifyStg));
 		setGateLibrary(config.getString(keyGateLibrary, defaultGateLibrary));
+		setSubstitutionLibrary(config.getString(keySubstitutionLibrary, defaultSubstitutionLibrary));
 		setOpenSynthesisResult(config.getBoolean(keyOpenSynthesisResult, defaultOpenSynthesisResult));
 	}
 
@@ -159,6 +173,7 @@
 		config.setDouble(keyWireWidth, getWireWidth());
 		config.setBoolean(keySimplifyStg, getSimplifyStg());
 		config.set(keyGateLibrary, getGateLibrary());
+		config.set(keySubstitutionLibrary, getSubstitutionLibrary());
 		config.setBoolean(keyOpenSynthesisResult, getOpenSynthesisResult());
 	}
 	
@@ -217,6 +232,14 @@
 	public static void setGateLibrary(String value) {
 		gateLibrary = value;
 	}
+
+	public static String getSubstitutionLibrary() {
+		return substitutionLibrary;
+	}
+
+	public static void setSubstitutionLibrary(String value) {
+		substitutionLibrary = value;
+	}
 	
 	public static boolean getOpenSynthesisResult() {
 		return openSynthesisResult;

=== modified file 'CircuitPlugin/src/org/workcraft/plugins/circuit/CircuitUtils.java'
--- CircuitPlugin/src/org/workcraft/plugins/circuit/CircuitUtils.java	2015-10-30 19:09:08 +0000
+++ CircuitPlugin/src/org/workcraft/plugins/circuit/CircuitUtils.java	2015-11-09 09:38:45 +0000
@@ -139,14 +139,14 @@
 		return zeroDelayOutput;
 	}
 
-	public static Contact findSignal(Circuit circuit, Contact contact) {
+	public static Contact findSignal(Circuit circuit, Contact contact, boolean transparentZeroDelayComponents) {
 		Contact result = contact;
-		Contact driver = findDriver(circuit, contact, true);
+		Contact driver = findDriver(circuit, contact, transparentZeroDelayComponents);
 		if (driver != null) {
 			result = driver;
 			for (Contact signal : Hierarchy.getDescendantsOfType(circuit.getRoot(), Contact.class)) {
 				if (signal.isPort() && signal.isOutput()) {
-					if (driver == CircuitUtils.findDriver(circuit, signal, true)) {
+					if (driver == CircuitUtils.findDriver(circuit, signal, transparentZeroDelayComponents)) {
 						result = signal;
 						break;
 					}
@@ -156,15 +156,15 @@
 		return result;
 	}
 
-	public static VisualContact findSignal(VisualCircuit circuit, VisualContact contact) {
-		Contact mathSignal = findSignal((Circuit)circuit.getMathModel(), contact.getReferencedContact());
+	public static VisualContact findSignal(VisualCircuit circuit, VisualContact contact, boolean transparentZeroDelayComponents) {
+		Contact mathSignal = findSignal((Circuit)circuit.getMathModel(), contact.getReferencedContact(), transparentZeroDelayComponents);
 		return circuit.getVisualComponent(mathSignal, VisualContact.class);
 	}
 
 	public static String getWireName(Circuit circuit, Contact contact) {
 		String result = null;
 		if (!circuit.getPreset(contact).isEmpty() || !circuit.getPostset(contact).isEmpty()) {
-			Contact signal = findSignal(circuit, contact);
+			Contact signal = findSignal(circuit, contact, false);
 			result = getContactName(circuit, signal);
 		}
 		return result;

=== modified file 'CircuitPlugin/src/org/workcraft/plugins/circuit/interop/GenlibImporter.java'
--- CircuitPlugin/src/org/workcraft/plugins/circuit/interop/GenlibImporter.java	2015-07-30 15:45:39 +0000
+++ CircuitPlugin/src/org/workcraft/plugins/circuit/interop/GenlibImporter.java	2015-11-09 09:38:45 +0000
@@ -33,6 +33,7 @@
 import org.workcraft.plugins.circuit.genlib.Library;
 import org.workcraft.plugins.circuit.javacc.GenlibParser;
 import org.workcraft.plugins.circuit.javacc.ParseException;
+import org.workcraft.plugins.shared.CommonDebugSettings;
 import org.workcraft.workspace.ModelEntry;
 
 public class GenlibImporter implements Importer {
@@ -54,9 +55,14 @@
 	
 	public Circuit importGenlib(InputStream in) throws DeserialisationException {
 		final Circuit circuit = new Circuit();
-		GenlibParser parser = new GenlibParser(in);
+		GenlibParser genlibParser = new GenlibParser(in);
+		if (CommonDebugSettings.getParserTracing()) {
+			genlibParser.enable_tracing();
+		} else {
+			genlibParser.disable_tracing();
+		}
 		try {
-			Library library = parser.parseGenlib();
+			Library library = genlibParser.parseGenlib();
 			for (final String name: library.getNames()) {
 				final Gate gate = library.get(name);
 				GenlibUtils.instantiateGate(gate, null, circuit);

=== modified file 'CircuitPlugin/src/org/workcraft/plugins/circuit/interop/VerilogImporter.java'
--- CircuitPlugin/src/org/workcraft/plugins/circuit/interop/VerilogImporter.java	2015-11-02 12:32:29 +0000
+++ CircuitPlugin/src/org/workcraft/plugins/circuit/interop/VerilogImporter.java	2015-11-09 09:38:45 +0000
@@ -128,8 +128,13 @@
 	
 	public Circuit importCircuit(InputStream in) throws DeserialisationException {
 		try {
-			VerilogParser parser = new VerilogParser(in);
-			HashMap<String, Module> modules = getModuleMap(parser.parseCircuit());
+			VerilogParser verilogParser = new VerilogParser(in);
+			if (CommonDebugSettings.getParserTracing()) {
+				verilogParser.enable_tracing();
+			} else {
+				verilogParser.disable_tracing();
+			}
+			HashMap<String, Module> modules = getModuleMap(verilogParser.parseCircuit());
 			HashSet<Module> topModules = getTopModule(modules);
 			if (topModules.size() == 0) {
 				throw new RuntimeException("No top module found.");
@@ -214,6 +219,7 @@
 	
 	private Circuit createCircuit(Module topModule, HashMap<String, Module> modules) {
 		Circuit circuit = new Circuit();
+		circuit.setTitle(topModule.name);
 		HashMap<Instance, FunctionComponent> instanceComponentMap = new HashMap<>();
 		HashMap<String, Wire> wires = createPorts(circuit, topModule);
 		for (Assign assign: topModule.assigns) {
@@ -363,10 +369,15 @@
 
 	private Expression convertStringToExpression(String formula) {
 		InputStream expressionStream = new ByteArrayInputStream(formula.getBytes());
-		ExpressionParser parser = new ExpressionParser(expressionStream);
+		ExpressionParser expressionParser = new ExpressionParser(expressionStream);
+		if (CommonDebugSettings.getParserTracing()) {
+			expressionParser.enable_tracing();
+		} else {
+			expressionParser.disable_tracing();
+		}
 		Expression expression = null;
 		try {
-			expression = parser.parseExpression();
+			expression = expressionParser.parseExpression();
 		} catch (ParseException e1) {
 			System.out.println("Warning: could not parse assign expression '" + formula + "'.");
 		}
@@ -383,8 +394,15 @@
 			final Framework framework = Framework.getInstance();
 			if (framework.checkFile(libraryFile, "Gate library access error")) {
 				try {
-					InputStream genlibInputStream = new FileInputStream(CircuitSettings.getGateLibrary());
-					library = new GenlibParser(genlibInputStream).parseGenlib();
+					InputStream genlibInputStream = new FileInputStream(libraryFileName);
+					GenlibParser genlibParser = new GenlibParser(genlibInputStream);
+					if (CommonDebugSettings.getParserTracing()) {
+						genlibParser.enable_tracing();
+					} else {
+						genlibParser.disable_tracing();
+					}
+					library = genlibParser.parseGenlib();
+					System.out.println("Info: mapping the imported Verilog into the gate library '" + libraryFileName + "'.");
 				} catch (FileNotFoundException e) {
 				} catch (ParseException e) {
 					System.out.println("Warning: could not parse the gate library '" + libraryFileName + "'.");

=== modified file 'CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/ExpressionParser.java'
--- CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/ExpressionParser.java	2015-10-22 16:04:43 +0000
+++ CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/ExpressionParser.java	2015-11-09 09:38:45 +0000
@@ -24,172 +24,197 @@
 public class ExpressionParser implements ExpressionParserConstants {
 
   final public Expression parseExpression() throws ParseException {
+    trace_call("parseExpression");
+    try {
         Expression term;
         List<Expression> terms = new LinkedList<Expression>();
-    term = parseTerm();
+      term = parseTerm();
                         terms.add(term);
-    label_1:
-    while (true) {
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case 9:
-      case 10:
-      case 11:
-        ;
-        break;
-      default:
-        jj_la1[0] = jj_gen;
-        break label_1;
-      }
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case 9:
-        jj_consume_token(9);
-        break;
-      case 10:
-        jj_consume_token(10);
-        break;
-      case 11:
-        jj_consume_token(11);
-        break;
-      default:
-        jj_la1[1] = jj_gen;
-        jj_consume_token(-1);
-        throw new ParseException();
-      }
-      term = parseTerm();
+      label_1:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case 9:
+        case 10:
+        case 11:
+          ;
+          break;
+        default:
+          jj_la1[0] = jj_gen;
+          break label_1;
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case 9:
+          jj_consume_token(9);
+          break;
+        case 10:
+          jj_consume_token(10);
+          break;
+        case 11:
+          jj_consume_token(11);
+          break;
+        default:
+          jj_la1[1] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+        term = parseTerm();
                                 terms.add(term);
-    }
+      }
                 if (terms.size() > 1) {
                         {if (true) return new Formula(terms);}
                 } else {
                         {if (true) return term;}
                 }
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseExpression");
+    }
   }
 
   final public Expression parseTerm() throws ParseException {
+    trace_call("parseTerm");
+    try {
         Expression factor;
         List<Expression> factors = new LinkedList<Expression>();
-    factor = parseFactor();
+      factor = parseFactor();
                         factors.add(factor);
-    label_2:
-    while (true) {
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case CONST0:
-      case CONST1:
-      case NAME:
-      case 12:
-      case 13:
-      case 14:
-      case 15:
-      case 16:
-      case 17:
-        ;
-        break;
-      default:
-        jj_la1[2] = jj_gen;
-        break label_2;
-      }
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case 12:
-      case 13:
-      case 14:
-        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-        case 12:
-          jj_consume_token(12);
-          break;
-        case 13:
-          jj_consume_token(13);
-          break;
-        case 14:
-          jj_consume_token(14);
-          break;
-        default:
-          jj_la1[3] = jj_gen;
-          jj_consume_token(-1);
-          throw new ParseException();
-        }
-        break;
-      default:
-        jj_la1[4] = jj_gen;
-        ;
-      }
-      factor = parseFactor();
+      label_2:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case CONST0:
+        case CONST1:
+        case NAME:
+        case 12:
+        case 13:
+        case 14:
+        case 15:
+        case 16:
+        case 17:
+          ;
+          break;
+        default:
+          jj_la1[2] = jj_gen;
+          break label_2;
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case 12:
+        case 13:
+        case 14:
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case 12:
+            jj_consume_token(12);
+            break;
+          case 13:
+            jj_consume_token(13);
+            break;
+          case 14:
+            jj_consume_token(14);
+            break;
+          default:
+            jj_la1[3] = jj_gen;
+            jj_consume_token(-1);
+            throw new ParseException();
+          }
+          break;
+        default:
+          jj_la1[4] = jj_gen;
+          ;
+        }
+        factor = parseFactor();
                                 factors.add(factor);
-    }
+      }
                 if (factors.size() > 1) {
                         {if (true) return new Term(factors);}
                 } else {
                         {if (true) return factor;}
                 }
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseTerm");
+    }
   }
 
   final public Expression parseFactor() throws ParseException {
+    trace_call("parseFactor");
+    try {
         Expression expression;
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case NAME:
-      expression = parseLiteral();
-      break;
-    case CONST0:
-    case CONST1:
-      expression = parseConstant();
-      break;
-    case 15:
-    case 16:
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case NAME:
+        expression = parseLiteral();
+        break;
+      case CONST0:
+      case CONST1:
+        expression = parseConstant();
+        break;
       case 15:
-        jj_consume_token(15);
-        break;
       case 16:
-        jj_consume_token(16);
-        break;
-      default:
-        jj_la1[5] = jj_gen;
-        jj_consume_token(-1);
-        throw new ParseException();
-      }
-      expression = parseFactor();
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case 15:
+          jj_consume_token(15);
+          break;
+        case 16:
+          jj_consume_token(16);
+          break;
+        default:
+          jj_la1[5] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+        expression = parseFactor();
                         {if (true) return new Negation(expression);}
-      break;
-    case 17:
-      jj_consume_token(17);
-      expression = parseExpression();
-      jj_consume_token(18);
+        break;
+      case 17:
+        jj_consume_token(17);
+        expression = parseExpression();
+        jj_consume_token(18);
                         {if (true) return new Factor(expression);}
-      break;
-    default:
-      jj_la1[6] = jj_gen;
-      jj_consume_token(-1);
-      throw new ParseException();
-    }
+        break;
+      default:
+        jj_la1[6] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
                 {if (true) return expression;}
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseFactor");
+    }
   }
 
   final public Expression parseLiteral() throws ParseException {
+    trace_call("parseLiteral");
+    try {
         Token nameToken;
-    nameToken = jj_consume_token(NAME);
+      nameToken = jj_consume_token(NAME);
                 String name = nameToken.image;
                 {if (true) return new Literal(name);}
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseLiteral");
+    }
   }
 
   final public Expression parseConstant() throws ParseException {
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case CONST0:
-      jj_consume_token(CONST0);
+    trace_call("parseConstant");
+    try {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case CONST0:
+        jj_consume_token(CONST0);
                         {if (true) return new Constant(false);}
-      break;
-    case CONST1:
-      jj_consume_token(CONST1);
+        break;
+      case CONST1:
+        jj_consume_token(CONST1);
                         {if (true) return new Constant(true);}
-      break;
-    default:
-      jj_la1[7] = jj_gen;
-      jj_consume_token(-1);
-      throw new ParseException();
+        break;
+      default:
+        jj_la1[7] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseConstant");
     }
-    throw new Error("Missing return statement in function");
   }
 
   /** Generated Token Manager. */
@@ -283,6 +308,7 @@
     jj_ntk = -1;
     if (token.kind == kind) {
       jj_gen++;
+      trace_token(token, "");
       return token;
     }
     token = oldToken;
@@ -297,6 +323,7 @@
     else token = token.next = token_source.getNextToken();
     jj_ntk = -1;
     jj_gen++;
+      trace_token(token, " (in getNextToken)");
     return token;
   }
 
@@ -352,12 +379,55 @@
     return new ParseException(token, exptokseq, tokenImage);
   }
 
-  /** Enable tracing. */
+  private int trace_indent = 0;
+  private boolean trace_enabled = true;
+
+/** Enable tracing. */
   final public void enable_tracing() {
+    trace_enabled = true;
   }
 
-  /** Disable tracing. */
+/** Disable tracing. */
   final public void disable_tracing() {
+    trace_enabled = false;
+  }
+
+  private void trace_call(String s) {
+    if (trace_enabled) {
+      for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
+      System.out.println("Call:   " + s);
+    }
+    trace_indent = trace_indent + 2;
+  }
+
+  private void trace_return(String s) {
+    trace_indent = trace_indent - 2;
+    if (trace_enabled) {
+      for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
+      System.out.println("Return: " + s);
+    }
+  }
+
+  private void trace_token(Token t, String where) {
+    if (trace_enabled) {
+      for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
+      System.out.print("Consumed token: <" + tokenImage[t.kind]);
+      if (t.kind != 0 && !tokenImage[t.kind].equals("\"" + t.image + "\"")) {
+        System.out.print(": \"" + t.image + "\"");
+      }
+      System.out.println(" at line " + t.beginLine + " column " + t.beginColumn + ">" + where);
+    }
+  }
+
+  private void trace_scan(Token t1, int t2) {
+    if (trace_enabled) {
+      for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
+      System.out.print("Visited token: <" + tokenImage[t1.kind]);
+      if (t1.kind != 0 && !tokenImage[t1.kind].equals("\"" + t1.image + "\"")) {
+        System.out.print(": \"" + t1.image + "\"");
+      }
+      System.out.println(" at line " + t1.beginLine + " column " + t1.beginColumn + ">; Expected token: <" + tokenImage[t2] + ">");
+    }
   }
 
 }

=== modified file 'CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/ExpressionParser.jj'
--- CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/ExpressionParser.jj	2015-10-22 16:04:43 +0000
+++ CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/ExpressionParser.jj	2015-11-09 09:38:45 +0000
@@ -6,7 +6,8 @@
   JDK_VERSION = "1.7";
   LOOKAHEAD = 1;
   STATIC = false;
-  DEBUG_PARSER = false;
+  DEBUG_PARSER = true;
+  DEBUG_LOOKAHEAD = false;
   DEBUG_TOKEN_MANAGER = false;
 }
 

=== modified file 'CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/GenlibParser.java'
--- CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/GenlibParser.java	2015-10-19 17:34:06 +0000
+++ CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/GenlibParser.java	2015-11-09 09:38:45 +0000
@@ -20,241 +20,291 @@
 public class GenlibParser implements GenlibParserConstants {
 
   final public Library parseGenlib() throws ParseException {
+    trace_call("parseGenlib");
+    try {
     List<Gate> gates;
-    gates = parseGates();
+      gates = parseGates();
         {if (true) return new Library(gates);}
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseGenlib");
+    }
   }
 
   final public List<Gate> parseGates() throws ParseException {
+    trace_call("parseGates");
+    try {
     Gate gate;
     List<Gate> gates = new LinkedList<Gate>();
-    label_1:
-    while (true) {
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case GATE:
-      case LATCH:
-        ;
-        break;
-      default:
-        jj_la1[0] = jj_gen;
-        break label_1;
-      }
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case GATE:
-        gate = parseGate();
-        break;
-      case LATCH:
-        gate = parseLatch();
-        break;
-      default:
-        jj_la1[1] = jj_gen;
-        jj_consume_token(-1);
-        throw new ParseException();
-      }
+      label_1:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case GATE:
+        case LATCH:
+          ;
+          break;
+        default:
+          jj_la1[0] = jj_gen;
+          break label_1;
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case GATE:
+          gate = parseGate();
+          break;
+        case LATCH:
+          gate = parseLatch();
+          break;
+        default:
+          jj_la1[1] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
             gates.add(gate);
-    }
+      }
         {if (true) return gates;}
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseGates");
+    }
   }
 
   final public Gate parseGate() throws ParseException {
+    trace_call("parseGate");
+    try {
     String name;
     Function function;
-    jj_consume_token(GATE);
-    name = parseName();
-    jj_consume_token(NUMERAL);
-    function = parseFunction();
-    label_2:
-    while (true) {
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case PIN:
-        ;
-        break;
-      default:
-        jj_la1[2] = jj_gen;
-        break label_2;
+      jj_consume_token(GATE);
+      name = parseName();
+      jj_consume_token(NUMERAL);
+      function = parseFunction();
+      label_2:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case PIN:
+          ;
+          break;
+        default:
+          jj_la1[2] = jj_gen;
+          break label_2;
+        }
+        parsePin();
       }
-      parsePin();
-    }
         {if (true) return new Gate(name, function, null, false);}
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseGate");
+    }
   }
 
   final public Gate parseLatch() throws ParseException {
+    trace_call("parseLatch");
+    try {
     String name;
     Function function;
     String next;
-    jj_consume_token(LATCH);
-    name = parseName();
-    jj_consume_token(NUMERAL);
-    function = parseFunction();
-    label_3:
-    while (true) {
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case PIN:
-        ;
-        break;
-      default:
-        jj_la1[3] = jj_gen;
-        break label_3;
-      }
-      parsePin();
-    }
-    next = parseSeq();
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case CONTROL:
-      parseControl();
-      break;
-    default:
-      jj_la1[4] = jj_gen;
-      ;
-    }
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case CONSTRAINT:
-      parseConstraint();
-      break;
-    default:
-      jj_la1[5] = jj_gen;
-      ;
-    }
+      jj_consume_token(LATCH);
+      name = parseName();
+      jj_consume_token(NUMERAL);
+      function = parseFunction();
+      label_3:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case PIN:
+          ;
+          break;
+        default:
+          jj_la1[3] = jj_gen;
+          break label_3;
+        }
+        parsePin();
+      }
+      next = parseSeq();
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case CONTROL:
+        parseControl();
+        break;
+      default:
+        jj_la1[4] = jj_gen;
+        ;
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case CONSTRAINT:
+        parseConstraint();
+        break;
+      default:
+        jj_la1[5] = jj_gen;
+        ;
+      }
         {if (true) return new Gate(name, function, next, false);}
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseLatch");
+    }
   }
 
   final public String parseName() throws ParseException {
+    trace_call("parseName");
+    try {
     Token nameToken;
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case NAME:
-      nameToken = jj_consume_token(NAME);
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case NAME:
+        nameToken = jj_consume_token(NAME);
                 {if (true) return nameToken.image;}
-      break;
-    case STRING:
-      nameToken = jj_consume_token(STRING);
+        break;
+      case STRING:
+        nameToken = jj_consume_token(STRING);
                 String s = nameToken.image;
             {if (true) return s.substring(1, s.length()-1);}
-      break;
-    default:
-      jj_la1[6] = jj_gen;
-      jj_consume_token(-1);
-      throw new ParseException();
+        break;
+      default:
+        jj_la1[6] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseName");
     }
-    throw new Error("Missing return statement in function");
   }
 
   final public Function parseFunction() throws ParseException {
+    trace_call("parseFunction");
+    try {
     Token nameToken;
     Token formulaToken;
-    nameToken = jj_consume_token(NAME);
-    formulaToken = jj_consume_token(FORMULA);
+      nameToken = jj_consume_token(NAME);
+      formulaToken = jj_consume_token(FORMULA);
         String formula = formulaToken.image.replaceAll("^=", "").replaceAll(";$", "");
         {if (true) return new Function(nameToken.image, formula);}
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseFunction");
+    }
   }
 
   final public void parsePin() throws ParseException {
-    jj_consume_token(PIN);
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case NAME:
-      jj_consume_token(NAME);
-      break;
-    case ANY_NAME:
-      jj_consume_token(ANY_NAME);
-      break;
-    default:
-      jj_la1[7] = jj_gen;
-      jj_consume_token(-1);
-      throw new ParseException();
-    }
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case INV:
-    case NONINV:
-    case UNKNOWN:
+    trace_call("parsePin");
+    try {
+      jj_consume_token(PIN);
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case NAME:
+        jj_consume_token(NAME);
+        break;
+      case ANY_NAME:
+        jj_consume_token(ANY_NAME);
+        break;
+      default:
+        jj_la1[7] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
       case INV:
-        jj_consume_token(INV);
-        break;
       case NONINV:
-        jj_consume_token(NONINV);
-        break;
       case UNKNOWN:
-        jj_consume_token(UNKNOWN);
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case INV:
+          jj_consume_token(INV);
+          break;
+        case NONINV:
+          jj_consume_token(NONINV);
+          break;
+        case UNKNOWN:
+          jj_consume_token(UNKNOWN);
+          break;
+        default:
+          jj_la1[8] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
         break;
       default:
-        jj_la1[8] = jj_gen;
-        jj_consume_token(-1);
-        throw new ParseException();
+        jj_la1[9] = jj_gen;
+        ;
       }
-      break;
-    default:
-      jj_la1[9] = jj_gen;
-      ;
+      jj_consume_token(NUMERAL);
+      jj_consume_token(NUMERAL);
+      jj_consume_token(NUMERAL);
+      jj_consume_token(NUMERAL);
+      jj_consume_token(NUMERAL);
+      jj_consume_token(NUMERAL);
+    } finally {
+      trace_return("parsePin");
     }
-    jj_consume_token(NUMERAL);
-    jj_consume_token(NUMERAL);
-    jj_consume_token(NUMERAL);
-    jj_consume_token(NUMERAL);
-    jj_consume_token(NUMERAL);
-    jj_consume_token(NUMERAL);
   }
 
   final public String parseSeq() throws ParseException {
+    trace_call("parseSeq");
+    try {
     Token nextToken = null;
-    jj_consume_token(SEQ);
-    jj_consume_token(NAME);
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case NAME:
-      nextToken = jj_consume_token(NAME);
-      break;
-    case ANY:
-      jj_consume_token(ANY);
-      break;
-    default:
-      jj_la1[10] = jj_gen;
-      jj_consume_token(-1);
-      throw new ParseException();
-    }
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case ACTIVE_LOW:
-      jj_consume_token(ACTIVE_LOW);
-      break;
-    case ACTIVE_HIGH:
-      jj_consume_token(ACTIVE_HIGH);
-      break;
-    case RISING_EDGE:
-      jj_consume_token(RISING_EDGE);
-      break;
-    case FALLING_EDGE:
-      jj_consume_token(FALLING_EDGE);
-      break;
-    case ASYNCH:
-      jj_consume_token(ASYNCH);
-      break;
-    default:
-      jj_la1[11] = jj_gen;
-      jj_consume_token(-1);
-      throw new ParseException();
-    }
+      jj_consume_token(SEQ);
+      jj_consume_token(NAME);
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case NAME:
+        nextToken = jj_consume_token(NAME);
+        break;
+      case ANY:
+        jj_consume_token(ANY);
+        break;
+      default:
+        jj_la1[10] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case ACTIVE_LOW:
+        jj_consume_token(ACTIVE_LOW);
+        break;
+      case ACTIVE_HIGH:
+        jj_consume_token(ACTIVE_HIGH);
+        break;
+      case RISING_EDGE:
+        jj_consume_token(RISING_EDGE);
+        break;
+      case FALLING_EDGE:
+        jj_consume_token(FALLING_EDGE);
+        break;
+      case ASYNCH:
+        jj_consume_token(ASYNCH);
+        break;
+      default:
+        jj_la1[11] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
         {if (true) return ((nextToken == null) ? null : nextToken.image);}
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseSeq");
+    }
   }
 
   final public void parseControl() throws ParseException {
-    jj_consume_token(CONTROL);
-    jj_consume_token(NAME);
-    jj_consume_token(NUMERAL);
-    jj_consume_token(NUMERAL);
-    jj_consume_token(NUMERAL);
-    jj_consume_token(NUMERAL);
-    jj_consume_token(NUMERAL);
-    jj_consume_token(NUMERAL);
+    trace_call("parseControl");
+    try {
+      jj_consume_token(CONTROL);
+      jj_consume_token(NAME);
+      jj_consume_token(NUMERAL);
+      jj_consume_token(NUMERAL);
+      jj_consume_token(NUMERAL);
+      jj_consume_token(NUMERAL);
+      jj_consume_token(NUMERAL);
+      jj_consume_token(NUMERAL);
+    } finally {
+      trace_return("parseControl");
+    }
   }
 
   final public void parseConstraint() throws ParseException {
-    jj_consume_token(CONSTRAINT);
-    jj_consume_token(NAME);
-    jj_consume_token(NUMERAL);
-    jj_consume_token(NUMERAL);
+    trace_call("parseConstraint");
+    try {
+      jj_consume_token(CONSTRAINT);
+      jj_consume_token(NAME);
+      jj_consume_token(NUMERAL);
+      jj_consume_token(NUMERAL);
+    } finally {
+      trace_return("parseConstraint");
+    }
   }
 
   /** Generated Token Manager. */
@@ -348,6 +398,7 @@
     jj_ntk = -1;
     if (token.kind == kind) {
       jj_gen++;
+      trace_token(token, "");
       return token;
     }
     token = oldToken;
@@ -362,6 +413,7 @@
     else token = token.next = token_source.getNextToken();
     jj_ntk = -1;
     jj_gen++;
+      trace_token(token, " (in getNextToken)");
     return token;
   }
 
@@ -417,12 +469,55 @@
     return new ParseException(token, exptokseq, tokenImage);
   }
 
-  /** Enable tracing. */
+  private int trace_indent = 0;
+  private boolean trace_enabled = true;
+
+/** Enable tracing. */
   final public void enable_tracing() {
+    trace_enabled = true;
   }
 
-  /** Disable tracing. */
+/** Disable tracing. */
   final public void disable_tracing() {
+    trace_enabled = false;
+  }
+
+  private void trace_call(String s) {
+    if (trace_enabled) {
+      for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
+      System.out.println("Call:   " + s);
+    }
+    trace_indent = trace_indent + 2;
+  }
+
+  private void trace_return(String s) {
+    trace_indent = trace_indent - 2;
+    if (trace_enabled) {
+      for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
+      System.out.println("Return: " + s);
+    }
+  }
+
+  private void trace_token(Token t, String where) {
+    if (trace_enabled) {
+      for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
+      System.out.print("Consumed token: <" + tokenImage[t.kind]);
+      if (t.kind != 0 && !tokenImage[t.kind].equals("\"" + t.image + "\"")) {
+        System.out.print(": \"" + t.image + "\"");
+      }
+      System.out.println(" at line " + t.beginLine + " column " + t.beginColumn + ">" + where);
+    }
+  }
+
+  private void trace_scan(Token t1, int t2) {
+    if (trace_enabled) {
+      for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
+      System.out.print("Visited token: <" + tokenImage[t1.kind]);
+      if (t1.kind != 0 && !tokenImage[t1.kind].equals("\"" + t1.image + "\"")) {
+        System.out.print(": \"" + t1.image + "\"");
+      }
+      System.out.println(" at line " + t1.beginLine + " column " + t1.beginColumn + ">; Expected token: <" + tokenImage[t2] + ">");
+    }
   }
 
 }

=== modified file 'CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/GenlibParser.jj'
--- CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/GenlibParser.jj	2015-10-19 17:34:06 +0000
+++ CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/GenlibParser.jj	2015-11-09 09:38:45 +0000
@@ -6,7 +6,9 @@
   JDK_VERSION = "1.7";
   LOOKAHEAD = 1;
   STATIC = false;
-  DEBUG_PARSER = false;
+  DEBUG_PARSER = true;
+  DEBUG_LOOKAHEAD = false;
+  DEBUG_TOKEN_MANAGER = false;
 }
 
 PARSER_BEGIN(GenlibParser)

=== added file 'CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/SubstitutionParser.java'
--- CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/SubstitutionParser.java	1970-01-01 00:00:00 +0000
+++ CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/SubstitutionParser.java	2015-11-09 09:38:45 +0000
@@ -0,0 +1,315 @@
+/* Generated By:JavaCC: Do not edit this line. SubstitutionParser.java */
+package org.workcraft.plugins.circuit.javacc;
+
+import java.util.List;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.HashMap;
+
+import org.workcraft.util.Pair;
+import org.workcraft.plugins.circuit.verilog.SubstitutionRule;
+
+public class SubstitutionParser implements SubstitutionParserConstants {
+
+  final public List<SubstitutionRule> parseSubstitutionRules() throws ParseException {
+    trace_call("parseSubstitutionRules");
+    try {
+        SubstitutionRule rule;
+    List<SubstitutionRule> rules = new LinkedList<SubstitutionRule>();
+      label_1:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case EXTENDED_NAME:
+          ;
+          break;
+        default:
+          jj_la1[0] = jj_gen;
+          break label_1;
+        }
+        rule = parseSubstitutionRule();
+            rules.add(rule);
+      }
+        {if (true) return rules;}
+    throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseSubstitutionRules");
+    }
+  }
+
+  final public SubstitutionRule parseSubstitutionRule() throws ParseException {
+    trace_call("parseSubstitutionRule");
+    try {
+        Pair<String, String> gateSubstitution;
+        Pair<String, String> portSubstitution;
+    Map<String, String> portSubstitutions = new HashMap<String, String>();
+      gateSubstitution = parseSubstitution();
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case 8:
+        jj_consume_token(8);
+        label_2:
+        while (true) {
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case EXTENDED_NAME:
+            ;
+            break;
+          default:
+            jj_la1[1] = jj_gen;
+            break label_2;
+          }
+          portSubstitution = parseSubstitution();
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case 10:
+            jj_consume_token(10);
+            break;
+          default:
+            jj_la1[2] = jj_gen;
+            ;
+          }
+                        String oldPortName = portSubstitution.getFirst();
+                        String newPortName = portSubstitution.getSecond();
+                portSubstitutions.put(oldPortName, newPortName);
+        }
+        jj_consume_token(9);
+        break;
+      default:
+        jj_la1[3] = jj_gen;
+        ;
+      }
+        String oldGateName = gateSubstitution.getFirst();
+        String newGateName = gateSubstitution.getSecond();
+        {if (true) return new SubstitutionRule(oldGateName, newGateName, portSubstitutions);}
+    throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseSubstitutionRule");
+    }
+  }
+
+  final public Pair<String, String> parseSubstitution() throws ParseException {
+    trace_call("parseSubstitution");
+    try {
+    Token oldName;
+    Token newName;
+      oldName = jj_consume_token(EXTENDED_NAME);
+      jj_consume_token(11);
+      newName = jj_consume_token(EXTENDED_NAME);
+        {if (true) return new Pair(oldName.image, newName.image);}
+    throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseSubstitution");
+    }
+  }
+
+  /** Generated Token Manager. */
+  public SubstitutionParserTokenManager token_source;
+  SimpleCharStream jj_input_stream;
+  /** Current token. */
+  public Token token;
+  /** Next token. */
+  public Token jj_nt;
+  private int jj_ntk;
+  private int jj_gen;
+  final private int[] jj_la1 = new int[4];
+  static private int[] jj_la1_0;
+  static {
+      jj_la1_init_0();
+   }
+   private static void jj_la1_init_0() {
+      jj_la1_0 = new int[] {0x80,0x80,0x400,0x100,};
+   }
+
+  /** Constructor with InputStream. */
+  public SubstitutionParser(java.io.InputStream stream) {
+     this(stream, null);
+  }
+  /** Constructor with InputStream and supplied encoding */
+  public SubstitutionParser(java.io.InputStream stream, String encoding) {
+    try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
+    token_source = new SubstitutionParserTokenManager(jj_input_stream);
+    token = new Token();
+    jj_ntk = -1;
+    jj_gen = 0;
+    for (int i = 0; i < 4; i++) jj_la1[i] = -1;
+  }
+
+  /** Reinitialise. */
+  public void ReInit(java.io.InputStream stream) {
+     ReInit(stream, null);
+  }
+  /** Reinitialise. */
+  public void ReInit(java.io.InputStream stream, String encoding) {
+    try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
+    token_source.ReInit(jj_input_stream);
+    token = new Token();
+    jj_ntk = -1;
+    jj_gen = 0;
+    for (int i = 0; i < 4; i++) jj_la1[i] = -1;
+  }
+
+  /** Constructor. */
+  public SubstitutionParser(java.io.Reader stream) {
+    jj_input_stream = new SimpleCharStream(stream, 1, 1);
+    token_source = new SubstitutionParserTokenManager(jj_input_stream);
+    token = new Token();
+    jj_ntk = -1;
+    jj_gen = 0;
+    for (int i = 0; i < 4; i++) jj_la1[i] = -1;
+  }
+
+  /** Reinitialise. */
+  public void ReInit(java.io.Reader stream) {
+    jj_input_stream.ReInit(stream, 1, 1);
+    token_source.ReInit(jj_input_stream);
+    token = new Token();
+    jj_ntk = -1;
+    jj_gen = 0;
+    for (int i = 0; i < 4; i++) jj_la1[i] = -1;
+  }
+
+  /** Constructor with generated Token Manager. */
+  public SubstitutionParser(SubstitutionParserTokenManager tm) {
+    token_source = tm;
+    token = new Token();
+    jj_ntk = -1;
+    jj_gen = 0;
+    for (int i = 0; i < 4; i++) jj_la1[i] = -1;
+  }
+
+  /** Reinitialise. */
+  public void ReInit(SubstitutionParserTokenManager tm) {
+    token_source = tm;
+    token = new Token();
+    jj_ntk = -1;
+    jj_gen = 0;
+    for (int i = 0; i < 4; i++) jj_la1[i] = -1;
+  }
+
+  private Token jj_consume_token(int kind) throws ParseException {
+    Token oldToken;
+    if ((oldToken = token).next != null) token = token.next;
+    else token = token.next = token_source.getNextToken();
+    jj_ntk = -1;
+    if (token.kind == kind) {
+      jj_gen++;
+      trace_token(token, "");
+      return token;
+    }
+    token = oldToken;
+    jj_kind = kind;
+    throw generateParseException();
+  }
+
+
+/** Get the next Token. */
+  final public Token getNextToken() {
+    if (token.next != null) token = token.next;
+    else token = token.next = token_source.getNextToken();
+    jj_ntk = -1;
+    jj_gen++;
+      trace_token(token, " (in getNextToken)");
+    return token;
+  }
+
+/** Get the specific Token. */
+  final public Token getToken(int index) {
+    Token t = token;
+    for (int i = 0; i < index; i++) {
+      if (t.next != null) t = t.next;
+      else t = t.next = token_source.getNextToken();
+    }
+    return t;
+  }
+
+  private int jj_ntk() {
+    if ((jj_nt=token.next) == null)
+      return (jj_ntk = (token.next=token_source.getNextToken()).kind);
+    else
+      return (jj_ntk = jj_nt.kind);
+  }
+
+  private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
+  private int[] jj_expentry;
+  private int jj_kind = -1;
+
+  /** Generate ParseException. */
+  public ParseException generateParseException() {
+    jj_expentries.clear();
+    boolean[] la1tokens = new boolean[12];
+    if (jj_kind >= 0) {
+      la1tokens[jj_kind] = true;
+      jj_kind = -1;
+    }
+    for (int i = 0; i < 4; i++) {
+      if (jj_la1[i] == jj_gen) {
+        for (int j = 0; j < 32; j++) {
+          if ((jj_la1_0[i] & (1<<j)) != 0) {
+            la1tokens[j] = true;
+          }
+        }
+      }
+    }
+    for (int i = 0; i < 12; i++) {
+      if (la1tokens[i]) {
+        jj_expentry = new int[1];
+        jj_expentry[0] = i;
+        jj_expentries.add(jj_expentry);
+      }
+    }
+    int[][] exptokseq = new int[jj_expentries.size()][];
+    for (int i = 0; i < jj_expentries.size(); i++) {
+      exptokseq[i] = jj_expentries.get(i);
+    }
+    return new ParseException(token, exptokseq, tokenImage);
+  }
+
+  private int trace_indent = 0;
+  private boolean trace_enabled = true;
+
+/** Enable tracing. */
+  final public void enable_tracing() {
+    trace_enabled = true;
+  }
+
+/** Disable tracing. */
+  final public void disable_tracing() {
+    trace_enabled = false;
+  }
+
+  private void trace_call(String s) {
+    if (trace_enabled) {
+      for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
+      System.out.println("Call:   " + s);
+    }
+    trace_indent = trace_indent + 2;
+  }
+
+  private void trace_return(String s) {
+    trace_indent = trace_indent - 2;
+    if (trace_enabled) {
+      for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
+      System.out.println("Return: " + s);
+    }
+  }
+
+  private void trace_token(Token t, String where) {
+    if (trace_enabled) {
+      for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
+      System.out.print("Consumed token: <" + tokenImage[t.kind]);
+      if (t.kind != 0 && !tokenImage[t.kind].equals("\"" + t.image + "\"")) {
+        System.out.print(": \"" + t.image + "\"");
+      }
+      System.out.println(" at line " + t.beginLine + " column " + t.beginColumn + ">" + where);
+    }
+  }
+
+  private void trace_scan(Token t1, int t2) {
+    if (trace_enabled) {
+      for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
+      System.out.print("Visited token: <" + tokenImage[t1.kind]);
+      if (t1.kind != 0 && !tokenImage[t1.kind].equals("\"" + t1.image + "\"")) {
+        System.out.print(": \"" + t1.image + "\"");
+      }
+      System.out.println(" at line " + t1.beginLine + " column " + t1.beginColumn + ">; Expected token: <" + tokenImage[t2] + ">");
+    }
+  }
+
+}

=== added file 'CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/SubstitutionParser.jj'
--- CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/SubstitutionParser.jj	1970-01-01 00:00:00 +0000
+++ CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/SubstitutionParser.jj	2015-11-09 09:38:45 +0000
@@ -0,0 +1,100 @@
+/**
+ * JavaCC file
+ */
+ 
+options {
+  JDK_VERSION = "1.7";
+  LOOKAHEAD = 1;
+  STATIC = false;
+  DEBUG_PARSER = true;
+  DEBUG_LOOKAHEAD = false;
+  DEBUG_TOKEN_MANAGER = false;
+}
+
+PARSER_BEGIN(SubstitutionParser)
+package org.workcraft.plugins.circuit.javacc;
+
+import java.util.List;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.HashMap;
+
+import org.workcraft.util.Pair;
+import org.workcraft.plugins.circuit.verilog.SubstitutionRule;
+
+public class SubstitutionParser {
+}
+PARSER_END(SubstitutionParser)
+
+SKIP:
+{
+    " "
+|   "\t"
+|   "\r"
+|   "\n"
+|   <"//" (~["\r", "\n"])*>
+|   < "`" (~["\r", "\n"])*> 
+}
+
+TOKEN :
+{
+    <EXTENDED_NAME : ["A"-"Z", "a"-"z", "_", "/" ] ([ "A"-"Z", "a"-"z", "_", "0"-"9", ":", "/", "\\", "-"])*>
+|   "("
+|   ")"
+|   ","
+}    
+    
+List<SubstitutionRule> parseSubstitutionRules() :
+{
+	SubstitutionRule rule;
+    List<SubstitutionRule> rules = new LinkedList<SubstitutionRule>();
+}
+{
+    (
+        rule = parseSubstitutionRule()
+        {
+            rules.add(rule);
+        }
+    )*
+    {
+        return rules;
+    }
+}
+    
+SubstitutionRule parseSubstitutionRule() :
+{
+	Pair<String, String> gateSubstitution;
+	Pair<String, String> portSubstitution;
+    Map<String, String> portSubstitutions = new HashMap<String, String>();
+}
+{
+    gateSubstitution = parseSubstitution()
+    [ "("
+    	(
+    		portSubstitution = parseSubstitution() [","] 
+        	{
+		    	String oldPortName = portSubstitution.getFirst();
+    			String newPortName = portSubstitution.getSecond();
+            	portSubstitutions.put(oldPortName, newPortName);
+        	}
+    	)*
+    	")"
+    ]
+    {
+    	String oldGateName = gateSubstitution.getFirst();
+    	String newGateName = gateSubstitution.getSecond();
+        return new SubstitutionRule(oldGateName, newGateName, portSubstitutions);
+    }
+}
+
+Pair<String, String> parseSubstitution():
+{
+    Token oldName;
+    Token newName;
+}
+{
+    oldName = <EXTENDED_NAME> "=" newName = <EXTENDED_NAME>
+    {
+        return new Pair(oldName.image, newName.image);
+    }
+}

=== added file 'CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/SubstitutionParserConstants.java'
--- CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/SubstitutionParserConstants.java	1970-01-01 00:00:00 +0000
+++ CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/SubstitutionParserConstants.java	2015-11-09 09:38:45 +0000
@@ -0,0 +1,35 @@
+/* Generated By:JavaCC: Do not edit this line. SubstitutionParserConstants.java */
+package org.workcraft.plugins.circuit.javacc;
+
+
+/**
+ * Token literal values and constants.
+ * Generated by org.javacc.parser.OtherFilesGen#start()
+ */
+public interface SubstitutionParserConstants {
+
+  /** End of File. */
+  int EOF = 0;
+  /** RegularExpression Id. */
+  int EXTENDED_NAME = 7;
+
+  /** Lexical state. */
+  int DEFAULT = 0;
+
+  /** Literal token values. */
+  String[] tokenImage = {
+    "<EOF>",
+    "\" \"",
+    "\"\\t\"",
+    "\"\\r\"",
+    "\"\\n\"",
+    "<token of kind 5>",
+    "<token of kind 6>",
+    "<EXTENDED_NAME>",
+    "\"(\"",
+    "\")\"",
+    "\",\"",
+    "\"=\"",
+  };
+
+}

=== added file 'CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/SubstitutionParserTokenManager.java'
--- CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/SubstitutionParserTokenManager.java	1970-01-01 00:00:00 +0000
+++ CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/SubstitutionParserTokenManager.java	2015-11-09 09:38:45 +0000
@@ -0,0 +1,399 @@
+/* Generated By:JavaCC: Do not edit this line. SubstitutionParserTokenManager.java */
+package org.workcraft.plugins.circuit.javacc;
+import java.util.List;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.HashMap;
+import org.workcraft.util.Pair;
+import org.workcraft.plugins.circuit.verilog.SubstitutionRule;
+
+/** Token Manager. */
+public class SubstitutionParserTokenManager implements SubstitutionParserConstants
+{
+
+  /** Debug output. */
+  public  java.io.PrintStream debugStream = System.out;
+  /** Set debug output. */
+  public  void setDebugStream(java.io.PrintStream ds) { debugStream = ds; }
+private final int jjStopStringLiteralDfa_0(int pos, long active0)
+{
+   switch (pos)
+   {
+      default :
+         return -1;
+   }
+}
+private final int jjStartNfa_0(int pos, long active0)
+{
+   return jjMoveNfa_0(jjStopStringLiteralDfa_0(pos, active0), pos + 1);
+}
+private int jjStopAtPos(int pos, int kind)
+{
+   jjmatchedKind = kind;
+   jjmatchedPos = pos;
+   return pos + 1;
+}
+private int jjMoveStringLiteralDfa0_0()
+{
+   switch(curChar)
+   {
+      case 40:
+         return jjStopAtPos(0, 8);
+      case 41:
+         return jjStopAtPos(0, 9);
+      case 44:
+         return jjStopAtPos(0, 10);
+      case 61:
+         return jjStopAtPos(0, 11);
+      default :
+         return jjMoveNfa_0(2, 0);
+   }
+}
+static final long[] jjbitVec0 = {
+   0x0L, 0x0L, 0xffffffffffffffffL, 0xffffffffffffffffL
+};
+private int jjMoveNfa_0(int startState, int curPos)
+{
+   int startsAt = 0;
+   jjnewStateCnt = 7;
+   int i = 1;
+   jjstateSet[0] = startState;
+   int kind = 0x7fffffff;
+   for (;;)
+   {
+      if (++jjround == 0x7fffffff)
+         ReInitRounds();
+      if (curChar < 64)
+      {
+         long l = 1L << curChar;
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 2:
+                  if (curChar == 47)
+                  {
+                     if (kind > 7)
+                        kind = 7;
+                     jjCheckNAdd(6);
+                  }
+                  if (curChar == 47)
+                     jjstateSet[jjnewStateCnt++] = 0;
+                  break;
+               case 0:
+                  if (curChar != 47)
+                     break;
+                  if (kind > 5)
+                     kind = 5;
+                  jjCheckNAdd(1);
+                  break;
+               case 1:
+                  if ((0xffffffffffffdbffL & l) == 0L)
+                     break;
+                  if (kind > 5)
+                     kind = 5;
+                  jjCheckNAdd(1);
+                  break;
+               case 4:
+                  if ((0xffffffffffffdbffL & l) == 0L)
+                     break;
+                  if (kind > 6)
+                     kind = 6;
+                  jjstateSet[jjnewStateCnt++] = 4;
+                  break;
+               case 5:
+                  if (curChar != 47)
+                     break;
+                  if (kind > 7)
+                     kind = 7;
+                  jjCheckNAdd(6);
+                  break;
+               case 6:
+                  if ((0x7ffa00000000000L & l) == 0L)
+                     break;
+                  if (kind > 7)
+                     kind = 7;
+                  jjCheckNAdd(6);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else if (curChar < 128)
+      {
+         long l = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 2:
+                  if ((0x7fffffe87fffffeL & l) != 0L)
+                  {
+                     if (kind > 7)
+                        kind = 7;
+                     jjCheckNAdd(6);
+                  }
+                  else if (curChar == 96)
+                  {
+                     if (kind > 6)
+                        kind = 6;
+                     jjCheckNAdd(4);
+                  }
+                  break;
+               case 1:
+                  if (kind > 5)
+                     kind = 5;
+                  jjstateSet[jjnewStateCnt++] = 1;
+                  break;
+               case 3:
+                  if (curChar != 96)
+                     break;
+                  if (kind > 6)
+                     kind = 6;
+                  jjCheckNAdd(4);
+                  break;
+               case 4:
+                  if (kind > 6)
+                     kind = 6;
+                  jjCheckNAdd(4);
+                  break;
+               case 5:
+                  if ((0x7fffffe87fffffeL & l) == 0L)
+                     break;
+                  if (kind > 7)
+                     kind = 7;
+                  jjCheckNAdd(6);
+                  break;
+               case 6:
+                  if ((0x7fffffe97fffffeL & l) == 0L)
+                     break;
+                  if (kind > 7)
+                     kind = 7;
+                  jjCheckNAdd(6);
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      else
+      {
+         int i2 = (curChar & 0xff) >> 6;
+         long l2 = 1L << (curChar & 077);
+         do
+         {
+            switch(jjstateSet[--i])
+            {
+               case 1:
+                  if ((jjbitVec0[i2] & l2) == 0L)
+                     break;
+                  if (kind > 5)
+                     kind = 5;
+                  jjstateSet[jjnewStateCnt++] = 1;
+                  break;
+               case 4:
+                  if ((jjbitVec0[i2] & l2) == 0L)
+                     break;
+                  if (kind > 6)
+                     kind = 6;
+                  jjstateSet[jjnewStateCnt++] = 4;
+                  break;
+               default : break;
+            }
+         } while(i != startsAt);
+      }
+      if (kind != 0x7fffffff)
+      {
+         jjmatchedKind = kind;
+         jjmatchedPos = curPos;
+         kind = 0x7fffffff;
+      }
+      ++curPos;
+      if ((i = jjnewStateCnt) == (startsAt = 7 - (jjnewStateCnt = startsAt)))
+         return curPos;
+      try { curChar = input_stream.readChar(); }
+      catch(java.io.IOException e) { return curPos; }
+   }
+}
+static final int[] jjnextStates = {
+};
+
+/** Token literal values. */
+public static final String[] jjstrLiteralImages = {
+"", null, null, null, null, null, null, null, "\50", "\51", "\54", "\75", };
+
+/** Lexer state names. */
+public static final String[] lexStateNames = {
+   "DEFAULT",
+};
+static final long[] jjtoToken = {
+   0xf81L, 
+};
+static final long[] jjtoSkip = {
+   0x7eL, 
+};
+protected SimpleCharStream input_stream;
+private final int[] jjrounds = new int[7];
+private final int[] jjstateSet = new int[14];
+protected char curChar;
+/** Constructor. */
+public SubstitutionParserTokenManager(SimpleCharStream stream){
+   if (SimpleCharStream.staticFlag)
+      throw new Error("ERROR: Cannot use a static CharStream class with a non-static lexical analyzer.");
+   input_stream = stream;
+}
+
+/** Constructor. */
+public SubstitutionParserTokenManager(SimpleCharStream stream, int lexState){
+   this(stream);
+   SwitchTo(lexState);
+}
+
+/** Reinitialise parser. */
+public void ReInit(SimpleCharStream stream)
+{
+   jjmatchedPos = jjnewStateCnt = 0;
+   curLexState = defaultLexState;
+   input_stream = stream;
+   ReInitRounds();
+}
+private void ReInitRounds()
+{
+   int i;
+   jjround = 0x80000001;
+   for (i = 7; i-- > 0;)
+      jjrounds[i] = 0x80000000;
+}
+
+/** Reinitialise parser. */
+public void ReInit(SimpleCharStream stream, int lexState)
+{
+   ReInit(stream);
+   SwitchTo(lexState);
+}
+
+/** Switch to specified lex state. */
+public void SwitchTo(int lexState)
+{
+   if (lexState >= 1 || lexState < 0)
+      throw new TokenMgrError("Error: Ignoring invalid lexical state : " + lexState + ". State unchanged.", TokenMgrError.INVALID_LEXICAL_STATE);
+   else
+      curLexState = lexState;
+}
+
+protected Token jjFillToken()
+{
+   final Token t;
+   final String curTokenImage;
+   final int beginLine;
+   final int endLine;
+   final int beginColumn;
+   final int endColumn;
+   String im = jjstrLiteralImages[jjmatchedKind];
+   curTokenImage = (im == null) ? input_stream.GetImage() : im;
+   beginLine = input_stream.getBeginLine();
+   beginColumn = input_stream.getBeginColumn();
+   endLine = input_stream.getEndLine();
+   endColumn = input_stream.getEndColumn();
+   t = Token.newToken(jjmatchedKind, curTokenImage);
+
+   t.beginLine = beginLine;
+   t.endLine = endLine;
+   t.beginColumn = beginColumn;
+   t.endColumn = endColumn;
+
+   return t;
+}
+
+int curLexState = 0;
+int defaultLexState = 0;
+int jjnewStateCnt;
+int jjround;
+int jjmatchedPos;
+int jjmatchedKind;
+
+/** Get the next Token. */
+public Token getNextToken() 
+{
+  Token matchedToken;
+  int curPos = 0;
+
+  EOFLoop :
+  for (;;)
+  {
+   try
+   {
+      curChar = input_stream.BeginToken();
+   }
+   catch(java.io.IOException e)
+   {
+      jjmatchedKind = 0;
+      matchedToken = jjFillToken();
+      return matchedToken;
+   }
+
+   try { input_stream.backup(0);
+      while (curChar <= 32 && (0x100002600L & (1L << curChar)) != 0L)
+         curChar = input_stream.BeginToken();
+   }
+   catch (java.io.IOException e1) { continue EOFLoop; }
+   jjmatchedKind = 0x7fffffff;
+   jjmatchedPos = 0;
+   curPos = jjMoveStringLiteralDfa0_0();
+   if (jjmatchedKind != 0x7fffffff)
+   {
+      if (jjmatchedPos + 1 < curPos)
+         input_stream.backup(curPos - jjmatchedPos - 1);
+      if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)
+      {
+         matchedToken = jjFillToken();
+         return matchedToken;
+      }
+      else
+      {
+         continue EOFLoop;
+      }
+   }
+   int error_line = input_stream.getEndLine();
+   int error_column = input_stream.getEndColumn();
+   String error_after = null;
+   boolean EOFSeen = false;
+   try { input_stream.readChar(); input_stream.backup(1); }
+   catch (java.io.IOException e1) {
+      EOFSeen = true;
+      error_after = curPos <= 1 ? "" : input_stream.GetImage();
+      if (curChar == '\n' || curChar == '\r') {
+         error_line++;
+         error_column = 0;
+      }
+      else
+         error_column++;
+   }
+   if (!EOFSeen) {
+      input_stream.backup(1);
+      error_after = curPos <= 1 ? "" : input_stream.GetImage();
+   }
+   throw new TokenMgrError(EOFSeen, curLexState, error_line, error_column, error_after, curChar, TokenMgrError.LEXICAL_ERROR);
+  }
+}
+
+private void jjCheckNAdd(int state)
+{
+   if (jjrounds[state] != jjround)
+   {
+      jjstateSet[jjnewStateCnt++] = state;
+      jjrounds[state] = jjround;
+   }
+}
+private void jjAddStates(int start, int end)
+{
+   do {
+      jjstateSet[jjnewStateCnt++] = jjnextStates[start];
+   } while (start++ != end);
+}
+private void jjCheckNAddTwoStates(int state1, int state2)
+{
+   jjCheckNAdd(state1);
+   jjCheckNAdd(state2);
+}
+
+}

=== modified file 'CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/VerilogParser.java'
--- CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/VerilogParser.java	2015-11-02 12:32:29 +0000
+++ CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/VerilogParser.java	2015-11-09 09:38:45 +0000
@@ -17,33 +17,45 @@
 public class VerilogParser implements VerilogParserConstants {
 
   final public List<Module> parseCircuit() throws ParseException {
+    trace_call("parseCircuit");
+    try {
     List<Module> modules;
-    modules = parseModules();
+      modules = parseModules();
         {if (true) return modules;}
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseCircuit");
+    }
   }
 
   final public List<Module> parseModules() throws ParseException {
+    trace_call("parseModules");
+    try {
     Module module;
     List<Module> modules = new LinkedList<Module>();
-    label_1:
-    while (true) {
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case MODULE:
-        ;
-        break;
-      default:
-        jj_la1[0] = jj_gen;
-        break label_1;
-      }
-      module = parseModule();
+      label_1:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case MODULE:
+          ;
+          break;
+        default:
+          jj_la1[0] = jj_gen;
+          break label_1;
+        }
+        module = parseModule();
             modules.add(module);
-    }
+      }
         {if (true) return modules;}
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseModules");
+    }
   }
 
   final public Module parseModule() throws ParseException {
+    trace_call("parseModule");
+    try {
     String name;
     List<Port> ports;
     List<Assign> assigns;
@@ -51,169 +63,199 @@
     List<Instance> group;
     Set<List<Instance>> groups = new HashSet<List<Instance>>();
     Map<String, Boolean> signalStates = null;
-    jj_consume_token(MODULE);
-    name = parseModuleName();
-    ports = parsePorts();
-    assigns = parseAssigns();
-    instances = parseInstances();
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case PETRIFY_UNMAPPED:
-      jj_consume_token(PETRIFY_UNMAPPED);
-      label_2:
-      while (true) {
-        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-        case PETRIFY_EQUATION:
-          ;
-          break;
-        default:
-          jj_la1[1] = jj_gen;
-          break label_2;
-        }
-        jj_consume_token(PETRIFY_EQUATION);
-        group = parseInstances();
+      jj_consume_token(MODULE);
+      name = parseModuleName();
+      ports = parsePorts();
+      assigns = parseAssigns();
+      instances = parseInstances();
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case PETRIFY_UNMAPPED:
+        jj_consume_token(PETRIFY_UNMAPPED);
+        label_2:
+        while (true) {
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case PETRIFY_EQUATION:
+            ;
+            break;
+          default:
+            jj_la1[1] = jj_gen;
+            break label_2;
+          }
+          jj_consume_token(PETRIFY_EQUATION);
+          group = parseInstances();
                         instances.addAll(group);
                         groups.add(group);
+        }
+        break;
+      default:
+        jj_la1[2] = jj_gen;
+        ;
       }
-      break;
-    default:
-      jj_la1[2] = jj_gen;
-      ;
-    }
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case PETRIFY_INIT_STATE:
-    case MPSAT_INIT_STATE:
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
       case PETRIFY_INIT_STATE:
-        jj_consume_token(PETRIFY_INIT_STATE);
-        break;
       case MPSAT_INIT_STATE:
-        jj_consume_token(MPSAT_INIT_STATE);
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case PETRIFY_INIT_STATE:
+          jj_consume_token(PETRIFY_INIT_STATE);
+          break;
+        case MPSAT_INIT_STATE:
+          jj_consume_token(MPSAT_INIT_STATE);
+          break;
+        default:
+          jj_la1[3] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+        signalStates = parseInitialState();
         break;
       default:
-        jj_la1[3] = jj_gen;
-        jj_consume_token(-1);
-        throw new ParseException();
+        jj_la1[4] = jj_gen;
+        ;
       }
-      signalStates = parseInitialState();
-      break;
-    default:
-      jj_la1[4] = jj_gen;
-      ;
-    }
-    jj_consume_token(ENDMODULE);
+      jj_consume_token(ENDMODULE);
         {if (true) return new Module(name, ports, assigns, instances, signalStates, groups);}
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseModule");
+    }
   }
 
   final public String parseModuleName() throws ParseException {
+    trace_call("parseModuleName");
+    try {
     Token nameToken;
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case NAME:
-      nameToken = jj_consume_token(NAME);
-      break;
-    case PETRIFY_NAME:
-      nameToken = jj_consume_token(PETRIFY_NAME);
-      break;
-    default:
-      jj_la1[5] = jj_gen;
-      jj_consume_token(-1);
-      throw new ParseException();
-    }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case NAME:
+        nameToken = jj_consume_token(NAME);
+        break;
+      case PETRIFY_NAME:
+        nameToken = jj_consume_token(PETRIFY_NAME);
+        break;
+      default:
+        jj_la1[5] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
         {if (true) return nameToken.image;}
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseModuleName");
+    }
   }
 
   final public List<Port> parsePorts() throws ParseException {
+    trace_call("parsePorts");
+    try {
     List<Port> ports;
-    if (jj_2_1(2147483647)) {
-      ports = parseCompactPorts();
-    } else {
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case 38:
-      case 44:
-        ports = parseComplexPorts();
-        break;
-      default:
-        jj_la1[6] = jj_gen;
-        jj_consume_token(-1);
-        throw new ParseException();
+      if (jj_2_1(2147483647)) {
+        ports = parseCompactPorts();
+      } else {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case 38:
+        case 44:
+          ports = parseComplexPorts();
+          break;
+        default:
+          jj_la1[6] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
       }
-    }
         {if (true) return ports;}
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parsePorts");
+    }
   }
 
   final public List<Port> parseCompactPorts() throws ParseException {
+    trace_call("parseCompactPorts");
+    try {
     Port port;
     List<Port> ports = new LinkedList<Port>();
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case 38:
-      jj_consume_token(38);
-      label_3:
-      while (true) {
-        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-        case INPUT:
-        case OUTPUT:
-          ;
-          break;
-        default:
-          jj_la1[7] = jj_gen;
-          break label_3;
-        }
-        port = parseCompactPort();
-        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-        case 42:
-          jj_consume_token(42);
-          break;
-        default:
-          jj_la1[8] = jj_gen;
-          ;
-        }
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case 38:
+        jj_consume_token(38);
+        label_3:
+        while (true) {
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case INPUT:
+          case OUTPUT:
+            ;
+            break;
+          default:
+            jj_la1[7] = jj_gen;
+            break label_3;
+          }
+          port = parseCompactPort();
+          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+          case 42:
+            jj_consume_token(42);
+            break;
+          default:
+            jj_la1[8] = jj_gen;
+            ;
+          }
                         ports.add(port);
+        }
+        jj_consume_token(39);
+        break;
+      default:
+        jj_la1[9] = jj_gen;
+        ;
       }
-      jj_consume_token(39);
-      break;
-    default:
-      jj_la1[9] = jj_gen;
-      ;
-    }
-    jj_consume_token(44);
+      jj_consume_token(44);
         {if (true) return ports;}
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseCompactPorts");
+    }
   }
 
   final public Port parseCompactPort() throws ParseException {
+    trace_call("parseCompactPort");
+    try {
     Port.Type type;
     Token nameToken;
-    type = parsePortType();
-    nameToken = jj_consume_token(NAME);
+      type = parsePortType();
+      nameToken = jj_consume_token(NAME);
         {if (true) return new Port(nameToken.image, type);}
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseCompactPort");
+    }
   }
 
   final public Port.Type parsePortType() throws ParseException {
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case INPUT:
-      jj_consume_token(INPUT);
+    trace_call("parsePortType");
+    try {
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case INPUT:
+        jj_consume_token(INPUT);
                 {if (true) return Port.Type.INPUT;}
-      break;
-    case OUTPUT:
-      jj_consume_token(OUTPUT);
+        break;
+      case OUTPUT:
+        jj_consume_token(OUTPUT);
                 {if (true) return Port.Type.OUTPUT;}
-      break;
-    default:
-      jj_la1[10] = jj_gen;
-      jj_consume_token(-1);
-      throw new ParseException();
+        break;
+      default:
+        jj_la1[10] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parsePortType");
     }
-    throw new Error("Missing return statement in function");
   }
 
   final public List<Port> parseComplexPorts() throws ParseException {
+    trace_call("parseComplexPorts");
+    try {
     List<String> declarations;
     List<Port> definitions;
-    declarations = parsePortsDeclaration();
-    definitions = parsePortsDefinitions();
+      declarations = parsePortsDeclaration();
+      definitions = parsePortsDefinitions();
         HashMap<String, Port.Type> nameToType = new HashMap<String, Port.Type>();
         for (Port port: definitions) {
                 nameToType.put(port.name, port.type);
@@ -225,335 +267,403 @@
         }
         {if (true) return ports;}
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseComplexPorts");
+    }
   }
 
   final public List<String> parsePortsDeclaration() throws ParseException {
+    trace_call("parsePortsDeclaration");
+    try {
     List<String> names = null;
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case 38:
-      jj_consume_token(38);
-      names = parseNames();
-      jj_consume_token(39);
-      break;
-    default:
-      jj_la1[11] = jj_gen;
-      ;
-    }
-    jj_consume_token(44);
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case 38:
+        jj_consume_token(38);
+        names = parseNames();
+        jj_consume_token(39);
+        break;
+      default:
+        jj_la1[11] = jj_gen;
+        ;
+      }
+      jj_consume_token(44);
                 List<String> ports = new LinkedList<String>();
                 if (names != null) {
                         ports.addAll(names);
                 }
                 {if (true) return ports;}
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parsePortsDeclaration");
+    }
   }
 
   final public List<Port> parsePortsDefinitions() throws ParseException {
+    trace_call("parsePortsDefinitions");
+    try {
     List<Port> ports;
     List<Port> allPorts = new LinkedList<Port>();
-    label_4:
-    while (true) {
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case INPUT:
-      case OUTPUT:
-      case INOUT:
-      case REG:
-      case WIRE:
-        ;
-        break;
-      default:
-        jj_la1[12] = jj_gen;
-        break label_4;
-      }
-      ports = parsePortsDefinition();
+      label_4:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case INPUT:
+        case OUTPUT:
+        case INOUT:
+        case REG:
+        case WIRE:
+          ;
+          break;
+        default:
+          jj_la1[12] = jj_gen;
+          break label_4;
+        }
+        ports = parsePortsDefinition();
                 if (ports != null) {
                         allPorts.addAll(ports);
                 }
-    }
+      }
         {if (true) return allPorts;}
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parsePortsDefinitions");
+    }
   }
 
   final public List<Port> parsePortsDefinition() throws ParseException {
+    trace_call("parsePortsDefinition");
+    try {
     List<String> names;
     Port.Type type;
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case INPUT:
-    case OUTPUT:
-      type = parsePortType();
-      names = parseNames();
-      jj_consume_token(44);
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case INPUT:
+      case OUTPUT:
+        type = parsePortType();
+        names = parseNames();
+        jj_consume_token(44);
                 List<Port> ports = new LinkedList<Port>();
                 for (String name: names) {
                         Port port = new Port(name, type);
                         ports.add(port);
                 }
                 {if (true) return ports;}
-      break;
-    case INOUT:
-    case REG:
-    case WIRE:
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case WIRE:
-        jj_consume_token(WIRE);
         break;
       case INOUT:
-        jj_consume_token(INOUT);
-        break;
       case REG:
-        jj_consume_token(REG);
-        break;
-      default:
-        jj_la1[13] = jj_gen;
-        jj_consume_token(-1);
-        throw new ParseException();
-      }
-      parseNames();
-      jj_consume_token(44);
+      case WIRE:
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case WIRE:
+          jj_consume_token(WIRE);
+          break;
+        case INOUT:
+          jj_consume_token(INOUT);
+          break;
+        case REG:
+          jj_consume_token(REG);
+          break;
+        default:
+          jj_la1[13] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+        parseNames();
+        jj_consume_token(44);
                         {if (true) return null;}
-      break;
-    default:
-      jj_la1[14] = jj_gen;
-      jj_consume_token(-1);
-      throw new ParseException();
+        break;
+      default:
+        jj_la1[14] = jj_gen;
+        jj_consume_token(-1);
+        throw new ParseException();
+      }
+    throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parsePortsDefinition");
     }
-    throw new Error("Missing return statement in function");
   }
 
   final public List<String> parseNames() throws ParseException {
+    trace_call("parseNames");
+    try {
     Token nameToken;
     List<String> names = new LinkedList<String>();
-    label_5:
-    while (true) {
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case NAME:
-        ;
-        break;
-      default:
-        jj_la1[15] = jj_gen;
-        break label_5;
-      }
-      nameToken = jj_consume_token(NAME);
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case 42:
-        jj_consume_token(42);
-        break;
-      default:
-        jj_la1[16] = jj_gen;
-        ;
-      }
+      label_5:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case NAME:
+          ;
+          break;
+        default:
+          jj_la1[15] = jj_gen;
+          break label_5;
+        }
+        nameToken = jj_consume_token(NAME);
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case 42:
+          jj_consume_token(42);
+          break;
+        default:
+          jj_la1[16] = jj_gen;
+          ;
+        }
                 String name = nameToken.image;
             names.add(name);
-    }
+      }
         {if (true) return names;}
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseNames");
+    }
   }
 
   final public Map<String, Boolean> parseInitialState() throws ParseException {
+    trace_call("parseInitialState");
+    try {
         Boolean state;
     Token nameToken;
     Map<String, Boolean> signalStates = new HashMap<String, Boolean>();
-    label_6:
-    while (true) {
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case NAME:
-      case 43:
-        ;
-        break;
-      default:
-        jj_la1[17] = jj_gen;
-        break label_6;
-      }
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case 43:
-        jj_consume_token(43);
-        nameToken = jj_consume_token(NAME);
+      label_6:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case NAME:
+        case 43:
+          ;
+          break;
+        default:
+          jj_la1[17] = jj_gen;
+          break label_6;
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case 43:
+          jj_consume_token(43);
+          nameToken = jj_consume_token(NAME);
                         state = false;
-        break;
-      case NAME:
-        nameToken = jj_consume_token(NAME);
+          break;
+        case NAME:
+          nameToken = jj_consume_token(NAME);
                 state = true;
-        break;
-      default:
-        jj_la1[18] = jj_gen;
-        jj_consume_token(-1);
-        throw new ParseException();
-      }
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case 42:
-        jj_consume_token(42);
-        break;
-      default:
-        jj_la1[19] = jj_gen;
-        ;
-      }
+          break;
+        default:
+          jj_la1[18] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case 42:
+          jj_consume_token(42);
+          break;
+        default:
+          jj_la1[19] = jj_gen;
+          ;
+        }
                 String name = nameToken.image;
             signalStates.put(name, state);
-    }
+      }
         {if (true) return signalStates;}
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseInitialState");
+    }
   }
 
   final public List<Assign> parseAssigns() throws ParseException {
+    trace_call("parseAssigns");
+    try {
         Assign assign;
     List<Assign> assigns = new LinkedList<Assign>();
-    label_7:
-    while (true) {
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case ASSIGN:
-        ;
-        break;
-      default:
-        jj_la1[20] = jj_gen;
-        break label_7;
-      }
-      assign = parseAssign();
+      label_7:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case ASSIGN:
+          ;
+          break;
+        default:
+          jj_la1[20] = jj_gen;
+          break label_7;
+        }
+        assign = parseAssign();
                 assigns.add(assign);
-    }
+      }
         {if (true) return assigns;}
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseAssigns");
+    }
   }
 
   final public Assign parseAssign() throws ParseException {
+    trace_call("parseAssign");
+    try {
     Token nameToken;
     Token formulaToken;
-    jj_consume_token(ASSIGN);
-    nameToken = jj_consume_token(NAME);
-    formulaToken = jj_consume_token(FORMULA);
+      jj_consume_token(ASSIGN);
+      nameToken = jj_consume_token(NAME);
+      formulaToken = jj_consume_token(FORMULA);
         String formula = formulaToken.image.replaceAll("^=", "").replaceAll(";$", "");
         {if (true) return new Assign(nameToken.image, formula);}
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseAssign");
+    }
   }
 
   final public List<Instance> parseInstances() throws ParseException {
+    trace_call("parseInstances");
+    try {
     Instance instance;
     List<Instance> instances = new LinkedList<Instance>();
-    label_8:
-    while (true) {
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case NAME:
-      case PETRIFY_NAME:
-      case PETRIFY_ZERO_DELAY:
-      case MPSAT_ZERO_DELAY:
-        ;
-        break;
-      default:
-        jj_la1[21] = jj_gen;
-        break label_8;
-      }
-      instance = parseInstance();
+      label_8:
+      while (true) {
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case NAME:
+        case PETRIFY_NAME:
+        case PETRIFY_ZERO_DELAY:
+        case MPSAT_ZERO_DELAY:
+          ;
+          break;
+        default:
+          jj_la1[21] = jj_gen;
+          break label_8;
+        }
+        instance = parseInstance();
             instances.add(instance);
-    }
+      }
         {if (true) return instances;}
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseInstances");
+    }
   }
 
   final public Instance parseInstance() throws ParseException {
+    trace_call("parseInstance");
+    try {
     boolean zeroDelay = false;
     String moduleName;
     Token nameToken = null;
     List<String> parameters;
     List<Pin> pins;
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case PETRIFY_ZERO_DELAY:
-    case MPSAT_ZERO_DELAY:
       switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
       case PETRIFY_ZERO_DELAY:
-        jj_consume_token(PETRIFY_ZERO_DELAY);
-        break;
       case MPSAT_ZERO_DELAY:
-        jj_consume_token(MPSAT_ZERO_DELAY);
-        break;
-      default:
-        jj_la1[22] = jj_gen;
-        jj_consume_token(-1);
-        throw new ParseException();
-      }
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case PETRIFY_ZERO_DELAY:
+          jj_consume_token(PETRIFY_ZERO_DELAY);
+          break;
+        case MPSAT_ZERO_DELAY:
+          jj_consume_token(MPSAT_ZERO_DELAY);
+          break;
+        default:
+          jj_la1[22] = jj_gen;
+          jj_consume_token(-1);
+          throw new ParseException();
+        }
                 zeroDelay = true;
-      break;
-    default:
-      jj_la1[23] = jj_gen;
-      ;
-    }
-    moduleName = parseModuleName();
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case NAME:
-      nameToken = jj_consume_token(NAME);
-      break;
-    default:
-      jj_la1[24] = jj_gen;
-      ;
-    }
-    jj_consume_token(38);
-    pins = parsePins();
-    jj_consume_token(39);
-    jj_consume_token(44);
+        break;
+      default:
+        jj_la1[23] = jj_gen;
+        ;
+      }
+      moduleName = parseModuleName();
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case NAME:
+        nameToken = jj_consume_token(NAME);
+        break;
+      default:
+        jj_la1[24] = jj_gen;
+        ;
+      }
+      jj_consume_token(38);
+      pins = parsePins();
+      jj_consume_token(39);
+      jj_consume_token(44);
         String name = (nameToken == null ? null : nameToken.image);
         {if (true) return new Instance(name, moduleName, pins, zeroDelay);}
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseInstance");
+    }
   }
 
   final public List<Pin> parsePins() throws ParseException {
+    trace_call("parsePins");
+    try {
     List<Pin> pins;
-    if (jj_2_2(2147483647)) {
-      pins = parseNamedPins();
-    } else {
-      pins = parseOrderedPins();
-    }
+      if (jj_2_2(2147483647)) {
+        pins = parseNamedPins();
+      } else {
+        pins = parseOrderedPins();
+      }
         {if (true) return pins;}
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parsePins");
+    }
   }
 
   final public List<Pin> parseNamedPins() throws ParseException {
+    trace_call("parseNamedPins");
+    try {
     Pin pin;
     List<Pin> pins = new LinkedList<Pin>();
-    label_9:
-    while (true) {
-      pin = parseNamedPin();
+      label_9:
+      while (true) {
+        pin = parseNamedPin();
             pins.add(pin);
-      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-      case 45:
-        ;
-        break;
-      default:
-        jj_la1[25] = jj_gen;
-        break label_9;
+        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+        case 45:
+          ;
+          break;
+        default:
+          jj_la1[25] = jj_gen;
+          break label_9;
+        }
       }
-    }
         {if (true) return pins;}
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseNamedPins");
+    }
   }
 
   final public Pin parseNamedPin() throws ParseException {
+    trace_call("parseNamedPin");
+    try {
     Token portName;
     Token netName;
-    jj_consume_token(45);
-    portName = jj_consume_token(NAME);
-    jj_consume_token(38);
-    netName = jj_consume_token(NAME);
-    jj_consume_token(39);
-    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
-    case 42:
-      jj_consume_token(42);
-      break;
-    default:
-      jj_la1[26] = jj_gen;
-      ;
-    }
+      jj_consume_token(45);
+      portName = jj_consume_token(NAME);
+      jj_consume_token(38);
+      netName = jj_consume_token(NAME);
+      jj_consume_token(39);
+      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
+      case 42:
+        jj_consume_token(42);
+        break;
+      default:
+        jj_la1[26] = jj_gen;
+        ;
+      }
         {if (true) return new Pin(portName.image, netName.image);}
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseNamedPin");
+    }
   }
 
   final public List<Pin> parseOrderedPins() throws ParseException {
+    trace_call("parseOrderedPins");
+    try {
     List<String> wires;
     List<Pin> pins = new LinkedList<Pin>();
-    wires = parseNames();
+      wires = parseNames();
         for (String wire: wires) {
                 Pin pin = new Pin(null, wire);
                 pins.add(pin);
         }
         {if (true) return pins;}
     throw new Error("Missing return statement in function");
+    } finally {
+      trace_return("parseOrderedPins");
+    }
   }
 
   private boolean jj_2_1(int xla) {
@@ -777,6 +887,7 @@
           }
         }
       }
+      trace_token(token, "");
       return token;
     }
     token = oldToken;
@@ -814,6 +925,7 @@
     else token = token.next = token_source.getNextToken();
     jj_ntk = -1;
     jj_gen++;
+      trace_token(token, " (in getNextToken)");
     return token;
   }
 
@@ -902,12 +1014,55 @@
     return new ParseException(token, exptokseq, tokenImage);
   }
 
-  /** Enable tracing. */
+  private int trace_indent = 0;
+  private boolean trace_enabled = true;
+
+/** Enable tracing. */
   final public void enable_tracing() {
+    trace_enabled = true;
   }
 
-  /** Disable tracing. */
+/** Disable tracing. */
   final public void disable_tracing() {
+    trace_enabled = false;
+  }
+
+  private void trace_call(String s) {
+    if (trace_enabled) {
+      for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
+      System.out.println("Call:   " + s);
+    }
+    trace_indent = trace_indent + 2;
+  }
+
+  private void trace_return(String s) {
+    trace_indent = trace_indent - 2;
+    if (trace_enabled) {
+      for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
+      System.out.println("Return: " + s);
+    }
+  }
+
+  private void trace_token(Token t, String where) {
+    if (trace_enabled) {
+      for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
+      System.out.print("Consumed token: <" + tokenImage[t.kind]);
+      if (t.kind != 0 && !tokenImage[t.kind].equals("\"" + t.image + "\"")) {
+        System.out.print(": \"" + t.image + "\"");
+      }
+      System.out.println(" at line " + t.beginLine + " column " + t.beginColumn + ">" + where);
+    }
+  }
+
+  private void trace_scan(Token t1, int t2) {
+    if (trace_enabled) {
+      for (int i = 0; i < trace_indent; i++) { System.out.print(" "); }
+      System.out.print("Visited token: <" + tokenImage[t1.kind]);
+      if (t1.kind != 0 && !tokenImage[t1.kind].equals("\"" + t1.image + "\"")) {
+        System.out.print(": \"" + t1.image + "\"");
+      }
+      System.out.println(" at line " + t1.beginLine + " column " + t1.beginColumn + ">; Expected token: <" + tokenImage[t2] + ">");
+    }
   }
 
   private void jj_rescan_token() {

=== modified file 'CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/VerilogParser.jj'
--- CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/VerilogParser.jj	2015-11-03 23:05:25 +0000
+++ CircuitPlugin/src/org/workcraft/plugins/circuit/javacc/VerilogParser.jj	2015-11-09 09:38:45 +0000
@@ -6,7 +6,7 @@
   JDK_VERSION = "1.7";
   LOOKAHEAD = 1;
   STATIC = false;
-  DEBUG_PARSER = false;
+  DEBUG_PARSER = true;
   DEBUG_LOOKAHEAD = false;
   DEBUG_TOKEN_MANAGER = false;
 }

=== modified file 'CircuitPlugin/src/org/workcraft/plugins/circuit/serialisation/VerilogSerialiser.java'
--- CircuitPlugin/src/org/workcraft/plugins/circuit/serialisation/VerilogSerialiser.java	2015-07-30 13:49:01 +0000
+++ CircuitPlugin/src/org/workcraft/plugins/circuit/serialisation/VerilogSerialiser.java	2015-11-09 09:38:45 +0000
@@ -21,18 +21,30 @@
 
 package org.workcraft.plugins.circuit.serialisation;
 
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.PrintWriter;
 import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
 import java.util.UUID;
 
+import org.workcraft.Framework;
 import org.workcraft.dom.Model;
 import org.workcraft.dom.hierarchy.NamespaceHelper;
 import org.workcraft.exceptions.ArgumentException;
 import org.workcraft.plugins.circuit.Circuit;
-import org.workcraft.plugins.circuit.CircuitComponent;
+import org.workcraft.plugins.circuit.CircuitSettings;
 import org.workcraft.plugins.circuit.CircuitUtils;
 import org.workcraft.plugins.circuit.Contact;
+import org.workcraft.plugins.circuit.FunctionComponent;
+import org.workcraft.plugins.circuit.javacc.ParseException;
+import org.workcraft.plugins.circuit.javacc.SubstitutionParser;
+import org.workcraft.plugins.circuit.verilog.SubstitutionRule;
+import org.workcraft.plugins.shared.CommonDebugSettings;
 import org.workcraft.serialisation.Format;
 import org.workcraft.serialisation.ModelSerialiser;
 import org.workcraft.serialisation.ReferenceProducer;
@@ -45,7 +57,7 @@
 	private static final String KEYWORD_INPUT = "input";
 	private static final String KEYWORD_MODULE = "module ";
 	private static final String KEYWORD_ENDMODULE = "endmodule";
-
+	
 	class ReferenceResolver implements ReferenceProducer {
 		HashMap<Object, String> refMap = new HashMap<Object, String>();
 		
@@ -94,6 +106,7 @@
 	private void writeCircuit(PrintWriter out, Circuit circuit) {
 		writeHeader(out, circuit);
 		writeInstances(out, circuit);
+		writeInitialState(out, circuit);
 		out.println(KEYWORD_ENDMODULE);
 	}
 	
@@ -130,7 +143,8 @@
 	}
 	
 	private void writeInstances(PrintWriter out, Circuit circuit) {
-		for (CircuitComponent component: Hierarchy.getDescendantsOfType(circuit.getRoot(), CircuitComponent.class)) {
+		HashMap<String, SubstitutionRule> substitutionRules = readSubsritutionRules();
+		for (FunctionComponent component: Hierarchy.getDescendantsOfType(circuit.getRoot(), FunctionComponent.class)) {
 			String moduleName = component.getModule();
 			String instanceRef = circuit.getNodeReference(component);
 			String instanceFlatName = NamespaceHelper.hierarchicalToFlatName(instanceRef);
@@ -138,6 +152,17 @@
 				System.out.println("  Warning: component '" + instanceFlatName + "' is not associated to a module.");
 				moduleName = "";
 			}
+			SubstitutionRule substitutionRule = substitutionRules.get(moduleName);
+			if (substitutionRule != null) {
+				String newModuleName = substitutionRule.newName;
+				if (newModuleName != null) {
+					System.out.println("Info: in component '" + instanceFlatName + "' renaming module '" + moduleName + "' to '" + newModuleName + "'.");
+					moduleName = newModuleName;
+				}
+			}
+			if (component.getIsZeroDelay() && (component.isBuffer() || component.isInverter())) {
+				out.println("    // This inverter should have a short delay");
+			}
 			out.print("    " + moduleName + " " + instanceFlatName + " (");
 			boolean first = true;
 			for (Contact contact: component.getContacts()) {
@@ -149,13 +174,77 @@
 				String contactName = contact.getName();
 				String wireName = CircuitUtils.getWireName(circuit, contact);
 				if ((wireName == null) || wireName.isEmpty()) {
-					System.out.println("  Warning: contact '" + contactName + "' of component '"+ instanceFlatName + "' is disconnected.");
+					System.out.println("  Warning: in component '" + instanceFlatName + "' contact '" + contactName + "' is disconnected.");
 					wireName = "";
 				}
+				if (substitutionRule != null) {
+					String newContactName = substitutionRule.substitutions.get(contactName);
+					if (newContactName != null) {
+						System.out.println("Info: in component '" + instanceFlatName + "' renaming contact '" + contactName + "' to '" + newContactName + "'.");
+						contactName = newContactName;
+					}
+				}
 				out.print("." + contactName + "(" + wireName + ")");
 			}
 			out.print(");\n");
 		}
 	}
 
+	private HashMap<String, SubstitutionRule> readSubsritutionRules() {
+		HashMap<String, SubstitutionRule> result = new HashMap<>();
+		String substitutionsFileName = CircuitSettings.getSubstitutionLibrary();
+		if ((substitutionsFileName == null) || substitutionsFileName.isEmpty()) {
+			System.out.println("Warning: file of substitutions is not specified.");
+		} else {
+			File libraryFile = new File(substitutionsFileName);
+			final Framework framework = Framework.getInstance();
+			if (framework.checkFile(libraryFile, "Access error for the file of substitutions")) {
+				try {
+					InputStream genlibInputStream = new FileInputStream(substitutionsFileName);
+					SubstitutionParser substitutionParser = new SubstitutionParser(genlibInputStream);
+					if (CommonDebugSettings.getParserTracing()) {
+						substitutionParser.enable_tracing();
+					} else {
+						substitutionParser.disable_tracing();
+					}
+					List<SubstitutionRule> rules = substitutionParser.parseSubstitutionRules();
+					for (SubstitutionRule rule: rules) {
+						result.put(rule.oldName, rule);
+					}
+					System.out.println("Info: renaming gates and pins using the file of substitutions '" + substitutionsFileName + "'.");
+				} catch (FileNotFoundException e) {
+				} catch (ParseException e) {
+					System.out.println("Warning: could not parse the file of substitutions '" + substitutionsFileName + "'.");
+				}
+			}
+		}
+		return result;
+	}
+	
+	private void writeInitialState(PrintWriter out, Circuit circuit) {
+		HashSet<Contact> contacts = new HashSet<>();
+		for (Contact contact: Hierarchy.getDescendantsOfType(circuit.getRoot(), Contact.class, new Func<Contact, Boolean>() {
+			@Override
+			public Boolean eval(Contact arg) {
+				return (arg.isPort() != arg.isOutput());
+			}
+		})) { 
+			contacts.add(contact);
+		}
+		out.println();
+		out.println("    // signal values at the initial state:");
+		out.print("    //");
+		for (Contact contact: contacts) {
+			String wireName = CircuitUtils.getWireName(circuit, contact);
+			if ((wireName != null) && !wireName.isEmpty()) {
+				out.print(" ");
+				if ( !contact.getInitToOne() ) {
+					out.print("!");
+				}
+				out.print(wireName);
+			}
+		}
+		out.println();
+	}
+	
 }

=== modified file 'CircuitPlugin/src/org/workcraft/plugins/circuit/stg/CircuitToStgConverter.java'
--- CircuitPlugin/src/org/workcraft/plugins/circuit/stg/CircuitToStgConverter.java	2015-11-02 12:32:29 +0000
+++ CircuitPlugin/src/org/workcraft/plugins/circuit/stg/CircuitToStgConverter.java	2015-11-09 09:38:45 +0000
@@ -212,7 +212,7 @@
 	private TwoWayMap<VisualContact, SignalStg> convertDriversToStgs(HashSet<VisualContact> drivers) {
 		TwoWayMap<VisualContact, SignalStg> result = new TwoWayMap<>();
 		for (VisualContact driver: drivers) {
-			VisualContact signal = CircuitUtils.findSignal(circuit, driver); 
+			VisualContact signal = CircuitUtils.findSignal(circuit, driver, true); 
 			Container container = getContainer(signal);
 			String signalName = CircuitUtils.getSignalName(circuit, signal);
 
@@ -276,7 +276,7 @@
 		
 		clauses.addAll(dnf.getClauses());
 
-		VisualContact signal = CircuitUtils.findSignal(circuit, driver); 
+		VisualContact signal = CircuitUtils.findSignal(circuit, driver, true); 
 		Container container = getContainer(signal);
 		String signalName = CircuitUtils.getSignalName(circuit, signal);
 		SignalTransition.Type signalType = CircuitUtils.getSignalType(circuit, signal);
@@ -459,7 +459,7 @@
 		for (VisualContact driver: drivers) {
 			SignalStg signalStg = driverToStgMap.getValue(driver);
 			if (signalStg != null) {
-				VisualContact signal = CircuitUtils.findSignal(circuit, driver); 
+				VisualContact signal = CircuitUtils.findSignal(circuit, driver, true); 
 				Point2D centerPosition = getPosition(signal);
 				setPosition(signalStg.zero, Geometry.add(centerPosition, OFFSET_P0));
 				setPosition(signalStg.one, Geometry.add(centerPosition, OFFSET_P1));

=== added file 'CircuitPlugin/src/org/workcraft/plugins/circuit/verilog/SubstitutionRule.java'
--- CircuitPlugin/src/org/workcraft/plugins/circuit/verilog/SubstitutionRule.java	1970-01-01 00:00:00 +0000
+++ CircuitPlugin/src/org/workcraft/plugins/circuit/verilog/SubstitutionRule.java	2015-11-09 09:38:45 +0000
@@ -0,0 +1,16 @@
+package org.workcraft.plugins.circuit.verilog;
+
+import java.util.Map;
+
+public class SubstitutionRule {
+	public final String oldName;
+	public final String newName;
+	public final Map<String, String> substitutions;
+	
+	public SubstitutionRule(String oldName, String newName, Map<String, String> substitutions) {
+		this.oldName = oldName;
+		this.newName = newName;
+		this.substitutions = substitutions;
+	}
+
+}

=== modified file 'WorkcraftCore/src/org/workcraft/plugins/shared/CommonDebugSettings.java'
--- WorkcraftCore/src/org/workcraft/plugins/shared/CommonDebugSettings.java	2015-10-13 17:22:00 +0000
+++ WorkcraftCore/src/org/workcraft/plugins/shared/CommonDebugSettings.java	2015-11-09 09:38:45 +0000
@@ -35,14 +35,17 @@
 	private static final String keyCopyModelOnChange = prefix + ".copyModelOnChange";
 	private static final String keyKeepTemporaryFiles = prefix + ".keepTemporaryFiles";
 	private static final String keyVerboseImport = prefix + ".verboseImport";
+	private static final String keyParserTracing = prefix + ".parserTracing";
 
 	private static final boolean defaultCopyModelOnChange = false; 
 	private static final Boolean defaultKeepTemporaryFiles = true;
 	private static final Boolean defaultVerboseImport = false;
+	private static final Boolean defaultParserTracing = false;
 
 	private static boolean copyModelOnChange = defaultCopyModelOnChange; 
 	private static Boolean keepTemporaryFiles = defaultKeepTemporaryFiles;
 	private static Boolean verboseImport = defaultVerboseImport;
+	private static Boolean parserTracing = defaultParserTracing;
 
 	public CommonDebugSettings() {
 		properties.add(new PropertyDeclaration<CommonDebugSettings, Boolean>(
@@ -74,6 +77,16 @@
 				return getVerboseImport();
 			}
 		});
+		
+		properties.add(new PropertyDeclaration<CommonDebugSettings, Boolean>(
+				this, "Log tracing information from parsers", Boolean.class, true, false, false) {
+			protected void setter(CommonDebugSettings object, Boolean value) {
+				setParserTracing(value);
+			}
+			protected Boolean getter(CommonDebugSettings object) {
+				return getParserTracing();
+			}
+		});
 	}
 	
 	@Override
@@ -86,6 +99,7 @@
 		setCopyModelOnChange(config.getBoolean(keyCopyModelOnChange, defaultCopyModelOnChange));
 		setKeepTemporaryFiles(config.getBoolean(keyKeepTemporaryFiles, defaultKeepTemporaryFiles));
 		setVerboseImport(config.getBoolean(keyVerboseImport, defaultVerboseImport));
+		setParserTracing(config.getBoolean(keyParserTracing, defaultParserTracing));
 	}
 
 	@Override
@@ -93,6 +107,7 @@
 		config.setBoolean(keyCopyModelOnChange, getCopyModelOnChange());
 		config.setBoolean(keyKeepTemporaryFiles, getKeepTemporaryFiles());
 		config.setBoolean(keyVerboseImport, getVerboseImport());
+		config.setBoolean(keyParserTracing, getParserTracing());
 	}
 
 	@Override
@@ -128,5 +143,13 @@
 	public static void setVerboseImport(Boolean value) {
 		verboseImport = value;
 	}
+	
+	public static Boolean getParserTracing() {
+		return parserTracing;
+	}
+
+	public static void setParserTracing(Boolean value) {
+		parserTracing = value;
+	}
 
 }