Update Grammar and Add support for callsites

A new feature in CTF v1.9
Add test cases for callsites
Improve other test cases

Change-Id: I10d28768ee267001638c7d5c94452e6eb26b311c
Signed-off-by: Matthew Khouzam <matthew.khouzam@ericsson.com>
Reviewed-on: https://git.eclipse.org/r/8373
Tested-by: Hudson CI
Reviewed-by: Alexandre Montplaisir <alexmonthy@voxpopuli.im>
IP-Clean: Alexandre Montplaisir <alexmonthy@voxpopuli.im>

diff --git a/org.eclipse.linuxtools.ctf.core.tests/src/org/eclipse/linuxtools/ctf/core/tests/AllCtfCoreTests.java b/org.eclipse.linuxtools.ctf.core.tests/src/org/eclipse/linuxtools/ctf/core/tests/AllCtfCoreTests.java
index 66f84009268d6a69a6a99e55e4b7eef1a9502b28..4da08457a74e4545c5e65056a83a802df5de77bc 100644 (file)
--- a/org.eclipse.linuxtools.ctf.core.tests/src/org/eclipse/linuxtools/ctf/core/tests/AllCtfCoreTests.java
+++ b/org.eclipse.linuxtools.ctf.core.tests/src/org/eclipse/linuxtools/ctf/core/tests/AllCtfCoreTests.java
@@ -8,7 +8,7 @@ import org.junit.runners.Suite;
  * The class <code>TestAll</code> builds a suite that can be used to run all of
  * the tests within its package as well as within any subpackages of its
  * package.
- * 
+ *
  * @author ematkho
  * @version $Revision: 1.0 $
  */
@@ -18,13 +18,13 @@ import org.junit.runners.Suite;
     org.eclipse.linuxtools.ctf.core.tests.types.TestAll.class,
     org.eclipse.linuxtools.ctf.core.tests.trace.TestAll.class,
     org.eclipse.linuxtools.ctf.core.tests.trace.UtilsTest.class,
-    //  org.eclipse.linuxtools.ctf.core.tests.event.TestAll.class,
+    org.eclipse.linuxtools.ctf.core.tests.event.TestAll.class,
 })
 public class AllCtfCoreTests {
 
     /**
      * Launch the test.
-     * 
+     *
      * @param args
      *            the command line arguments
      */

diff --git a/org.eclipse.linuxtools.ctf.core.tests/src/org/eclipse/linuxtools/ctf/core/tests/event/CTFCallsiteTest.java b/org.eclipse.linuxtools.ctf.core.tests/src/org/eclipse/linuxtools/ctf/core/tests/event/CTFCallsiteTest.java
new file mode 100644 (file)
index 0000000..e5bf475
--- /dev/null
+++ b/org.eclipse.linuxtools.ctf.core.tests/src/org/eclipse/linuxtools/ctf/core/tests/event/CTFCallsiteTest.java
@@ -0,0 +1,96 @@
+package org.eclipse.linuxtools.ctf.core.tests.event;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import java.util.Arrays;
+
+import org.eclipse.linuxtools.ctf.core.event.CTFCallsite;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * The class <code>CTFCallsiteTest</code> contains tests for the class
+ * <code>{@link CTFCallsite}</code>.
+ *
+ * @author Matthew Khouzam
+ * @version $Revision: 1.0 $
+ */
+
+public class CTFCallsiteTest {
+    /**
+     * Perform pre-test initialization.
+     */
+    @Before
+    public void setUp() {
+        // add additional set up code here
+    }
+
+    /**
+     * Perform post-test clean-up.
+     */
+    @After
+    public void tearDown() {
+        // Add additional tear down code here
+    }
+
+    @SuppressWarnings("nls")
+    private static CTFCallsite GenerateCS(long ip){
+        return new CTFCallsite("event name", "func name", ip, "file.java", 1);
+    }
+
+    /**
+     * Test the constructor
+     */
+    @Test
+    public void constructorTest(){
+        CTFCallsite cs = GenerateCS(0x01);
+        assertNotNull(cs);
+    }
+
+    /**
+     * Test the comparator (it should sort using the IP)
+     */
+    @Test
+    public void comparatorTest(){
+        CTFCallsite cs[] = new CTFCallsite[5];
+        long vals[] = {1L, 0L, -2L, 2L, -1L};
+        for(int i = 0 ; i < 5 ; i++ ){
+            cs[i] = GenerateCS(vals[i]);
+        }
+
+        assertEquals(1, cs[0].compareTo(cs[1]));
+        assertEquals(-1, cs[1].compareTo(cs[0]));
+        assertEquals(0, cs[0].compareTo(cs[0]));
+        assertEquals(-1, cs[0].compareTo(cs[2]));
+        assertEquals(1, cs[2].compareTo(cs[0]));
+
+        Arrays.sort(cs);
+
+        assertEquals( 0L, cs[0].getIp());
+        assertEquals( 1L, cs[1].getIp());
+        assertEquals( 2L, cs[2].getIp());
+        assertEquals( -2L , cs[3].getIp());
+        assertEquals( -1L, cs[4].getIp());
+    }
+
+    /**
+     * Tests the output of a callsite toString function
+     */
+    @Test
+    public void toStringTest(){
+        CTFCallsite cs = GenerateCS(0x01);
+        assertEquals("file.java/func name:1", cs.toString()); //$NON-NLS-1$
+    }
+
+    /**
+     * Launch the test.
+     *
+     * @param args
+     *            the command line arguments
+     */
+    public static void main(String[] args) {
+        new org.junit.runner.JUnitCore().run(CTFCallsiteTest.class);
+    }
+}

diff --git a/org.eclipse.linuxtools.ctf.core.tests/src/org/eclipse/linuxtools/ctf/core/tests/event/CTFEventFieldTest.java b/org.eclipse.linuxtools.ctf.core.tests/src/org/eclipse/linuxtools/ctf/core/tests/event/CTFEventFieldTest.java
index 4b1369721467088781709ab63cbf01cc5bbbc1fc..77112c12913a2f2447a967eddc2b3b5838cb95ad 100644 (file)
--- a/org.eclipse.linuxtools.ctf.core.tests/src/org/eclipse/linuxtools/ctf/core/tests/event/CTFEventFieldTest.java
+++ b/org.eclipse.linuxtools.ctf.core.tests/src/org/eclipse/linuxtools/ctf/core/tests/event/CTFEventFieldTest.java
@@ -96,9 +96,9 @@ public class CTFEventFieldTest {
      * @throws CTFReaderException
      */
     @Test
-    public void testParseField_simple() throws CTFReaderException {
-        Definition fieldDef = new SequenceDefinition(new SequenceDeclaration(
-                "", new StringDeclaration()), null, fieldName); //$NON-NLS-1$
+    public void testParseField_simple() {
+        final StringDeclaration elemType = new StringDeclaration();
+        Definition fieldDef = elemType.createDefinition(null, fieldName);
 
         assertNotNull(fieldDef);
     }
@@ -125,7 +125,7 @@ public class CTFEventFieldTest {
                 new StringDeclaration(), null, fieldName);
         fieldDef.setString(new StringBuilder("Hello World")); //$NON-NLS-1$
 
-        String other = fieldName + "=Hello World"; //$NON-NLS-1$
+        String other = "\"Hello World\""; //$NON-NLS-1$
         assertNotNull(fieldDef);
         assertEquals(fieldDef.toString(), other);
     }
@@ -176,8 +176,7 @@ public class CTFEventFieldTest {
         ((IntegerDefinition) ((ArrayDefinition) fieldDef).getDefinitions()[11]).setValue(0);
 
         assertNotNull(fieldDef);
-        String other = fieldName
-                + "={ 72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 0}"; //$NON-NLS-1$
+        String other = "[ 72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 0 ]"; //$NON-NLS-1$
         assertEquals(other, fieldDef.toString());
     }
 }
\ No newline at end of file

diff --git a/org.eclipse.linuxtools.ctf.core.tests/src/org/eclipse/linuxtools/ctf/core/tests/event/TestAll.java b/org.eclipse.linuxtools.ctf.core.tests/src/org/eclipse/linuxtools/ctf/core/tests/event/TestAll.java
index 1a3d40e54175a60602c388a398f7c8d1b804743e..e6e7e4bd56a2527d63e876194547fd2e2ccc3886 100644 (file)
--- a/org.eclipse.linuxtools.ctf.core.tests/src/org/eclipse/linuxtools/ctf/core/tests/event/TestAll.java
+++ b/org.eclipse.linuxtools.ctf.core.tests/src/org/eclipse/linuxtools/ctf/core/tests/event/TestAll.java
@@ -8,19 +8,17 @@ import org.junit.runners.Suite;
  * The class <code>TestAll</code> builds a suite that can be used to run all of
  * the tests within its package as well as within any subpackages of its
  * package.
- * 
+ *
  * @author ematkho
  * @version $Revision: 1.0 $
  */
 @RunWith(Suite.class)
-@Suite.SuiteClasses({
-    org.eclipse.linuxtools.ctf.core.tests.event.CTFEventFieldTest.class,
-})
+@Suite.SuiteClasses({ CTFEventFieldTest.class, CTFCallsiteTest.class })
 public class TestAll {
 
     /**
      * Launch the test.
-     * 
+     *
      * @param args
      *            the command line arguments
      */

diff --git a/org.eclipse.linuxtools.ctf.core.tests/src/org/eclipse/linuxtools/ctf/core/tests/trace/CTFTraceCallsitePerformanceTest.java b/org.eclipse.linuxtools.ctf.core.tests/src/org/eclipse/linuxtools/ctf/core/tests/trace/CTFTraceCallsitePerformanceTest.java
new file mode 100644 (file)
index 0000000..a641be0
--- /dev/null
+++ b/org.eclipse.linuxtools.ctf.core.tests/src/org/eclipse/linuxtools/ctf/core/tests/trace/CTFTraceCallsitePerformanceTest.java
@@ -0,0 +1,190 @@
+package org.eclipse.linuxtools.ctf.core.tests.trace;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.List;
+import java.util.Random;
+
+import org.eclipse.linuxtools.ctf.core.event.CTFCallsite;
+import org.eclipse.linuxtools.ctf.core.tests.TestParams;
+import org.eclipse.linuxtools.ctf.core.trace.CTFReaderException;
+import org.eclipse.linuxtools.ctf.core.trace.CTFTrace;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Test the performance of the callsite storage in the CTF trace.
+ * @author Matthew Khouzam
+ *
+ */
+public class CTFTraceCallsitePerformanceTest {
+
+    private static final int NUMBER_OF_SEEKS = 100000;
+
+    @SuppressWarnings("nls")
+    private final String[] callsites = { "Alligator", "Bunny", "Cat",
+            "Dolphin", "Echidna", "Gazelle", "Heron", "Ibex", "Jackalope",
+            "Koala", "Lynx", "Meerkat", "Narwhal", "Ocelot", "Pangolin",
+            "Quetzal", "Ringtail", "Sandpiper", "Tiger", "Urchin", "Vulture",
+            "Walrus", "X-Ray Tetra", "Zonkey" };
+
+    @SuppressWarnings("nls")
+    private final String[] functions = { "sentence", "together", "children",
+            "mountain", "chipmunk", "crashing", "drinking", "insisted",
+            "insulted", "invented", "squinted", "standing", "swishing",
+            "talented", "whiplash", "complain", "granddad", "sprinkle",
+            "surprise", "umbrella", "anything", "anywhere", "baseball",
+            "birthday", "bluebird", "cheerful", "colorful", "daylight",
+            "doghouse", "driveway", "everyone" };
+
+    @SuppressWarnings("nls")
+    private final String[] files = { "Adult.java", "Aeroplane.java",
+            "Air.java", "Airforce.java", "Airport.java", "Album.java",
+            "Alphabet.java", "Apple.java", "Arm.java", "Army.java", "Babby.java" };
+
+    Random rnd = new Random();
+    CTFTrace fTrace = null;
+
+    /**
+     * main, launches the tests.
+     * @param args not read
+     */
+    public static void main(String[] args) {
+        new org.junit.runner.JUnitCore().run(CTFTraceCallsitePerformanceTest.class);
+    }
+
+
+    /**
+     * sets up the test by making a new trace.
+     * @throws CTFReaderException an exception from the reader
+     * @throws SecurityException an exception from accessing files illegally
+     * @throws IllegalArgumentException an exception for passing bad values
+     */
+    @Before
+    public void setup() throws CTFReaderException, SecurityException,
+            IllegalArgumentException {
+        fTrace = new CTFTrace(TestParams.getTraceFile().getParentFile());
+    }
+
+    private void addCallsites(int numCallsites) {
+        long stepSize = (Long.MAX_VALUE / (numCallsites + 1));
+        int jitter = (int) Math.min(stepSize, Integer.MAX_VALUE);
+        for (int i = 0; i < numCallsites; i++) {
+            final long ip = ((i)) * stepSize + rnd.nextInt(jitter);
+            fTrace.addCallsite(getRandomElement(callsites),
+                    getRandomElement(functions), ip, getRandomElement(files),
+                    (ip / 1000000) * 100);
+        }
+    }
+
+    private String getRandomElement(String[] array) {
+        return array[rnd.nextInt(array.length)];
+    }
+
+    private long testMain() {
+        List<CTFCallsite> l = fTrace.getCallsiteCandidates(callsites[0]);
+        CTFCallsite cs = fTrace.getCallsite(1);
+        CTFCallsite cs1 = fTrace.getCallsite(callsites[0]);
+        CTFCallsite cs2 = fTrace.getCallsite(callsites[0], 1);
+        assertNotNull(l);
+        assertNotNull(cs);
+        assertNotNull(cs1);
+        assertNotNull(cs2);
+        /* performance test */
+        long start = System.nanoTime();
+        perfTest();
+        long end = System.nanoTime();
+        long diff = end - start;
+        assertTrue(diff > 0);
+        return diff;
+    }
+
+    /**
+     * @param callsiteSize
+     */
+    private void test(int callsiteSize) {
+        addCallsites(callsiteSize);
+        long ns = testMain();
+        System.out.println( "perf ( " + callsiteSize + ", " + ns + ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+    }
+
+    private void perfTest() {
+        for (int i = 0; i < NUMBER_OF_SEEKS; i++) {
+            fTrace.getCallsite((((long) rnd.nextInt()) << 16L));
+        }
+    }
+
+    /**
+     * Test seeks with 1000 callsites
+     */
+    @Test
+    public void test1KCallsites() {
+        test(1000);
+    }
+
+    /**
+     * Test seeks with 2000 callsites
+     */
+    @Test
+    public void test2KCallsites() {
+        test(2000);
+    }
+
+    /**
+     * Test seeks with 5000 callsites
+     */
+    @Test
+    public void test5KCallsites() {
+        test(5000);
+    }
+
+    /**
+     * Test seeks with 10000 callsites
+     */
+    @Test
+    public void test10KCallsites() {
+        test(10000);
+    }
+
+    /**
+     * Test seeks with 20000 callsites
+     */
+    @Test
+    public void test20KCallsites() {
+        test(20000);
+    }
+
+    /**
+     * Test seeks with 50000 callsites
+     */
+    @Test
+    public void test50KCallsites() {
+        test(50000);
+    }
+
+    /**
+     * Test seeks with 100000 callsites
+     */
+    @Test
+    public void test100KCallsites() {
+        test(100000);
+    }
+
+    /**
+     * Test seeks with 1000000 callsites
+     */
+    @Test
+    public void test1MCallsites() {
+        test(1000000);
+    }
+
+    /**
+     * Test seeks with 2000000 callsites
+     */
+    @Test
+    public void test2MCallsites() {
+        test(2000000);
+    }
+
+}

diff --git a/org.eclipse.linuxtools.ctf.core.tests/src/org/eclipse/linuxtools/ctf/core/tests/trace/CTFTraceTest.java b/org.eclipse.linuxtools.ctf.core.tests/src/org/eclipse/linuxtools/ctf/core/tests/trace/CTFTraceTest.java
index 87b2e44e7b2070a05a267f05f25265d4d6596177..26296657318b924d7c1cd30838cd50436779a19c 100644 (file)
--- a/org.eclipse.linuxtools.ctf.core.tests/src/org/eclipse/linuxtools/ctf/core/tests/trace/CTFTraceTest.java
+++ b/org.eclipse.linuxtools.ctf.core.tests/src/org/eclipse/linuxtools/ctf/core/tests/trace/CTFTraceTest.java
@@ -105,7 +105,7 @@ public class CTFTraceTest {
     @Test
     public void testAddStream() throws ParseException, CTFReaderException {
         Stream stream = new Stream(TestParams.createTrace());
-        stream.setId(1L);
+        stream.setId(1234);
         fixture.addStream(stream);
     }
 
@@ -332,7 +332,7 @@ public class CTFTraceTest {
      */
     @Test
     public void testGetClock_3() {
-        String name = ""; //$NON-NLS-1$
+        String name = "invisibleClock"; //$NON-NLS-1$
         CTFClock result = fixture.getClock(name);
         assertNull(result);
     }
@@ -343,7 +343,7 @@ public class CTFTraceTest {
      */
     @Test
     public void testSetClock_1() {
-        String name = ""; //$NON-NLS-1$
+        String name = "clockyClock"; //$NON-NLS-1$
         fixture.addClock(name, new CTFClock());
         CTFClock result = fixture.getClock(name);
 
@@ -382,7 +382,7 @@ public class CTFTraceTest {
      */
     @Test
     public void testLookupEnvironment_2() {
-        String key = "test"; //$NON-NLS-1$
+        String key = "otherTest"; //$NON-NLS-1$
         String result = fixture.lookupEnvironment(key);
         assertNull(result);
     }

diff --git a/org.eclipse.linuxtools.ctf.core.tests/src/org/eclipse/linuxtools/ctf/core/tests/trace/TestAll.java b/org.eclipse.linuxtools.ctf.core.tests/src/org/eclipse/linuxtools/ctf/core/tests/trace/TestAll.java
index 3c9025911f40efc7618b862d22792abf84c68ed9..c96e3eb7a0cd6af253951676b35b1582be649e8a 100644 (file)
--- a/org.eclipse.linuxtools.ctf.core.tests/src/org/eclipse/linuxtools/ctf/core/tests/trace/TestAll.java
+++ b/org.eclipse.linuxtools.ctf.core.tests/src/org/eclipse/linuxtools/ctf/core/tests/trace/TestAll.java
@@ -14,13 +14,16 @@ import org.junit.runners.Suite;
  */
 @RunWith(Suite.class)
 @Suite.SuiteClasses({
+        CTFTraceCallsitePerformanceTest.class,
+        CTFTraceTest.class,
         CTFTraceReaderTest.class,
         StreamInputTest.class,
         StreamInputReaderTimestampComparatorTest.class,
         StreamInputReaderTest.class,
         StreamInputReaderComparatorTest.class,
         StreamInputPacketIndexEntryTest.class,
-        StreamInputPacketIndexTest.class, StreamTest.class, CTFTraceTest.class,
+        StreamInputPacketIndexTest.class,
+        StreamTest.class,
         MetadataTest.class, })
 public class TestAll {
 

diff --git a/org.eclipse.linuxtools.ctf.core/src/org/eclipse/linuxtools/ctf/core/event/CTFCallsite.java b/org.eclipse.linuxtools.ctf.core/src/org/eclipse/linuxtools/ctf/core/event/CTFCallsite.java
new file mode 100644 (file)
index 0000000..26dd7ff
--- /dev/null
+++ b/org.eclipse.linuxtools.ctf.core/src/org/eclipse/linuxtools/ctf/core/event/CTFCallsite.java
@@ -0,0 +1,156 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Ericsson
+ *
+ * All rights reserved. This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License v1.0 which
+ * accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *  Matthew Khouzam - Initial API and implementation
+ *
+ *******************************************************************************/
+
+package org.eclipse.linuxtools.ctf.core.event;
+
+/**
+ * Callsite information to help with cdt integration
+ *
+ * @author Matthew Khouzam
+ *
+ * @since 1.2
+ */
+public class CTFCallsite implements Comparable<CTFCallsite> {
+    /**
+     * The callsite constructor
+     *
+     * @param en
+     *            The event name
+     * @param func
+     *            the function name
+     * @param ip
+     *            the instruction pointer of the callsite
+     * @param fn
+     *            the file name of the callsite
+     * @param line
+     *            the line number of the callsite
+     */
+    public CTFCallsite(String en, String func, long ip, String fn, long line) {
+        EventName = en;
+        FileName = fn;
+        FunctionName = func;
+        this.ip = ip;
+        this.LineNumber = line;
+    }
+
+    static private final long MASK32 = 0x00000000ffffffffL;
+    /**
+     * The event name
+     */
+    private final String EventName;
+    /**
+     * the file name of the callsite
+     */
+    private final String FileName;
+    /**
+     * the instruction pointer
+     */
+    private final long ip;
+    /**
+     * the function name
+     */
+    private final String FunctionName;
+    /**
+     * the line number of the callsite
+     */
+    private final long LineNumber;
+
+    /* Getters */
+    /**
+     * @return the eventName
+     */
+    public String getEventName() {
+        return EventName;
+    }
+
+    /**
+     * @return the fileName
+     */
+    public String getFileName() {
+        return FileName;
+    }
+
+    /**
+     * @return the ip
+     */
+    public long getIp() {
+        return ip;
+    }
+
+    /**
+     * @return the functionName
+     */
+    public String getFunctionName() {
+        return FunctionName;
+    }
+
+    /**
+     * @return the lineNumber
+     */
+    public long getLineNumber() {
+        return LineNumber;
+    }
+
+    /*
+     * The callsites will be sorted by calling addresses. To do this we take IPs
+     * (instruction pointers) and compare them. Java only supports signed
+     * operation and since memory addresses are unsigned, we will convert the
+     * longs into integers that contain the high and low bytes and compare them.
+     */
+    @Override
+    public int compareTo(CTFCallsite o) {
+        /*
+         * mask32 is 32 zeros followed by 32 ones, when we bitwise and this it
+         * will return the lower 32 bits
+         */
+
+        long other = o.ip;
+        /*
+         * To get a high int: we downshift by 32 and bitwise and with the mask
+         * to get rid of the sign
+         *
+         * To get the low int: we bitwise and with the mask.
+         */
+        long otherHigh = (other >> 32) & MASK32;
+        long otherLow = other & MASK32;
+        long ownHigh = (ip >> 32) & MASK32;
+        long ownLow = ip & MASK32;
+        /* are the high values different, if so ignore the lower values */
+        if (ownHigh > otherHigh) {
+            return 1;
+        }
+        if (ownHigh < otherHigh ) {
+            return -1;
+        }
+        /* the high values are the same, compare the lower values */
+        if (ownLow > otherLow) {
+            return 1;
+        }
+        if (ownLow < otherLow) {
+            return -1;
+        }
+        /* the values are identical */
+        return 0;
+    }
+
+
+    /*
+     * (non-Javadoc)
+     *
+     * @see java.lang.Object#toString()
+     */
+    @Override
+    public String toString() {
+        return FileName + "/" + FunctionName + ":" + LineNumber; //$NON-NLS-1$ //$NON-NLS-2$
+    }
+}

diff --git a/org.eclipse.linuxtools.ctf.core/src/org/eclipse/linuxtools/ctf/core/trace/CTFTrace.java b/org.eclipse.linuxtools.ctf.core/src/org/eclipse/linuxtools/ctf/core/trace/CTFTrace.java
index eac8cb87fbc9236d1cbfa50ec1f5627ec209da17..cac5d839b62a76f3010944ca9b37594ebf103421 100644 (file)
--- a/org.eclipse.linuxtools.ctf.core/src/org/eclipse/linuxtools/ctf/core/trace/CTFTrace.java
+++ b/org.eclipse.linuxtools.ctf.core/src/org/eclipse/linuxtools/ctf/core/trace/CTFTrace.java
@@ -22,16 +22,20 @@ import java.nio.MappedByteBuffer;
 import java.nio.channels.FileChannel;
 import java.nio.channels.FileChannel.MapMode;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.ListIterator;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
+import java.util.TreeSet;
 import java.util.UUID;
 
+import org.eclipse.linuxtools.ctf.core.event.CTFCallsite;
 import org.eclipse.linuxtools.ctf.core.event.CTFClock;
 import org.eclipse.linuxtools.ctf.core.event.EventDeclaration;
 import org.eclipse.linuxtools.ctf.core.event.EventDefinition;
@@ -154,6 +158,11 @@ public class CTFTrace implements IDefinitionScope {
     /** map of all the indexes */
     private final HashMap<StreamInput, StreamInputPacketIndex> indexes;
 
+    /** Callsite helpers */
+    private HashMap<String, LinkedList<CTFCallsite>> callsitesByName = new HashMap<String, LinkedList<CTFCallsite>>();
+    /** Callsite helpers */
+    private TreeSet<CTFCallsite> callsitesByIP = new TreeSet<CTFCallsite>();
+
 
 
     // ------------------------------------------------------------------------
@@ -744,6 +753,104 @@ public class CTFTrace implements IDefinitionScope {
         return value;
     }
 
+    /**
+     * Adds a callsite
+     *
+     * @param eventName
+     *            the event name of the callsite
+     * @param funcName
+     *            the name of the callsite function
+     * @param ip
+     *            the ip of the callsite
+     * @param fileName
+     *            the filename of the callsite
+     * @param lineNumber
+     *            the line number of the callsite
+     */
+    public void addCallsite(String eventName, String funcName, long ip,
+            String fileName, long lineNumber) {
+        final CTFCallsite cs = new CTFCallsite(eventName, funcName, ip,
+                fileName, lineNumber);
+        LinkedList<CTFCallsite> csl = callsitesByName.get(eventName);
+        if (csl == null) {
+            csl = new LinkedList<CTFCallsite>();
+            callsitesByName.put(eventName, csl);
+        }
+
+        ListIterator<CTFCallsite> iter = csl.listIterator();
+        int index = 0;
+        for (; index < csl.size(); index++) {
+            if (iter.next().compareTo(cs) < 0) {
+                break;
+            }
+        }
+
+        csl.add(index, cs);
+
+        callsitesByIP.add(cs);
+    }
+
+    /**
+     * Gets the list of callsites associated to an event name. O(1)
+     *
+     * @param eventName
+     *            the event name
+     * @return the callsite list can be empty
+     * @since 1.2
+     */
+    public List<CTFCallsite> getCallsiteCandidates(String eventName) {
+        LinkedList<CTFCallsite> retVal = callsitesByName.get(eventName);
+        if( retVal == null ) {
+            retVal = new LinkedList<CTFCallsite>();
+        }
+        return retVal;
+    }
+
+    /**
+     * The I'm feeling lucky of getCallsiteCandidates O(1)
+     *
+     * @param eventName
+     *            the event name
+     * @return the first callsite that has that event name, can be null
+     * @since 1.2
+     */
+    public CTFCallsite getCallsite(String eventName) {
+        return callsitesByName.get(eventName).getFirst();
+    }
+
+    /**
+     * Gets a callsite from the instruction pointer O(log(n))
+     *
+     * @param ip
+     *            the instruction pointer to lookup
+     * @return the callsite just before that IP in the list remember the IP is
+     *         backwards on X86, can be null if no callsite is before the IP.
+     * @since 1.2
+     */
+    public CTFCallsite getCallsite(long ip) {
+        CTFCallsite cs = new CTFCallsite(null, null, ip, null, 0L);
+        return callsitesByIP.ceiling(cs);
+    }
+
+    /**
+     * Gets a callsite using the event name and instruction pointer O(log(n))
+     *
+     * @param eventName
+     *            the name of the event
+     * @param ip
+     *            the instruction pointer
+     * @return the closest matching callsite, can be null
+     */
+    public CTFCallsite getCallsite(String eventName, long ip) {
+        final LinkedList<CTFCallsite> candidates = callsitesByName.get(eventName);
+        final CTFCallsite dummyCs = new CTFCallsite(null, null, ip, null, -1);
+        final int pos = Collections.binarySearch(candidates, dummyCs)+1;
+        if( pos >= candidates.size()) {
+            return null;
+        }
+        return candidates.get(pos);
+    }
+
 }
 
 class MetadataFileFilter implements FileFilter {

diff --git a/org.eclipse.linuxtools.ctf.core/src/org/eclipse/linuxtools/internal/ctf/core/event/metadata/IOStructGen.java b/org.eclipse.linuxtools.ctf.core/src/org/eclipse/linuxtools/internal/ctf/core/event/metadata/IOStructGen.java
index 3b17b6f1e5076dbe29e8d9102f7e4dd731739ff0..d300ebf4fc1326fd4e2b61a7ed0df6dec2749d9b 100644 (file)
--- a/org.eclipse.linuxtools.ctf.core/src/org/eclipse/linuxtools/internal/ctf/core/event/metadata/IOStructGen.java
+++ b/org.eclipse.linuxtools.ctf.core/src/org/eclipse/linuxtools/internal/ctf/core/event/metadata/IOStructGen.java
@@ -134,16 +134,18 @@ public class IOStructGen {
         List<CommonTree> declarations = new ArrayList<CommonTree>();
         List<CommonTree> environments = new ArrayList<CommonTree>();
         List<CommonTree> clocks = new ArrayList<CommonTree>();
+        List<CommonTree> callsites = new ArrayList<CommonTree>();
         /* Create a new declaration scope with no parent. */
         pushScope();
 
         try {
             for (CommonTree child : children) {
+                final int type = child.getType();
                 if (DEBUG_) {
                     out.write(child.toString()
-                            + " -> " + child.getType() + '\n'); //$NON-NLS-1$
+                            + " -> " + type + '\n'); //$NON-NLS-1$
                 }
-                switch (child.getType()) {
+                switch (type) {
                 case CTFParser.DECLARATION:
                     declarations.add(child);
                     break;
@@ -166,6 +168,9 @@ public class IOStructGen {
                 case CTFParser.ENV:
                     environments.add(child);
                     break;
+                case CTFParser.CALLSITE:
+                    callsites.add(child);
+                    break;
                 default:
                     childTypeError(child);
                 }
@@ -197,6 +202,12 @@ public class IOStructGen {
             for (CommonTree clock : clocks) {
                 parseClock(clock);
             }
+            if (DEBUG_) {
+                out.write("Callsites\n"); //$NON-NLS-1$
+            }
+            for (CommonTree callsite : callsites) {
+                parseCallsite(callsite);
+            }
 
             if (DEBUG_) {
                 out.write("Streams\n"); //$NON-NLS-1$
@@ -239,6 +250,37 @@ public class IOStructGen {
         popScope();
     }
 
+    private void parseCallsite(CommonTree callsite) {
+
+        List<CommonTree> children = callsite.getChildren();
+        String name = null;
+        String func_name = null;
+        long line_number = -1;
+        long ip = -1;
+        String file_name = null;
+
+        for (CommonTree child : children) {
+            String left;
+            /* this is a regex to find the leading and trailing quotes*/
+            final String regex = "^\"|\"$"; //$NON-NLS-1$
+            /* this is to replace the previous quotes with nothing... effectively deleting them */
+            final String nullString = ""; //$NON-NLS-1$
+            left = child.getChild(0).getChild(0).getChild(0).getText();
+            if (left.equals("name")) { //$NON-NLS-1$
+                name = child.getChild(1).getChild(0).getChild(0).getText().replaceAll(regex, nullString);
+            } else if (left.equals("func")) { //$NON-NLS-1$
+                func_name = child.getChild(1).getChild(0).getChild(0).getText().replaceAll(regex, nullString);
+            } else if (left.equals("ip")) { //$NON-NLS-1$
+                ip = Long.parseLong(child.getChild(1).getChild(0).getChild(0).getText().substring(2),16); // trim the 0x
+            } else if (left.equals("file")) { //$NON-NLS-1$
+                file_name = child.getChild(1).getChild(0).getChild(0).getText().replaceAll(regex, nullString);
+            } else if (left.equals("line")) { //$NON-NLS-1$
+                line_number = Long.parseLong(child.getChild(1).getChild(0).getChild(0).getText());
+            }
+        }
+        trace.addCallsite(name, func_name, ip,file_name, line_number);
+    }
+
     private void parseEnvironment(CommonTree environment) {
         List<CommonTree> children = environment.getChildren();
         for (CommonTree child : children) {

diff --git a/org.eclipse.linuxtools.ctf.parser/Grammar/CTFLexer.g b/org.eclipse.linuxtools.ctf.parser/Grammar/CTFLexer.g
index 22acde6727bee27d90d88706c92cc00a22cde059..3ccf81ca821b6833804235f4fcb9d6c663d4982f 100644 (file)
--- a/org.eclipse.linuxtools.ctf.parser/Grammar/CTFLexer.g
+++ b/org.eclipse.linuxtools.ctf.parser/Grammar/CTFLexer.g
@@ -42,6 +42,11 @@ COMPLEXTOK       : '_Complex' ;
 IMAGINARYTOK     : '_Imaginary' ;
 ENVTOK           : 'env' ;
 CLOCKTOK         : 'clock' ;
+/*
+ * Callsite tokens (v1.9)
+ */
+CALLSITETOK      : 'callsite' ;
+
 
 /*
  * Spec still to come.

diff --git a/org.eclipse.linuxtools.ctf.parser/Grammar/CTFParser.g b/org.eclipse.linuxtools.ctf.parser/Grammar/CTFParser.g
index 9906e80f658860dad7d1c02c50e076d5de273dbb..049079ee07dc6621dfeca08f7df113e871d9616b 100644 (file)
--- a/org.eclipse.linuxtools.ctf.parser/Grammar/CTFParser.g
+++ b/org.eclipse.linuxtools.ctf.parser/Grammar/CTFParser.g
@@ -15,6 +15,7 @@ tokens {
        TRACE;
        ENV;
        CLOCK;
+       CALLSITE;
        
        DECLARATION;
        SV_DECLARATION;
@@ -938,6 +939,7 @@ ctfSpecifierHead
        | TRACETOK -> TRACE
        | ENVTOK -> ENV
        | CLOCKTOK -> CLOCK
+       | CALLSITETOK -> CALLSITE
   ;
 
 ctfTypeSpecifier

diff --git a/org.eclipse.linuxtools.ctf.parser/Grammar/regenGrammar.sh b/org.eclipse.linuxtools.ctf.parser/Grammar/regenGrammar.sh
new file mode 100755 (executable)
index 0000000..fac6f4d
--- /dev/null
+++ b/org.eclipse.linuxtools.ctf.parser/Grammar/regenGrammar.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+
+antlr3 CTFLexer.g -o ../src/org/eclipse/linuxtools/ctf/parser/
+antlr3 CTFParser.g -o ../src/org/eclipse/linuxtools/ctf/parser/
+rm ../src/org/eclipse/linuxtools/ctf/parser/*.tokens

diff --git a/org.eclipse.linuxtools.ctf.parser/src/org/eclipse/linuxtools/ctf/parser/CTFLexer.java b/org.eclipse.linuxtools.ctf.parser/src/org/eclipse/linuxtools/ctf/parser/CTFLexer.java
index 88de1ad3e2229491d56e10f582a3d274abbc28a7..2515eb9eb0eab3f4ef93df73638b050f3232cba7 100644 (file)
--- a/org.eclipse.linuxtools.ctf.parser/src/org/eclipse/linuxtools/ctf/parser/CTFLexer.java
+++ b/org.eclipse.linuxtools.ctf.parser/src/org/eclipse/linuxtools/ctf/parser/CTFLexer.java
@@ -1,4 +1,4 @@
-// $ANTLR !Unknown version! Grammar/CTFLexer.g 2012-03-09 14:59:17
+// $ANTLR !Unknown version! CTFLexer.g 2012-10-22 14:14:33
 
 package org.eclipse.linuxtools.ctf.parser;
 
@@ -8,96 +8,89 @@ import org.antlr.runtime.DFA;
 import org.antlr.runtime.EarlyExitException;
 import org.antlr.runtime.Lexer;
 import org.antlr.runtime.MismatchedSetException;
-import org.antlr.runtime.MismatchedTokenException;
 import org.antlr.runtime.NoViableAltException;
 import org.antlr.runtime.RecognitionException;
 import org.antlr.runtime.RecognizerSharedState;
 
-
-/**
- * TSDL Lexer. For internal use only.
- *
- * @author Matthew Khouzam and Antlr
- *
- */
-@SuppressWarnings({"nls", "javadoc", "incomplete-switch"})
+@SuppressWarnings({ "javadoc", "nls", "incomplete-switch" })
 public class CTFLexer extends Lexer {
-    public static final int SIGN = 49;
-    public static final int TERM = 47;
+    public static final int SIGN = 50;
+    public static final int TERM = 48;
     public static final int BOOLTOK = 26;
-    public static final int LT = 39;
+    public static final int LT = 40;
     public static final int TYPEDEFTOK = 22;
-    public static final int STRING_CONTENT = 70;
-    public static final int INTEGER_TYPES_SUFFIX = 53;
-    public static final int POINTER = 48;
-    public static final int HEX_PREFIX = 57;
+    public static final int STRING_CONTENT = 71;
+    public static final int INTEGER_TYPES_SUFFIX = 54;
+    public static final int POINTER = 49;
+    public static final int HEX_PREFIX = 58;
     public static final int INTTOK = 13;
-    public static final int SEPARATOR = 34;
-    public static final int TYPE_ASSIGNMENT = 38;
+    public static final int SEPARATOR = 35;
+    public static final int TYPE_ASSIGNMENT = 39;
     public static final int ENUMTOK = 8;
     public static final int COMPLEXTOK = 27;
     public static final int IMAGINARYTOK = 28;
-    public static final int DOUBLEQUOTE = 69;
+    public static final int DOUBLEQUOTE = 70;
     public static final int STREAMTOK = 17;
     public static final int EOF = -1;
-    public static final int INFINITYTOK = 32;
-    public static final int LPAREN = 43;
-    public static final int STRINGPREFIX = 65;
+    public static final int LPAREN = 44;
+    public static final int INFINITYTOK = 33;
+    public static final int STRINGPREFIX = 66;
     public static final int UNSIGNEDTOK = 23;
-    public static final int ESCAPE_SEQUENCE = 64;
-    public static final int CHAR_CONTENT = 67;
-    public static final int RPAREN = 44;
-    public static final int UNICODE_ESCAPE = 62;
-    public static final int STRING_LITERAL = 71;
-    public static final int SINGLEQUOTE = 66;
-    public static final int IDENTIFIER = 78;
+    public static final int ESCAPE_SEQUENCE = 65;
+    public static final int CHAR_CONTENT = 68;
+    public static final int RPAREN = 45;
+    public static final int UNICODE_ESCAPE = 63;
+    public static final int STRING_LITERAL = 72;
+    public static final int CALLSITETOK = 31;
+    public static final int SINGLEQUOTE = 67;
+    public static final int IDENTIFIER = 79;
     public static final int ALIGNTOK = 4;
     public static final int FLOATTOK = 11;
-    public static final int COMMENT_CLOSE = 74;
+    public static final int COMMENT_CLOSE = 75;
     public static final int STRINGTOK = 18;
-    public static final int HEX_LITERAL = 59;
-    public static final int DIGIT = 55;
-    public static final int COMMENT = 75;
-    public static final int DOT = 51;
+    public static final int HEX_LITERAL = 60;
+    public static final int DIGIT = 56;
+    public static final int COMMENT = 76;
+    public static final int DOT = 52;
     public static final int STRUCTTOK = 19;
     public static final int ENVTOK = 29;
     public static final int TYPEALIASTOK = 21;
-    public static final int OPENBRAC = 41;
+    public static final int OPENBRAC = 42;
     public static final int FLOATINGPOINTTOK = 10;
     public static final int EVENTTOK = 9;
-    public static final int LINE_COMMENT = 76;
-    public static final int NINFINITYTOK = 33;
+    public static final int LINE_COMMENT = 77;
+    public static final int NINFINITYTOK = 34;
     public static final int VOIDTOK = 25;
     public static final int DOUBLETOK = 7;
-    public static final int CHARACTER_LITERAL = 68;
-    public static final int OCTAL_LITERAL = 54;
-    public static final int COMMENT_OPEN = 73;
-    public static final int HEX_DIGIT = 58;
-    public static final int OCTAL_ESCAPE = 61;
-    public static final int NANNUMBERTOK = 31;
+    public static final int CHARACTER_LITERAL = 69;
+    public static final int OCTAL_LITERAL = 55;
+    public static final int COMMENT_OPEN = 74;
+    public static final int HEX_DIGIT = 59;
+    public static final int OCTAL_ESCAPE = 62;
+    public static final int NANNUMBERTOK = 32;
     public static final int LONGTOK = 14;
     public static final int CLOCKTOK = 30;
     public static final int SIGNEDTOK = 16;
     public static final int TRACETOK = 20;
-    public static final int COLON = 35;
-    public static final int HEXADECIMAL_ESCAPE = 63;
+    public static final int COLON = 36;
+    public static final int HEXADECIMAL_ESCAPE = 64;
     public static final int CHARTOK = 6;
-    public static final int LCURL = 45;
-    public static final int WS = 72;
+    public static final int LCURL = 46;
+    public static final int WS = 73;
     public static final int INTEGERTOK = 12;
     public static final int VARIANTTOK = 24;
-    public static final int ELIPSES = 36;
-    public static final int NONDIGIT = 77;
-    public static final int RCURL = 46;
-    public static final int ARROW = 50;
-    public static final int GT = 40;
-    public static final int ASSIGNMENT = 37;
+    public static final int ELIPSES = 37;
+    public static final int NONDIGIT = 78;
+    public static final int RCURL = 47;
+    public static final int ARROW = 51;
+    public static final int GT = 41;
+    public static final int ASSIGNMENT = 38;
     public static final int SHORTTOK = 15;
-    public static final int NONZERO_DIGIT = 60;
-    public static final int DECIMAL_LITERAL = 56;
+    public static final int NONZERO_DIGIT = 61;
+    public static final int DECIMAL_LITERAL = 57;
     public static final int CONSTTOK = 5;
-    public static final int BACKSLASH = 52;
-    public static final int CLOSEBRAC = 42;
+    public static final int BACKSLASH = 53;
+    public static final int CLOSEBRAC = 43;
 
     // delegates
     // delegators
@@ -116,758 +109,1296 @@ public class CTFLexer extends Lexer {
 
     @Override
     public String getGrammarFileName() {
-        return "Grammar/CTFLexer.g";
+        return "CTFLexer.g";
     }
 
     // $ANTLR start "ALIGNTOK"
     public final void mALIGNTOK() throws RecognitionException {
-        int _type = ALIGNTOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("align", _type, _channel);
+        try {
+            int _type = ALIGNTOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:18:18: ( 'align' )
+            // CTFLexer.g:18:20: 'align'
+            {
+                match("align");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "ALIGNTOK"
 
     // $ANTLR start "CONSTTOK"
     public final void mCONSTTOK() throws RecognitionException {
-        int _type = CONSTTOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("const", _type, _channel);
+        try {
+            int _type = CONSTTOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:19:18: ( 'const' )
+            // CTFLexer.g:19:20: 'const'
+            {
+                match("const");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "CONSTTOK"
 
     // $ANTLR start "CHARTOK"
     public final void mCHARTOK() throws RecognitionException {
-        int _type = CHARTOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("char", _type, _channel);
+        try {
+            int _type = CHARTOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:20:18: ( 'char' )
+            // CTFLexer.g:20:20: 'char'
+            {
+                match("char");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "CHARTOK"
 
     // $ANTLR start "DOUBLETOK"
     public final void mDOUBLETOK() throws RecognitionException {
-        int _type = DOUBLETOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("double", _type, _channel);
+        try {
+            int _type = DOUBLETOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:21:18: ( 'double' )
+            // CTFLexer.g:21:20: 'double'
+            {
+                match("double");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "DOUBLETOK"
 
     // $ANTLR start "ENUMTOK"
     public final void mENUMTOK() throws RecognitionException {
-        int _type = ENUMTOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("enum", _type, _channel);
+        try {
+            int _type = ENUMTOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:22:18: ( 'enum' )
+            // CTFLexer.g:22:20: 'enum'
+            {
+                match("enum");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "ENUMTOK"
 
     // $ANTLR start "EVENTTOK"
     public final void mEVENTTOK() throws RecognitionException {
-        int _type = EVENTTOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("event", _type, _channel);
+        try {
+            int _type = EVENTTOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:23:18: ( 'event' )
+            // CTFLexer.g:23:20: 'event'
+            {
+                match("event");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "EVENTTOK"
 
     // $ANTLR start "FLOATINGPOINTTOK"
     public final void mFLOATINGPOINTTOK() throws RecognitionException {
-        int _type = FLOATINGPOINTTOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("floating_point", _type, _channel);
+        try {
+            int _type = FLOATINGPOINTTOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:24:18: ( 'floating_point' )
+            // CTFLexer.g:24:20: 'floating_point'
+            {
+                match("floating_point");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "FLOATINGPOINTTOK"
 
     // $ANTLR start "FLOATTOK"
     public final void mFLOATTOK() throws RecognitionException {
-        int _type = FLOATTOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("float", _type, _channel);
+        try {
+            int _type = FLOATTOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:25:18: ( 'float' )
+            // CTFLexer.g:25:20: 'float'
+            {
+                match("float");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "FLOATTOK"
 
     // $ANTLR start "INTEGERTOK"
     public final void mINTEGERTOK() throws RecognitionException {
-        int _type = INTEGERTOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("integer", _type, _channel);
+        try {
+            int _type = INTEGERTOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:26:18: ( 'integer' )
+            // CTFLexer.g:26:20: 'integer'
+            {
+                match("integer");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "INTEGERTOK"
 
     // $ANTLR start "INTTOK"
     public final void mINTTOK() throws RecognitionException {
-        int _type = INTTOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("int", _type, _channel);
+        try {
+            int _type = INTTOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:27:18: ( 'int' )
+            // CTFLexer.g:27:20: 'int'
+            {
+                match("int");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "INTTOK"
 
     // $ANTLR start "LONGTOK"
     public final void mLONGTOK() throws RecognitionException {
-        int _type = LONGTOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("long", _type, _channel);
+        try {
+            int _type = LONGTOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:28:18: ( 'long' )
+            // CTFLexer.g:28:20: 'long'
+            {
+                match("long");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "LONGTOK"
 
     // $ANTLR start "SHORTTOK"
     public final void mSHORTTOK() throws RecognitionException {
-        int _type = SHORTTOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("short", _type, _channel);
+        try {
+            int _type = SHORTTOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:29:18: ( 'short' )
+            // CTFLexer.g:29:20: 'short'
+            {
+                match("short");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "SHORTTOK"
 
     // $ANTLR start "SIGNEDTOK"
     public final void mSIGNEDTOK() throws RecognitionException {
-        int _type = SIGNEDTOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("signed", _type, _channel);
+        try {
+            int _type = SIGNEDTOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:30:18: ( 'signed' )
+            // CTFLexer.g:30:20: 'signed'
+            {
+                match("signed");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "SIGNEDTOK"
 
     // $ANTLR start "STREAMTOK"
     public final void mSTREAMTOK() throws RecognitionException {
-        int _type = STREAMTOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("stream", _type, _channel);
+        try {
+            int _type = STREAMTOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:31:18: ( 'stream' )
+            // CTFLexer.g:31:20: 'stream'
+            {
+                match("stream");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "STREAMTOK"
 
     // $ANTLR start "STRINGTOK"
     public final void mSTRINGTOK() throws RecognitionException {
-        int _type = STRINGTOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("string", _type, _channel);
+        try {
+            int _type = STRINGTOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:32:18: ( 'string' )
+            // CTFLexer.g:32:20: 'string'
+            {
+                match("string");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "STRINGTOK"
 
     // $ANTLR start "STRUCTTOK"
     public final void mSTRUCTTOK() throws RecognitionException {
-        int _type = STRUCTTOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("struct", _type, _channel);
+        try {
+            int _type = STRUCTTOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:33:18: ( 'struct' )
+            // CTFLexer.g:33:20: 'struct'
+            {
+                match("struct");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "STRUCTTOK"
 
     // $ANTLR start "TRACETOK"
     public final void mTRACETOK() throws RecognitionException {
-        int _type = TRACETOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("trace", _type, _channel);
+        try {
+            int _type = TRACETOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:34:18: ( 'trace' )
+            // CTFLexer.g:34:20: 'trace'
+            {
+                match("trace");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "TRACETOK"
 
     // $ANTLR start "TYPEALIASTOK"
     public final void mTYPEALIASTOK() throws RecognitionException {
-        int _type = TYPEALIASTOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("typealias", _type, _channel);
+        try {
+            int _type = TYPEALIASTOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:35:18: ( 'typealias' )
+            // CTFLexer.g:35:20: 'typealias'
+            {
+                match("typealias");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "TYPEALIASTOK"
 
     // $ANTLR start "TYPEDEFTOK"
     public final void mTYPEDEFTOK() throws RecognitionException {
-        int _type = TYPEDEFTOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("typedef", _type, _channel);
+        try {
+            int _type = TYPEDEFTOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:36:18: ( 'typedef' )
+            // CTFLexer.g:36:20: 'typedef'
+            {
+                match("typedef");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "TYPEDEFTOK"
 
     // $ANTLR start "UNSIGNEDTOK"
     public final void mUNSIGNEDTOK() throws RecognitionException {
-        int _type = UNSIGNEDTOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("unsigned", _type, _channel);
+        try {
+            int _type = UNSIGNEDTOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:37:18: ( 'unsigned' )
+            // CTFLexer.g:37:20: 'unsigned'
+            {
+                match("unsigned");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "UNSIGNEDTOK"
 
     // $ANTLR start "VARIANTTOK"
     public final void mVARIANTTOK() throws RecognitionException {
-        int _type = VARIANTTOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("variant", _type, _channel);
+        try {
+            int _type = VARIANTTOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:38:18: ( 'variant' )
+            // CTFLexer.g:38:20: 'variant'
+            {
+                match("variant");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "VARIANTTOK"
 
     // $ANTLR start "VOIDTOK"
     public final void mVOIDTOK() throws RecognitionException {
-        int _type = VOIDTOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("void", _type, _channel);
+        try {
+            int _type = VOIDTOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:39:18: ( 'void' )
+            // CTFLexer.g:39:20: 'void'
+            {
+                match("void");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "VOIDTOK"
 
     // $ANTLR start "BOOLTOK"
     public final void mBOOLTOK() throws RecognitionException {
-        int _type = BOOLTOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("_Bool", _type, _channel);
+        try {
+            int _type = BOOLTOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:40:18: ( '_Bool' )
+            // CTFLexer.g:40:20: '_Bool'
+            {
+                match("_Bool");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "BOOLTOK"
 
     // $ANTLR start "COMPLEXTOK"
     public final void mCOMPLEXTOK() throws RecognitionException {
-        int _type = COMPLEXTOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("_Complex", _type, _channel);
+        try {
+            int _type = COMPLEXTOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:41:18: ( '_Complex' )
+            // CTFLexer.g:41:20: '_Complex'
+            {
+                match("_Complex");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "COMPLEXTOK"
 
     // $ANTLR start "IMAGINARYTOK"
     public final void mIMAGINARYTOK() throws RecognitionException {
-        int _type = IMAGINARYTOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("_Imaginary", _type, _channel);
+        try {
+            int _type = IMAGINARYTOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:42:18: ( '_Imaginary' )
+            // CTFLexer.g:42:20: '_Imaginary'
+            {
+                match("_Imaginary");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "IMAGINARYTOK"
 
     // $ANTLR start "ENVTOK"
     public final void mENVTOK() throws RecognitionException {
-        int _type = ENVTOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("env", _type, _channel);
+        try {
+            int _type = ENVTOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:43:18: ( 'env' )
+            // CTFLexer.g:43:20: 'env'
+            {
+                match("env");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "ENVTOK"
 
     // $ANTLR start "CLOCKTOK"
     public final void mCLOCKTOK() throws RecognitionException {
-        int _type = CLOCKTOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("clock", _type, _channel);
+        try {
+            int _type = CLOCKTOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:44:18: ( 'clock' )
+            // CTFLexer.g:44:20: 'clock'
+            {
+                match("clock");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "CLOCKTOK"
 
+    // $ANTLR start "CALLSITETOK"
+    public final void mCALLSITETOK() throws RecognitionException {
+        try {
+            int _type = CALLSITETOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:48:18: ( 'callsite' )
+            // CTFLexer.g:48:20: 'callsite'
+            {
+                match("callsite");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
+    }
+
+    // $ANTLR end "CALLSITETOK"
+
     // $ANTLR start "NANNUMBERTOK"
     public final void mNANNUMBERTOK() throws RecognitionException {
-        int _type = NANNUMBERTOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("NaN", _type, _channel);
+        try {
+            int _type = NANNUMBERTOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:54:15: ( 'NaN' )
+            // CTFLexer.g:54:17: 'NaN'
+            {
+                match("NaN");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "NANNUMBERTOK"
 
     // $ANTLR start "INFINITYTOK"
     public final void mINFINITYTOK() throws RecognitionException {
-        int _type = INFINITYTOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("+inf", _type, _channel);
+        try {
+            int _type = INFINITYTOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:55:15: ( '+inf' )
+            // CTFLexer.g:55:17: '+inf'
+            {
+                match("+inf");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "INFINITYTOK"
 
     // $ANTLR start "NINFINITYTOK"
     public final void mNINFINITYTOK() throws RecognitionException {
-        int _type = NINFINITYTOK;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("-inf", _type, _channel);
+        try {
+            int _type = NINFINITYTOK;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:56:15: ( '-inf' )
+            // CTFLexer.g:56:17: '-inf'
+            {
+                match("-inf");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "NINFINITYTOK"
 
     // $ANTLR start "SEPARATOR"
     public final void mSEPARATOR() throws RecognitionException {
-        int _type = SEPARATOR;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match(',', _type, _channel);
+        try {
+            int _type = SEPARATOR;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:61:20: ( ',' )
+            // CTFLexer.g:61:22: ','
+            {
+                match(',');
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "SEPARATOR"
 
     // $ANTLR start "COLON"
     public final void mCOLON() throws RecognitionException {
-        int _type = COLON;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match(':', _type, _channel);
+        try {
+            int _type = COLON;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:62:20: ( ':' )
+            // CTFLexer.g:62:22: ':'
+            {
+                match(':');
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "COLON"
 
     // $ANTLR start "ELIPSES"
     public final void mELIPSES() throws RecognitionException {
-        int _type = ELIPSES;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("...", _type, _channel);
+        try {
+            int _type = ELIPSES;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:63:20: ( '...' )
+            // CTFLexer.g:63:22: '...'
+            {
+                match("...");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "ELIPSES"
 
     // $ANTLR start "ASSIGNMENT"
     public final void mASSIGNMENT() throws RecognitionException {
-        int _type = ASSIGNMENT;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match('=', _type, _channel);
+        try {
+            int _type = ASSIGNMENT;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:64:20: ( '=' )
+            // CTFLexer.g:64:22: '='
+            {
+                match('=');
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "ASSIGNMENT"
 
     // $ANTLR start "TYPE_ASSIGNMENT"
     public final void mTYPE_ASSIGNMENT() throws RecognitionException {
-        int _type = TYPE_ASSIGNMENT;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match(":=", _type, _channel);
+        try {
+            int _type = TYPE_ASSIGNMENT;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:65:20: ( ':=' )
+            // CTFLexer.g:65:22: ':='
+            {
+                match(":=");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "TYPE_ASSIGNMENT"
 
     // $ANTLR start "LT"
     public final void mLT() throws RecognitionException {
-        int _type = LT;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match('<', _type, _channel);
+        try {
+            int _type = LT;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:66:20: ( '<' )
+            // CTFLexer.g:66:22: '<'
+            {
+                match('<');
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "LT"
 
     // $ANTLR start "GT"
     public final void mGT() throws RecognitionException {
-        int _type = GT;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match('>', _type, _channel);
+        try {
+            int _type = GT;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:67:20: ( '>' )
+            // CTFLexer.g:67:22: '>'
+            {
+                match('>');
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "GT"
 
     // $ANTLR start "OPENBRAC"
     public final void mOPENBRAC() throws RecognitionException {
-        int _type = OPENBRAC;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match('[', _type, _channel);
+        try {
+            int _type = OPENBRAC;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:68:20: ( '[' )
+            // CTFLexer.g:68:22: '['
+            {
+                match('[');
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "OPENBRAC"
 
     // $ANTLR start "CLOSEBRAC"
     public final void mCLOSEBRAC() throws RecognitionException {
-        int _type = CLOSEBRAC;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match(']', _type, _channel);
+        try {
+            int _type = CLOSEBRAC;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:69:20: ( ']' )
+            // CTFLexer.g:69:22: ']'
+            {
+                match(']');
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "CLOSEBRAC"
 
     // $ANTLR start "LPAREN"
     public final void mLPAREN() throws RecognitionException {
-        int _type = LPAREN;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match('(', _type, _channel);
+        try {
+            int _type = LPAREN;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:70:20: ( '(' )
+            // CTFLexer.g:70:22: '('
+            {
+                match('(');
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "LPAREN"
 
     // $ANTLR start "RPAREN"
     public final void mRPAREN() throws RecognitionException {
-        int _type = RPAREN;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match(')', _type, _channel);
+        try {
+            int _type = RPAREN;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:71:20: ( ')' )
+            // CTFLexer.g:71:22: ')'
+            {
+                match(')');
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "RPAREN"
 
     // $ANTLR start "LCURL"
     public final void mLCURL() throws RecognitionException {
-        int _type = LCURL;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match('{', _type, _channel);
+        try {
+            int _type = LCURL;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:72:20: ( '{' )
+            // CTFLexer.g:72:22: '{'
+            {
+                match('{');
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "LCURL"
 
     // $ANTLR start "RCURL"
     public final void mRCURL() throws RecognitionException {
-        int _type = RCURL;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match('}', _type, _channel);
+        try {
+            int _type = RCURL;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:73:20: ( '}' )
+            // CTFLexer.g:73:22: '}'
+            {
+                match('}');
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "RCURL"
 
     // $ANTLR start "TERM"
     public final void mTERM() throws RecognitionException {
-        int _type = TERM;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match(';', _type, _channel);
+        try {
+            int _type = TERM;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:74:20: ( ';' )
+            // CTFLexer.g:74:22: ';'
+            {
+                match(';');
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "TERM"
 
     // $ANTLR start "POINTER"
     public final void mPOINTER() throws RecognitionException {
-        int _type = POINTER;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match('*', _type, _channel);
-    }
-
-    /**
-     * @param matchable
-     * @param _type
-     * @param _channel
-     * @throws MismatchedTokenException
-     */
-    private void match(String matchable, int _type, int _channel)
-            throws MismatchedTokenException {
-        match(matchable);
-        setState(_type, _channel);
-    }
-
-    /**
-     * @param matchable
-     * @param _type
-     * @param _channel
-     * @throws MismatchedTokenException
-     */
-    private void match(char matchable, int _type, int _channel)
-            throws MismatchedTokenException {
-        match(matchable);
-        setState(_type, _channel);
-    }
-
-    /**
-     * @param _type
-     * @param _channel
-     */
-    private void setState(int _type, int _channel) {
-        state.type = _type;
-        state.channel = _channel;
+        try {
+            int _type = POINTER;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:75:20: ( '*' )
+            // CTFLexer.g:75:22: '*'
+            {
+                match('*');
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "POINTER"
 
     // $ANTLR start "SIGN"
     public final void mSIGN() throws RecognitionException {
-        int _type = SIGN;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        // Grammar/CTFLexer.g:71:20: ( '+' | '-' )
-        // Grammar/CTFLexer.g:
-        {
-            if ((input.LA(1) == '+') || (input.LA(1) == '-')) {
-                input.consume();
+        try {
+            int _type = SIGN;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:76:20: ( '+' | '-' )
+            // CTFLexer.g:
+            {
+                if (input.LA(1) == '+' || input.LA(1) == '-') {
+                    input.consume();
+
+                } else {
+                    MismatchedSetException mse = new MismatchedSetException(
+                            null, input);
+                    recover(mse);
+                    throw mse;
+                }
 
-            } else {
-                MismatchedSetException mse = new MismatchedSetException(null,
-                        input);
-                recover(mse);
-                throw mse;
             }
 
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
         }
-
-        setState(_type, _channel);
     }
 
     // $ANTLR end "SIGN"
 
     // $ANTLR start "ARROW"
     public final void mARROW() throws RecognitionException {
-        int _type = ARROW;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match("->", _type, _channel);
+        try {
+            int _type = ARROW;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:77:20: ( '->' )
+            // CTFLexer.g:77:22: '->'
+            {
+                match("->");
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "ARROW"
 
     // $ANTLR start "DOT"
     public final void mDOT() throws RecognitionException {
-        int _type = DOT;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        match('.', _type, _channel);
-    }
+        try {
+            int _type = DOT;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:78:20: ( '.' )
+            // CTFLexer.g:78:22: '.'
+            {
+                match('.');
 
-    // $ANTLR end "DOT"
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
+    }
+
+    // $ANTLR end "DOT"
 
     // $ANTLR start "BACKSLASH"
     public final void mBACKSLASH() throws RecognitionException {
-        match('\\');
+        try {
+            // CTFLexer.g:79:20: ( '\\\\' )
+            // CTFLexer.g:79:22: '\\\\'
+            {
+                match('\\');
+
+            }
+
+        } finally {
+        }
     }
 
     // $ANTLR end "BACKSLASH"
 
     // $ANTLR start "OCTAL_LITERAL"
     public final void mOCTAL_LITERAL() throws RecognitionException {
-        int _type = OCTAL_LITERAL;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        {
-            match('0');
-            // Grammar/CTFLexer.g:89:21: ( '0' .. '7' )+
-            int cnt1 = 0;
-            loop1: do {
-                int alt1 = 2;
-                int LA1_0 = input.LA(1);
-
-                if ((((LA1_0 >= '0') && (LA1_0 <= '7')))) {
-                    alt1 = 1;
-                }
+        try {
+            int _type = OCTAL_LITERAL;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:94:15: ( '0' ( '0' .. '7' )+ ( INTEGER_TYPES_SUFFIX )?
+            // )
+            // CTFLexer.g:94:17: '0' ( '0' .. '7' )+ ( INTEGER_TYPES_SUFFIX )?
+            {
+                match('0');
+                // CTFLexer.g:94:21: ( '0' .. '7' )+
+                int cnt1 = 0;
+                loop1: do {
+                    int alt1 = 2;
+                    int LA1_0 = input.LA(1);
+
+                    if (((LA1_0 >= '0' && LA1_0 <= '7'))) {
+                        alt1 = 1;
+                    }
+
+                    switch (alt1) {
+                    case 1:
+                    // CTFLexer.g:94:22: '0' .. '7'
+                    {
+                        matchRange('0', '7');
+
+                    }
+                        break;
+
+                    default:
+                        if (cnt1 >= 1) {
+                            break loop1;
+                        }
+                        EarlyExitException eee = new EarlyExitException(1,
+                                input);
+                        throw eee;
+                    }
+                    cnt1++;
+                } while (true);
 
-                switch (alt1) {
+                // CTFLexer.g:94:33: ( INTEGER_TYPES_SUFFIX )?
+                int alt2 = 2;
+                int LA2_0 = input.LA(1);
+
+                if ((LA2_0 == 'L' || LA2_0 == 'U' || LA2_0 == 'l' || LA2_0 == 'u')) {
+                    alt2 = 1;
+                }
+                switch (alt2) {
                 case 1:
-                // Grammar/CTFLexer.g:89:22: '0' .. '7'
+                // CTFLexer.g:94:33: INTEGER_TYPES_SUFFIX
                 {
-                    matchRange('0', '7');
+                    mINTEGER_TYPES_SUFFIX();
 
                 }
                     break;
 
-                default:
-                    if (cnt1 >= 1) {
-                        break loop1;
-                    }
-                    EarlyExitException eee = new EarlyExitException(1, input);
-                    throw eee;
                 }
-                cnt1++;
-            } while (true);
-
-            // Grammar/CTFLexer.g:89:33: ( INTEGER_TYPES_SUFFIX )?
-            int alt2 = 2;
-            int LA2_0 = input.LA(1);
-
-            if (((LA2_0 == 'L') || (LA2_0 == 'U') || (LA2_0 == 'l') || (LA2_0 == 'u'))) {
-                alt2 = 1;
-            }
-            switch (alt2) {
-            case 1:
-            // Grammar/CTFLexer.g:89:33: INTEGER_TYPES_SUFFIX
-            {
-                mINTEGER_TYPES_SUFFIX();
-
-            }
-                break;
 
             }
 
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
         }
-
-        setState(_type, _channel);
     }
 
     // $ANTLR end "OCTAL_LITERAL"
 
     // $ANTLR start "DECIMAL_LITERAL"
     public final void mDECIMAL_LITERAL() throws RecognitionException {
-        int _type = DECIMAL_LITERAL;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        // Grammar/CTFLexer.g:91:17: ( ( DIGIT )+ ( INTEGER_TYPES_SUFFIX )?
-        // )
-        // Grammar/CTFLexer.g:91:19: ( DIGIT )+ ( INTEGER_TYPES_SUFFIX )?
-        {
-            // Grammar/CTFLexer.g:91:19: ( DIGIT )+
-            int cnt3 = 0;
-            loop3: do {
-                int alt3 = 2;
-                int LA3_0 = input.LA(1);
-
-                if ((((LA3_0 >= '0') && (LA3_0 <= '9')))) {
-                    alt3 = 1;
-                }
+        try {
+            int _type = DECIMAL_LITERAL;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:96:17: ( ( DIGIT )+ ( INTEGER_TYPES_SUFFIX )? )
+            // CTFLexer.g:96:19: ( DIGIT )+ ( INTEGER_TYPES_SUFFIX )?
+            {
+                // CTFLexer.g:96:19: ( DIGIT )+
+                int cnt3 = 0;
+                loop3: do {
+                    int alt3 = 2;
+                    int LA3_0 = input.LA(1);
+
+                    if (((LA3_0 >= '0' && LA3_0 <= '9'))) {
+                        alt3 = 1;
+                    }
+
+                    switch (alt3) {
+                    case 1:
+                    // CTFLexer.g:96:19: DIGIT
+                    {
+                        mDIGIT();
+
+                    }
+                        break;
+
+                    default:
+                        if (cnt3 >= 1) {
+                            break loop3;
+                        }
+                        EarlyExitException eee = new EarlyExitException(3,
+                                input);
+                        throw eee;
+                    }
+                    cnt3++;
+                } while (true);
 
-                switch (alt3) {
+                // CTFLexer.g:96:26: ( INTEGER_TYPES_SUFFIX )?
+                int alt4 = 2;
+                int LA4_0 = input.LA(1);
+
+                if ((LA4_0 == 'L' || LA4_0 == 'U' || LA4_0 == 'l' || LA4_0 == 'u')) {
+                    alt4 = 1;
+                }
+                switch (alt4) {
                 case 1:
-                // Grammar/CTFLexer.g:91:19: DIGIT
+                // CTFLexer.g:96:26: INTEGER_TYPES_SUFFIX
                 {
-                    mDIGIT();
+                    mINTEGER_TYPES_SUFFIX();
 
                 }
                     break;
 
-                default:
-                    if (cnt3 >= 1) {
-                        break loop3;
-                    }
-                    EarlyExitException eee = new EarlyExitException(3, input);
-                    throw eee;
                 }
-                cnt3++;
-            } while (true);
-
-            // Grammar/CTFLexer.g:91:26: ( INTEGER_TYPES_SUFFIX )?
-            int alt4 = 2;
-            int LA4_0 = input.LA(1);
-
-            if (((LA4_0 == 'L') || (LA4_0 == 'U') || (LA4_0 == 'l') || (LA4_0 == 'u'))) {
-                alt4 = 1;
-            }
-            switch (alt4) {
-            case 1:
-            // Grammar/CTFLexer.g:91:26: INTEGER_TYPES_SUFFIX
-            {
-                mINTEGER_TYPES_SUFFIX();
-
-            }
-                break;
 
             }
 
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
         }
-
-        setState(_type, _channel);
     }
 
     // $ANTLR end "DECIMAL_LITERAL"
 
     // $ANTLR start "HEX_LITERAL"
     public final void mHEX_LITERAL() throws RecognitionException {
-        int _type = HEX_LITERAL;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        // Grammar/CTFLexer.g:93:13: ( HEX_PREFIX ( HEX_DIGIT )+ (
-        // INTEGER_TYPES_SUFFIX )? )
-        // Grammar/CTFLexer.g:93:15: HEX_PREFIX ( HEX_DIGIT )+ (
-        // INTEGER_TYPES_SUFFIX )?
-        {
-            mHEX_PREFIX();
-            // Grammar/CTFLexer.g:93:26: ( HEX_DIGIT )+
-            int cnt5 = 0;
-            loop5: do {
-                int alt5 = 2;
-                int LA5_0 = input.LA(1);
-
-                if ((((LA5_0 >= '0') && (LA5_0 <= '9'))
-                        || ((LA5_0 >= 'A') && (LA5_0 <= 'F')) || ((LA5_0 >= 'a') && (LA5_0 <= 'f')))) {
-                    alt5 = 1;
-                }
+        try {
+            int _type = HEX_LITERAL;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:98:13: ( HEX_PREFIX ( HEX_DIGIT )+ (
+            // INTEGER_TYPES_SUFFIX )? )
+            // CTFLexer.g:98:15: HEX_PREFIX ( HEX_DIGIT )+ (
+            // INTEGER_TYPES_SUFFIX )?
+            {
+                mHEX_PREFIX();
+                // CTFLexer.g:98:26: ( HEX_DIGIT )+
+                int cnt5 = 0;
+                loop5: do {
+                    int alt5 = 2;
+                    int LA5_0 = input.LA(1);
+
+                    if (((LA5_0 >= '0' && LA5_0 <= '9')
+                            || (LA5_0 >= 'A' && LA5_0 <= 'F') || (LA5_0 >= 'a' && LA5_0 <= 'f'))) {
+                        alt5 = 1;
+                    }
+
+                    switch (alt5) {
+                    case 1:
+                    // CTFLexer.g:98:26: HEX_DIGIT
+                    {
+                        mHEX_DIGIT();
+
+                    }
+                        break;
+
+                    default:
+                        if (cnt5 >= 1) {
+                            break loop5;
+                        }
+                        EarlyExitException eee = new EarlyExitException(5,
+                                input);
+                        throw eee;
+                    }
+                    cnt5++;
+                } while (true);
+
+                // CTFLexer.g:98:37: ( INTEGER_TYPES_SUFFIX )?
+                int alt6 = 2;
+                int LA6_0 = input.LA(1);
 
-                switch (alt5) {
+                if ((LA6_0 == 'L' || LA6_0 == 'U' || LA6_0 == 'l' || LA6_0 == 'u')) {
+                    alt6 = 1;
+                }
+                switch (alt6) {
                 case 1:
-                // Grammar/CTFLexer.g:93:26: HEX_DIGIT
+                // CTFLexer.g:98:37: INTEGER_TYPES_SUFFIX
                 {
-                    mHEX_DIGIT();
+                    mINTEGER_TYPES_SUFFIX();
 
                 }
                     break;
 
-                default:
-                    if (cnt5 >= 1) {
-                        break loop5;
-                    }
-                    EarlyExitException eee = new EarlyExitException(5, input);
-                    throw eee;
                 }
-                cnt5++;
-            } while (true);
-
-            // Grammar/CTFLexer.g:93:37: ( INTEGER_TYPES_SUFFIX )?
-            int alt6 = 2;
-            int LA6_0 = input.LA(1);
-
-            if (((LA6_0 == 'L') || (LA6_0 == 'U') || (LA6_0 == 'l') || (LA6_0 == 'u'))) {
-                alt6 = 1;
-            }
-            switch (alt6) {
-            case 1:
-            // Grammar/CTFLexer.g:93:37: INTEGER_TYPES_SUFFIX
-            {
-                mINTEGER_TYPES_SUFFIX();
-
-            }
-                break;
 
             }
 
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
         }
-
-        setState(_type, _channel);
     }
 
     // $ANTLR end "HEX_LITERAL"
 
     // $ANTLR start "HEX_DIGIT"
     public final void mHEX_DIGIT() throws RecognitionException {
-        int alt7 = 3;
-        switch (input.LA(1)) {
-        case '0':
-        case '1':
-        case '2':
-        case '3':
-        case '4':
-        case '5':
-        case '6':
-        case '7':
-        case '8':
-        case '9': {
-            alt7 = 1;
-        }
-            break;
-        case 'a':
-        case 'b':
-        case 'c':
-        case 'd':
-        case 'e':
-        case 'f': {
-            alt7 = 2;
-        }
-            break;
-        case 'A':
-        case 'B':
-        case 'C':
-        case 'D':
-        case 'E':
-        case 'F': {
-            alt7 = 3;
-        }
-            break;
-        default:
-            NoViableAltException nvae = new NoViableAltException("", 7, 0,
-                    input);
-
-            throw nvae;
-        }
+        try {
+            // CTFLexer.g:99:20: ( DIGIT | ( 'a' .. 'f' ) | ( 'A' .. 'F' ) )
+            int alt7 = 3;
+            switch (input.LA(1)) {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9': {
+                alt7 = 1;
+            }
+                break;
+            case 'a':
+            case 'b':
+            case 'c':
+            case 'd':
+            case 'e':
+            case 'f': {
+                alt7 = 2;
+            }
+                break;
+            case 'A':
+            case 'B':
+            case 'C':
+            case 'D':
+            case 'E':
+            case 'F': {
+                alt7 = 3;
+            }
+                break;
+            default:
+                NoViableAltException nvae = new NoViableAltException("", 7, 0,
+                        input);
 
-        switch (alt7) {
-        case 1:
-        // Grammar/CTFLexer.g:94:22: DIGIT
-        {
-            mDIGIT();
+                throw nvae;
+            }
 
-        }
-            break;
-        case 2:
-        // Grammar/CTFLexer.g:94:30: ( 'a' .. 'f' )
-        {
-            // Grammar/CTFLexer.g:94:30: ( 'a' .. 'f' )
-            // Grammar/CTFLexer.g:94:31: 'a' .. 'f'
+            switch (alt7) {
+            case 1:
+            // CTFLexer.g:99:22: DIGIT
             {
-                matchRange('a', 'f');
+                mDIGIT();
 
             }
-
-        }
-            break;
-        case 3:
-        // Grammar/CTFLexer.g:94:43: ( 'A' .. 'F' )
-        {
-            // Grammar/CTFLexer.g:94:43: ( 'A' .. 'F' )
-            // Grammar/CTFLexer.g:94:44: 'A' .. 'F'
+                break;
+            case 2:
+            // CTFLexer.g:99:30: ( 'a' .. 'f' )
             {
-                matchRange('A', 'F');
+                // CTFLexer.g:99:30: ( 'a' .. 'f' )
+                // CTFLexer.g:99:31: 'a' .. 'f'
+                {
+                    matchRange('a', 'f');
+
+                }
 
             }
+                break;
+            case 3:
+            // CTFLexer.g:99:43: ( 'A' .. 'F' )
+            {
+                // CTFLexer.g:99:43: ( 'A' .. 'F' )
+                // CTFLexer.g:99:44: 'A' .. 'F'
+                {
+                    matchRange('A', 'F');
 
-        }
-            break;
+                }
 
+            }
+                break;
+
+            }
+        } finally {
         }
     }
 
@@ -875,116 +1406,133 @@ public class CTFLexer extends Lexer {
 
     // $ANTLR start "HEX_PREFIX"
     public final void mHEX_PREFIX() throws RecognitionException {
-        {
-            match('0');
-            if ((input.LA(1) == 'X') || (input.LA(1) == 'x')) {
-                input.consume();
+        try {
+            // CTFLexer.g:100:21: ( '0' ( 'x' | 'X' ) )
+            // CTFLexer.g:100:23: '0' ( 'x' | 'X' )
+            {
+                match('0');
+                if (input.LA(1) == 'X' || input.LA(1) == 'x') {
+                    input.consume();
+
+                } else {
+                    MismatchedSetException mse = new MismatchedSetException(
+                            null, input);
+                    recover(mse);
+                    throw mse;
+                }
 
-            } else {
-                MismatchedSetException mse = new MismatchedSetException(null,
-                        input);
-                recover(mse);
-                throw mse;
             }
 
+        } finally {
         }
-
     }
 
     // $ANTLR end "HEX_PREFIX"
 
     // $ANTLR start "DIGIT"
     public final void mDIGIT() throws RecognitionException {
-        // Grammar/CTFLexer.g:98:16: ( '0' .. '9' )
-        // Grammar/CTFLexer.g:98:18: '0' .. '9'
-        {
-            matchRange('0', '9');
+        try {
+            // CTFLexer.g:103:16: ( '0' .. '9' )
+            // CTFLexer.g:103:18: '0' .. '9'
+            {
+                matchRange('0', '9');
 
-        }
+            }
 
+        } finally {
+        }
     }
 
     // $ANTLR end "DIGIT"
 
     // $ANTLR start "NONZERO_DIGIT"
     public final void mNONZERO_DIGIT() throws RecognitionException {
-        // Grammar/CTFLexer.g:99:24: ( '1' .. '9' )
-        // Grammar/CTFLexer.g:99:26: '1' .. '9'
-        {
-            matchRange('1', '9');
+        try {
+            // CTFLexer.g:104:24: ( '1' .. '9' )
+            // CTFLexer.g:104:26: '1' .. '9'
+            {
+                matchRange('1', '9');
 
-        }
+            }
 
+        } finally {
+        }
     }
 
     // $ANTLR end "NONZERO_DIGIT"
 
     // $ANTLR start "INTEGER_TYPES_SUFFIX"
     public final void mINTEGER_TYPES_SUFFIX() throws RecognitionException {
-        // Grammar/CTFLexer.g:107:31: ( ( 'l' ( 'l' )? | 'L' ( 'L' )? ) | (
-        // 'u' | 'U' ) | ( 'u' | 'U' ) ( 'l' ( 'l' )? | 'L' ( 'L' )? ) | (
-        // 'l' ( 'l' )? | 'L' ( 'L' )? ) ( 'u' | 'U' ) )
-        int alt17 = 4;
-        alt17 = dfa17.predict(input);
-        switch (alt17) {
-        case 1:
-        // Grammar/CTFLexer.g:108:4: ( 'l' ( 'l' )? | 'L' ( 'L' )? )
-        {
-            // Grammar/CTFLexer.g:108:4: ( 'l' ( 'l' )? | 'L' ( 'L' )? )
-            int alt10 = 2;
-            int LA10_0 = input.LA(1);
-
-            if ((LA10_0 == 'l')) {
-                alt10 = 1;
-            } else if ((LA10_0 == 'L')) {
-                alt10 = 2;
-            } else {
-                NoViableAltException nvae = new NoViableAltException("", 10, 0,
-                        input);
-
-                throw nvae;
-            }
-            switch (alt10) {
+        try {
+            // CTFLexer.g:112:31: ( ( 'l' ( 'l' )? | 'L' ( 'L' )? ) | ( 'u' |
+            // 'U' ) | ( 'u' | 'U' ) ( 'l' ( 'l' )? | 'L' ( 'L' )? ) | ( 'l' (
+            // 'l' )? | 'L' ( 'L' )? ) ( 'u' | 'U' ) )
+            int alt17 = 4;
+            alt17 = dfa17.predict(input);
+            switch (alt17) {
             case 1:
-            // Grammar/CTFLexer.g:108:5: 'l' ( 'l' )?
+            // CTFLexer.g:113:4: ( 'l' ( 'l' )? | 'L' ( 'L' )? )
             {
-                match('l');
-                // Grammar/CTFLexer.g:108:9: ( 'l' )?
-                int alt8 = 2;
-                int LA8_0 = input.LA(1);
+                // CTFLexer.g:113:4: ( 'l' ( 'l' )? | 'L' ( 'L' )? )
+                int alt10 = 2;
+                int LA10_0 = input.LA(1);
+
+                if ((LA10_0 == 'l')) {
+                    alt10 = 1;
+                } else if ((LA10_0 == 'L')) {
+                    alt10 = 2;
+                } else {
+                    NoViableAltException nvae = new NoViableAltException("",
+                            10, 0, input);
 
-                if ((LA8_0 == 'l')) {
-                    alt8 = 1;
+                    throw nvae;
                 }
-                switch (alt8) {
+                switch (alt10) {
                 case 1:
-                // Grammar/CTFLexer.g:108:10: 'l'
+                // CTFLexer.g:113:5: 'l' ( 'l' )?
                 {
                     match('l');
+                    // CTFLexer.g:113:9: ( 'l' )?
+                    int alt8 = 2;
+                    int LA8_0 = input.LA(1);
 
-                }
-                    break;
+                    if ((LA8_0 == 'l')) {
+                        alt8 = 1;
+                    }
+                    switch (alt8) {
+                    case 1:
+                    // CTFLexer.g:113:10: 'l'
+                    {
+                        match('l');
 
-                }
+                    }
+                        break;
 
-            }
-                break;
-            case 2:
-            // Grammar/CTFLexer.g:108:18: 'L' ( 'L' )?
-            {
-                match('L');
-                // Grammar/CTFLexer.g:108:22: ( 'L' )?
-                int alt9 = 2;
-                int LA9_0 = input.LA(1);
+                    }
 
-                if ((LA9_0 == 'L')) {
-                    alt9 = 1;
                 }
-                switch (alt9) {
-                case 1:
-                // Grammar/CTFLexer.g:108:23: 'L'
+                    break;
+                case 2:
+                // CTFLexer.g:113:18: 'L' ( 'L' )?
                 {
                     match('L');
+                    // CTFLexer.g:113:22: ( 'L' )?
+                    int alt9 = 2;
+                    int LA9_0 = input.LA(1);
+
+                    if ((LA9_0 == 'L')) {
+                        alt9 = 1;
+                    }
+                    switch (alt9) {
+                    case 1:
+                    // CTFLexer.g:113:23: 'L'
+                    {
+                        match('L');
+
+                    }
+                        break;
+
+                    }
 
                 }
                     break;
@@ -993,95 +1541,94 @@ public class CTFLexer extends Lexer {
 
             }
                 break;
+            case 2:
+            // CTFLexer.g:114:4: ( 'u' | 'U' )
+            {
+                if (input.LA(1) == 'U' || input.LA(1) == 'u') {
+                    input.consume();
 
-            }
-
-        }
-            break;
-        case 2:
-        // Grammar/CTFLexer.g:109:4: ( 'u' | 'U' )
-        {
-            if ((input.LA(1) == 'U') || (input.LA(1) == 'u')) {
-                input.consume();
-
-            } else {
-                MismatchedSetException mse = new MismatchedSetException(null,
-                        input);
-                recover(mse);
-                throw mse;
-            }
-
-        }
-            break;
-        case 3:
-        // Grammar/CTFLexer.g:110:4: ( 'u' | 'U' ) ( 'l' ( 'l' )? | 'L' (
-        // 'L' )? )
-        {
-            if ((input.LA(1) == 'U') || (input.LA(1) == 'u')) {
-                input.consume();
+                } else {
+                    MismatchedSetException mse = new MismatchedSetException(
+                            null, input);
+                    recover(mse);
+                    throw mse;
+                }
 
-            } else {
-                MismatchedSetException mse = new MismatchedSetException(null,
-                        input);
-                recover(mse);
-                throw mse;
             }
+                break;
+            case 3:
+            // CTFLexer.g:115:4: ( 'u' | 'U' ) ( 'l' ( 'l' )? | 'L' ( 'L' )? )
+            {
+                if (input.LA(1) == 'U' || input.LA(1) == 'u') {
+                    input.consume();
 
-            // Grammar/CTFLexer.g:110:16: ( 'l' ( 'l' )? | 'L' ( 'L' )? )
-            int alt13 = 2;
-            int LA13_0 = input.LA(1);
+                } else {
+                    MismatchedSetException mse = new MismatchedSetException(
+                            null, input);
+                    recover(mse);
+                    throw mse;
+                }
 
-            if ((LA13_0 == 'l')) {
-                alt13 = 1;
-            } else if ((LA13_0 == 'L')) {
-                alt13 = 2;
-            } else {
-                NoViableAltException nvae = new NoViableAltException("", 13, 0,
-                        input);
+                // CTFLexer.g:115:16: ( 'l' ( 'l' )? | 'L' ( 'L' )? )
+                int alt13 = 2;
+                int LA13_0 = input.LA(1);
 
-                throw nvae;
-            }
-            switch (alt13) {
-            case 1:
-            // Grammar/CTFLexer.g:110:17: 'l' ( 'l' )?
-            {
-                match('l');
-                // Grammar/CTFLexer.g:110:21: ( 'l' )?
-                int alt11 = 2;
-                int LA11_0 = input.LA(1);
+                if ((LA13_0 == 'l')) {
+                    alt13 = 1;
+                } else if ((LA13_0 == 'L')) {
+                    alt13 = 2;
+                } else {
+                    NoViableAltException nvae = new NoViableAltException("",
+                            13, 0, input);
 
-                if ((LA11_0 == 'l')) {
-                    alt11 = 1;
+                    throw nvae;
                 }
-                switch (alt11) {
+                switch (alt13) {
                 case 1:
-                // Grammar/CTFLexer.g:110:22: 'l'
+                // CTFLexer.g:115:17: 'l' ( 'l' )?
                 {
                     match('l');
+                    // CTFLexer.g:115:21: ( 'l' )?
+                    int alt11 = 2;
+                    int LA11_0 = input.LA(1);
 
-                }
-                    break;
+                    if ((LA11_0 == 'l')) {
+                        alt11 = 1;
+                    }
+                    switch (alt11) {
+                    case 1:
+                    // CTFLexer.g:115:22: 'l'
+                    {
+                        match('l');
 
-                }
+                    }
+                        break;
 
-            }
-                break;
-            case 2:
-            // Grammar/CTFLexer.g:110:30: 'L' ( 'L' )?
-            {
-                match('L');
-                // Grammar/CTFLexer.g:110:34: ( 'L' )?
-                int alt12 = 2;
-                int LA12_0 = input.LA(1);
+                    }
 
-                if ((LA12_0 == 'L')) {
-                    alt12 = 1;
                 }
-                switch (alt12) {
-                case 1:
-                // Grammar/CTFLexer.g:110:35: 'L'
+                    break;
+                case 2:
+                // CTFLexer.g:115:30: 'L' ( 'L' )?
                 {
                     match('L');
+                    // CTFLexer.g:115:34: ( 'L' )?
+                    int alt12 = 2;
+                    int LA12_0 = input.LA(1);
+
+                    if ((LA12_0 == 'L')) {
+                        alt12 = 1;
+                    }
+                    switch (alt12) {
+                    case 1:
+                    // CTFLexer.g:115:35: 'L'
+                    {
+                        match('L');
+
+                    }
+                        break;
+
+                    }
 
                 }
                     break;
@@ -1090,94 +1637,90 @@ public class CTFLexer extends Lexer {
 
             }
                 break;
-
-            }
-
-        }
-            break;
-        case 4:
-        // Grammar/CTFLexer.g:111:4: ( 'l' ( 'l' )? | 'L' ( 'L' )? ) ( 'u' |
-        // 'U' )
-        {
-            // Grammar/CTFLexer.g:111:4: ( 'l' ( 'l' )? | 'L' ( 'L' )? )
-            int alt16 = 2;
-            int LA16_0 = input.LA(1);
-
-            if ((LA16_0 == 'l')) {
-                alt16 = 1;
-            } else if ((LA16_0 == 'L')) {
-                alt16 = 2;
-            } else {
-                NoViableAltException nvae = new NoViableAltException("", 16, 0,
-                        input);
-
-                throw nvae;
-            }
-            switch (alt16) {
-            case 1:
-            // Grammar/CTFLexer.g:111:5: 'l' ( 'l' )?
+            case 4:
+            // CTFLexer.g:116:4: ( 'l' ( 'l' )? | 'L' ( 'L' )? ) ( 'u' | 'U' )
             {
-                match('l');
-                // Grammar/CTFLexer.g:111:9: ( 'l' )?
-                int alt14 = 2;
-                int LA14_0 = input.LA(1);
+                // CTFLexer.g:116:4: ( 'l' ( 'l' )? | 'L' ( 'L' )? )
+                int alt16 = 2;
+                int LA16_0 = input.LA(1);
+
+                if ((LA16_0 == 'l')) {
+                    alt16 = 1;
+                } else if ((LA16_0 == 'L')) {
+                    alt16 = 2;
+                } else {
+                    NoViableAltException nvae = new NoViableAltException("",
+                            16, 0, input);
 
-                if ((LA14_0 == 'l')) {
-                    alt14 = 1;
+                    throw nvae;
                 }
-                switch (alt14) {
+                switch (alt16) {
                 case 1:
-                // Grammar/CTFLexer.g:111:10: 'l'
+                // CTFLexer.g:116:5: 'l' ( 'l' )?
                 {
                     match('l');
+                    // CTFLexer.g:116:9: ( 'l' )?
+                    int alt14 = 2;
+                    int LA14_0 = input.LA(1);
 
-                }
-                    break;
+                    if ((LA14_0 == 'l')) {
+                        alt14 = 1;
+                    }
+                    switch (alt14) {
+                    case 1:
+                    // CTFLexer.g:116:10: 'l'
+                    {
+                        match('l');
 
-                }
+                    }
+                        break;
 
-            }
-                break;
-            case 2:
-            // Grammar/CTFLexer.g:111:18: 'L' ( 'L' )?
-            {
-                match('L');
-                // Grammar/CTFLexer.g:111:22: ( 'L' )?
-                int alt15 = 2;
-                int LA15_0 = input.LA(1);
+                    }
 
-                if ((LA15_0 == 'L')) {
-                    alt15 = 1;
                 }
-                switch (alt15) {
-                case 1:
-                // Grammar/CTFLexer.g:111:23: 'L'
+                    break;
+                case 2:
+                // CTFLexer.g:116:18: 'L' ( 'L' )?
                 {
                     match('L');
+                    // CTFLexer.g:116:22: ( 'L' )?
+                    int alt15 = 2;
+                    int LA15_0 = input.LA(1);
+
+                    if ((LA15_0 == 'L')) {
+                        alt15 = 1;
+                    }
+                    switch (alt15) {
+                    case 1:
+                    // CTFLexer.g:116:23: 'L'
+                    {
+                        match('L');
+
+                    }
+                        break;
+
+                    }
 
                 }
                     break;
 
                 }
 
-            }
-                break;
-
-            }
+                if (input.LA(1) == 'U' || input.LA(1) == 'u') {
+                    input.consume();
 
-            if ((input.LA(1) == 'U') || (input.LA(1) == 'u')) {
-                input.consume();
+                } else {
+                    MismatchedSetException mse = new MismatchedSetException(
+                            null, input);
+                    recover(mse);
+                    throw mse;
+                }
 
-            } else {
-                MismatchedSetException mse = new MismatchedSetException(null,
-                        input);
-                recover(mse);
-                throw mse;
             }
+                break;
 
-        }
-            break;
-
+            }
+        } finally {
         }
     }
 
@@ -1185,106 +1728,109 @@ public class CTFLexer extends Lexer {
 
     // $ANTLR start "ESCAPE_SEQUENCE"
     public final void mESCAPE_SEQUENCE() throws RecognitionException {
-        // Grammar/CTFLexer.g:117:26: ( BACKSLASH ( '\\'' | '\"' | '?' |
-        // BACKSLASH | 'a' | 'b' | 'f' | 'n' | 'r' | 't' | 'v' ) |
-        // OCTAL_ESCAPE | UNICODE_ESCAPE | HEXADECIMAL_ESCAPE )
-        int alt18 = 4;
-        int LA18_0 = input.LA(1);
-
-        if ((LA18_0 == '\\')) {
-            switch (input.LA(2)) {
-            case 'U':
-            case 'u': {
-                alt18 = 3;
-            }
-                break;
-            case '0':
-            case '1':
-            case '2':
-            case '3':
-            case '4':
-            case '5':
-            case '6':
-            case '7': {
-                alt18 = 2;
-            }
-                break;
-            case 'x': {
-                alt18 = 4;
-            }
-                break;
-            case '\"':
-            case '\'':
-            case '?':
-            case '\\':
-            case 'a':
-            case 'b':
-            case 'f':
-            case 'n':
-            case 'r':
-            case 't':
-            case 'v': {
-                alt18 = 1;
-            }
-                break;
-            default:
-                NoViableAltException nvae = new NoViableAltException("", 18, 1,
+        try {
+            // CTFLexer.g:122:26: ( BACKSLASH ( '\\'' | '\"' | '?' | BACKSLASH |
+            // 'a' | 'b' | 'f' | 'n' | 'r' | 't' | 'v' ) | OCTAL_ESCAPE |
+            // UNICODE_ESCAPE | HEXADECIMAL_ESCAPE )
+            int alt18 = 4;
+            int LA18_0 = input.LA(1);
+
+            if ((LA18_0 == '\\')) {
+                switch (input.LA(2)) {
+                case 'x': {
+                    alt18 = 4;
+                }
+                    break;
+                case '0':
+                case '1':
+                case '2':
+                case '3':
+                case '4':
+                case '5':
+                case '6':
+                case '7': {
+                    alt18 = 2;
+                }
+                    break;
+                case '\"':
+                case '\'':
+                case '?':
+                case '\\':
+                case 'a':
+                case 'b':
+                case 'f':
+                case 'n':
+                case 'r':
+                case 't':
+                case 'v': {
+                    alt18 = 1;
+                }
+                    break;
+                case 'U':
+                case 'u': {
+                    alt18 = 3;
+                }
+                    break;
+                default:
+                    NoViableAltException nvae = new NoViableAltException("",
+                            18, 1, input);
+
+                    throw nvae;
+                }
+
+            } else {
+                NoViableAltException nvae = new NoViableAltException("", 18, 0,
                         input);
 
                 throw nvae;
             }
+            switch (alt18) {
+            case 1:
+            // CTFLexer.g:123:4: BACKSLASH ( '\\'' | '\"' | '?' | BACKSLASH |
+            // 'a' | 'b' | 'f' | 'n' | 'r' | 't' | 'v' )
+            {
+                mBACKSLASH();
+                if (input.LA(1) == '\"' || input.LA(1) == '\''
+                        || input.LA(1) == '?' || input.LA(1) == '\\'
+                        || (input.LA(1) >= 'a' && input.LA(1) <= 'b')
+                        || input.LA(1) == 'f' || input.LA(1) == 'n'
+                        || input.LA(1) == 'r' || input.LA(1) == 't'
+                        || input.LA(1) == 'v') {
+                    input.consume();
 
-        } else {
-            NoViableAltException nvae = new NoViableAltException("", 18, 0,
-                    input);
-
-            throw nvae;
-        }
-        switch (alt18) {
-        case 1:
-        // Grammar/CTFLexer.g:118:4: BACKSLASH ( '\\'' | '\"' | '?' |
-        // BACKSLASH | 'a' | 'b' | 'f' | 'n' | 'r' | 't' | 'v' )
-        {
-            mBACKSLASH();
-            if ((input.LA(1) == '\"') || (input.LA(1) == '\'')
-                    || (input.LA(1) == '?') || (input.LA(1) == '\\')
-                    || ((input.LA(1) >= 'a') && (input.LA(1) <= 'b'))
-                    || (input.LA(1) == 'f') || (input.LA(1) == 'n')
-                    || (input.LA(1) == 'r') || (input.LA(1) == 't')
-                    || (input.LA(1) == 'v')) {
-                input.consume();
+                } else {
+                    MismatchedSetException mse = new MismatchedSetException(
+                            null, input);
+                    recover(mse);
+                    throw mse;
+                }
 
-            } else {
-                MismatchedSetException mse = new MismatchedSetException(null,
-                        input);
-                recover(mse);
-                throw mse;
             }
+                break;
+            case 2:
+            // CTFLexer.g:124:4: OCTAL_ESCAPE
+            {
+                mOCTAL_ESCAPE();
 
-        }
-            break;
-        case 2:
-        // Grammar/CTFLexer.g:119:4: OCTAL_ESCAPE
-        {
-            mOCTAL_ESCAPE();
-
-        }
-            break;
-        case 3:
-        // Grammar/CTFLexer.g:120:4: UNICODE_ESCAPE
-        {
-            mUNICODE_ESCAPE();
+            }
+                break;
+            case 3:
+            // CTFLexer.g:125:4: UNICODE_ESCAPE
+            {
+                mUNICODE_ESCAPE();
 
-        }
-            break;
-        case 4:
-        // Grammar/CTFLexer.g:121:4: HEXADECIMAL_ESCAPE
-        {
-            mHEXADECIMAL_ESCAPE();
+            }
+                break;
+            case 4:
+            // CTFLexer.g:126:4: HEXADECIMAL_ESCAPE
+            {
+                mHEXADECIMAL_ESCAPE();
 
-        }
-            break;
+            }
+                break;
 
+            }
+        } finally {
         }
     }
 
@@ -1292,112 +1838,115 @@ public class CTFLexer extends Lexer {
 
     // $ANTLR start "OCTAL_ESCAPE"
     public final void mOCTAL_ESCAPE() throws RecognitionException {
-        // Grammar/CTFLexer.g:127:23: ( BACKSLASH ( '0' .. '3' ) ( '0' ..
-        // '7' ) ( '0' .. '7' ) | BACKSLASH ( '0' .. '7' ) ( '0' .. '7' ) |
-        // BACKSLASH ( '0' .. '7' ) )
-        int alt19 = 3;
-        int LA19_0 = input.LA(1);
-
-        if ((LA19_0 == '\\')) {
-            int LA19_1 = input.LA(2);
-
-            if ((((LA19_1 >= '0') && (LA19_1 <= '3')))) {
-                int LA19_2 = input.LA(3);
-
-                if ((((LA19_2 >= '0') && (LA19_2 <= '7')))) {
-                    int LA19_5 = input.LA(4);
-
-                    if ((((LA19_5 >= '0') && (LA19_5 <= '7')))) {
-                        alt19 = 1;
+        try {
+            // CTFLexer.g:132:23: ( BACKSLASH ( '0' .. '3' ) ( '0' .. '7' ) (
+            // '0' .. '7' ) | BACKSLASH ( '0' .. '7' ) ( '0' .. '7' ) |
+            // BACKSLASH ( '0' .. '7' ) )
+            int alt19 = 3;
+            int LA19_0 = input.LA(1);
+
+            if ((LA19_0 == '\\')) {
+                int LA19_1 = input.LA(2);
+
+                if (((LA19_1 >= '0' && LA19_1 <= '3'))) {
+                    int LA19_2 = input.LA(3);
+
+                    if (((LA19_2 >= '0' && LA19_2 <= '7'))) {
+                        int LA19_4 = input.LA(4);
+
+                        if (((LA19_4 >= '0' && LA19_4 <= '7'))) {
+                            alt19 = 1;
+                        } else {
+                            alt19 = 2;
+                        }
                     } else {
+                        alt19 = 3;
+                    }
+                } else if (((LA19_1 >= '4' && LA19_1 <= '7'))) {
+                    int LA19_3 = input.LA(3);
+
+                    if (((LA19_3 >= '0' && LA19_3 <= '7'))) {
                         alt19 = 2;
+                    } else {
+                        alt19 = 3;
                     }
                 } else {
-                    alt19 = 3;
-                }
-            } else if ((((LA19_1 >= '4') && (LA19_1 <= '7')))) {
-                int LA19_3 = input.LA(3);
+                    NoViableAltException nvae = new NoViableAltException("",
+                            19, 1, input);
 
-                if ((((LA19_3 >= '0') && (LA19_3 <= '7')))) {
-                    alt19 = 2;
-                } else {
-                    alt19 = 3;
+                    throw nvae;
                 }
             } else {
-                NoViableAltException nvae = new NoViableAltException("", 19, 1,
+                NoViableAltException nvae = new NoViableAltException("", 19, 0,
                         input);
 
                 throw nvae;
             }
-        } else {
-            NoViableAltException nvae = new NoViableAltException("", 19, 0,
-                    input);
-
-            throw nvae;
-        }
-        switch (alt19) {
-        case 1:
-        // Grammar/CTFLexer.g:128:5: BACKSLASH ( '0' .. '3' ) ( '0' .. '7' )
-        // ( '0' .. '7' )
-        {
-            mBACKSLASH();
-            // Grammar/CTFLexer.g:128:15: ( '0' .. '3' )
-            // Grammar/CTFLexer.g:128:16: '0' .. '3'
+            switch (alt19) {
+            case 1:
+            // CTFLexer.g:133:5: BACKSLASH ( '0' .. '3' ) ( '0' .. '7' ) ( '0'
+            // .. '7' )
             {
-                matchRange('0', '3');
+                mBACKSLASH();
+                // CTFLexer.g:133:15: ( '0' .. '3' )
+                // CTFLexer.g:133:16: '0' .. '3'
+                {
+                    matchRange('0', '3');
 
-            }
+                }
 
-            // Grammar/CTFLexer.g:128:26: ( '0' .. '7' )
-            // Grammar/CTFLexer.g:128:27: '0' .. '7'
-            {
-                matchRange('0', '7');
+                // CTFLexer.g:133:26: ( '0' .. '7' )
+                // CTFLexer.g:133:27: '0' .. '7'
+                {
+                    matchRange('0', '7');
 
-            }
+                }
 
-            // Grammar/CTFLexer.g:128:37: ( '0' .. '7' )
-            // Grammar/CTFLexer.g:128:38: '0' .. '7'
-            {
-                matchRange('0', '7');
+                // CTFLexer.g:133:37: ( '0' .. '7' )
+                // CTFLexer.g:133:38: '0' .. '7'
+                {
+                    matchRange('0', '7');
 
-            }
+                }
 
-        }
-            break;
-        case 2:
-        // Grammar/CTFLexer.g:129:5: BACKSLASH ( '0' .. '7' ) ( '0' .. '7' )
-        {
-            mBACKSLASH();
-            // Grammar/CTFLexer.g:129:15: ( '0' .. '7' )
-            // Grammar/CTFLexer.g:129:16: '0' .. '7'
+            }
+                break;
+            case 2:
+            // CTFLexer.g:134:5: BACKSLASH ( '0' .. '7' ) ( '0' .. '7' )
             {
-                matchRange('0', '7');
+                mBACKSLASH();
+                // CTFLexer.g:134:15: ( '0' .. '7' )
+                // CTFLexer.g:134:16: '0' .. '7'
+                {
+                    matchRange('0', '7');
 
-            }
+                }
 
-            // Grammar/CTFLexer.g:129:26: ( '0' .. '7' )
-            // Grammar/CTFLexer.g:129:27: '0' .. '7'
-            {
-                matchRange('0', '7');
+                // CTFLexer.g:134:26: ( '0' .. '7' )
+                // CTFLexer.g:134:27: '0' .. '7'
+                {
+                    matchRange('0', '7');
 
-            }
+                }
 
-        }
-            break;
-        case 3:
-        // Grammar/CTFLexer.g:130:5: BACKSLASH ( '0' .. '7' )
-        {
-            mBACKSLASH();
-            // Grammar/CTFLexer.g:130:15: ( '0' .. '7' )
-            // Grammar/CTFLexer.g:130:16: '0' .. '7'
+            }
+                break;
+            case 3:
+            // CTFLexer.g:135:5: BACKSLASH ( '0' .. '7' )
             {
-                matchRange('0', '7');
+                mBACKSLASH();
+                // CTFLexer.g:135:15: ( '0' .. '7' )
+                // CTFLexer.g:135:16: '0' .. '7'
+                {
+                    matchRange('0', '7');
 
-            }
+                }
 
-        }
-            break;
+            }
+                break;
 
+            }
+        } finally {
         }
     }
 
@@ -1405,41 +1954,46 @@ public class CTFLexer extends Lexer {
 
     // $ANTLR start "HEXADECIMAL_ESCAPE"
     public final void mHEXADECIMAL_ESCAPE() throws RecognitionException {
-        // Grammar/CTFLexer.g:136:29: ( BACKSLASH 'x' ( HEX_DIGIT )+ )
-        // Grammar/CTFLexer.g:136:31: BACKSLASH 'x' ( HEX_DIGIT )+
-        {
-            mBACKSLASH();
-            match('x');
-            // Grammar/CTFLexer.g:136:45: ( HEX_DIGIT )+
-            int cnt20 = 0;
-            loop20: do {
-                int alt20 = 2;
-                int LA20_0 = input.LA(1);
-
-                if ((((LA20_0 >= '0') && (LA20_0 <= '9'))
-                        || ((LA20_0 >= 'A') && (LA20_0 <= 'F')) || ((LA20_0 >= 'a') && (LA20_0 <= 'f')))) {
-                    alt20 = 1;
-                }
-
-                switch (alt20) {
-                case 1:
-                // Grammar/CTFLexer.g:136:45: HEX_DIGIT
-                {
-                    mHEX_DIGIT();
+        try {
+            // CTFLexer.g:141:29: ( BACKSLASH 'x' ( HEX_DIGIT )+ )
+            // CTFLexer.g:141:31: BACKSLASH 'x' ( HEX_DIGIT )+
+            {
+                mBACKSLASH();
+                match('x');
+                // CTFLexer.g:141:45: ( HEX_DIGIT )+
+                int cnt20 = 0;
+                loop20: do {
+                    int alt20 = 2;
+                    int LA20_0 = input.LA(1);
+
+                    if (((LA20_0 >= '0' && LA20_0 <= '9')
+                            || (LA20_0 >= 'A' && LA20_0 <= 'F') || (LA20_0 >= 'a' && LA20_0 <= 'f'))) {
+                        alt20 = 1;
+                    }
 
-                }
-                    break;
+                    switch (alt20) {
+                    case 1:
+                    // CTFLexer.g:141:45: HEX_DIGIT
+                    {
+                        mHEX_DIGIT();
 
-                default:
-                    if (cnt20 >= 1) {
-                        break loop20;
                     }
-                    EarlyExitException eee = new EarlyExitException(20, input);
-                    throw eee;
-                }
-                cnt20++;
-            } while (true);
+                        break;
+
+                    default:
+                        if (cnt20 >= 1) {
+                            break loop20;
+                        }
+                        EarlyExitException eee = new EarlyExitException(20,
+                                input);
+                        throw eee;
+                    }
+                    cnt20++;
+                } while (true);
+
+            }
 
+        } finally {
         }
     }
 
@@ -1447,62 +2001,66 @@ public class CTFLexer extends Lexer {
 
     // $ANTLR start "UNICODE_ESCAPE"
     public final void mUNICODE_ESCAPE() throws RecognitionException {
-        // Grammar/CTFLexer.g:141:25: ( BACKSLASH 'u' HEX_DIGIT HEX_DIGIT
-        // HEX_DIGIT HEX_DIGIT | BACKSLASH 'U' HEX_DIGIT HEX_DIGIT HEX_DIGIT
-        // HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT )
-        int alt21 = 2;
-        int LA21_0 = input.LA(1);
-
-        if ((LA21_0 == '\\')) {
-            int LA21_1 = input.LA(2);
-
-            if ((LA21_1 == 'u')) {
-                alt21 = 1;
-            } else if ((LA21_1 == 'U')) {
-                alt21 = 2;
+        try {
+            // CTFLexer.g:146:25: ( BACKSLASH 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT
+            // HEX_DIGIT | BACKSLASH 'U' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT
+            // HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT )
+            int alt21 = 2;
+            int LA21_0 = input.LA(1);
+
+            if ((LA21_0 == '\\')) {
+                int LA21_1 = input.LA(2);
+
+                if ((LA21_1 == 'U')) {
+                    alt21 = 2;
+                } else if ((LA21_1 == 'u')) {
+                    alt21 = 1;
+                } else {
+                    NoViableAltException nvae = new NoViableAltException("",
+                            21, 1, input);
+
+                    throw nvae;
+                }
             } else {
-                NoViableAltException nvae = new NoViableAltException("", 21, 1,
+                NoViableAltException nvae = new NoViableAltException("", 21, 0,
                         input);
 
                 throw nvae;
             }
-        } else {
-            NoViableAltException nvae = new NoViableAltException("", 21, 0,
-                    input);
+            switch (alt21) {
+            case 1:
+            // CTFLexer.g:147:5: BACKSLASH 'u' HEX_DIGIT HEX_DIGIT HEX_DIGIT
+            // HEX_DIGIT
+            {
+                mBACKSLASH();
+                match('u');
+                mHEX_DIGIT();
+                mHEX_DIGIT();
+                mHEX_DIGIT();
+                mHEX_DIGIT();
 
-            throw nvae;
-        }
-        switch (alt21) {
-        case 1:
-        // Grammar/CTFLexer.g:142:5: BACKSLASH 'u' HEX_DIGIT HEX_DIGIT
-        // HEX_DIGIT HEX_DIGIT
-        {
-            mBACKSLASH();
-            match('u');
-            mHEX_DIGIT();
-            mHEX_DIGIT();
-            mHEX_DIGIT();
-            mHEX_DIGIT();
+            }
+                break;
+            case 2:
+            // CTFLexer.g:148:5: BACKSLASH 'U' HEX_DIGIT HEX_DIGIT HEX_DIGIT
+            // HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT
+            {
+                mBACKSLASH();
+                match('U');
+                mHEX_DIGIT();
+                mHEX_DIGIT();
+                mHEX_DIGIT();
+                mHEX_DIGIT();
+                mHEX_DIGIT();
+                mHEX_DIGIT();
+                mHEX_DIGIT();
+                mHEX_DIGIT();
 
-        }
-            break;
-        case 2:
-        // Grammar/CTFLexer.g:143:5: BACKSLASH 'U' HEX_DIGIT HEX_DIGIT
-        // HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT
-        {
-            mBACKSLASH();
-            match('U');
-            mHEX_DIGIT();
-            mHEX_DIGIT();
-            mHEX_DIGIT();
-            mHEX_DIGIT();
-            mHEX_DIGIT();
-            mHEX_DIGIT();
-            mHEX_DIGIT();
-            mHEX_DIGIT();
+            }
+                break;
 
-        }
-            break;
+            }
+        } finally {
         }
     }
 
@@ -1510,238 +2068,318 @@ public class CTFLexer extends Lexer {
 
     // $ANTLR start "STRINGPREFIX"
     public final void mSTRINGPREFIX() throws RecognitionException {
-        match('L');
+        try {
+            // CTFLexer.g:153:23: ( 'L' )
+            // CTFLexer.g:153:25: 'L'
+            {
+                match('L');
+
+            }
+
+        } finally {
+        }
     }
 
     // $ANTLR end "STRINGPREFIX"
 
     // $ANTLR start "CHARACTER_LITERAL"
     public final void mCHARACTER_LITERAL() throws RecognitionException {
-        int _type = CHARACTER_LITERAL;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        // Grammar/CTFLexer.g:153:19: ( ( STRINGPREFIX )? SINGLEQUOTE (
-        // CHAR_CONTENT )+ SINGLEQUOTE )
-        // Grammar/CTFLexer.g:153:21: ( STRINGPREFIX )? SINGLEQUOTE (
-        // CHAR_CONTENT )+ SINGLEQUOTE
-        {
-            // Grammar/CTFLexer.g:153:21: ( STRINGPREFIX )?
-            int alt22 = 2;
-            int LA22_0 = input.LA(1);
-
-            if ((LA22_0 == 'L')) {
-                alt22 = 1;
-            }
-            switch (alt22) {
-            case 1:
-            // Grammar/CTFLexer.g:153:21: STRINGPREFIX
+        try {
+            int _type = CHARACTER_LITERAL;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:158:19: ( ( STRINGPREFIX )? SINGLEQUOTE ( CHAR_CONTENT
+            // )+ SINGLEQUOTE )
+            // CTFLexer.g:158:21: ( STRINGPREFIX )? SINGLEQUOTE ( CHAR_CONTENT
+            // )+ SINGLEQUOTE
             {
-                mSTRINGPREFIX();
-
-            }
-                break;
-
-            }
-
-            mSINGLEQUOTE();
-            // Grammar/CTFLexer.g:153:47: ( CHAR_CONTENT )+
-            int cnt23 = 0;
-            loop23: do {
-                int alt23 = 2;
-                int LA23_0 = input.LA(1);
+                // CTFLexer.g:158:21: ( STRINGPREFIX )?
+                int alt22 = 2;
+                int LA22_0 = input.LA(1);
 
-                if ((((LA23_0 >= '\u0000') && (LA23_0 <= '&')) || ((LA23_0 >= '(') && (LA23_0 <= '\uFFFF')))) {
-                    alt23 = 1;
+                if ((LA22_0 == 'L')) {
+                    alt22 = 1;
                 }
-
-                switch (alt23) {
+                switch (alt22) {
                 case 1:
-                // Grammar/CTFLexer.g:153:47: CHAR_CONTENT
+                // CTFLexer.g:158:21: STRINGPREFIX
                 {
-                    mCHAR_CONTENT();
+                    mSTRINGPREFIX();
 
                 }
                     break;
 
-                default:
-                    if (cnt23 >= 1) {
-                        break loop23;
-                    }
-                    EarlyExitException eee = new EarlyExitException(23, input);
-                    throw eee;
                 }
-                cnt23++;
-            } while (true);
 
-            mSINGLEQUOTE();
+                mSINGLEQUOTE();
+                // CTFLexer.g:158:47: ( CHAR_CONTENT )+
+                int cnt23 = 0;
+                loop23: do {
+                    int alt23 = 2;
+                    int LA23_0 = input.LA(1);
 
-        }
+                    if (((LA23_0 >= '\u0000' && LA23_0 <= '&') || (LA23_0 >= '(' && LA23_0 <= '\uFFFF'))) {
+                        alt23 = 1;
+                    }
+
+                    switch (alt23) {
+                    case 1:
+                    // CTFLexer.g:158:47: CHAR_CONTENT
+                    {
+                        mCHAR_CONTENT();
+
+                    }
+                        break;
+
+                    default:
+                        if (cnt23 >= 1) {
+                            break loop23;
+                        }
+                        EarlyExitException eee = new EarlyExitException(23,
+                                input);
+                        throw eee;
+                    }
+                    cnt23++;
+                } while (true);
+
+                mSINGLEQUOTE();
 
-        setState(_type, _channel);
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "CHARACTER_LITERAL"
 
     // $ANTLR start "CHAR_CONTENT"
     public final void mCHAR_CONTENT() throws RecognitionException {
-        // Grammar/CTFLexer.g:154:23: ( ( ESCAPE_SEQUENCE | ~ ( BACKSLASH |
-        // SINGLEQUOTE ) ) )
-        // Grammar/CTFLexer.g:154:25: ( ESCAPE_SEQUENCE | ~ ( BACKSLASH |
-        // SINGLEQUOTE ) )
-        {
-            // Grammar/CTFLexer.g:154:25: ( ESCAPE_SEQUENCE | ~ ( BACKSLASH
-            // | SINGLEQUOTE ) )
-            int alt24 = 2;
-            int LA24_0 = input.LA(1);
-
-            if ((LA24_0 == '\\')) {
-                alt24 = 1;
-            } else if ((((LA24_0 >= '\u0000') && (LA24_0 <= '&'))
-                    || ((LA24_0 >= '(') && (LA24_0 <= '[')) || ((LA24_0 >= ']') && (LA24_0 <= '\uFFFF')))) {
-                alt24 = 2;
-            } else {
-                NoViableAltException nvae = new NoViableAltException("", 24, 0,
-                        input);
-
-                throw nvae;
-            }
-            switch (alt24) {
-            case 1:
-            // Grammar/CTFLexer.g:154:26: ESCAPE_SEQUENCE
+        try {
+            // CTFLexer.g:159:23: ( ( ESCAPE_SEQUENCE | ~ ( BACKSLASH |
+            // SINGLEQUOTE ) ) )
+            // CTFLexer.g:159:25: ( ESCAPE_SEQUENCE | ~ ( BACKSLASH |
+            // SINGLEQUOTE ) )
             {
-                mESCAPE_SEQUENCE();
+                // CTFLexer.g:159:25: ( ESCAPE_SEQUENCE | ~ ( BACKSLASH |
+                // SINGLEQUOTE ) )
+                int alt24 = 2;
+                int LA24_0 = input.LA(1);
+
+                if ((LA24_0 == '\\')) {
+                    alt24 = 1;
+                } else if (((LA24_0 >= '\u0000' && LA24_0 <= '&')
+                        || (LA24_0 >= '(' && LA24_0 <= '[') || (LA24_0 >= ']' && LA24_0 <= '\uFFFF'))) {
+                    alt24 = 2;
+                } else {
+                    NoViableAltException nvae = new NoViableAltException("",
+                            24, 0, input);
 
-            }
-                break;
-            case 2:
-            // Grammar/CTFLexer.g:154:44: ~ ( BACKSLASH | SINGLEQUOTE )
-            {
-                if (((input.LA(1) >= '\u0000') && (input.LA(1) <= '&'))
-                        || ((input.LA(1) >= '(') && (input.LA(1) <= '['))
-                        || ((input.LA(1) >= ']') && (input.LA(1) <= '\uFFFF'))) {
-                    input.consume();
+                    throw nvae;
+                }
+                switch (alt24) {
+                case 1:
+                // CTFLexer.g:159:26: ESCAPE_SEQUENCE
+                {
+                    mESCAPE_SEQUENCE();
 
-                } else {
-                    MismatchedSetException mse = new MismatchedSetException(
-                            null, input);
-                    recover(mse);
-                    throw mse;
                 }
+                    break;
+                case 2:
+                // CTFLexer.g:159:44: ~ ( BACKSLASH | SINGLEQUOTE )
+                {
+                    if ((input.LA(1) >= '\u0000' && input.LA(1) <= '&')
+                            || (input.LA(1) >= '(' && input.LA(1) <= '[')
+                            || (input.LA(1) >= ']' && input.LA(1) <= '\uFFFF')) {
+                        input.consume();
 
-            }
-                break;
+                    } else {
+                        MismatchedSetException mse = new MismatchedSetException(
+                                null, input);
+                        recover(mse);
+                        throw mse;
+                    }
+
+                }
+                    break;
+
+                }
 
             }
 
+        } finally {
         }
-
     }
 
     // $ANTLR end "CHAR_CONTENT"
 
     // $ANTLR start "SINGLEQUOTE"
     public final void mSINGLEQUOTE() throws RecognitionException {
-        match('\'');
+        try {
+            // CTFLexer.g:160:22: ( '\\'' )
+            // CTFLexer.g:160:24: '\\''
+            {
+                match('\'');
+
+            }
+
+        } finally {
+        }
     }
 
     // $ANTLR end "SINGLEQUOTE"
 
     // $ANTLR start "STRING_LITERAL"
     public final void mSTRING_LITERAL() throws RecognitionException {
-        int _type = STRING_LITERAL;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        // Grammar/CTFLexer.g:160:16: ( ( STRINGPREFIX )? DOUBLEQUOTE (
-        // STRING_CONTENT )* DOUBLEQUOTE )
-        // Grammar/CTFLexer.g:160:18: ( STRINGPREFIX )? DOUBLEQUOTE (
-        // STRING_CONTENT )* DOUBLEQUOTE
-        {
-            // Grammar/CTFLexer.g:160:18: ( STRINGPREFIX )?
-            int alt25 = 2;
-            int LA25_0 = input.LA(1);
-
-            if ((LA25_0 == 'L')) {
-                alt25 = 1;
-            }
-            switch (alt25) {
-            case 1:
-            // Grammar/CTFLexer.g:160:18: STRINGPREFIX
+        try {
+            int _type = STRING_LITERAL;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:165:16: ( ( STRINGPREFIX )? DOUBLEQUOTE (
+            // STRING_CONTENT )* DOUBLEQUOTE )
+            // CTFLexer.g:165:18: ( STRINGPREFIX )? DOUBLEQUOTE ( STRING_CONTENT
+            // )* DOUBLEQUOTE
             {
-                mSTRINGPREFIX();
+                // CTFLexer.g:165:18: ( STRINGPREFIX )?
+                int alt25 = 2;
+                int LA25_0 = input.LA(1);
 
-            }
-                break;
+                if ((LA25_0 == 'L')) {
+                    alt25 = 1;
+                }
+                switch (alt25) {
+                case 1:
+                // CTFLexer.g:165:18: STRINGPREFIX
+                {
+                    mSTRINGPREFIX();
+
+                }
+                    break;
+
+                }
+
+                mDOUBLEQUOTE();
+                // CTFLexer.g:165:44: ( STRING_CONTENT )*
+                loop26: do {
+                    int alt26 = 2;
+                    int LA26_0 = input.LA(1);
+
+                    if (((LA26_0 >= '\u0000' && LA26_0 <= '!') || (LA26_0 >= '#' && LA26_0 <= '\uFFFF'))) {
+                        alt26 = 1;
+                    }
+
+                    switch (alt26) {
+                    case 1:
+                    // CTFLexer.g:165:44: STRING_CONTENT
+                    {
+                        mSTRING_CONTENT();
+
+                    }
+                        break;
+
+                    default:
+                        break loop26;
+                    }
+                } while (true);
+
+                mDOUBLEQUOTE();
 
             }
 
-            mDOUBLEQUOTE();
-            // Grammar/CTFLexer.g:160:44: ( STRING_CONTENT )*
-            loop26: do {
-                int alt26 = 2;
-                int LA26_0 = input.LA(1);
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
+    }
+
+    // $ANTLR end "STRING_LITERAL"
 
-                if ((((LA26_0 >= '\u0000') && (LA26_0 <= '!')) || ((LA26_0 >= '#') && (LA26_0 <= '\uFFFF')))) {
-                    alt26 = 1;
-                }
+    // $ANTLR start "STRING_CONTENT"
+    public final void mSTRING_CONTENT() throws RecognitionException {
+        try {
+            // CTFLexer.g:166:25: ( ( ESCAPE_SEQUENCE | ~ ( BACKSLASH |
+            // DOUBLEQUOTE ) ) )
+            // CTFLexer.g:166:27: ( ESCAPE_SEQUENCE | ~ ( BACKSLASH |
+            // DOUBLEQUOTE ) )
+            {
+                // CTFLexer.g:166:27: ( ESCAPE_SEQUENCE | ~ ( BACKSLASH |
+                // DOUBLEQUOTE ) )
+                int alt27 = 2;
+                int LA27_0 = input.LA(1);
+
+                if ((LA27_0 == '\\')) {
+                    alt27 = 1;
+                } else if (((LA27_0 >= '\u0000' && LA27_0 <= '!')
+                        || (LA27_0 >= '#' && LA27_0 <= '[') || (LA27_0 >= ']' && LA27_0 <= '\uFFFF'))) {
+                    alt27 = 2;
+                } else {
+                    NoViableAltException nvae = new NoViableAltException("",
+                            27, 0, input);
 
-                switch (alt26) {
+                    throw nvae;
+                }
+                switch (alt27) {
                 case 1:
-                // Grammar/CTFLexer.g:160:44: STRING_CONTENT
+                // CTFLexer.g:166:28: ESCAPE_SEQUENCE
+                {
+                    mESCAPE_SEQUENCE();
+
+                }
+                    break;
+                case 2:
+                // CTFLexer.g:166:46: ~ ( BACKSLASH | DOUBLEQUOTE )
                 {
-                    mSTRING_CONTENT();
+                    if ((input.LA(1) >= '\u0000' && input.LA(1) <= '!')
+                            || (input.LA(1) >= '#' && input.LA(1) <= '[')
+                            || (input.LA(1) >= ']' && input.LA(1) <= '\uFFFF')) {
+                        input.consume();
+
+                    } else {
+                        MismatchedSetException mse = new MismatchedSetException(
+                                null, input);
+                        recover(mse);
+                        throw mse;
+                    }
 
                 }
                     break;
 
-                default:
-                    break loop26;
                 }
-            } while (true);
 
-            mDOUBLEQUOTE();
+            }
 
+        } finally {
         }
-
-        setState(_type, _channel);
     }
 
-    // $ANTLR end "STRING_LITERAL"
-
-    // $ANTLR start "STRING_CONTENT"
-    public final void mSTRING_CONTENT() throws RecognitionException {
-        // Grammar/CTFLexer.g:161:25: ( ( ESCAPE_SEQUENCE | ~ ( BACKSLASH |
-        // DOUBLEQUOTE ) ) )
-        // Grammar/CTFLexer.g:161:27: ( ESCAPE_SEQUENCE | ~ ( BACKSLASH |
-        // DOUBLEQUOTE ) )
-        {
-            // Grammar/CTFLexer.g:161:27: ( ESCAPE_SEQUENCE | ~ ( BACKSLASH
-            // | DOUBLEQUOTE ) )
-            int alt27 = 2;
-            int LA27_0 = input.LA(1);
-
-            if ((LA27_0 == '\\')) {
-                alt27 = 1;
-            } else if ((((LA27_0 >= '\u0000') && (LA27_0 <= '!'))
-                    || ((LA27_0 >= '#') && (LA27_0 <= '[')) || ((LA27_0 >= ']') && (LA27_0 <= '\uFFFF')))) {
-                alt27 = 2;
-            } else {
-                NoViableAltException nvae = new NoViableAltException("", 27, 0,
-                        input);
+    // $ANTLR end "STRING_CONTENT"
 
-                throw nvae;
-            }
-            switch (alt27) {
-            case 1:
-            // Grammar/CTFLexer.g:161:28: ESCAPE_SEQUENCE
+    // $ANTLR start "DOUBLEQUOTE"
+    public final void mDOUBLEQUOTE() throws RecognitionException {
+        try {
+            // CTFLexer.g:167:22: ( '\"' )
+            // CTFLexer.g:167:24: '\"'
             {
-                mESCAPE_SEQUENCE();
+                match('\"');
 
             }
-                break;
-            case 2:
-            // Grammar/CTFLexer.g:161:46: ~ ( BACKSLASH | DOUBLEQUOTE )
+
+        } finally {
+        }
+    }
+
+    // $ANTLR end "DOUBLEQUOTE"
+
+    // $ANTLR start "WS"
+    public final void mWS() throws RecognitionException {
+        try {
+            int _type = WS;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:172:4: ( ( ' ' | '\\r' | '\\t' | '\ ' | '\\n' ) )
+            // CTFLexer.g:172:6: ( ' ' | '\\r' | '\\t' | '\ ' | '\\n' )
             {
-                if (((input.LA(1) >= '\u0000') && (input.LA(1) <= '!'))
-                        || ((input.LA(1) >= '#') && (input.LA(1) <= '['))
-                        || ((input.LA(1) >= ']') && (input.LA(1) <= '\uFFFF'))) {
+                if ((input.LA(1) >= '\t' && input.LA(1) <= '\n')
+                        || (input.LA(1) >= '\f' && input.LA(1) <= '\r')
+                        || input.LA(1) == ' ') {
                     input.consume();
 
                 } else {
@@ -1751,350 +2389,346 @@ public class CTFLexer extends Lexer {
                     throw mse;
                 }
 
-            }
-                break;
-
-            }
-
-        }
-
-    }
-
-    // $ANTLR end "STRING_CONTENT"
-
-    // $ANTLR start "DOUBLEQUOTE"
-    public final void mDOUBLEQUOTE() throws RecognitionException {
-        match('\"');
-    }
-
-    // $ANTLR end "DOUBLEQUOTE"
-
-    // $ANTLR start "WS"
-    public final void mWS() throws RecognitionException {
-        int _type = WS;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        // Grammar/CTFLexer.g:167:4: ( ( ' ' | '\\r' | '\\t' | '\ ' | '\\n'
-        // ) )
-        // Grammar/CTFLexer.g:167:6: ( ' ' | '\\r' | '\\t' | '\ ' | '\\n' )
-        {
-            if (((input.LA(1) >= '\t') && (input.LA(1) <= '\n'))
-                    || ((input.LA(1) >= '\f') && (input.LA(1) <= '\r'))
-                    || (input.LA(1) == ' ')) {
-                input.consume();
+                _channel = HIDDEN;
 
-            } else {
-                MismatchedSetException mse = new MismatchedSetException(null,
-                        input);
-                recover(mse);
-                throw mse;
             }
 
-            _channel = HIDDEN;
-
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
         }
-
-        setState(_type, _channel);
     }
 
     // $ANTLR end "WS"
 
     // $ANTLR start "COMMENT"
     public final void mCOMMENT() throws RecognitionException {
-        int _type = COMMENT;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        // Grammar/CTFLexer.g:174:9: ( COMMENT_OPEN ( . )* COMMENT_CLOSE )
-        // Grammar/CTFLexer.g:174:11: COMMENT_OPEN ( . )* COMMENT_CLOSE
-        {
-            mCOMMENT_OPEN();
-            // Grammar/CTFLexer.g:174:24: ( . )*
-            loop28: do {
-                int alt28 = 2;
-                int LA28_0 = input.LA(1);
-
-                if ((LA28_0 == '*')) {
-                    int LA28_1 = input.LA(2);
-
-                    if ((LA28_1 == '/')) {
-                        alt28 = 2;
-                    } else if ((((LA28_1 >= '\u0000') && (LA28_1 <= '.')) || ((LA28_1 >= '0') && (LA28_1 <= '\uFFFF')))) {
+        try {
+            int _type = COMMENT;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:179:9: ( COMMENT_OPEN ( . )* COMMENT_CLOSE )
+            // CTFLexer.g:179:11: COMMENT_OPEN ( . )* COMMENT_CLOSE
+            {
+                mCOMMENT_OPEN();
+                // CTFLexer.g:179:24: ( . )*
+                loop28: do {
+                    int alt28 = 2;
+                    int LA28_0 = input.LA(1);
+
+                    if ((LA28_0 == '*')) {
+                        int LA28_1 = input.LA(2);
+
+                        if ((LA28_1 == '/')) {
+                            alt28 = 2;
+                        } else if (((LA28_1 >= '\u0000' && LA28_1 <= '.') || (LA28_1 >= '0' && LA28_1 <= '\uFFFF'))) {
+                            alt28 = 1;
+                        }
+
+                    } else if (((LA28_0 >= '\u0000' && LA28_0 <= ')') || (LA28_0 >= '+' && LA28_0 <= '\uFFFF'))) {
                         alt28 = 1;
                     }
 
-                } else if ((((LA28_0 >= '\u0000') && (LA28_0 <= ')')) || ((LA28_0 >= '+') && (LA28_0 <= '\uFFFF')))) {
-                    alt28 = 1;
-                }
+                    switch (alt28) {
+                    case 1:
+                    // CTFLexer.g:179:24: .
+                    {
+                        matchAny();
 
-                switch (alt28) {
-                case 1:
-                // Grammar/CTFLexer.g:174:24: .
-                {
-                    matchAny();
+                    }
+                        break;
 
-                }
-                    break;
+                    default:
+                        break loop28;
+                    }
+                } while (true);
 
-                default:
-                    break loop28;
-                }
-            } while (true);
+                mCOMMENT_CLOSE();
+                _channel = HIDDEN;
 
-            mCOMMENT_CLOSE();
-            _channel = HIDDEN;
+            }
 
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
         }
-
-        setState(_type, _channel);
     }
 
     // $ANTLR end "COMMENT"
 
     // $ANTLR start "COMMENT_OPEN"
     public final void mCOMMENT_OPEN() throws RecognitionException {
-        match("/*");
+        try {
+            // CTFLexer.g:180:23: ( '/*' )
+            // CTFLexer.g:180:25: '/*'
+            {
+                match("/*");
+
+            }
+
+        } finally {
+        }
     }
 
     // $ANTLR end "COMMENT_OPEN"
 
     // $ANTLR start "COMMENT_CLOSE"
     public final void mCOMMENT_CLOSE() throws RecognitionException {
-        match("*/");
+        try {
+            // CTFLexer.g:181:24: ( '*/' )
+            // CTFLexer.g:181:26: '*/'
+            {
+                match("*/");
+
+            }
+
+        } finally {
+        }
     }
 
     // $ANTLR end "COMMENT_CLOSE"
 
     // $ANTLR start "LINE_COMMENT"
     public final void mLINE_COMMENT() throws RecognitionException {
-        int _type = LINE_COMMENT;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        // Grammar/CTFLexer.g:181:14: ( '//' (~ ( '\\n' | '\\r' ) )* ( '\\r'
-        // )? '\\n' )
-        // Grammar/CTFLexer.g:181:16: '//' (~ ( '\\n' | '\\r' ) )* ( '\\r'
-        // )? '\\n'
-        {
-            match("//");
+        try {
+            int _type = LINE_COMMENT;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:186:14: ( '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )?
+            // '\\n' )
+            // CTFLexer.g:186:16: '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n'
+            {
+                match("//");
 
-            // Grammar/CTFLexer.g:181:21: (~ ( '\\n' | '\\r' ) )*
-            loop29: do {
-                int alt29 = 2;
-                int LA29_0 = input.LA(1);
+                // CTFLexer.g:186:21: (~ ( '\\n' | '\\r' ) )*
+                loop29: do {
+                    int alt29 = 2;
+                    int LA29_0 = input.LA(1);
 
-                if ((((LA29_0 >= '\u0000') && (LA29_0 <= '\t'))
-                        || ((LA29_0 >= '\u000B') && (LA29_0 <= '\f')) || ((LA29_0 >= '\u000E') && (LA29_0 <= '\uFFFF')))) {
-                    alt29 = 1;
-                }
+                    if (((LA29_0 >= '\u0000' && LA29_0 <= '\t')
+                            || (LA29_0 >= '\u000B' && LA29_0 <= '\f') || (LA29_0 >= '\u000E' && LA29_0 <= '\uFFFF'))) {
+                        alt29 = 1;
+                    }
 
-                switch (alt29) {
-                case 1:
-                // Grammar/CTFLexer.g:181:21: ~ ( '\\n' | '\\r' )
-                {
-                    if (((input.LA(1) >= '\u0000') && (input.LA(1) <= '\t'))
-                            || ((input.LA(1) >= '\u000B') && (input.LA(1) <= '\f'))
-                            || ((input.LA(1) >= '\u000E') && (input.LA(1) <= '\uFFFF'))) {
-                        input.consume();
+                    switch (alt29) {
+                    case 1:
+                    // CTFLexer.g:186:21: ~ ( '\\n' | '\\r' )
+                    {
+                        if ((input.LA(1) >= '\u0000' && input.LA(1) <= '\t')
+                                || (input.LA(1) >= '\u000B' && input.LA(1) <= '\f')
+                                || (input.LA(1) >= '\u000E' && input.LA(1) <= '\uFFFF')) {
+                            input.consume();
+
+                        } else {
+                            MismatchedSetException mse = new MismatchedSetException(
+                                    null, input);
+                            recover(mse);
+                            throw mse;
+                        }
 
-                    } else {
-                        MismatchedSetException mse = new MismatchedSetException(
-                                null, input);
-                        recover(mse);
-                        throw mse;
                     }
+                        break;
 
-                }
-                    break;
+                    default:
+                        break loop29;
+                    }
+                } while (true);
 
-                default:
-                    break loop29;
+                // CTFLexer.g:186:35: ( '\\r' )?
+                int alt30 = 2;
+                int LA30_0 = input.LA(1);
+
+                if ((LA30_0 == '\r')) {
+                    alt30 = 1;
                 }
-            } while (true);
+                switch (alt30) {
+                case 1:
+                // CTFLexer.g:186:35: '\\r'
+                {
+                    match('\r');
 
-            // Grammar/CTFLexer.g:181:35: ( '\\r' )?
-            int alt30 = 2;
-            int LA30_0 = input.LA(1);
+                }
+                    break;
 
-            if ((LA30_0 == '\r')) {
-                alt30 = 1;
-            }
-            switch (alt30) {
-            case 1:
-            // Grammar/CTFLexer.g:181:35: '\\r'
-            {
-                match('\r');
+                }
 
-            }
-                break;
+                match('\n');
+                _channel = HIDDEN;
 
             }
 
-            match('\n');
-            _channel = HIDDEN;
-
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
         }
-
-        setState(_type, _channel);
     }
 
     // $ANTLR end "LINE_COMMENT"
 
     // $ANTLR start "IDENTIFIER"
     public final void mIDENTIFIER() throws RecognitionException {
-        int _type = IDENTIFIER;
-        int _channel = DEFAULT_TOKEN_CHANNEL;
-        // Grammar/CTFLexer.g:186:12: ( NONDIGIT ( NONDIGIT | DIGIT )* )
-        // Grammar/CTFLexer.g:186:14: NONDIGIT ( NONDIGIT | DIGIT )*
-        {
-            mNONDIGIT();
-            // Grammar/CTFLexer.g:186:23: ( NONDIGIT | DIGIT )*
-            loop31: do {
-                int alt31 = 3;
-                int LA31_0 = input.LA(1);
-
-                if ((((LA31_0 >= 'A') && (LA31_0 <= 'Z')) || (LA31_0 == '_') || ((LA31_0 >= 'a') && (LA31_0 <= 'z')))) {
-                    alt31 = 1;
-                } else if ((((LA31_0 >= '0') && (LA31_0 <= '9')))) {
-                    alt31 = 2;
-                }
+        try {
+            int _type = IDENTIFIER;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // CTFLexer.g:191:12: ( NONDIGIT ( NONDIGIT | DIGIT )* )
+            // CTFLexer.g:191:14: NONDIGIT ( NONDIGIT | DIGIT )*
+            {
+                mNONDIGIT();
+                // CTFLexer.g:191:23: ( NONDIGIT | DIGIT )*
+                loop31: do {
+                    int alt31 = 3;
+                    int LA31_0 = input.LA(1);
+
+                    if (((LA31_0 >= 'A' && LA31_0 <= 'Z') || LA31_0 == '_' || (LA31_0 >= 'a' && LA31_0 <= 'z'))) {
+                        alt31 = 1;
+                    } else if (((LA31_0 >= '0' && LA31_0 <= '9'))) {
+                        alt31 = 2;
+                    }
 
-                switch (alt31) {
-                case 1:
-                // Grammar/CTFLexer.g:186:24: NONDIGIT
-                {
-                    mNONDIGIT();
+                    switch (alt31) {
+                    case 1:
+                    // CTFLexer.g:191:24: NONDIGIT
+                    {
+                        mNONDIGIT();
 
-                }
-                    break;
-                case 2:
-                // Grammar/CTFLexer.g:186:35: DIGIT
-                {
-                    mDIGIT();
+                    }
+                        break;
+                    case 2:
+                    // CTFLexer.g:191:35: DIGIT
+                    {
+                        mDIGIT();
 
-                }
-                    break;
+                    }
+                        break;
 
-                default:
-                    break loop31;
-                }
-            } while (true);
+                    default:
+                        break loop31;
+                    }
+                } while (true);
 
-        }
+            }
 
-        setState(_type, _channel);
+            state.type = _type;
+            state.channel = _channel;
+        } finally {
+        }
     }
 
     // $ANTLR end "IDENTIFIER"
 
     // $ANTLR start "NONDIGIT"
     public final void mNONDIGIT() throws RecognitionException {
-        // Grammar/CTFLexer.g:187:19: ( ( '_' ) | ( 'A' .. 'Z' ) | ( 'a' ..
-        // 'z' ) )
-        int alt32 = 3;
-        switch (input.LA(1)) {
-        case '_': {
-            alt32 = 1;
-        }
-            break;
-        case 'A':
-        case 'B':
-        case 'C':
-        case 'D':
-        case 'E':
-        case 'F':
-        case 'G':
-        case 'H':
-        case 'I':
-        case 'J':
-        case 'K':
-        case 'L':
-        case 'M':
-        case 'N':
-        case 'O':
-        case 'P':
-        case 'Q':
-        case 'R':
-        case 'S':
-        case 'T':
-        case 'U':
-        case 'V':
-        case 'W':
-        case 'X':
-        case 'Y':
-        case 'Z': {
-            alt32 = 2;
-        }
-            break;
-        case 'a':
-        case 'b':
-        case 'c':
-        case 'd':
-        case 'e':
-        case 'f':
-        case 'g':
-        case 'h':
-        case 'i':
-        case 'j':
-        case 'k':
-        case 'l':
-        case 'm':
-        case 'n':
-        case 'o':
-        case 'p':
-        case 'q':
-        case 'r':
-        case 's':
-        case 't':
-        case 'u':
-        case 'v':
-        case 'w':
-        case 'x':
-        case 'y':
-        case 'z': {
-            alt32 = 3;
-        }
-            break;
-        default:
-            NoViableAltException nvae = new NoViableAltException("", 32, 0,
-                    input);
+        try {
+            // CTFLexer.g:192:19: ( ( '_' ) | ( 'A' .. 'Z' ) | ( 'a' .. 'z' ) )
+            int alt32 = 3;
+            switch (input.LA(1)) {
+            case '_': {
+                alt32 = 1;
+            }
+                break;
+            case 'A':
+            case 'B':
+            case 'C':
+            case 'D':
+            case 'E':
+            case 'F':
+            case 'G':
+            case 'H':
+            case 'I':
+            case 'J':
+            case 'K':
+            case 'L':
+            case 'M':
+            case 'N':
+            case 'O':
+            case 'P':
+            case 'Q':
+            case 'R':
+            case 'S':
+            case 'T':
+            case 'U':
+            case 'V':
+            case 'W':
+            case 'X':
+            case 'Y':
+            case 'Z': {
+                alt32 = 2;
+            }
+                break;
+            case 'a':
+            case 'b':
+            case 'c':
+            case 'd':
+            case 'e':
+            case 'f':
+            case 'g':
+            case 'h':
+            case 'i':
+            case 'j':
+            case 'k':
+            case 'l':
+            case 'm':
+            case 'n':
+            case 'o':
+            case 'p':
+            case 'q':
+            case 'r':
+            case 's':
+            case 't':
+            case 'u':
+            case 'v':
+            case 'w':
+            case 'x':
+            case 'y':
+            case 'z': {
+                alt32 = 3;
+            }
+                break;
+            default:
+                NoViableAltException nvae = new NoViableAltException("", 32, 0,
+                        input);
 
-            throw nvae;
-        }
+                throw nvae;
+            }
 
-        switch (alt32) {
-        case 1:
-        // Grammar/CTFLexer.g:187:21: ( '_' )
-        {
-            // Grammar/CTFLexer.g:187:21: ( '_' )
-            // Grammar/CTFLexer.g:187:22: '_'
+            switch (alt32) {
+            case 1:
+            // CTFLexer.g:192:21: ( '_' )
             {
-                match('_');
+                // CTFLexer.g:192:21: ( '_' )
+                // CTFLexer.g:192:22: '_'
+                {
+                    match('_');
 
-            }
+                }
 
-        }
-            break;
-        case 2:
-        // Grammar/CTFLexer.g:187:29: ( 'A' .. 'Z' )
-        {
-            // Grammar/CTFLexer.g:187:29: ( 'A' .. 'Z' )
-            // Grammar/CTFLexer.g:187:30: 'A' .. 'Z'
+            }
+                break;
+            case 2:
+            // CTFLexer.g:192:29: ( 'A' .. 'Z' )
             {
-                matchRange('A', 'Z');
+                // CTFLexer.g:192:29: ( 'A' .. 'Z' )
+                // CTFLexer.g:192:30: 'A' .. 'Z'
+                {
+                    matchRange('A', 'Z');
 
-            }
+                }
 
-        }
-            break;
-        case 3:
-        // Grammar/CTFLexer.g:187:42: ( 'a' .. 'z' )
-        {
-            // Grammar/CTFLexer.g:187:42: ( 'a' .. 'z' )
-            // Grammar/CTFLexer.g:187:43: 'a' .. 'z'
+            }
+                break;
+            case 3:
+            // CTFLexer.g:192:42: ( 'a' .. 'z' )
             {
-                matchRange('a', 'z');
+                // CTFLexer.g:192:42: ( 'a' .. 'z' )
+                // CTFLexer.g:192:43: 'a' .. 'z'
+                {
+                    matchRange('a', 'z');
 
-            }
+                }
 
-        }
-            break;
+            }
+                break;
 
+            }
+        } finally {
         }
     }
 
@@ -2102,414 +2736,421 @@ public class CTFLexer extends Lexer {
 
     @Override
     public void mTokens() throws RecognitionException {
-        // Grammar/CTFLexer.g:1:8: ( ALIGNTOK | CONSTTOK | CHARTOK | DOUBLETOK |
-        // ENUMTOK | EVENTTOK | FLOATINGPOINTTOK | FLOATTOK | INTEGERTOK |
-        // INTTOK | LONGTOK | SHORTTOK | SIGNEDTOK | STREAMTOK | STRINGTOK |
-        // STRUCTTOK | TRACETOK | TYPEALIASTOK | TYPEDEFTOK | UNSIGNEDTOK |
-        // VARIANTTOK | VOIDTOK | BOOLTOK | COMPLEXTOK | IMAGINARYTOK | ENVTOK |
-        // CLOCKTOK | NANNUMBERTOK | INFINITYTOK | NINFINITYTOK | SEPARATOR |
+        // CTFLexer.g:1:8: ( ALIGNTOK | CONSTTOK | CHARTOK | DOUBLETOK | ENUMTOK
+        // | EVENTTOK | FLOATINGPOINTTOK | FLOATTOK | INTEGERTOK | INTTOK |
+        // LONGTOK | SHORTTOK | SIGNEDTOK | STREAMTOK | STRINGTOK | STRUCTTOK |
+        // TRACETOK | TYPEALIASTOK | TYPEDEFTOK | UNSIGNEDTOK | VARIANTTOK |
+        // VOIDTOK | BOOLTOK | COMPLEXTOK | IMAGINARYTOK | ENVTOK | CLOCKTOK |
+        // CALLSITETOK | NANNUMBERTOK | INFINITYTOK | NINFINITYTOK | SEPARATOR |
         // COLON | ELIPSES | ASSIGNMENT | TYPE_ASSIGNMENT | LT | GT | OPENBRAC |
         // CLOSEBRAC | LPAREN | RPAREN | LCURL | RCURL | TERM | POINTER | SIGN |
         // ARROW | DOT | OCTAL_LITERAL | DECIMAL_LITERAL | HEX_LITERAL |
         // CHARACTER_LITERAL | STRING_LITERAL | WS | COMMENT | LINE_COMMENT |
         // IDENTIFIER )
-        int alt33 = 57;
+        int alt33 = 58;
         alt33 = dfa33.predict(input);
         switch (alt33) {
         case 1:
-        // Grammar/CTFLexer.g:1:10: ALIGNTOK
+        // CTFLexer.g:1:10: ALIGNTOK
         {
             mALIGNTOK();
 
         }
             break;
         case 2:
-        // Grammar/CTFLexer.g:1:19: CONSTTOK
+        // CTFLexer.g:1:19: CONSTTOK
         {
             mCONSTTOK();
 
         }
             break;
         case 3:
-        // Grammar/CTFLexer.g:1:28: CHARTOK
+        // CTFLexer.g:1:28: CHARTOK
         {
             mCHARTOK();
 
         }
             break;
         case 4:
-        // Grammar/CTFLexer.g:1:36: DOUBLETOK
+        // CTFLexer.g:1:36: DOUBLETOK
         {
             mDOUBLETOK();
 
         }
             break;
         case 5:
-        // Grammar/CTFLexer.g:1:46: ENUMTOK
+        // CTFLexer.g:1:46: ENUMTOK
         {
             mENUMTOK();
 
         }
             break;
         case 6:
-        // Grammar/CTFLexer.g:1:54: EVENTTOK
+        // CTFLexer.g:1:54: EVENTTOK
         {
             mEVENTTOK();
 
         }
             break;
         case 7:
-        // Grammar/CTFLexer.g:1:63: FLOATINGPOINTTOK
+        // CTFLexer.g:1:63: FLOATINGPOINTTOK
         {
             mFLOATINGPOINTTOK();
 
         }
             break;
         case 8:
-        // Grammar/CTFLexer.g:1:80: FLOATTOK
+        // CTFLexer.g:1:80: FLOATTOK
         {
             mFLOATTOK();
 
         }
             break;
         case 9:
-        // Grammar/CTFLexer.g:1:89: INTEGERTOK
+        // CTFLexer.g:1:89: INTEGERTOK
         {
             mINTEGERTOK();
 
         }
             break;
         case 10:
-        // Grammar/CTFLexer.g:1:100: INTTOK
+        // CTFLexer.g:1:100: INTTOK
         {
             mINTTOK();
 
         }
             break;
         case 11:
-        // Grammar/CTFLexer.g:1:107: LONGTOK
+        // CTFLexer.g:1:107: LONGTOK
         {
             mLONGTOK();
 
         }
             break;
         case 12:
-        // Grammar/CTFLexer.g:1:115: SHORTTOK
+        // CTFLexer.g:1:115: SHORTTOK
         {
             mSHORTTOK();
 
         }
             break;
         case 13:
-        // Grammar/CTFLexer.g:1:124: SIGNEDTOK
+        // CTFLexer.g:1:124: SIGNEDTOK
         {
             mSIGNEDTOK();
 
         }
             break;
         case 14:
-        // Grammar/CTFLexer.g:1:134: STREAMTOK
+        // CTFLexer.g:1:134: STREAMTOK
         {
             mSTREAMTOK();
 
         }
             break;
         case 15:
-        // Grammar/CTFLexer.g:1:144: STRINGTOK
+        // CTFLexer.g:1:144: STRINGTOK
         {
             mSTRINGTOK();
 
         }
             break;
         case 16:
-        // Grammar/CTFLexer.g:1:154: STRUCTTOK
+        // CTFLexer.g:1:154: STRUCTTOK
         {
             mSTRUCTTOK();
 
         }
             break;
         case 17:
-        // Grammar/CTFLexer.g:1:164: TRACETOK
+        // CTFLexer.g:1:164: TRACETOK
         {
             mTRACETOK();
 
         }
             break;
         case 18:
-        // Grammar/CTFLexer.g:1:173: TYPEALIASTOK
+        // CTFLexer.g:1:173: TYPEALIASTOK
         {
             mTYPEALIASTOK();
 
         }
             break;
         case 19:
-        // Grammar/CTFLexer.g:1:186: TYPEDEFTOK
+        // CTFLexer.g:1:186: TYPEDEFTOK
         {
             mTYPEDEFTOK();
 
         }
             break;
         case 20:
-        // Grammar/CTFLexer.g:1:197: UNSIGNEDTOK
+        // CTFLexer.g:1:197: UNSIGNEDTOK
         {
             mUNSIGNEDTOK();
 
         }
             break;
         case 21:
-        // Grammar/CTFLexer.g:1:209: VARIANTTOK
+        // CTFLexer.g:1:209: VARIANTTOK
         {
             mVARIANTTOK();
 
         }
             break;
         case 22:
-        // Grammar/CTFLexer.g:1:220: VOIDTOK
+        // CTFLexer.g:1:220: VOIDTOK
         {
             mVOIDTOK();
 
         }
             break;
         case 23:
-        // Grammar/CTFLexer.g:1:228: BOOLTOK
+        // CTFLexer.g:1:228: BOOLTOK
         {
             mBOOLTOK();
 
         }
             break;
         case 24:
-        // Grammar/CTFLexer.g:1:236: COMPLEXTOK
+        // CTFLexer.g:1:236: COMPLEXTOK
         {
             mCOMPLEXTOK();
 
         }
             break;
         case 25:
-        // Grammar/CTFLexer.g:1:247: IMAGINARYTOK
+        // CTFLexer.g:1:247: IMAGINARYTOK
         {
             mIMAGINARYTOK();
 
         }
             break;
         case 26:
-        // Grammar/CTFLexer.g:1:260: ENVTOK
+        // CTFLexer.g:1:260: ENVTOK
         {
             mENVTOK();
 
         }
             break;
         case 27:
-        // Grammar/CTFLexer.g:1:267: CLOCKTOK
+        // CTFLexer.g:1:267: CLOCKTOK
         {
             mCLOCKTOK();
 
         }
             break;
         case 28:
-        // Grammar/CTFLexer.g:1:276: NANNUMBERTOK
+        // CTFLexer.g:1:276: CALLSITETOK
         {
-            mNANNUMBERTOK();
+            mCALLSITETOK();
 
         }
             break;
         case 29:
-        // Grammar/CTFLexer.g:1:289: INFINITYTOK
+        // CTFLexer.g:1:288: NANNUMBERTOK
         {
-            mINFINITYTOK();
+            mNANNUMBERTOK();
 
         }
             break;
         case 30:
-        // Grammar/CTFLexer.g:1:301: NINFINITYTOK
+        // CTFLexer.g:1:301: INFINITYTOK
         {
-            mNINFINITYTOK();
+            mINFINITYTOK();
 
         }
             break;
         case 31:
-        // Grammar/CTFLexer.g:1:314: SEPARATOR
+        // CTFLexer.g:1:313: NINFINITYTOK
         {
-            mSEPARATOR();
+            mNINFINITYTOK();
 
         }
             break;
         case 32:
-        // Grammar/CTFLexer.g:1:324: COLON
+        // CTFLexer.g:1:326: SEPARATOR
         {
-            mCOLON();
+            mSEPARATOR();
 
         }
             break;
         case 33:
-        // Grammar/CTFLexer.g:1:330: ELIPSES
+        // CTFLexer.g:1:336: COLON
         {
-            mELIPSES();
+            mCOLON();
 
         }
             break;
         case 34:
-        // Grammar/CTFLexer.g:1:338: ASSIGNMENT
+        // CTFLexer.g:1:342: ELIPSES
         {
-            mASSIGNMENT();
+            mELIPSES();
 
         }
             break;
         case 35:
-        // Grammar/CTFLexer.g:1:349: TYPE_ASSIGNMENT
+        // CTFLexer.g:1:350: ASSIGNMENT
         {
-            mTYPE_ASSIGNMENT();
+            mASSIGNMENT();
 
         }
             break;
         case 36:
-        // Grammar/CTFLexer.g:1:365: LT
+        // CTFLexer.g:1:361: TYPE_ASSIGNMENT
         {
-            mLT();
+            mTYPE_ASSIGNMENT();
 
         }
             break;
         case 37:
-        // Grammar/CTFLexer.g:1:368: GT
+        // CTFLexer.g:1:377: LT
         {
-            mGT();
+            mLT();
 
         }
             break;
         case 38:
-        // Grammar/CTFLexer.g:1:371: OPENBRAC
+        // CTFLexer.g:1:380: GT
         {
-            mOPENBRAC();
+            mGT();
 
         }
             break;
         case 39:
-        // Grammar/CTFLexer.g:1:380: CLOSEBRAC
+        // CTFLexer.g:1:383: OPENBRAC
         {
-            mCLOSEBRAC();
+            mOPENBRAC();
 
         }
             break;
         case 40:
-        // Grammar/CTFLexer.g:1:390: LPAREN
+        // CTFLexer.g:1:392: CLOSEBRAC
         {
-            mLPAREN();
+            mCLOSEBRAC();
 
         }
             break;
         case 41:
-        // Grammar/CTFLexer.g:1:397: RPAREN
+        // CTFLexer.g:1:402: LPAREN
         {
-            mRPAREN();
+            mLPAREN();
 
         }
             break;
         case 42:
-        // Grammar/CTFLexer.g:1:404: LCURL
+        // CTFLexer.g:1:409: RPAREN
         {
-            mLCURL();
+            mRPAREN();
 
         }
             break;
         case 43:
-        // Grammar/CTFLexer.g:1:410: RCURL
+        // CTFLexer.g:1:416: LCURL
         {
-            mRCURL();
+            mLCURL();
 
         }
             break;
         case 44:
-        // Grammar/CTFLexer.g:1:416: TERM
+        // CTFLexer.g:1:422: RCURL
         {
-            mTERM();
+            mRCURL();
 
         }
             break;
         case 45:
-        // Grammar/CTFLexer.g:1:421: POINTER
+        // CTFLexer.g:1:428: TERM
         {
-            mPOINTER();
+            mTERM();
 
         }
             break;
         case 46:
-        // Grammar/CTFLexer.g:1:429: SIGN
+        // CTFLexer.g:1:433: POINTER
         {
-            mSIGN();
+            mPOINTER();
 
         }
             break;
         case 47:
-        // Grammar/CTFLexer.g:1:434: ARROW
+        // CTFLexer.g:1:441: SIGN
         {
-            mARROW();
+            mSIGN();
 
         }
             break;
         case 48:
-        // Grammar/CTFLexer.g:1:440: DOT
+        // CTFLexer.g:1:446: ARROW
         {
-            mDOT();
+            mARROW();
 
         }
             break;
         case 49:
-        // Grammar/CTFLexer.g:1:444: OCTAL_LITERAL
+        // CTFLexer.g:1:452: DOT
         {
-            mOCTAL_LITERAL();
+            mDOT();
 
         }
             break;
         case 50:
-        // Grammar/CTFLexer.g:1:458: DECIMAL_LITERAL
+        // CTFLexer.g:1:456: OCTAL_LITERAL
         {
-            mDECIMAL_LITERAL();
+            mOCTAL_LITERAL();
 
         }
             break;
         case 51:
-        // Grammar/CTFLexer.g:1:474: HEX_LITERAL
+        // CTFLexer.g:1:470: DECIMAL_LITERAL
         {
-            mHEX_LITERAL();
+            mDECIMAL_LITERAL();
 
         }
             break;
         case 52:
-        // Grammar/CTFLexer.g:1:486: CHARACTER_LITERAL
+        // CTFLexer.g:1:486: HEX_LITERAL
         {
-            mCHARACTER_LITERAL();
+            mHEX_LITERAL();
 
         }
             break;
         case 53:
-        // Grammar/CTFLexer.g:1:504: STRING_LITERAL
+        // CTFLexer.g:1:498: CHARACTER_LITERAL
         {
-            mSTRING_LITERAL();
+            mCHARACTER_LITERAL();
 
         }
             break;
         case 54:
-        // Grammar/CTFLexer.g:1:519: WS
+        // CTFLexer.g:1:516: STRING_LITERAL
         {
-            mWS();
+            mSTRING_LITERAL();
 
         }
             break;
         case 55:
-        // Grammar/CTFLexer.g:1:522: COMMENT
+        // CTFLexer.g:1:531: WS
         {
-            mCOMMENT();
+            mWS();
 
         }
             break;
         case 56:
-        // Grammar/CTFLexer.g:1:530: LINE_COMMENT
+        // CTFLexer.g:1:534: COMMENT
         {
-            mLINE_COMMENT();
+            mCOMMENT();
 
         }
             break;
         case 57:
-        // Grammar/CTFLexer.g:1:543: IDENTIFIER
+        // CTFLexer.g:1:542: LINE_COMMENT
+        {
+            mLINE_COMMENT();
+
+        }
+            break;
+        case 58:
+        // CTFLexer.g:1:555: IDENTIFIER
         {
             mIDENTIFIER();
 
@@ -2522,27 +3163,24 @@ public class CTFLexer extends Lexer {
 
     protected DFA17 dfa17 = new DFA17(this);
     protected DFA33 dfa33 = new DFA33(this);
-    static final String DFA17_eotS = "\1\uffff\2\5\1\11\1\5\2\uffff\1\5\2\uffff";
+    static final String DFA17_eotS = "\1\uffff\2\6\1\11\1\6\2\uffff\1\6\2\uffff";
     static final String DFA17_eofS = "\12\uffff";
     static final String DFA17_minS = "\1\114\1\125\2\114\1\125\2\uffff\1\125\2\uffff";
     static final String DFA17_maxS = "\3\165\1\154\1\165\2\uffff\1\165\2\uffff";
-    static final String DFA17_acceptS = "\5\uffff\1\1\1\4\1\uffff\1\3\1\2";
+    static final String DFA17_acceptS = "\5\uffff\1\4\1\1\1\uffff\1\3\1\2";
     static final String DFA17_specialS = "\12\uffff}>";
     static final String[] DFA17_transitionS = {
             "\1\2\10\uffff\1\3\26\uffff\1\1\10\uffff\1\3",
-            "\1\6\26\uffff\1\4\10\uffff\1\6", "\1\7\10\uffff\1\6\37\uffff\1\6",
-            "\1\10\37\uffff\1\10", "\1\6\37\uffff\1\6", "", "",
-            "\1\6\37\uffff\1\6", "", "" };
+            "\1\5\26\uffff\1\4\10\uffff\1\5", "\1\7\10\uffff\1\5\37\uffff\1\5",
+            "\1\10\37\uffff\1\10", "\1\5\37\uffff\1\5", "", "",
+            "\1\5\37\uffff\1\5", "", "" };
 
     static final short[] DFA17_eot = DFA.unpackEncodedString(DFA17_eotS);
     static final short[] DFA17_eof = DFA.unpackEncodedString(DFA17_eofS);
-    static final char[] DFA17_min = DFA
-            .unpackEncodedStringToUnsignedChars(DFA17_minS);
-    static final char[] DFA17_max = DFA
-            .unpackEncodedStringToUnsignedChars(DFA17_maxS);
+    static final char[] DFA17_min = DFA.unpackEncodedStringToUnsignedChars(DFA17_minS);
+    static final char[] DFA17_max = DFA.unpackEncodedStringToUnsignedChars(DFA17_maxS);
     static final short[] DFA17_accept = DFA.unpackEncodedString(DFA17_acceptS);
-    static final short[] DFA17_special = DFA
-            .unpackEncodedString(DFA17_specialS);
+    static final short[] DFA17_special = DFA.unpackEncodedString(DFA17_specialS);
     static final short[][] DFA17_transition;
 
     static {
@@ -2553,7 +3191,7 @@ public class CTFLexer extends Lexer {
         }
     }
 
-    static class DFA17 extends DFA {
+    class DFA17 extends DFA {
 
         public DFA17(BaseRecognizer recognizer) {
             this.recognizer = recognizer;
@@ -2569,66 +3207,68 @@ public class CTFLexer extends Lexer {
 
         @Override
         public String getDescription() {
-            return "102:10: fragment INTEGER_TYPES_SUFFIX : ( ( 'l' ( 'l' )? | 'L' ( 'L' )? ) | ( 'u' | 'U' ) | ( 'u' | 'U' ) ( 'l' ( 'l' )? | 'L' ( 'L' )? ) | ( 'l' ( 'l' )? | 'L' ( 'L' )? ) ( 'u' | 'U' ) );";
-        }
-    }
-
-    static final String DFA33_eotS = "\1\uffff\15\45\2\75\1\uffff\1\101\1\103\13\uffff\1\37\1\uffff\1"
-            + "\45\5\uffff\26\45\11\uffff\1\137\2\uffff\6\45\1\151\2\45\1\155\14"
-            + "\45\1\174\1\uffff\3\137\2\45\1\u0084\2\45\1\u0087\1\uffff\3\45\1"
-            + "\uffff\1\u008b\11\45\1\u0096\3\45\1\uffff\1\137\1\uffff\3\137\1"
-            + "\u009c\1\u009d\1\uffff\1\u009e\1\45\1\uffff\1\u00a0\1\u00a2\1\45"
-            + "\1\uffff\1\u00a4\4\45\1\u00a9\4\45\1\uffff\1\u00ae\2\45\5\uffff"
-            + "\1\u00b1\1\uffff\1\45\1\uffff\1\45\1\uffff\1\u00b4\1\u00b5\1\u00b6"
-            + "\1\u00b7\1\uffff\4\45\1\uffff\2\45\1\uffff\1\45\1\u00bf\4\uffff"
-            + "\1\45\1\u00c1\1\45\1\u00c3\3\45\1\uffff\1\45\1\uffff\1\u00c8\1\uffff"
-            + "\1\u00c9\2\45\1\u00cc\2\uffff\2\45\1\uffff\1\u00cf\1\45\1\uffff"
-            + "\2\45\1\u00d3\1\uffff";
-    static final String DFA33_eofS = "\u00d4\uffff";
-    static final String DFA33_minS = "\1\11\1\154\1\150\1\157\1\156\1\154\1\156\1\157\1\150\1\162\1\156"
+            return "107:10: fragment INTEGER_TYPES_SUFFIX : ( ( 'l' ( 'l' )? | 'L' ( 'L' )? ) | ( 'u' | 'U' ) | ( 'u' | 'U' ) ( 'l' ( 'l' )? | 'L' ( 'L' )? ) | ( 'l' ( 'l' )? | 'L' ( 'L' )? ) ( 'u' | 'U' ) );";
+        }
+    }
+
+    static final String DFA33_eotS = "\1\uffff\15\45\2\76\1\uffff\1\102\1\104\13\uffff\1\37\1\uffff\1"
+            + "\45\5\uffff\27\45\11\uffff\1\144\2\uffff\7\45\1\154\2\45\1\160\14"
+            + "\45\1\177\3\144\1\uffff\2\45\1\u0087\3\45\1\u008b\1\uffff\3\45\1"
+            + "\uffff\1\u008f\11\45\1\u009a\3\45\1\uffff\1\144\1\uffff\3\144\1"
+            + "\u00a0\1\u00a1\1\uffff\1\u00a2\2\45\1\uffff\1\u00a5\1\u00a7\1\45"
+            + "\1\uffff\1\u00a9\4\45\1\u00ae\4\45\1\uffff\1\u00b3\2\45\5\uffff"
+            + "\1\45\1\u00b7\1\uffff\1\45\1\uffff\1\45\1\uffff\1\u00ba\1\u00bb"
+            + "\1\u00bc\1\u00bd\1\uffff\4\45\1\uffff\3\45\1\uffff\1\45\1\u00c6"
+            + "\4\uffff\1\45\1\u00c8\1\45\1\u00ca\2\45\1\u00cd\1\45\1\uffff\1\45"
+            + "\1\uffff\1\u00d0\1\uffff\1\u00d1\1\45\1\uffff\1\45\1\u00d4\2\uffff"
+            + "\2\45\1\uffff\1\u00d7\1\45\1\uffff\2\45\1\u00db\1\uffff";
+    static final String DFA33_eofS = "\u00dc\uffff";
+    static final String DFA33_minS = "\1\11\1\154\1\141\1\157\1\156\1\154\1\156\1\157\1\150\1\162\1\156"
             + "\1\141\1\102\1\141\1\151\1\76\1\uffff\1\75\1\56\13\uffff\1\60\1"
-            + "\uffff\1\42\3\uffff\1\52\1\uffff\1\151\1\156\1\141\1\157\2\165\1"
-            + "\145\1\157\1\164\1\156\1\157\1\147\1\162\1\141\1\160\1\163\1\162"
-            + "\1\151\2\157\1\155\1\116\11\uffff\1\60\2\uffff\1\147\1\163\1\162"
-            + "\1\143\1\142\1\155\1\60\1\156\1\141\1\60\1\147\1\162\1\156\1\145"
-            + "\1\143\1\145\2\151\1\144\1\157\1\155\1\141\1\60\1\uffff\1\125\2"
-            + "\114\1\156\1\164\1\60\1\153\1\154\1\60\1\uffff\2\164\1\147\1\uffff"
-            + "\1\60\1\164\1\145\1\141\1\156\1\143\1\145\1\141\1\147\1\141\1\60"
-            + "\1\154\1\160\1\147\1\uffff\1\125\1\uffff\1\125\1\154\1\114\2\60"
-            + "\1\uffff\1\60\1\145\1\uffff\2\60\1\145\1\uffff\1\60\1\144\1\155"
-            + "\1\147\1\164\1\60\1\154\1\145\2\156\1\uffff\1\60\1\154\1\151\5\uffff"
-            + "\1\60\1\uffff\1\156\1\uffff\1\162\1\uffff\4\60\1\uffff\1\151\1\146"
-            + "\1\145\1\164\1\uffff\1\145\1\156\1\uffff\1\147\1\60\4\uffff\1\141"
-            + "\1\60\1\144\1\60\1\170\1\141\1\137\1\uffff\1\163\1\uffff\1\60\1"
-            + "\uffff\1\60\1\162\1\160\1\60\2\uffff\1\171\1\157\1\uffff\1\60\1"
-            + "\151\1\uffff\1\156\1\164\1\60\1\uffff";
+            + "\uffff\1\42\3\uffff\1\52\1\uffff\1\151\1\156\1\141\1\157\1\154\2"
+            + "\165\1\145\1\157\1\164\1\156\1\157\1\147\1\162\1\141\1\160\1\163"
+            + "\1\162\1\151\2\157\1\155\1\116\11\uffff\1\60\2\uffff\1\147\1\163"
+            + "\1\162\1\143\1\154\1\142\1\155\1\60\1\156\1\141\1\60\1\147\1\162"
+            + "\1\156\1\145\1\143\1\145\2\151\1\144\1\157\1\155\1\141\1\60\1\125"
+            + "\2\114\1\uffff\1\156\1\164\1\60\1\153\1\163\1\154\1\60\1\uffff\2"
+            + "\164\1\147\1\uffff\1\60\1\164\1\145\1\141\1\156\1\143\1\145\1\141"
+            + "\1\147\1\141\1\60\1\154\1\160\1\147\1\uffff\1\125\1\uffff\1\125"
+            + "\1\154\1\114\2\60\1\uffff\1\60\1\151\1\145\1\uffff\2\60\1\145\1"
+            + "\uffff\1\60\1\144\1\155\1\147\1\164\1\60\1\154\1\145\2\156\1\uffff"
+            + "\1\60\1\154\1\151\5\uffff\1\164\1\60\1\uffff\1\156\1\uffff\1\162"
+            + "\1\uffff\4\60\1\uffff\1\151\1\146\1\145\1\164\1\uffff\1\145\1\156"
+            + "\1\145\1\uffff\1\147\1\60\4\uffff\1\141\1\60\1\144\1\60\1\170\1"
+            + "\141\1\60\1\137\1\uffff\1\163\1\uffff\1\60\1\uffff\1\60\1\162\1"
+            + "\uffff\1\160\1\60\2\uffff\1\171\1\157\1\uffff\1\60\1\151\1\uffff"
+            + "\1\156\1\164\1\60\1\uffff";
     static final String DFA33_maxS = "\1\175\1\154\2\157\1\166\1\154\1\156\1\157\1\164\1\171\1\156\1\157"
             + "\1\111\1\141\2\151\1\uffff\1\75\1\56\13\uffff\1\170\1\uffff\1\47"
-            + "\3\uffff\1\57\1\uffff\1\151\1\156\1\141\1\157\1\165\1\166\1\145"
-            + "\1\157\1\164\1\156\1\157\1\147\1\162\1\141\1\160\1\163\1\162\1\151"
-            + "\2\157\1\155\1\116\11\uffff\1\165\2\uffff\1\147\1\163\1\162\1\143"
-            + "\1\142\1\155\1\172\1\156\1\141\1\172\1\147\1\162\1\156\1\165\1\143"
-            + "\1\145\2\151\1\144\1\157\1\155\1\141\1\172\1\uffff\2\165\1\154\1"
-            + "\156\1\164\1\172\1\153\1\154\1\172\1\uffff\2\164\1\147\1\uffff\1"
-            + "\172\1\164\1\145\1\141\1\156\1\143\1\145\1\144\1\147\1\141\1\172"
-            + "\1\154\1\160\1\147\1\uffff\1\165\1\uffff\1\165\1\154\1\114\2\172"
-            + "\1\uffff\1\172\1\145\1\uffff\2\172\1\145\1\uffff\1\172\1\144\1\155"
-            + "\1\147\1\164\1\172\1\154\1\145\2\156\1\uffff\1\172\1\154\1\151\5"
-            + "\uffff\1\172\1\uffff\1\156\1\uffff\1\162\1\uffff\4\172\1\uffff\1"
-            + "\151\1\146\1\145\1\164\1\uffff\1\145\1\156\1\uffff\1\147\1\172\4"
-            + "\uffff\1\141\1\172\1\144\1\172\1\170\1\141\1\137\1\uffff\1\163\1"
-            + "\uffff\1\172\1\uffff\1\172\1\162\1\160\1\172\2\uffff\1\171\1\157"
-            + "\1\uffff\1\172\1\151\1\uffff\1\156\1\164\1\172\1\uffff";
-    static final String DFA33_acceptS = "\20\uffff\1\37\2\uffff\1\42\1\44\1\45\1\46\1\47\1\50\1\51\1\52\1"
-            + "\53\1\54\1\55\1\uffff\1\62\1\uffff\1\64\1\65\1\66\1\uffff\1\71\26"
-            + "\uffff\1\35\1\56\1\36\1\57\1\43\1\40\1\41\1\60\1\63\1\uffff\1\67"
-            + "\1\70\27\uffff\1\61\11\uffff\1\32\3\uffff\1\12\16\uffff\1\34\1\uffff"
-            + "\1\61\5\uffff\1\3\2\uffff\1\5\3\uffff\1\13\12\uffff\1\26\3\uffff"
-            + "\2\61\1\1\1\2\1\33\1\uffff\1\6\1\uffff\1\10\1\uffff\1\14\4\uffff"
-            + "\1\21\4\uffff\1\27\2\uffff\1\4\2\uffff\1\15\1\16\1\17\1\20\7\uffff"
-            + "\1\11\1\uffff\1\23\1\uffff\1\25\4\uffff\1\24\1\30\2\uffff\1\22\2"
-            + "\uffff\1\31\3\uffff\1\7";
-    static final String DFA33_specialS = "\u00d4\uffff}>";
+            + "\3\uffff\1\57\1\uffff\1\151\1\156\1\141\1\157\1\154\1\165\1\166"
+            + "\1\145\1\157\1\164\1\156\1\157\1\147\1\162\1\141\1\160\1\163\1\162"
+            + "\1\151\2\157\1\155\1\116\11\uffff\1\165\2\uffff\1\147\1\163\1\162"
+            + "\1\143\1\154\1\142\1\155\1\172\1\156\1\141\1\172\1\147\1\162\1\156"
+            + "\1\165\1\143\1\145\2\151\1\144\1\157\1\155\1\141\1\172\2\165\1\154"
+            + "\1\uffff\1\156\1\164\1\172\1\153\1\163\1\154\1\172\1\uffff\2\164"
+            + "\1\147\1\uffff\1\172\1\164\1\145\1\141\1\156\1\143\1\145\1\144\1"
+            + "\147\1\141\1\172\1\154\1\160\1\147\1\uffff\1\165\1\uffff\1\165\1"
+            + "\154\1\114\2\172\1\uffff\1\172\1\151\1\145\1\uffff\2\172\1\145\1"
+            + "\uffff\1\172\1\144\1\155\1\147\1\164\1\172\1\154\1\145\2\156\1\uffff"
+            + "\1\172\1\154\1\151\5\uffff\1\164\1\172\1\uffff\1\156\1\uffff\1\162"
+            + "\1\uffff\4\172\1\uffff\1\151\1\146\1\145\1\164\1\uffff\1\145\1\156"
+            + "\1\145\1\uffff\1\147\1\172\4\uffff\1\141\1\172\1\144\1\172\1\170"
+            + "\1\141\1\172\1\137\1\uffff\1\163\1\uffff\1\172\1\uffff\1\172\1\162"
+            + "\1\uffff\1\160\1\172\2\uffff\1\171\1\157\1\uffff\1\172\1\151\1\uffff"
+            + "\1\156\1\164\1\172\1\uffff";
+    static final String DFA33_acceptS = "\20\uffff\1\40\2\uffff\1\43\1\45\1\46\1\47\1\50\1\51\1\52\1\53\1"
+            + "\54\1\55\1\56\1\uffff\1\63\1\uffff\1\65\1\66\1\67\1\uffff\1\72\27"
+            + "\uffff\1\36\1\57\1\37\1\60\1\44\1\41\1\42\1\61\1\64\1\uffff\1\70"
+            + "\1\71\33\uffff\1\62\7\uffff\1\32\3\uffff\1\12\16\uffff\1\35\1\uffff"
+            + "\1\62\5\uffff\1\3\3\uffff\1\5\3\uffff\1\13\12\uffff\1\26\3\uffff"
+            + "\2\62\1\1\1\2\1\33\2\uffff\1\6\1\uffff\1\10\1\uffff\1\14\4\uffff"
+            + "\1\21\4\uffff\1\27\3\uffff\1\4\2\uffff\1\15\1\16\1\17\1\20\10\uffff"
+            + "\1\11\1\uffff\1\23\1\uffff\1\25\2\uffff\1\34\2\uffff\1\24\1\30\2"
+            + "\uffff\1\22\2\uffff\1\31\3\uffff\1\7";
+    static final String DFA33_specialS = "\u00dc\uffff}>";
     static final String[] DFA33_transitionS = {
             "\2\43\1\uffff\2\43\22\uffff\1\43\1\uffff\1\42\4\uffff\1\41\1"
                     + "\30\1\31\1\35\1\16\1\20\1\17\1\22\1\44\1\36\11\37\1\21\1\34"
@@ -2636,23 +3276,23 @@ public class CTFLexer extends Lexer {
                     + "\1\27\1\uffff\1\14\1\uffff\1\1\1\45\1\2\1\3\1\4\1\5\2\45\1\6"
                     + "\2\45\1\7\6\45\1\10\1\11\1\12\1\13\4\45\1\32\1\uffff\1\33",
             "\1\46",
-            "\1\50\3\uffff\1\51\2\uffff\1\47",
-            "\1\52",
-            "\1\53\7\uffff\1\54",
-            "\1\55",
+            "\1\52\6\uffff\1\50\3\uffff\1\51\2\uffff\1\47",
+            "\1\53",
+            "\1\54\7\uffff\1\55",
             "\1\56",
             "\1\57",
-            "\1\60\1\61\12\uffff\1\62",
-            "\1\63\6\uffff\1\64",
-            "\1\65",
-            "\1\66\15\uffff\1\67",
-            "\1\70\1\71\5\uffff\1\72",
-            "\1\73",
+            "\1\60",
+            "\1\61\1\62\12\uffff\1\63",
+            "\1\64\6\uffff\1\65",
+            "\1\66",
+            "\1\67\15\uffff\1\70",
+            "\1\71\1\72\5\uffff\1\73",
             "\1\74",
-            "\1\77\52\uffff\1\76",
+            "\1\75",
+            "\1\100\52\uffff\1\77",
             "",
-            "\1\100",
-            "\1\102",
+            "\1\101",
+            "\1\103",
             "",
             "",
             "",
@@ -2664,22 +3304,21 @@ public class CTFLexer extends Lexer {
             "",
             "",
             "",
-            "\10\105\40\uffff\1\104\37\uffff\1\104",
+            "\10\106\40\uffff\1\105\37\uffff\1\105",
             "",
             "\1\42\4\uffff\1\41",
             "",
             "",
             "",
-            "\1\106\4\uffff\1\107",
+            "\1\107\4\uffff\1\110",
             "",
-            "\1\110",
             "\1\111",
             "\1\112",
             "\1\113",
             "\1\114",
-            "\1\115\1\116",
-            "\1\117",
-            "\1\120",
+            "\1\115",
+            "\1\116",
+            "\1\117\1\120",
             "\1\121",
             "\1\122",
             "\1\123",
@@ -2694,6 +3333,8 @@ public class CTFLexer extends Lexer {
             "\1\134",
             "\1\135",
             "\1\136",
+            "\1\137",
+            "\1\140",
             "",
             "",
             "",
@@ -2703,112 +3344,113 @@ public class CTFLexer extends Lexer {
             "",
             "",
             "",
-            "\10\105\2\37\22\uffff\1\141\10\uffff\1\142\26\uffff\1\140\10"
-                    + "\uffff\1\142",
+            "\10\106\2\37\22\uffff\1\142\10\uffff\1\143\26\uffff\1\141\10"
+                    + "\uffff\1\143",
             "",
             "",
-            "\1\143",
-            "\1\144",
             "\1\145",
             "\1\146",
             "\1\147",
             "\1\150",
-            "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
+            "\1\151",
             "\1\152",
             "\1\153",
-            "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\4\45\1\154\25\45",
+            "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
+            "\1\155",
             "\1\156",
-            "\1\157",
-            "\1\160",
-            "\1\161\3\uffff\1\162\13\uffff\1\163",
-            "\1\164",
-            "\1\165",
-            "\1\166",
+            "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\4\45\1\157\25\45",
+            "\1\161",
+            "\1\162",
+            "\1\163",
+            "\1\164\3\uffff\1\165\13\uffff\1\166",
             "\1\167",
             "\1\170",
             "\1\171",
             "\1\172",
             "\1\173",
+            "\1\174",
+            "\1\175",
+            "\1\176",
             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
+            "\1\u0081\26\uffff\1\u0080\10\uffff\1\u0081",
+            "\1\u0082\10\uffff\1\u0081\37\uffff\1\u0081",
+            "\1\u0084\37\uffff\1\u0083",
             "",
-            "\1\176\26\uffff\1\175\10\uffff\1\176",
-            "\1\177\10\uffff\1\176\37\uffff\1\176",
-            "\1\u0081\37\uffff\1\u0080",
-            "\1\u0082",
-            "\1\u0083",
-            "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
             "\1\u0085",
             "\1\u0086",
             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
-            "",
             "\1\u0088",
             "\1\u0089",
             "\1\u008a",
-            "",
             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
+            "",
             "\1\u008c",
             "\1\u008d",
             "\1\u008e",
-            "\1\u008f",
+            "",
+            "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
             "\1\u0090",
             "\1\u0091",
-            "\1\u0092\2\uffff\1\u0093",
+            "\1\u0092",
+            "\1\u0093",
             "\1\u0094",
             "\1\u0095",
-            "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
-            "\1\u0097",
+            "\1\u0096\2\uffff\1\u0097",
             "\1\u0098",
             "\1\u0099",
+            "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
+            "\1\u009b",
+            "\1\u009c",
+            "\1\u009d",
             "",
-            "\1\176\37\uffff\1\176",
+            "\1\u0081\37\uffff\1\u0081",
             "",
-            "\1\176\37\uffff\1\176",
-            "\1\u009a",
-            "\1\u009b",
+            "\1\u0081\37\uffff\1\u0081",
+            "\1\u009e",
+            "\1\u009f",
             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
             "",
             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
-            "\1\u009f",
+            "\1\u00a3",
+            "\1\u00a4",
             "",
             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
-            "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\10\45\1\u00a1\21"
-                    + "\45", "\1\u00a3", "",
-            "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "\1\u00a5",
-            "\1\u00a6", "\1\u00a7", "\1\u00a8",
+            "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\10\45\1\u00a6\21"
+                    + "\45", "\1\u00a8", "",
             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "\1\u00aa",
-            "\1\u00ab", "\1\u00ac", "\1\u00ad", "",
+            "\1\u00ab", "\1\u00ac", "\1\u00ad",
             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "\1\u00af",
-            "\1\u00b0", "", "", "", "", "",
-            "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "", "\1\u00b2",
-            "", "\1\u00b3", "",
+            "\1\u00b0", "\1\u00b1", "\1\u00b2", "",
+            "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "\1\u00b4",
+            "\1\u00b5", "", "", "", "", "", "\1\u00b6",
+            "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "", "\1\u00b8",
+            "", "\1\u00b9", "",
             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
-            "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "", "\1\u00b8",
-            "\1\u00b9", "\1\u00ba", "\1\u00bb", "", "\1\u00bc", "\1\u00bd", "",
-            "\1\u00be", "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "",
-            "", "", "", "\1\u00c0",
-            "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "\1\u00c2",
-            "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "\1\u00c4",
-            "\1\u00c5", "\1\u00c6", "", "\1\u00c7", "",
-            "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "",
-            "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "\1\u00ca",
-            "\1\u00cb", "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "",
-            "", "\1\u00cd", "\1\u00ce", "",
-            "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "\1\u00d0", "",
-            "\1\u00d1", "\1\u00d2",
+            "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "", "\1\u00be",
+            "\1\u00bf", "\1\u00c0", "\1\u00c1", "", "\1\u00c2", "\1\u00c3",
+            "\1\u00c4", "", "\1\u00c5",
+            "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "", "", "", "",
+            "\1\u00c7", "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
+            "\1\u00c9", "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
+            "\1\u00cb", "\1\u00cc",
+            "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "\1\u00ce", "",
+            "\1\u00cf", "", "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
+            "", "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "\1\u00d2",
+            "", "\1\u00d3", "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45",
+            "", "", "\1\u00d5", "\1\u00d6", "",
+            "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "\1\u00d8", "",
+            "\1\u00d9", "\1\u00da",
             "\12\45\7\uffff\32\45\4\uffff\1\45\1\uffff\32\45", "" };
 
     static final short[] DFA33_eot = DFA.unpackEncodedString(DFA33_eotS);
     static final short[] DFA33_eof = DFA.unpackEncodedString(DFA33_eofS);
-    static final char[] DFA33_min = DFA
-            .unpackEncodedStringToUnsignedChars(DFA33_minS);
-    static final char[] DFA33_max = DFA
-            .unpackEncodedStringToUnsignedChars(DFA33_maxS);
+    static final char[] DFA33_min = DFA.unpackEncodedStringToUnsignedChars(DFA33_minS);
+    static final char[] DFA33_max = DFA.unpackEncodedStringToUnsignedChars(DFA33_maxS);
     static final short[] DFA33_accept = DFA.unpackEncodedString(DFA33_acceptS);
-    static final short[] DFA33_special = DFA
-            .unpackEncodedString(DFA33_specialS);
+    static final short[] DFA33_special = DFA.unpackEncodedString(DFA33_specialS);
     static final short[][] DFA33_transition;
 
     static {
@@ -2819,7 +3461,7 @@ public class CTFLexer extends Lexer {
         }
     }
 
-    static class DFA33 extends DFA {
+    class DFA33 extends DFA {
 
         public DFA33(BaseRecognizer recognizer) {
             this.recognizer = recognizer;
@@ -2835,8 +3477,8 @@ public class CTFLexer extends Lexer {
 
         @Override
         public String getDescription() {
-            return "1:1: Tokens : ( ALIGNTOK | CONSTTOK | CHARTOK | DOUBLETOK | ENUMTOK | EVENTTOK | FLOATINGPOINTTOK | FLOATTOK | INTEGERTOK | INTTOK | LONGTOK | SHORTTOK | SIGNEDTOK | STREAMTOK | STRINGTOK | STRUCTTOK | TRACETOK | TYPEALIASTOK | TYPEDEFTOK | UNSIGNEDTOK | VARIANTTOK | VOIDTOK | BOOLTOK | COMPLEXTOK | IMAGINARYTOK | ENVTOK | CLOCKTOK | NANNUMBERTOK | INFINITYTOK | NINFINITYTOK | SEPARATOR | COLON | ELIPSES | ASSIGNMENT | TYPE_ASSIGNMENT | LT | GT | OPENBRAC | CLOSEBRAC | LPAREN | RPAREN | LCURL | RCURL | TERM | POINTER | SIGN | ARROW | DOT | OCTAL_LITERAL | DECIMAL_LITERAL | HEX_LITERAL | CHARACTER_LITERAL | STRING_LITERAL | WS | COMMENT | LINE_COMMENT | IDENTIFIER );";
+            return "1:1: Tokens : ( ALIGNTOK | CONSTTOK | CHARTOK | DOUBLETOK | ENUMTOK | EVENTTOK | FLOATINGPOINTTOK | FLOATTOK | INTEGERTOK | INTTOK | LONGTOK | SHORTTOK | SIGNEDTOK | STREAMTOK | STRINGTOK | STRUCTTOK | TRACETOK | TYPEALIASTOK | TYPEDEFTOK | UNSIGNEDTOK | VARIANTTOK | VOIDTOK | BOOLTOK | COMPLEXTOK | IMAGINARYTOK | ENVTOK | CLOCKTOK | CALLSITETOK | NANNUMBERTOK | INFINITYTOK | NINFINITYTOK | SEPARATOR | COLON | ELIPSES | ASSIGNMENT | TYPE_ASSIGNMENT | LT | GT | OPENBRAC | CLOSEBRAC | LPAREN | RPAREN | LCURL | RCURL | TERM | POINTER | SIGN | ARROW | DOT | OCTAL_LITERAL | DECIMAL_LITERAL | HEX_LITERAL | CHARACTER_LITERAL | STRING_LITERAL | WS | COMMENT | LINE_COMMENT | IDENTIFIER );";
         }
     }
 
-}
+}
\ No newline at end of file

diff --git a/org.eclipse.linuxtools.ctf.parser/src/org/eclipse/linuxtools/ctf/parser/CTFParser.java b/org.eclipse.linuxtools.ctf.parser/src/org/eclipse/linuxtools/ctf/parser/CTFParser.java
index 239966ee5c375b612c2f86d0f88e81d638ae9a84..0ebd8fa5a6ef727119ffecfb6da93763ab2e60c4 100644 (file)
--- a/org.eclipse.linuxtools.ctf.parser/src/org/eclipse/linuxtools/ctf/parser/CTFParser.java
+++ b/org.eclipse.linuxtools.ctf.parser/src/org/eclipse/linuxtools/ctf/parser/CTFParser.java
@@ -1,7 +1,6 @@
-// $ANTLR !Unknown version! Grammar/CTFParser.g 2012-03-09 14:59:18
-
-package org.eclipse.linuxtools.ctf.parser;
+// $ANTLR !Unknown version! CTFParser.g 2012-10-22 14:14:35
 
+package  org.eclipse.linuxtools.ctf.parser;
 import java.util.HashSet;
 import java.util.Set;
 import java.util.Stack;
@@ -28,166 +27,133 @@ import org.antlr.runtime.tree.RewriteRuleSubtreeStream;
 import org.antlr.runtime.tree.RewriteRuleTokenStream;
 import org.antlr.runtime.tree.TreeAdaptor;
 
-/**
- * TSDL parser. For internal use only.
- *
- * @author Matthew Khouzam and Antlr
- *
- */
-@SuppressWarnings({ "nls", "unused", "unchecked", "rawtypes", "javadoc",
-        "null", "incomplete-switch" })
+@SuppressWarnings("all")
 public class CTFParser extends Parser {
-    public static final String[] tokenNames = new String[] { "<invalid>",
-            "<EOR>", "<DOWN>", "<UP>", "ALIGNTOK", "CONSTTOK", "CHARTOK",
-            "DOUBLETOK", "ENUMTOK", "EVENTTOK", "FLOATINGPOINTTOK", "FLOATTOK",
-            "INTEGERTOK", "INTTOK", "LONGTOK", "SHORTTOK", "SIGNEDTOK",
-            "STREAMTOK", "STRINGTOK", "STRUCTTOK", "TRACETOK", "TYPEALIASTOK",
-            "TYPEDEFTOK", "UNSIGNEDTOK", "VARIANTTOK", "VOIDTOK", "BOOLTOK",
-            "COMPLEXTOK", "IMAGINARYTOK", "ENVTOK", "CLOCKTOK", "NANNUMBERTOK",
-            "INFINITYTOK", "NINFINITYTOK", "SEPARATOR", "COLON", "ELIPSES",
-            "ASSIGNMENT", "TYPE_ASSIGNMENT", "LT", "GT", "OPENBRAC",
-            "CLOSEBRAC", "LPAREN", "RPAREN", "LCURL", "RCURL", "TERM",
-            "POINTER", "SIGN", "ARROW", "DOT", "BACKSLASH",
-            "INTEGER_TYPES_SUFFIX", "OCTAL_LITERAL", "DIGIT",
-            "DECIMAL_LITERAL", "HEX_PREFIX", "HEX_DIGIT", "HEX_LITERAL",
-            "NONZERO_DIGIT", "OCTAL_ESCAPE", "UNICODE_ESCAPE",
-            "HEXADECIMAL_ESCAPE", "ESCAPE_SEQUENCE", "STRINGPREFIX",
-            "SINGLEQUOTE", "CHAR_CONTENT", "CHARACTER_LITERAL", "DOUBLEQUOTE",
-            "STRING_CONTENT", "STRING_LITERAL", "WS", "COMMENT_OPEN",
-            "COMMENT_CLOSE", "COMMENT", "LINE_COMMENT", "NONDIGIT",
-            "IDENTIFIER", "ROOT", "EVENT", "STREAM", "TRACE", "ENV", "CLOCK",
-            "DECLARATION", "SV_DECLARATION", "TYPE_SPECIFIER_LIST",
-            "TYPE_DECLARATOR_LIST", "TYPE_DECLARATOR", "STRUCT", "STRUCT_NAME",
-            "STRUCT_BODY", "ALIGN", "CTF_EXPRESSION_TYPE",
-            "CTF_EXPRESSION_VAL", "CTF_LEFT", "CTF_RIGHT",
-            "UNARY_EXPRESSION_STRING", "UNARY_EXPRESSION_STRING_QUOTES",
-            "UNARY_EXPRESSION_DEC", "UNARY_EXPRESSION_HEX",
-            "UNARY_EXPRESSION_OCT", "LENGTH", "TYPEDEF", "TYPEALIAS",
-            "TYPEALIAS_TARGET", "TYPEALIAS_ALIAS", "INTEGER", "STRING",
-            "FLOATING_POINT", "ENUM", "ENUM_CONTAINER_TYPE", "ENUM_ENUMERATOR",
-            "ENUM_NAME", "ENUM_VALUE", "ENUM_VALUE_RANGE", "ENUM_BODY",
-            "VARIANT", "VARIANT_NAME", "VARIANT_TAG", "VARIANT_BODY",
-            "DECLARATOR" };
-    public static final int SIGN = 49;
-    public static final int LT = 39;
-    public static final int TYPEDEFTOK = 22;
-    public static final int VARIANT_NAME = 119;
-    public static final int ENV = 83;
-    public static final int INTEGER_TYPES_SUFFIX = 53;
-    public static final int POINTER = 48;
-    public static final int TRACE = 82;
-    public static final int HEX_PREFIX = 57;
-    public static final int INTTOK = 13;
-    public static final int SEPARATOR = 34;
-    public static final int ENUMTOK = 8;
-    public static final int COMPLEXTOK = 27;
-    public static final int IMAGINARYTOK = 28;
-    public static final int STREAMTOK = 17;
-    public static final int EOF = -1;
-    public static final int UNARY_EXPRESSION_OCT = 102;
-    public static final int ENUM_VALUE = 115;
-    public static final int UNSIGNEDTOK = 23;
-    public static final int ENUM_NAME = 114;
-    public static final int RPAREN = 44;
-    public static final int CHAR_CONTENT = 67;
-    public static final int STRING_LITERAL = 71;
-    public static final int UNARY_EXPRESSION_STRING_QUOTES = 99;
-    public static final int ALIGNTOK = 4;
-    public static final int FLOATTOK = 11;
-    public static final int STRUCT_BODY = 92;
-    public static final int ENUM_BODY = 117;
-    public static final int COMMENT_CLOSE = 74;
-    public static final int STRINGTOK = 18;
-    public static final int COMMENT = 75;
-    public static final int STREAM = 81;
-    public static final int UNARY_EXPRESSION_HEX = 101;
-    public static final int UNARY_EXPRESSION_DEC = 100;
-    public static final int FLOATINGPOINTTOK = 10;
-    public static final int LINE_COMMENT = 76;
-    public static final int CTF_EXPRESSION_TYPE = 94;
-    public static final int DOUBLETOK = 7;
-    public static final int TYPE_DECLARATOR = 89;
-    public static final int CHARACTER_LITERAL = 68;
-    public static final int OCTAL_ESCAPE = 61;
-    public static final int STRUCT_NAME = 91;
-    public static final int VARIANT = 118;
-    public static final int NANNUMBERTOK = 31;
-    public static final int ENUM_ENUMERATOR = 113;
-    public static final int FLOATING_POINT = 110;
-    public static final int DECLARATOR = 122;
-    public static final int SIGNEDTOK = 16;
-    public static final int CHARTOK = 6;
-    public static final int WS = 72;
-    public static final int INTEGERTOK = 12;
-    public static final int VARIANT_BODY = 121;
-    public static final int NONDIGIT = 77;
-    public static final int GT = 40;
-    public static final int TYPEALIAS_TARGET = 106;
-    public static final int DECIMAL_LITERAL = 56;
-    public static final int BACKSLASH = 52;
-    public static final int CLOSEBRAC = 42;
-    public static final int TERM = 47;
-    public static final int BOOLTOK = 26;
-    public static final int CTF_RIGHT = 97;
-    public static final int TYPE_DECLARATOR_LIST = 88;
-    public static final int STRING_CONTENT = 70;
-    public static final int TYPE_ASSIGNMENT = 38;
-    public static final int ENUM_CONTAINER_TYPE = 112;
-    public static final int DOUBLEQUOTE = 69;
-    public static final int ENUM_VALUE_RANGE = 116;
-    public static final int DECLARATION = 85;
-    public static final int LENGTH = 103;
-    public static final int LPAREN = 43;
-    public static final int INFINITYTOK = 32;
-    public static final int STRINGPREFIX = 65;
-    public static final int CTF_EXPRESSION_VAL = 95;
-    public static final int ESCAPE_SEQUENCE = 64;
-    public static final int UNICODE_ESCAPE = 62;
-    public static final int SINGLEQUOTE = 66;
-    public static final int IDENTIFIER = 78;
-    public static final int HEX_LITERAL = 59;
-    public static final int ALIGN = 93;
-    public static final int DIGIT = 55;
-    public static final int DOT = 51;
-    public static final int ENVTOK = 29;
-    public static final int STRUCTTOK = 19;
-    public static final int OPENBRAC = 41;
-    public static final int TYPEALIASTOK = 21;
-    public static final int CLOCK = 84;
-    public static final int INTEGER = 108;
-    public static final int TYPEALIAS = 105;
-    public static final int EVENTTOK = 9;
-    public static final int NINFINITYTOK = 33;
-    public static final int TYPEDEF = 104;
-    public static final int VOIDTOK = 25;
-    public static final int TYPE_SPECIFIER_LIST = 87;
-    public static final int OCTAL_LITERAL = 54;
-    public static final int COMMENT_OPEN = 73;
-    public static final int HEX_DIGIT = 58;
-    public static final int STRUCT = 90;
-    public static final int EVENT = 80;
-    public static final int LONGTOK = 14;
-    public static final int ROOT = 79;
-    public static final int CTF_LEFT = 96;
-    public static final int CLOCKTOK = 30;
-    public static final int TRACETOK = 20;
-    public static final int COLON = 35;
-    public static final int HEXADECIMAL_ESCAPE = 63;
-    public static final int LCURL = 45;
-    public static final int VARIANTTOK = 24;
-    public static final int VARIANT_TAG = 120;
-    public static final int ENUM = 111;
-    public static final int ELIPSES = 36;
-    public static final int RCURL = 46;
-    public static final int TYPEALIAS_ALIAS = 107;
-    public static final int UNARY_EXPRESSION_STRING = 98;
-    public static final int ARROW = 50;
-    public static final int ASSIGNMENT = 37;
-    public static final int SHORTTOK = 15;
-    public static final int SV_DECLARATION = 86;
-    public static final int NONZERO_DIGIT = 60;
-    public static final int CONSTTOK = 5;
-    public static final int STRING = 109;
+    public static final String[] tokenNames = new String[] {
+        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "ALIGNTOK", "CONSTTOK", "CHARTOK", "DOUBLETOK", "ENUMTOK", "EVENTTOK", "FLOATINGPOINTTOK", "FLOATTOK", "INTEGERTOK", "INTTOK", "LONGTOK", "SHORTTOK", "SIGNEDTOK", "STREAMTOK", "STRINGTOK", "STRUCTTOK", "TRACETOK", "TYPEALIASTOK", "TYPEDEFTOK", "UNSIGNEDTOK", "VARIANTTOK", "VOIDTOK", "BOOLTOK", "COMPLEXTOK", "IMAGINARYTOK", "ENVTOK", "CLOCKTOK", "CALLSITETOK", "NANNUMBERTOK", "INFINITYTOK", "NINFINITYTOK", "SEPARATOR", "COLON", "ELIPSES", "ASSIGNMENT", "TYPE_ASSIGNMENT", "LT", "GT", "OPENBRAC", "CLOSEBRAC", "LPAREN", "RPAREN", "LCURL", "RCURL", "TERM", "POINTER", "SIGN", "ARROW", "DOT", "BACKSLASH", "INTEGER_TYPES_SUFFIX", "OCTAL_LITERAL", "DIGIT", "DECIMAL_LITERAL", "HEX_PREFIX", "HEX_DIGIT", "HEX_LITERAL", "NONZERO_DIGIT", "OCTAL_ESCAPE", "UNICODE_ESCAPE", "HEXADECIMAL_ESCAPE", "ESCAPE_SEQUENCE", "STRINGPREFIX", "SINGLEQUOTE", "CHAR_CONTENT", "CHARACTER_LITERAL", "DOUBLEQUOTE", "STRING_CONTENT", "STRING_LITERAL", "WS", "COMMENT_OPEN", "COMMENT_CLOSE", "COMMENT", "LINE_COMMENT", "NONDIGIT", "IDENTIFIER", "ROOT", "EVENT", "STREAM", "TRACE", "ENV", "CLOCK", "CALLSITE", "DECLARATION", "SV_DECLARATION", "TYPE_SPECIFIER_LIST", "TYPE_DECLARATOR_LIST", "TYPE_DECLARATOR", "STRUCT", "STRUCT_NAME", "STRUCT_BODY", "ALIGN", "CTF_EXPRESSION_TYPE", "CTF_EXPRESSION_VAL", "CTF_LEFT", "CTF_RIGHT", "UNARY_EXPRESSION_STRING", "UNARY_EXPRESSION_STRING_QUOTES", "UNARY_EXPRESSION_DEC", "UNARY_EXPRESSION_HEX", "UNARY_EXPRESSION_OCT", "LENGTH", "TYPEDEF", "TYPEALIAS", "TYPEALIAS_TARGET", "TYPEALIAS_ALIAS", "INTEGER", "STRING", "FLOATING_POINT", "ENUM", "ENUM_CONTAINER_TYPE", "ENUM_ENUMERATOR", "ENUM_NAME", "ENUM_VALUE", "ENUM_VALUE_RANGE", "ENUM_BODY", "VARIANT", "VARIANT_NAME", "VARIANT_TAG", "VARIANT_BODY", "DECLARATOR"
+    };
+    public static final int SIGN=50;
+    public static final int LT=40;
+    public static final int TYPEDEFTOK=22;
+    public static final int VARIANT_NAME=121;
+    public static final int ENV=84;
+    public static final int INTEGER_TYPES_SUFFIX=54;
+    public static final int POINTER=49;
+    public static final int TRACE=83;
+    public static final int HEX_PREFIX=58;
+    public static final int INTTOK=13;
+    public static final int SEPARATOR=35;
+    public static final int ENUMTOK=8;
+    public static final int COMPLEXTOK=27;
+    public static final int IMAGINARYTOK=28;
+    public static final int STREAMTOK=17;
+    public static final int EOF=-1;
+    public static final int UNARY_EXPRESSION_OCT=104;
+    public static final int ENUM_VALUE=117;
+    public static final int UNSIGNEDTOK=23;
+    public static final int ENUM_NAME=116;
+    public static final int RPAREN=45;
+    public static final int CHAR_CONTENT=68;
+    public static final int STRING_LITERAL=72;
+    public static final int UNARY_EXPRESSION_STRING_QUOTES=101;
+    public static final int ALIGNTOK=4;
+    public static final int FLOATTOK=11;
+    public static final int STRUCT_BODY=94;
+    public static final int ENUM_BODY=119;
+    public static final int COMMENT_CLOSE=75;
+    public static final int STRINGTOK=18;
+    public static final int COMMENT=76;
+    public static final int STREAM=82;
+    public static final int UNARY_EXPRESSION_HEX=103;
+    public static final int UNARY_EXPRESSION_DEC=102;
+    public static final int FLOATINGPOINTTOK=10;
+    public static final int LINE_COMMENT=77;
+    public static final int CTF_EXPRESSION_TYPE=96;
+    public static final int DOUBLETOK=7;
+    public static final int TYPE_DECLARATOR=91;
+    public static final int CHARACTER_LITERAL=69;
+    public static final int STRUCT_NAME=93;
+    public static final int OCTAL_ESCAPE=62;
+    public static final int VARIANT=120;
+    public static final int NANNUMBERTOK=32;
+    public static final int ENUM_ENUMERATOR=115;
+    public static final int FLOATING_POINT=112;
+    public static final int DECLARATOR=124;
+    public static final int SIGNEDTOK=16;
+    public static final int CHARTOK=6;
+    public static final int WS=73;
+    public static final int INTEGERTOK=12;
+    public static final int VARIANT_BODY=123;
+    public static final int NONDIGIT=78;
+    public static final int GT=41;
+    public static final int TYPEALIAS_TARGET=108;
+    public static final int DECIMAL_LITERAL=57;
+    public static final int BACKSLASH=53;
+    public static final int CLOSEBRAC=43;
+    public static final int TERM=48;
+    public static final int BOOLTOK=26;
+    public static final int CTF_RIGHT=99;
+    public static final int TYPE_DECLARATOR_LIST=90;
+    public static final int STRING_CONTENT=71;
+    public static final int TYPE_ASSIGNMENT=39;
+    public static final int ENUM_CONTAINER_TYPE=114;
+    public static final int DOUBLEQUOTE=70;
+    public static final int ENUM_VALUE_RANGE=118;
+    public static final int DECLARATION=87;
+    public static final int LENGTH=105;
+    public static final int INFINITYTOK=33;
+    public static final int LPAREN=44;
+    public static final int STRINGPREFIX=66;
+    public static final int CTF_EXPRESSION_VAL=97;
+    public static final int ESCAPE_SEQUENCE=65;
+    public static final int UNICODE_ESCAPE=63;
+    public static final int CALLSITETOK=31;
+    public static final int SINGLEQUOTE=67;
+    public static final int IDENTIFIER=79;
+    public static final int HEX_LITERAL=60;
+    public static final int ALIGN=95;
+    public static final int DIGIT=56;
+    public static final int DOT=52;
+    public static final int ENVTOK=29;
+    public static final int STRUCTTOK=19;
+    public static final int TYPEALIASTOK=21;
+    public static final int OPENBRAC=42;
+    public static final int CLOCK=85;
+    public static final int INTEGER=110;
+    public static final int TYPEALIAS=107;
+    public static final int CALLSITE=86;
+    public static final int EVENTTOK=9;
+    public static final int NINFINITYTOK=34;
+    public static final int TYPEDEF=106;
+    public static final int VOIDTOK=25;
+    public static final int TYPE_SPECIFIER_LIST=89;
+    public static final int OCTAL_LITERAL=55;
+    public static final int COMMENT_OPEN=74;
+    public static final int HEX_DIGIT=59;
+    public static final int STRUCT=92;
+    public static final int EVENT=81;
+    public static final int LONGTOK=14;
+    public static final int ROOT=80;
+    public static final int CTF_LEFT=98;
+    public static final int CLOCKTOK=30;
+    public static final int TRACETOK=20;
+    public static final int COLON=36;
+    public static final int HEXADECIMAL_ESCAPE=64;
+    public static final int LCURL=46;
+    public static final int VARIANTTOK=24;
+    public static final int VARIANT_TAG=122;
+    public static final int ENUM=113;
+    public static final int ELIPSES=37;
+    public static final int RCURL=47;
+    public static final int TYPEALIAS_ALIAS=109;
+    public static final int UNARY_EXPRESSION_STRING=100;
+    public static final int ARROW=51;
+    public static final int ASSIGNMENT=38;
+    public static final int SHORTTOK=15;
+    public static final int SV_DECLARATION=88;
+    public static final int NONZERO_DIGIT=61;
+    public static final int CONSTTOK=5;
+    public static final int STRING=111;
 
     // delegates
     // delegators
@@ -195,161 +161,141 @@ public class CTFParser extends Parser {
     protected static class Symbols_scope {
         Set<String> types;
     }
-
     protected Stack Symbols_stack = new Stack();
 
-    public CTFParser(TokenStream input) {
-        this(input, new RecognizerSharedState());
-    }
 
-    public CTFParser(TokenStream input, RecognizerSharedState state) {
-        super(input, state);
+        public CTFParser(TokenStream input) {
+            this(input, new RecognizerSharedState());
+        }
+        public CTFParser(TokenStream input, RecognizerSharedState state) {
+            super(input, state);
 
-    }
+        }
 
     protected TreeAdaptor adaptor = new CommonTreeAdaptor();
 
     public void setTreeAdaptor(TreeAdaptor adaptor) {
         this.adaptor = adaptor;
     }
-
     public TreeAdaptor getTreeAdaptor() {
         return adaptor;
     }
 
-    @Override
-    public String[] getTokenNames() {
-        return CTFParser.tokenNames;
-    }
+    public String[] getTokenNames() { return CTFParser.tokenNames; }
+    public String getGrammarFileName() { return "CTFParser.g"; }
 
-    @Override
-    public String getGrammarFileName() {
-        return "Grammar/CTFParser.g";
-    }
 
-    public CTFParser(TokenStream input, boolean verbose) {
+      public CTFParser(TokenStream input, boolean verbose) {
         this(input);
         this.verbose = verbose;
-    }
+      }
 
-    /*
-     * To disable automatic error recovery. When we have a mismatched token,
-     * simply throw an exception.
-     */
-    @Override
-    protected Object recoverFromMismatchedToken(IntStream input, int ttype,
-            BitSet follow) throws RecognitionException {
+      /* To disable automatic error recovery. When we have a mismatched token, simply throw an exception. */
+      @Override
+      protected Object recoverFromMismatchedToken(IntStream input, int ttype, BitSet follow) throws RecognitionException
+      {
         throw new MismatchedTokenException(ttype, input);
-    }
-
-    /**
-     * Checks if a given name has been defined has a type. From:
-     * http://www.antlr.org/grammar/1153358328744/C.g
-     *
-     * @param name
-     *            The name to check.
-     * @return True if is is a type, false otherwise.
-     */
-    boolean isTypeName(String name) {
+      }
+
+      /**
+       * Checks if a given name has been defined has a type.
+       * From: http://www.antlr.org/grammar/1153358328744/C.g
+       *
+       * @param name The name to check.
+       * @return True if is is a type, false otherwise.
+       */
+      boolean isTypeName(String name) {
         for (int i = Symbols_stack.size() - 1; i >= 0; i--) {
-            Symbols_scope scope = (Symbols_scope) Symbols_stack.get(i);
-            if (scope.types.contains(name)) {
-                return true;
-            }
+          Symbols_scope scope = (Symbols_scope)Symbols_stack.get(i);
+          if (scope.types.contains(name)) {
+            return true;
+          }
         }
         return false;
-    }
+      }
 
-    void addTypeName(String name) {
-        ((Symbols_scope) Symbols_stack.peek()).types.add(name);
+      void addTypeName(String name) {
+        ((Symbols_scope)Symbols_stack.peek()).types.add(name);
         if (verbose) {
-            debug_print("New type: " + name);
+          debug_print("New type: " + name);
         }
-    }
+      }
 
-    boolean _inTypedef = false;
+      boolean _inTypedef = false;
 
-    void typedefOn() {
+      void typedefOn() {
         debug_print("typedefOn");
         _inTypedef = true;
-    }
+      }
 
-    void typedefOff() {
-        debug_print("typedefOff");
+      void typedefOff() {
+      debug_print("typedefOff");
         _inTypedef = false;
-    }
+      }
 
-    boolean inTypedef() {
+      boolean inTypedef() {
         return _inTypedef;
-    }
+      }
 
-    boolean _inTypealiasAlias = false;
+      boolean _inTypealiasAlias = false;
 
-    void typealiasAliasOn() {
-        debug_print("typealiasAliasOn");
+      void typealiasAliasOn() {
+      debug_print("typealiasAliasOn");
         _inTypealiasAlias = true;
-    }
+      }
 
-    void typealiasAliasOff() {
-        debug_print("typealiasAliasOff");
+      void typealiasAliasOff() {
+      debug_print("typealiasAliasOff");
         _inTypealiasAlias = false;
-    }
+      }
 
-    boolean inTypealiasAlias() {
+      boolean inTypealiasAlias() {
         return _inTypealiasAlias;
-    }
+      }
 
-    static void print_tabs(int n) {
+      void print_tabs(int n) {
         for (int i = 0; i < n; i++) {
-            if(System.out != null) {//findbugs
-                System.out.print("  ");
-            }
+          System.out.print("  ");
         }
-    }
+      }
 
-    void enter(String name) {
+      void enter(String name) {
         if (verbose) {
-            if (state.backtracking == 0) {
-                print_tabs(depth);
-                debug_print("+ " + name);
-                depth++;
-            }
-        }
-    }
-
-    void exit(String name) {
+           if (state.backtracking == 0) {
+                   print_tabs(depth);
+                   debug_print("+ " + name);
+                   depth++;
+                 }
+         }
+      }
+
+      void exit(String name) {
         if (verbose) {
-            depth--;
-            print_tabs(depth);
-            debug_print("- " + name);
-        }
-    }
+           depth--;
+           print_tabs(depth);
+           debug_print("- " + name);
+         }
+      }
 
-    void debug_print(String str) {
+      void debug_print(String str) {
         if (verbose) {
-            if(System.out != null) {//findbugs
-                System.out.println(str);
-            }
+          System.out.println(str);
         }
-    }
+      }
+
+      int depth = 0;
 
-    int depth = 0;
+      /* Prints rule entry and exit while parsing */
+      boolean verbose = false;
 
-    /* Prints rule entry and exit while parsing */
-    boolean verbose = false;
 
     public static class parse_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "parse"
-    // Grammar/CTFParser.g:198:1: parse : ( declaration )+ EOF -> ^( ROOT (
-    // declaration )+ ) ;
+    // CTFParser.g:199:1: parse : ( declaration )+ EOF -> ^( ROOT ( declaration )+ ) ;
     public final CTFParser.parse_return parse() throws RecognitionException {
         Symbols_stack.push(new Symbols_scope());
 
@@ -358,136 +304,123 @@ public class CTFParser extends Parser {
 
         CommonTree root_0 = null;
 
-        Token EOF2 = null;
+        Token EOF2=null;
         CTFParser.declaration_return declaration1 = null;
 
-        CommonTree EOF2_tree = null;
-        RewriteRuleTokenStream stream_EOF = new RewriteRuleTokenStream(adaptor,
-                "token EOF");
-        RewriteRuleSubtreeStream stream_declaration = new RewriteRuleSubtreeStream(
-                adaptor, "rule declaration");
 
-        enter("parse");
-        debug_print("Scope push " + Symbols_stack.size());
-        ((Symbols_scope) Symbols_stack.peek()).types = new HashSet<String>();
+        CommonTree EOF2_tree=null;
+        RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
+        RewriteRuleSubtreeStream stream_declaration=new RewriteRuleSubtreeStream(adaptor,"rule declaration");
+
+          enter("parse");
+          debug_print("Scope push " + Symbols_stack.size());
+          ((Symbols_scope)Symbols_stack.peek()).types = new HashSet<String>();
 
         try {
-            // Grammar/CTFParser.g:211:1: ( ( declaration )+ EOF -> ^( ROOT (
-            // declaration )+ ) )
-            // Grammar/CTFParser.g:212:3: ( declaration )+ EOF
+            // CTFParser.g:212:1: ( ( declaration )+ EOF -> ^( ROOT ( declaration )+ ) )
+            // CTFParser.g:213:3: ( declaration )+ EOF
             {
-                // Grammar/CTFParser.g:212:3: ( declaration )+
-                int cnt1 = 0;
-                loop1: do {
-                    int alt1 = 2;
-                    int LA1_0 = input.LA(1);
-
-                    if ((((LA1_0 >= CONSTTOK) && (LA1_0 <= ENUMTOK))
-                            || ((LA1_0 >= FLOATINGPOINTTOK) && (LA1_0 <= SIGNEDTOK))
-                            || ((LA1_0 >= STRINGTOK) && (LA1_0 <= STRUCTTOK)) || ((LA1_0 >= TYPEDEFTOK) && (LA1_0 <= IMAGINARYTOK)))) {
-                        alt1 = 1;
-                    } else if ((LA1_0 == IDENTIFIER)
-                            && ((inTypealiasAlias() || isTypeName(input.LT(1)
-                                    .getText())))) {
-                        alt1 = 1;
-                    } else if (((LA1_0 == EVENTTOK) || (LA1_0 == STREAMTOK)
-                            || ((LA1_0 >= TRACETOK) && (LA1_0 <= TYPEALIASTOK)) || ((LA1_0 >= ENVTOK) && (LA1_0 <= CLOCKTOK)))) {
-                        alt1 = 1;
-                    }
-
-                    switch (alt1) {
-                    case 1:
-                    // Grammar/CTFParser.g:212:3: declaration
-                    {
-                        pushFollow(FOLLOW_declaration_in_parse321);
-                        declaration1 = declaration();
-
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_declaration.add(declaration1.getTree());
-                        }
+            // CTFParser.g:213:3: ( declaration )+
+            int cnt1=0;
+            loop1:
+            do {
+                int alt1=2;
+                int LA1_0 = input.LA(1);
 
-                    }
-                        break;
+                if ( ((LA1_0>=CONSTTOK && LA1_0<=ENUMTOK)||(LA1_0>=FLOATINGPOINTTOK && LA1_0<=SIGNEDTOK)||(LA1_0>=STRINGTOK && LA1_0<=STRUCTTOK)||(LA1_0>=TYPEDEFTOK && LA1_0<=IMAGINARYTOK)) ) {
+                    alt1=1;
+                }
+                else if ( (LA1_0==IDENTIFIER) && ((inTypealiasAlias() || isTypeName(input.LT(1).getText())))) {
+                    alt1=1;
+                }
+                else if ( (LA1_0==EVENTTOK||LA1_0==STREAMTOK||(LA1_0>=TRACETOK && LA1_0<=TYPEALIASTOK)||(LA1_0>=ENVTOK && LA1_0<=CALLSITETOK)) ) {
+                    alt1=1;
+                }
 
-                    default:
-                        if (cnt1 >= 1) {
-                            break loop1;
-                        }
-                        if (state.backtracking > 0) {
-                            state.failed = true;
-                            return retval;
-                        }
-                        EarlyExitException eee = new EarlyExitException(1,
-                                input);
-                        throw eee;
+
+                switch (alt1) {
+               case 1 :
+                   // CTFParser.g:213:3: declaration
+                   {
+                   pushFollow(FOLLOW_declaration_in_parse325);
+                   declaration1=declaration();
+
+                   state._fsp--;
+                   if (state.failed) {
+                        return retval;
+                    }
+                   if ( state.backtracking==0 ) {
+                        stream_declaration.add(declaration1.getTree());
                     }
-                    cnt1++;
-                } while (true);
 
-                EOF2 = (Token) match(input, EOF, FOLLOW_EOF_in_parse324);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_EOF.add(EOF2);
+                   }
+                   break;
+
+               default :
+                   if ( cnt1 >= 1 ) {
+                        break loop1;
+                    }
+                   if (state.backtracking>0) {state.failed=true; return retval;}
+                        EarlyExitException eee =
+                            new EarlyExitException(1, input);
+                        throw eee;
                 }
+                cnt1++;
+            } while (true);
 
-                // AST REWRITE
-                // elements: declaration
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
+            EOF2=(Token)match(input,EOF,FOLLOW_EOF_in_parse328); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_EOF.add(EOF2);
+            }
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 212:20: -> ^( ROOT ( declaration )+ )
-                    {
-                        // Grammar/CTFParser.g:212:23: ^( ROOT ( declaration )+
-                        // )
-                        {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(
-                                    adaptor.create(ROOT, "ROOT"), root_1);
 
-                            if (!(stream_declaration.hasNext())) {
-                                throw new RewriteEarlyExitException();
-                            }
-                            while (stream_declaration.hasNext()) {
-                                adaptor.addChild(root_1,
-                                        stream_declaration.nextTree());
 
-                            }
-                            stream_declaration.reset();
+            // AST REWRITE
+            // elements: declaration
+            // token labels:
+            // rule labels: retval
+            // token list labels:
+            // rule list labels:
+            // wildcard labels:
+            if ( state.backtracking==0 ) {
+            retval.tree = root_0;
+            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                            adaptor.addChild(root_0, root_1);
-                        }
+            root_0 = (CommonTree)adaptor.nil();
+            // 213:20: -> ^( ROOT ( declaration )+ )
+            {
+                // CTFParser.g:213:23: ^( ROOT ( declaration )+ )
+                {
+                CommonTree root_1 = (CommonTree)adaptor.nil();
+                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ROOT, "ROOT"), root_1);
 
-                    }
+                if ( !(stream_declaration.hasNext()) ) {
+                    throw new RewriteEarlyExitException();
+                }
+                while ( stream_declaration.hasNext() ) {
+                    adaptor.addChild(root_1, stream_declaration.nextTree());
 
-                    retval.tree = root_0;
                 }
+                stream_declaration.reset();
+
+                adaptor.addChild(root_0, root_1);
+                }
+
+            }
+
+            retval.tree = root_0;}
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 debug_print("Scope pop " + Symbols_stack.size());
                 exit("parse");
@@ -497,143 +430,122 @@ public class CTFParser extends Parser {
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-        } finally {
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
             Symbols_stack.pop();
 
         }
         return retval;
     }
-
     // $ANTLR end "parse"
 
     public static class numberLiteral_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "numberLiteral"
-    // Grammar/CTFParser.g:215:1: numberLiteral : ( SIGN )* ( HEX_LITERAL -> ^(
-    // UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN )* ) | DECIMAL_LITERAL -> ^(
-    // UNARY_EXPRESSION_DEC DECIMAL_LITERAL ( SIGN )* ) | OCTAL_LITERAL -> ^(
-    // UNARY_EXPRESSION_OCT OCTAL_LITERAL ( SIGN )* ) ) ;
-    public final CTFParser.numberLiteral_return numberLiteral()
-            throws RecognitionException {
+    // CTFParser.g:216:1: numberLiteral : ( SIGN )* ( HEX_LITERAL -> ^( UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN )* ) | DECIMAL_LITERAL -> ^( UNARY_EXPRESSION_DEC DECIMAL_LITERAL ( SIGN )* ) | OCTAL_LITERAL -> ^( UNARY_EXPRESSION_OCT OCTAL_LITERAL ( SIGN )* ) ) ;
+    public final CTFParser.numberLiteral_return numberLiteral() throws RecognitionException {
         CTFParser.numberLiteral_return retval = new CTFParser.numberLiteral_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token SIGN3 = null;
-        Token HEX_LITERAL4 = null;
-        Token DECIMAL_LITERAL5 = null;
-        Token OCTAL_LITERAL6 = null;
-
-        CommonTree SIGN3_tree = null;
-        CommonTree HEX_LITERAL4_tree = null;
-        CommonTree DECIMAL_LITERAL5_tree = null;
-        CommonTree OCTAL_LITERAL6_tree = null;
-        RewriteRuleTokenStream stream_SIGN = new RewriteRuleTokenStream(
-                adaptor, "token SIGN");
-        RewriteRuleTokenStream stream_OCTAL_LITERAL = new RewriteRuleTokenStream(
-                adaptor, "token OCTAL_LITERAL");
-        RewriteRuleTokenStream stream_HEX_LITERAL = new RewriteRuleTokenStream(
-                adaptor, "token HEX_LITERAL");
-        RewriteRuleTokenStream stream_DECIMAL_LITERAL = new RewriteRuleTokenStream(
-                adaptor, "token DECIMAL_LITERAL");
-
-        enter("numberLiteral");
+        Token SIGN3=null;
+        Token HEX_LITERAL4=null;
+        Token DECIMAL_LITERAL5=null;
+        Token OCTAL_LITERAL6=null;
+
+        CommonTree SIGN3_tree=null;
+        CommonTree HEX_LITERAL4_tree=null;
+        CommonTree DECIMAL_LITERAL5_tree=null;
+        CommonTree OCTAL_LITERAL6_tree=null;
+        RewriteRuleTokenStream stream_SIGN=new RewriteRuleTokenStream(adaptor,"token SIGN");
+        RewriteRuleTokenStream stream_OCTAL_LITERAL=new RewriteRuleTokenStream(adaptor,"token OCTAL_LITERAL");
+        RewriteRuleTokenStream stream_HEX_LITERAL=new RewriteRuleTokenStream(adaptor,"token HEX_LITERAL");
+        RewriteRuleTokenStream stream_DECIMAL_LITERAL=new RewriteRuleTokenStream(adaptor,"token DECIMAL_LITERAL");
+
+
+          enter("numberLiteral");
 
         try {
-            // Grammar/CTFParser.g:223:1: ( ( SIGN )* ( HEX_LITERAL -> ^(
-            // UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN )* ) | DECIMAL_LITERAL ->
-            // ^( UNARY_EXPRESSION_DEC DECIMAL_LITERAL ( SIGN )* ) |
-            // OCTAL_LITERAL -> ^( UNARY_EXPRESSION_OCT OCTAL_LITERAL ( SIGN )*
-            // ) ) )
-            // Grammar/CTFParser.g:224:3: ( SIGN )* ( HEX_LITERAL -> ^(
-            // UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN )* ) | DECIMAL_LITERAL ->
-            // ^( UNARY_EXPRESSION_DEC DECIMAL_LITERAL ( SIGN )* ) |
-            // OCTAL_LITERAL -> ^( UNARY_EXPRESSION_OCT OCTAL_LITERAL ( SIGN )*
-            // ) )
+            // CTFParser.g:224:1: ( ( SIGN )* ( HEX_LITERAL -> ^( UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN )* ) | DECIMAL_LITERAL -> ^( UNARY_EXPRESSION_DEC DECIMAL_LITERAL ( SIGN )* ) | OCTAL_LITERAL -> ^( UNARY_EXPRESSION_OCT OCTAL_LITERAL ( SIGN )* ) ) )
+            // CTFParser.g:225:3: ( SIGN )* ( HEX_LITERAL -> ^( UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN )* ) | DECIMAL_LITERAL -> ^( UNARY_EXPRESSION_DEC DECIMAL_LITERAL ( SIGN )* ) | OCTAL_LITERAL -> ^( UNARY_EXPRESSION_OCT OCTAL_LITERAL ( SIGN )* ) )
             {
-                // Grammar/CTFParser.g:224:3: ( SIGN )*
-                loop2: do {
-                    int alt2 = 2;
-                    int LA2_0 = input.LA(1);
+            // CTFParser.g:225:3: ( SIGN )*
+            loop2:
+            do {
+                int alt2=2;
+                int LA2_0 = input.LA(1);
 
-                    if ((LA2_0 == SIGN)) {
-                        alt2 = 1;
-                    }
+                if ( (LA2_0==SIGN) ) {
+                    alt2=1;
+                }
 
-                    switch (alt2) {
-                    case 1:
-                    // Grammar/CTFParser.g:224:3: SIGN
-                    {
-                        SIGN3 = (Token) match(input, SIGN,
-                                FOLLOW_SIGN_in_numberLiteral357);
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_SIGN.add(SIGN3);
-                        }
 
+                switch (alt2) {
+               case 1 :
+                   // CTFParser.g:225:3: SIGN
+                   {
+                   SIGN3=(Token)match(input,SIGN,FOLLOW_SIGN_in_numberLiteral361); if (state.failed) {
+                        return retval;
                     }
-                        break;
-
-                    default:
-                        break loop2;
+                   if ( state.backtracking==0 ) {
+                        stream_SIGN.add(SIGN3);
                     }
-                } while (true);
 
-                // Grammar/CTFParser.g:224:10: ( HEX_LITERAL -> ^(
-                // UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN )* ) |
-                // DECIMAL_LITERAL -> ^( UNARY_EXPRESSION_DEC DECIMAL_LITERAL (
-                // SIGN )* ) | OCTAL_LITERAL -> ^( UNARY_EXPRESSION_OCT
-                // OCTAL_LITERAL ( SIGN )* ) )
-                int alt3 = 3;
-                switch (input.LA(1)) {
-                case HEX_LITERAL: {
-                    alt3 = 1;
+
+                   }
+                   break;
+
+               default :
+                   break loop2;
                 }
-                    break;
-                case DECIMAL_LITERAL: {
-                    alt3 = 2;
+            } while (true);
+
+            // CTFParser.g:225:10: ( HEX_LITERAL -> ^( UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN )* ) | DECIMAL_LITERAL -> ^( UNARY_EXPRESSION_DEC DECIMAL_LITERAL ( SIGN )* ) | OCTAL_LITERAL -> ^( UNARY_EXPRESSION_OCT OCTAL_LITERAL ( SIGN )* ) )
+            int alt3=3;
+            switch ( input.LA(1) ) {
+            case HEX_LITERAL:
+                {
+                alt3=1;
                 }
-                    break;
-                case OCTAL_LITERAL: {
-                    alt3 = 3;
+                break;
+            case DECIMAL_LITERAL:
+                {
+                alt3=2;
                 }
-                    break;
-                default:
-                    if (state.backtracking > 0) {
-                        state.failed = true;
-                        return retval;
-                    }
-                    NoViableAltException nvae = new NoViableAltException("", 3,
-                            0, input);
-
-                    throw nvae;
+                break;
+            case OCTAL_LITERAL:
+                {
+                alt3=3;
                 }
+                break;
+            default:
+                if (state.backtracking>0) {state.failed=true; return retval;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 3, 0, input);
 
-                switch (alt3) {
-                case 1:
-                // Grammar/CTFParser.g:224:11: HEX_LITERAL
-                {
-                    HEX_LITERAL4 = (Token) match(input, HEX_LITERAL,
-                            FOLLOW_HEX_LITERAL_in_numberLiteral362);
-                    if (state.failed) {
+                throw nvae;
+            }
+
+            switch (alt3) {
+                case 1 :
+                    // CTFParser.g:225:11: HEX_LITERAL
+                    {
+                    HEX_LITERAL4=(Token)match(input,HEX_LITERAL,FOLLOW_HEX_LITERAL_in_numberLiteral366); if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
+                    if ( state.backtracking==0 ) {
                         stream_HEX_LITERAL.add(HEX_LITERAL4);
                     }
 
+
+
                     // AST REWRITE
                     // elements: SIGN, HEX_LITERAL
                     // token labels:
@@ -641,57 +553,46 @@ public class CTFParser extends Parser {
                     // token list labels:
                     // rule list labels:
                     // wildcard labels:
-                    if (state.backtracking == 0) {
-                        retval.tree = root_0;
-//                        RewriteRuleSubtreeStream stream_retval =
-                                new RewriteRuleSubtreeStream(
-                                adaptor, "rule retval",
-                                retval != null ? retval.tree : null);
-
-                        root_0 = (CommonTree) adaptor.nil();
-                        // 224:23: -> ^( UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN
-                        // )* )
+                    if ( state.backtracking==0 ) {
+                    retval.tree = root_0;
+                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+                    root_0 = (CommonTree)adaptor.nil();
+                    // 225:23: -> ^( UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN )* )
+                    {
+                        // CTFParser.g:225:26: ^( UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN )* )
                         {
-                            // Grammar/CTFParser.g:224:26: ^(
-                            // UNARY_EXPRESSION_HEX HEX_LITERAL ( SIGN )* )
-                            {
-                                CommonTree root_1 = (CommonTree) adaptor.nil();
-                                root_1 = (CommonTree) adaptor
-                                        .becomeRoot(adaptor.create(
-                                                UNARY_EXPRESSION_HEX,
-                                                "UNARY_EXPRESSION_HEX"), root_1);
-
-                                adaptor.addChild(root_1,
-                                        stream_HEX_LITERAL.nextNode());
-                                // Grammar/CTFParser.g:224:61: ( SIGN )*
-                                while (stream_SIGN.hasNext()) {
-                                    adaptor.addChild(root_1,
-                                            stream_SIGN.nextNode());
+                        CommonTree root_1 = (CommonTree)adaptor.nil();
+                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(UNARY_EXPRESSION_HEX, "UNARY_EXPRESSION_HEX"), root_1);
 
-                                }
-                                stream_SIGN.reset();
+                        adaptor.addChild(root_1, stream_HEX_LITERAL.nextNode());
+                        // CTFParser.g:225:61: ( SIGN )*
+                        while ( stream_SIGN.hasNext() ) {
+                            adaptor.addChild(root_1, stream_SIGN.nextNode());
 
-                                adaptor.addChild(root_0, root_1);
-                            }
+                        }
+                        stream_SIGN.reset();
 
+                        adaptor.addChild(root_0, root_1);
                         }
 
-                        retval.tree = root_0;
                     }
-                }
+
+                    retval.tree = root_0;}
+                    }
                     break;
-                case 2:
-                // Grammar/CTFParser.g:225:5: DECIMAL_LITERAL
-                {
-                    DECIMAL_LITERAL5 = (Token) match(input, DECIMAL_LITERAL,
-                            FOLLOW_DECIMAL_LITERAL_in_numberLiteral379);
-                    if (state.failed) {
+                case 2 :
+                    // CTFParser.g:226:5: DECIMAL_LITERAL
+                    {
+                    DECIMAL_LITERAL5=(Token)match(input,DECIMAL_LITERAL,FOLLOW_DECIMAL_LITERAL_in_numberLiteral383); if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
+                    if ( state.backtracking==0 ) {
                         stream_DECIMAL_LITERAL.add(DECIMAL_LITERAL5);
                     }
 
+
+
                     // AST REWRITE
                     // elements: DECIMAL_LITERAL, SIGN
                     // token labels:
@@ -699,931 +600,814 @@ public class CTFParser extends Parser {
                     // token list labels:
                     // rule list labels:
                     // wildcard labels:
-                    if (state.backtracking == 0) {
-                        retval.tree = root_0;
-//                        RewriteRuleSubtreeStream stream_retval =
-                                new RewriteRuleSubtreeStream(
-                                adaptor, "rule retval",
-                                retval != null ? retval.tree : null);
-
-                        root_0 = (CommonTree) adaptor.nil();
-                        // 225:21: -> ^( UNARY_EXPRESSION_DEC DECIMAL_LITERAL (
-                        // SIGN )* )
+                    if ( state.backtracking==0 ) {
+                    retval.tree = root_0;
+                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+                    root_0 = (CommonTree)adaptor.nil();
+                    // 226:21: -> ^( UNARY_EXPRESSION_DEC DECIMAL_LITERAL ( SIGN )* )
+                    {
+                        // CTFParser.g:226:24: ^( UNARY_EXPRESSION_DEC DECIMAL_LITERAL ( SIGN )* )
                         {
-                            // Grammar/CTFParser.g:225:24: ^(
-                            // UNARY_EXPRESSION_DEC DECIMAL_LITERAL ( SIGN )* )
-                            {
-                                CommonTree root_1 = (CommonTree) adaptor.nil();
-                                root_1 = (CommonTree) adaptor
-                                        .becomeRoot(adaptor.create(
-                                                UNARY_EXPRESSION_DEC,
-                                                "UNARY_EXPRESSION_DEC"), root_1);
-
-                                adaptor.addChild(root_1,
-                                        stream_DECIMAL_LITERAL.nextNode());
-                                // Grammar/CTFParser.g:225:63: ( SIGN )*
-                                while (stream_SIGN.hasNext()) {
-                                    adaptor.addChild(root_1,
-                                            stream_SIGN.nextNode());
+                        CommonTree root_1 = (CommonTree)adaptor.nil();
+                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(UNARY_EXPRESSION_DEC, "UNARY_EXPRESSION_DEC"), root_1);
 
-                                }
-                                stream_SIGN.reset();
+                        adaptor.addChild(root_1, stream_DECIMAL_LITERAL.nextNode());
+                        // CTFParser.g:226:63: ( SIGN )*
+                        while ( stream_SIGN.hasNext() ) {
+                            adaptor.addChild(root_1, stream_SIGN.nextNode());
 
-                                adaptor.addChild(root_0, root_1);
-                            }
+                        }
+                        stream_SIGN.reset();
 
+                        adaptor.addChild(root_0, root_1);
                         }
 
-                        retval.tree = root_0;
                     }
-                }
+
+                    retval.tree = root_0;}
+                    }
                     break;
-                case 3:
-                // Grammar/CTFParser.g:226:5: OCTAL_LITERAL
-                {
-                    OCTAL_LITERAL6 = (Token) match(input, OCTAL_LITERAL,
-                            FOLLOW_OCTAL_LITERAL_in_numberLiteral396);
-                    if (state.failed) {
+                case 3 :
+                    // CTFParser.g:227:5: OCTAL_LITERAL
+                    {
+                    OCTAL_LITERAL6=(Token)match(input,OCTAL_LITERAL,FOLLOW_OCTAL_LITERAL_in_numberLiteral400); if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
+                    if ( state.backtracking==0 ) {
                         stream_OCTAL_LITERAL.add(OCTAL_LITERAL6);
                     }
 
+
+
                     // AST REWRITE
-                    // elements: SIGN, OCTAL_LITERAL
+                    // elements: OCTAL_LITERAL, SIGN
                     // token labels:
                     // rule labels: retval
                     // token list labels:
                     // rule list labels:
                     // wildcard labels:
-                    if (state.backtracking == 0) {
-                        retval.tree = root_0;
-//                        RewriteRuleSubtreeStream stream_retval =
-                                new RewriteRuleSubtreeStream(
-                                adaptor, "rule retval",
-                                retval != null ? retval.tree : null);
-
-                        root_0 = (CommonTree) adaptor.nil();
-                        // 226:19: -> ^( UNARY_EXPRESSION_OCT OCTAL_LITERAL (
-                        // SIGN )* )
+                    if ( state.backtracking==0 ) {
+                    retval.tree = root_0;
+                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+                    root_0 = (CommonTree)adaptor.nil();
+                    // 227:19: -> ^( UNARY_EXPRESSION_OCT OCTAL_LITERAL ( SIGN )* )
+                    {
+                        // CTFParser.g:227:22: ^( UNARY_EXPRESSION_OCT OCTAL_LITERAL ( SIGN )* )
                         {
-                            // Grammar/CTFParser.g:226:22: ^(
-                            // UNARY_EXPRESSION_OCT OCTAL_LITERAL ( SIGN )* )
-                            {
-                                CommonTree root_1 = (CommonTree) adaptor.nil();
-                                root_1 = (CommonTree) adaptor
-                                        .becomeRoot(adaptor.create(
-                                                UNARY_EXPRESSION_OCT,
-                                                "UNARY_EXPRESSION_OCT"), root_1);
-
-                                adaptor.addChild(root_1,
-                                        stream_OCTAL_LITERAL.nextNode());
-                                // Grammar/CTFParser.g:226:59: ( SIGN )*
-                                while (stream_SIGN.hasNext()) {
-                                    adaptor.addChild(root_1,
-                                            stream_SIGN.nextNode());
+                        CommonTree root_1 = (CommonTree)adaptor.nil();
+                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(UNARY_EXPRESSION_OCT, "UNARY_EXPRESSION_OCT"), root_1);
 
-                                }
-                                stream_SIGN.reset();
+                        adaptor.addChild(root_1, stream_OCTAL_LITERAL.nextNode());
+                        // CTFParser.g:227:59: ( SIGN )*
+                        while ( stream_SIGN.hasNext() ) {
+                            adaptor.addChild(root_1, stream_SIGN.nextNode());
 
-                                adaptor.addChild(root_0, root_1);
-                            }
+                        }
+                        stream_SIGN.reset();
 
+                        adaptor.addChild(root_0, root_1);
                         }
 
-                        retval.tree = root_0;
                     }
-                }
+
+                    retval.tree = root_0;}
+                    }
                     break;
 
-                }
+            }
+
 
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                debug_print(input.toString(retval.start, input.LT(-1)));
+                debug_print(input.toString(retval.start,input.LT(-1)));
                 exit("numberLiteral");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "numberLiteral"
 
     public static class constant_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "constant"
-    // Grammar/CTFParser.g:229:1: constant : ( numberLiteral | enumConstant |
-    // CHARACTER_LITERAL );
-    public final CTFParser.constant_return constant()
-            throws RecognitionException {
+    // CTFParser.g:230:1: constant : ( numberLiteral | enumConstant | CHARACTER_LITERAL );
+    public final CTFParser.constant_return constant() throws RecognitionException {
         CTFParser.constant_return retval = new CTFParser.constant_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token CHARACTER_LITERAL9 = null;
+        Token CHARACTER_LITERAL9=null;
         CTFParser.numberLiteral_return numberLiteral7 = null;
 
         CTFParser.enumConstant_return enumConstant8 = null;
 
-        CommonTree CHARACTER_LITERAL9_tree = null;
 
-        enter("constant");
+        CommonTree CHARACTER_LITERAL9_tree=null;
+
+
+          enter("constant");
 
         try {
-            // Grammar/CTFParser.g:236:1: ( numberLiteral | enumConstant |
-            // CHARACTER_LITERAL )
-            int alt4 = 3;
-            switch (input.LA(1)) {
+            // CTFParser.g:237:1: ( numberLiteral | enumConstant | CHARACTER_LITERAL )
+            int alt4=3;
+            switch ( input.LA(1) ) {
             case SIGN:
             case OCTAL_LITERAL:
             case DECIMAL_LITERAL:
-            case HEX_LITERAL: {
-                alt4 = 1;
-            }
+            case HEX_LITERAL:
+                {
+                alt4=1;
+                }
                 break;
             case ALIGNTOK:
             case EVENTTOK:
             case SIGNEDTOK:
             case STRINGTOK:
             case STRING_LITERAL:
-            case IDENTIFIER: {
-                alt4 = 2;
-            }
+            case IDENTIFIER:
+                {
+                alt4=2;
+                }
                 break;
-            case CHARACTER_LITERAL: {
-                alt4 = 3;
-            }
+            case CHARACTER_LITERAL:
+                {
+                alt4=3;
+                }
                 break;
             default:
-                if (state.backtracking > 0) {
-                    state.failed = true;
-                    return retval;
-                }
-                NoViableAltException nvae = new NoViableAltException("", 4, 0,
-                        input);
+                if (state.backtracking>0) {state.failed=true; return retval;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 4, 0, input);
 
                 throw nvae;
             }
 
             switch (alt4) {
-            case 1:
-            // Grammar/CTFParser.g:237:4: numberLiteral
-            {
-                root_0 = (CommonTree) adaptor.nil();
+                case 1 :
+                    // CTFParser.g:238:4: numberLiteral
+                    {
+                    root_0 = (CommonTree)adaptor.nil();
 
-                pushFollow(FOLLOW_numberLiteral_in_constant432);
-                numberLiteral7 = numberLiteral();
+                    pushFollow(FOLLOW_numberLiteral_in_constant436);
+                    numberLiteral7=numberLiteral();
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    adaptor.addChild(root_0, numberLiteral7.getTree());
-                }
+                    state._fsp--;
+                    if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        adaptor.addChild(root_0, numberLiteral7.getTree());
+                    }
 
-            }
-                break;
-            case 2:
-            // Grammar/CTFParser.g:238:5: enumConstant
-            {
-                root_0 = (CommonTree) adaptor.nil();
+                    }
+                    break;
+                case 2 :
+                    // CTFParser.g:239:5: enumConstant
+                    {
+                    root_0 = (CommonTree)adaptor.nil();
 
-                pushFollow(FOLLOW_enumConstant_in_constant438);
-                enumConstant8 = enumConstant();
+                    pushFollow(FOLLOW_enumConstant_in_constant442);
+                    enumConstant8=enumConstant();
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    adaptor.addChild(root_0, enumConstant8.getTree());
-                }
+                    state._fsp--;
+                    if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        adaptor.addChild(root_0, enumConstant8.getTree());
+                    }
 
-            }
-                break;
-            case 3:
-            // Grammar/CTFParser.g:239:5: CHARACTER_LITERAL
-            {
-                root_0 = (CommonTree) adaptor.nil();
+                    }
+                    break;
+                case 3 :
+                    // CTFParser.g:240:5: CHARACTER_LITERAL
+                    {
+                    root_0 = (CommonTree)adaptor.nil();
 
-                CHARACTER_LITERAL9 = (Token) match(input, CHARACTER_LITERAL,
-                        FOLLOW_CHARACTER_LITERAL_in_constant444);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    CHARACTER_LITERAL9_tree = (CommonTree) adaptor
-                            .create(CHARACTER_LITERAL9);
+                    CHARACTER_LITERAL9=(Token)match(input,CHARACTER_LITERAL,FOLLOW_CHARACTER_LITERAL_in_constant448); if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                    CHARACTER_LITERAL9_tree = (CommonTree)adaptor.create(CHARACTER_LITERAL9);
                     adaptor.addChild(root_0, CHARACTER_LITERAL9_tree);
-                }
+                    }
 
-            }
-                break;
+                    }
+                    break;
 
             }
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 exit("constant");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "constant"
 
     public static class primaryExpression_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "primaryExpression"
-    // Grammar/CTFParser.g:242:1: primaryExpression : ( ( IDENTIFIER )=>
-    // IDENTIFIER -> ^( UNARY_EXPRESSION_STRING IDENTIFIER ) | ( ctfKeyword )=>
-    // ctfKeyword -> ^( UNARY_EXPRESSION_STRING ctfKeyword ) | ( STRING_LITERAL
-    // )=> STRING_LITERAL -> ^( UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL )
-    // | constant );
-    public final CTFParser.primaryExpression_return primaryExpression()
-            throws RecognitionException {
+    // CTFParser.g:243:1: primaryExpression : ( ( IDENTIFIER )=> IDENTIFIER -> ^( UNARY_EXPRESSION_STRING IDENTIFIER ) | ( ctfKeyword )=> ctfKeyword -> ^( UNARY_EXPRESSION_STRING ctfKeyword ) | ( STRING_LITERAL )=> STRING_LITERAL -> ^( UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL ) | constant );
+    public final CTFParser.primaryExpression_return primaryExpression() throws RecognitionException {
         CTFParser.primaryExpression_return retval = new CTFParser.primaryExpression_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token IDENTIFIER10 = null;
-        Token STRING_LITERAL12 = null;
+        Token IDENTIFIER10=null;
+        Token STRING_LITERAL12=null;
         CTFParser.ctfKeyword_return ctfKeyword11 = null;
 
         CTFParser.constant_return constant13 = null;
 
-        CommonTree IDENTIFIER10_tree = null;
-        CommonTree STRING_LITERAL12_tree = null;
-        RewriteRuleTokenStream stream_STRING_LITERAL = new RewriteRuleTokenStream(
-                adaptor, "token STRING_LITERAL");
-        RewriteRuleTokenStream stream_IDENTIFIER = new RewriteRuleTokenStream(
-                adaptor, "token IDENTIFIER");
-        RewriteRuleSubtreeStream stream_ctfKeyword = new RewriteRuleSubtreeStream(
-                adaptor, "rule ctfKeyword");
 
-        enter("primaryExpression");
+        CommonTree IDENTIFIER10_tree=null;
+        CommonTree STRING_LITERAL12_tree=null;
+        RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL");
+        RewriteRuleTokenStream stream_IDENTIFIER=new RewriteRuleTokenStream(adaptor,"token IDENTIFIER");
+        RewriteRuleSubtreeStream stream_ctfKeyword=new RewriteRuleSubtreeStream(adaptor,"rule ctfKeyword");
+
+          enter("primaryExpression");
 
         try {
-            // Grammar/CTFParser.g:249:1: ( ( IDENTIFIER )=> IDENTIFIER -> ^(
-            // UNARY_EXPRESSION_STRING IDENTIFIER ) | ( ctfKeyword )=>
-            // ctfKeyword -> ^( UNARY_EXPRESSION_STRING ctfKeyword ) | (
-            // STRING_LITERAL )=> STRING_LITERAL -> ^(
-            // UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL ) | constant )
-            int alt5 = 4;
-            switch (input.LA(1)) {
-            case IDENTIFIER: {
+            // CTFParser.g:250:1: ( ( IDENTIFIER )=> IDENTIFIER -> ^( UNARY_EXPRESSION_STRING IDENTIFIER ) | ( ctfKeyword )=> ctfKeyword -> ^( UNARY_EXPRESSION_STRING ctfKeyword ) | ( STRING_LITERAL )=> STRING_LITERAL -> ^( UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL ) | constant )
+            int alt5=4;
+            switch ( input.LA(1) ) {
+            case IDENTIFIER:
+                {
                 int LA5_1 = input.LA(2);
 
-                if ((synpred1_CTFParser())) {
-                    alt5 = 1;
-                } else if ((true)) {
-                    alt5 = 4;
-                } else {
-                    if (state.backtracking > 0) {
-                        state.failed = true;
-                        return retval;
-                    }
-                    NoViableAltException nvae = new NoViableAltException("", 5,
-                            1, input);
+                if ( (synpred1_CTFParser()) ) {
+                    alt5=1;
+                }
+                else if ( (true) ) {
+                    alt5=4;
+                }
+                else {
+                    if (state.backtracking>0) {state.failed=true; return retval;}
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 5, 1, input);
 
                     throw nvae;
                 }
-            }
+                }
                 break;
             case ALIGNTOK:
             case EVENTTOK:
             case SIGNEDTOK:
-            case STRINGTOK: {
+            case STRINGTOK:
+                {
                 int LA5_2 = input.LA(2);
 
-                if ((synpred2_CTFParser())) {
-                    alt5 = 2;
-                } else if ((true)) {
-                    alt5 = 4;
-                } else {
-                    if (state.backtracking > 0) {
-                        state.failed = true;
-                        return retval;
-                    }
-                    NoViableAltException nvae = new NoViableAltException("", 5,
-                            2, input);
+                if ( (synpred2_CTFParser()) ) {
+                    alt5=2;
+                }
+                else if ( (true) ) {
+                    alt5=4;
+                }
+                else {
+                    if (state.backtracking>0) {state.failed=true; return retval;}
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 5, 2, input);
 
                     throw nvae;
                 }
-            }
+                }
                 break;
-            case STRING_LITERAL: {
+            case STRING_LITERAL:
+                {
                 int LA5_3 = input.LA(2);
 
-                if ((synpred3_CTFParser())) {
-                    alt5 = 3;
-                } else if ((true)) {
-                    alt5 = 4;
-                } else {
-                    if (state.backtracking > 0) {
-                        state.failed = true;
-                        return retval;
-                    }
-                    NoViableAltException nvae = new NoViableAltException("", 5,
-                            3, input);
+                if ( (synpred3_CTFParser()) ) {
+                    alt5=3;
+                }
+                else if ( (true) ) {
+                    alt5=4;
+                }
+                else {
+                    if (state.backtracking>0) {state.failed=true; return retval;}
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 5, 3, input);
 
                     throw nvae;
                 }
-            }
+                }
                 break;
             case SIGN:
             case OCTAL_LITERAL:
             case DECIMAL_LITERAL:
             case HEX_LITERAL:
-            case CHARACTER_LITERAL: {
-                alt5 = 4;
-            }
+            case CHARACTER_LITERAL:
+                {
+                alt5=4;
+                }
                 break;
             default:
-                if (state.backtracking > 0) {
-                    state.failed = true;
-                    return retval;
-                }
-                NoViableAltException nvae = new NoViableAltException("", 5, 0,
-                        input);
+                if (state.backtracking>0) {state.failed=true; return retval;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 5, 0, input);
 
                 throw nvae;
             }
 
             switch (alt5) {
-            case 1:
-            // Grammar/CTFParser.g:250:5: ( IDENTIFIER )=> IDENTIFIER
-            {
-                IDENTIFIER10 = (Token) match(input, IDENTIFIER,
-                        FOLLOW_IDENTIFIER_in_primaryExpression475);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_IDENTIFIER.add(IDENTIFIER10);
-                }
+                case 1 :
+                    // CTFParser.g:251:5: ( IDENTIFIER )=> IDENTIFIER
+                    {
+                    IDENTIFIER10=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_primaryExpression479); if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        stream_IDENTIFIER.add(IDENTIFIER10);
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       debug_print("IDENTIFIER: " + (IDENTIFIER10!=null?IDENTIFIER10.getText():null));
+                    }
 
-                if (state.backtracking == 0) {
-                    debug_print("IDENTIFIER: "
-                            + (IDENTIFIER10 != null ? IDENTIFIER10.getText()
-                                    : null));
-                }
 
-                // AST REWRITE
-                // elements: IDENTIFIER
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
+                    // AST REWRITE
+                    // elements: IDENTIFIER
+                    // token labels:
+                    // rule labels: retval
+                    // token list labels:
+                    // rule list labels:
+                    // wildcard labels:
+                    if ( state.backtracking==0 ) {
                     retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
+                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 250:83: -> ^( UNARY_EXPRESSION_STRING IDENTIFIER )
+                    root_0 = (CommonTree)adaptor.nil();
+                    // 251:83: -> ^( UNARY_EXPRESSION_STRING IDENTIFIER )
                     {
-                        // Grammar/CTFParser.g:250:86: ^(
-                        // UNARY_EXPRESSION_STRING IDENTIFIER )
+                        // CTFParser.g:251:86: ^( UNARY_EXPRESSION_STRING IDENTIFIER )
                         {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(adaptor
-                                    .create(UNARY_EXPRESSION_STRING,
-                                            "UNARY_EXPRESSION_STRING"), root_1);
+                        CommonTree root_1 = (CommonTree)adaptor.nil();
+                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(UNARY_EXPRESSION_STRING, "UNARY_EXPRESSION_STRING"), root_1);
 
-                            adaptor.addChild(root_1,
-                                    stream_IDENTIFIER.nextNode());
+                        adaptor.addChild(root_1, stream_IDENTIFIER.nextNode());
 
-                            adaptor.addChild(root_0, root_1);
+                        adaptor.addChild(root_0, root_1);
                         }
 
                     }
 
-                    retval.tree = root_0;
-                }
-            }
-                break;
-            case 2:
-            // Grammar/CTFParser.g:251:5: ( ctfKeyword )=> ctfKeyword
-            {
-                pushFollow(FOLLOW_ctfKeyword_in_primaryExpression497);
-                ctfKeyword11 = ctfKeyword();
+                    retval.tree = root_0;}
+                    }
+                    break;
+                case 2 :
+                    // CTFParser.g:252:5: ( ctfKeyword )=> ctfKeyword
+                    {
+                    pushFollow(FOLLOW_ctfKeyword_in_primaryExpression501);
+                    ctfKeyword11=ctfKeyword();
+
+                    state._fsp--;
+                    if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        stream_ctfKeyword.add(ctfKeyword11.getTree());
+                    }
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_ctfKeyword.add(ctfKeyword11.getTree());
-                }
 
-                // AST REWRITE
-                // elements: ctfKeyword
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
+                    // AST REWRITE
+                    // elements: ctfKeyword
+                    // token labels:
+                    // rule labels: retval
+                    // token list labels:
+                    // rule list labels:
+                    // wildcard labels:
+                    if ( state.backtracking==0 ) {
                     retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
+                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 251:32: -> ^( UNARY_EXPRESSION_STRING ctfKeyword )
+                    root_0 = (CommonTree)adaptor.nil();
+                    // 252:32: -> ^( UNARY_EXPRESSION_STRING ctfKeyword )
                     {
-                        // Grammar/CTFParser.g:251:35: ^(
-                        // UNARY_EXPRESSION_STRING ctfKeyword )
+                        // CTFParser.g:252:35: ^( UNARY_EXPRESSION_STRING ctfKeyword )
                         {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(adaptor
-                                    .create(UNARY_EXPRESSION_STRING,
-                                            "UNARY_EXPRESSION_STRING"), root_1);
+                        CommonTree root_1 = (CommonTree)adaptor.nil();
+                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(UNARY_EXPRESSION_STRING, "UNARY_EXPRESSION_STRING"), root_1);
 
-                            adaptor.addChild(root_1,
-                                    stream_ctfKeyword.nextTree());
+                        adaptor.addChild(root_1, stream_ctfKeyword.nextTree());
 
-                            adaptor.addChild(root_0, root_1);
+                        adaptor.addChild(root_0, root_1);
                         }
 
                     }
 
-                    retval.tree = root_0;
-                }
-            }
-                break;
-            case 3:
-            // Grammar/CTFParser.g:252:5: ( STRING_LITERAL )=> STRING_LITERAL
-            {
-                STRING_LITERAL12 = (Token) match(input, STRING_LITERAL,
-                        FOLLOW_STRING_LITERAL_in_primaryExpression517);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_STRING_LITERAL.add(STRING_LITERAL12);
-                }
+                    retval.tree = root_0;}
+                    }
+                    break;
+                case 3 :
+                    // CTFParser.g:253:5: ( STRING_LITERAL )=> STRING_LITERAL
+                    {
+                    STRING_LITERAL12=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_primaryExpression521); if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        stream_STRING_LITERAL.add(STRING_LITERAL12);
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       debug_print("STRING_LITERAL: " + (STRING_LITERAL12!=null?STRING_LITERAL12.getText():null));
+                    }
 
-                if (state.backtracking == 0) {
-                    debug_print("STRING_LITERAL: "
-                            + (STRING_LITERAL12 != null ? STRING_LITERAL12
-                                    .getText() : null));
-                }
 
-                // AST REWRITE
-                // elements: STRING_LITERAL
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
+                    // AST REWRITE
+                    // elements: STRING_LITERAL
+                    // token labels:
+                    // rule labels: retval
+                    // token list labels:
+                    // rule list labels:
+                    // wildcard labels:
+                    if ( state.backtracking==0 ) {
                     retval.tree = root_0;
-                    new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
+                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 252:99: -> ^( UNARY_EXPRESSION_STRING_QUOTES
-                    // STRING_LITERAL )
+                    root_0 = (CommonTree)adaptor.nil();
+                    // 253:99: -> ^( UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL )
                     {
-                        // Grammar/CTFParser.g:252:102: ^(
-                        // UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL )
+                        // CTFParser.g:253:102: ^( UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL )
                         {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(adaptor
-                                    .create(UNARY_EXPRESSION_STRING_QUOTES,
-                                            "UNARY_EXPRESSION_STRING_QUOTES"),
-                                    root_1);
+                        CommonTree root_1 = (CommonTree)adaptor.nil();
+                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(UNARY_EXPRESSION_STRING_QUOTES, "UNARY_EXPRESSION_STRING_QUOTES"), root_1);
 
-                            adaptor.addChild(root_1,
-                                    stream_STRING_LITERAL.nextNode());
+                        adaptor.addChild(root_1, stream_STRING_LITERAL.nextNode());
 
-                            adaptor.addChild(root_0, root_1);
+                        adaptor.addChild(root_0, root_1);
                         }
 
                     }
 
-                    retval.tree = root_0;
-                }
-            }
-                break;
-            case 4:
-            // Grammar/CTFParser.g:254:5: constant
-            {
-                root_0 = (CommonTree) adaptor.nil();
+                    retval.tree = root_0;}
+                    }
+                    break;
+                case 4 :
+                    // CTFParser.g:255:5: constant
+                    {
+                    root_0 = (CommonTree)adaptor.nil();
 
-                pushFollow(FOLLOW_constant_in_primaryExpression538);
-                constant13 = constant();
+                    pushFollow(FOLLOW_constant_in_primaryExpression542);
+                    constant13=constant();
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    adaptor.addChild(root_0, constant13.getTree());
-                }
+                    state._fsp--;
+                    if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        adaptor.addChild(root_0, constant13.getTree());
+                    }
 
-            }
-                break;
+                    }
+                    break;
 
             }
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 exit("primaryExpression");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "primaryExpression"
 
     public static class reference_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "reference"
-    // Grammar/CTFParser.g:257:1: reference : (ref= DOT | ref= ARROW )
-    // IDENTIFIER -> ^( $ref ^( UNARY_EXPRESSION_STRING IDENTIFIER ) ) ;
-    public final CTFParser.reference_return reference()
-            throws RecognitionException {
+    // CTFParser.g:258:1: reference : (ref= DOT | ref= ARROW ) IDENTIFIER -> ^( $ref ^( UNARY_EXPRESSION_STRING IDENTIFIER ) ) ;
+    public final CTFParser.reference_return reference() throws RecognitionException {
         CTFParser.reference_return retval = new CTFParser.reference_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token ref = null;
-        Token IDENTIFIER14 = null;
+        Token ref=null;
+        Token IDENTIFIER14=null;
+
+        CommonTree ref_tree=null;
+        CommonTree IDENTIFIER14_tree=null;
+        RewriteRuleTokenStream stream_ARROW=new RewriteRuleTokenStream(adaptor,"token ARROW");
+        RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
+        RewriteRuleTokenStream stream_IDENTIFIER=new RewriteRuleTokenStream(adaptor,"token IDENTIFIER");
 
-        CommonTree ref_tree = null;
-        CommonTree IDENTIFIER14_tree = null;
-        RewriteRuleTokenStream stream_ARROW = new RewriteRuleTokenStream(
-                adaptor, "token ARROW");
-        RewriteRuleTokenStream stream_DOT = new RewriteRuleTokenStream(adaptor,
-                "token DOT");
-        RewriteRuleTokenStream stream_IDENTIFIER = new RewriteRuleTokenStream(
-                adaptor, "token IDENTIFIER");
 
-        enter("reference");
+          enter("reference");
 
         try {
-            // Grammar/CTFParser.g:265:1: ( (ref= DOT | ref= ARROW ) IDENTIFIER
-            // -> ^( $ref ^( UNARY_EXPRESSION_STRING IDENTIFIER ) ) )
-            // Grammar/CTFParser.g:266:3: (ref= DOT | ref= ARROW ) IDENTIFIER
+            // CTFParser.g:266:1: ( (ref= DOT | ref= ARROW ) IDENTIFIER -> ^( $ref ^( UNARY_EXPRESSION_STRING IDENTIFIER ) ) )
+            // CTFParser.g:267:3: (ref= DOT | ref= ARROW ) IDENTIFIER
             {
-                // Grammar/CTFParser.g:266:3: (ref= DOT | ref= ARROW )
-                int alt6 = 2;
-                int LA6_0 = input.LA(1);
-
-                if ((LA6_0 == DOT)) {
-                    alt6 = 1;
-                } else if ((LA6_0 == ARROW)) {
-                    alt6 = 2;
-                } else {
-                    if (state.backtracking > 0) {
-                        state.failed = true;
-                        return retval;
-                    }
-                    NoViableAltException nvae = new NoViableAltException("", 6,
-                            0, input);
+            // CTFParser.g:267:3: (ref= DOT | ref= ARROW )
+            int alt6=2;
+            int LA6_0 = input.LA(1);
 
-                    throw nvae;
-                }
-                switch (alt6) {
-                case 1:
-                // Grammar/CTFParser.g:266:4: ref= DOT
-                {
-                    ref = (Token) match(input, DOT, FOLLOW_DOT_in_reference564);
-                    if (state.failed) {
+            if ( (LA6_0==DOT) ) {
+                alt6=1;
+            }
+            else if ( (LA6_0==ARROW) ) {
+                alt6=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return retval;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 6, 0, input);
+
+                throw nvae;
+            }
+            switch (alt6) {
+                case 1 :
+                    // CTFParser.g:267:4: ref= DOT
+                    {
+                    ref=(Token)match(input,DOT,FOLLOW_DOT_in_reference568); if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
+                    if ( state.backtracking==0 ) {
                         stream_DOT.add(ref);
                     }
 
-                }
+
+                    }
                     break;
-                case 2:
-                // Grammar/CTFParser.g:266:14: ref= ARROW
-                {
-                    ref = (Token) match(input, ARROW,
-                            FOLLOW_ARROW_in_reference570);
-                    if (state.failed) {
+                case 2 :
+                    // CTFParser.g:267:14: ref= ARROW
+                    {
+                    ref=(Token)match(input,ARROW,FOLLOW_ARROW_in_reference574); if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
+                    if ( state.backtracking==0 ) {
                         stream_ARROW.add(ref);
                     }
 
-                }
+
+                    }
                     break;
 
-                }
+            }
 
-                IDENTIFIER14 = (Token) match(input, IDENTIFIER,
-                        FOLLOW_IDENTIFIER_in_reference573);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_IDENTIFIER.add(IDENTIFIER14);
-                }
+            IDENTIFIER14=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_reference577); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_IDENTIFIER.add(IDENTIFIER14);
+            }
 
-                // AST REWRITE
-                // elements: IDENTIFIER, ref
-                // token labels: ref
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-                    RewriteRuleTokenStream stream_ref = new RewriteRuleTokenStream(
-                            adaptor, "token ref", ref);
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
-
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 266:36: -> ^( $ref ^( UNARY_EXPRESSION_STRING IDENTIFIER
-                    // ) )
-                    {
-                        // Grammar/CTFParser.g:266:39: ^( $ref ^(
-                        // UNARY_EXPRESSION_STRING IDENTIFIER ) )
-                        {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(
-                                    stream_ref.nextNode(), root_1);
 
-                            // Grammar/CTFParser.g:266:46: ^(
-                            // UNARY_EXPRESSION_STRING IDENTIFIER )
-                            {
-                                CommonTree root_2 = (CommonTree) adaptor.nil();
-                                root_2 = (CommonTree) adaptor.becomeRoot(
-                                        adaptor.create(UNARY_EXPRESSION_STRING,
-                                                "UNARY_EXPRESSION_STRING"),
-                                        root_2);
 
-                                adaptor.addChild(root_2,
-                                        stream_IDENTIFIER.nextNode());
+            // AST REWRITE
+            // elements: IDENTIFIER, ref
+            // token labels: ref
+            // rule labels: retval
+            // token list labels:
+            // rule list labels:
+            // wildcard labels:
+            if ( state.backtracking==0 ) {
+            retval.tree = root_0;
+            RewriteRuleTokenStream stream_ref=new RewriteRuleTokenStream(adaptor,"token ref",ref);
+            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                                adaptor.addChild(root_1, root_2);
-                            }
+            root_0 = (CommonTree)adaptor.nil();
+            // 267:36: -> ^( $ref ^( UNARY_EXPRESSION_STRING IDENTIFIER ) )
+            {
+                // CTFParser.g:267:39: ^( $ref ^( UNARY_EXPRESSION_STRING IDENTIFIER ) )
+                {
+                CommonTree root_1 = (CommonTree)adaptor.nil();
+                root_1 = (CommonTree)adaptor.becomeRoot(stream_ref.nextNode(), root_1);
 
-                            adaptor.addChild(root_0, root_1);
-                        }
+                // CTFParser.g:267:46: ^( UNARY_EXPRESSION_STRING IDENTIFIER )
+                {
+                CommonTree root_2 = (CommonTree)adaptor.nil();
+                root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(UNARY_EXPRESSION_STRING, "UNARY_EXPRESSION_STRING"), root_2);
 
-                    }
+                adaptor.addChild(root_2, stream_IDENTIFIER.nextNode());
 
-                    retval.tree = root_0;
+                adaptor.addChild(root_1, root_2);
                 }
+
+                adaptor.addChild(root_0, root_1);
+                }
+
+            }
+
+            retval.tree = root_0;}
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                debug_print(input.toString(retval.start, input.LT(-1)));
+                debug_print(input.toString(retval.start,input.LT(-1)));
                 exit("reference");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "reference"
 
-    public static class postfixExpressionSuffix_return extends
-            ParserRuleReturnScope {
+    public static class postfixExpressionSuffix_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "postfixExpressionSuffix"
-    // Grammar/CTFParser.g:269:1: postfixExpressionSuffix : ( ( OPENBRAC
-    // unaryExpression CLOSEBRAC ) | reference );
-    public final CTFParser.postfixExpressionSuffix_return postfixExpressionSuffix()
-            throws RecognitionException {
+    // CTFParser.g:270:1: postfixExpressionSuffix : ( ( OPENBRAC unaryExpression CLOSEBRAC ) | reference );
+    public final CTFParser.postfixExpressionSuffix_return postfixExpressionSuffix() throws RecognitionException {
         CTFParser.postfixExpressionSuffix_return retval = new CTFParser.postfixExpressionSuffix_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token OPENBRAC15 = null;
-        Token CLOSEBRAC17 = null;
+        Token OPENBRAC15=null;
+        Token CLOSEBRAC17=null;
         CTFParser.unaryExpression_return unaryExpression16 = null;
 
         CTFParser.reference_return reference18 = null;
 
-        CommonTree OPENBRAC15_tree = null;
-        CommonTree CLOSEBRAC17_tree = null;
 
-        enter("postfixExpressionSuffix");
+        CommonTree OPENBRAC15_tree=null;
+        CommonTree CLOSEBRAC17_tree=null;
+
+
+          enter("postfixExpressionSuffix");
 
         try {
-            // Grammar/CTFParser.g:276:1: ( ( OPENBRAC unaryExpression CLOSEBRAC
-            // ) | reference )
-            int alt7 = 2;
+            // CTFParser.g:277:1: ( ( OPENBRAC unaryExpression CLOSEBRAC ) | reference )
+            int alt7=2;
             int LA7_0 = input.LA(1);
 
-            if ((LA7_0 == OPENBRAC)) {
-                alt7 = 1;
-            } else if ((((LA7_0 >= ARROW) && (LA7_0 <= DOT)))) {
-                alt7 = 2;
-            } else {
-                if (state.backtracking > 0) {
-                    state.failed = true;
-                    return retval;
-                }
-                NoViableAltException nvae = new NoViableAltException("", 7, 0,
-                        input);
+            if ( (LA7_0==OPENBRAC) ) {
+                alt7=1;
+            }
+            else if ( ((LA7_0>=ARROW && LA7_0<=DOT)) ) {
+                alt7=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return retval;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 7, 0, input);
 
                 throw nvae;
             }
             switch (alt7) {
-            case 1:
-            // Grammar/CTFParser.g:277:5: ( OPENBRAC unaryExpression CLOSEBRAC )
-            {
-                root_0 = (CommonTree) adaptor.nil();
+                case 1 :
+                    // CTFParser.g:278:5: ( OPENBRAC unaryExpression CLOSEBRAC )
+                    {
+                    root_0 = (CommonTree)adaptor.nil();
 
-                // Grammar/CTFParser.g:277:5: ( OPENBRAC unaryExpression
-                // CLOSEBRAC )
-                // Grammar/CTFParser.g:277:6: OPENBRAC unaryExpression CLOSEBRAC
-                {
-                    OPENBRAC15 = (Token) match(input, OPENBRAC,
-                            FOLLOW_OPENBRAC_in_postfixExpressionSuffix612);
-                    if (state.failed) {
+                    // CTFParser.g:278:5: ( OPENBRAC unaryExpression CLOSEBRAC )
+                    // CTFParser.g:278:6: OPENBRAC unaryExpression CLOSEBRAC
+                    {
+                    OPENBRAC15=(Token)match(input,OPENBRAC,FOLLOW_OPENBRAC_in_postfixExpressionSuffix616); if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
-                        OPENBRAC15_tree = (CommonTree) adaptor
-                                .create(OPENBRAC15);
-                        adaptor.addChild(root_0, OPENBRAC15_tree);
+                    if ( state.backtracking==0 ) {
+                    OPENBRAC15_tree = (CommonTree)adaptor.create(OPENBRAC15);
+                    adaptor.addChild(root_0, OPENBRAC15_tree);
                     }
-                    pushFollow(FOLLOW_unaryExpression_in_postfixExpressionSuffix614);
-                    unaryExpression16 = unaryExpression();
+                    pushFollow(FOLLOW_unaryExpression_in_postfixExpressionSuffix618);
+                    unaryExpression16=unaryExpression();
 
                     state._fsp--;
                     if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
+                    if ( state.backtracking==0 ) {
                         adaptor.addChild(root_0, unaryExpression16.getTree());
                     }
-//                    CLOSEBRAC17 = (Token)
-                            match(input, CLOSEBRAC,
-                            FOLLOW_CLOSEBRAC_in_postfixExpressionSuffix616);
-                    if (state.failed) {
+                    CLOSEBRAC17=(Token)match(input,CLOSEBRAC,FOLLOW_CLOSEBRAC_in_postfixExpressionSuffix620); if (state.failed) {
                         return retval;
                     }
 
-                }
+                    }
 
-            }
-                break;
-            case 2:
-            // Grammar/CTFParser.g:278:5: reference
-            {
-                root_0 = (CommonTree) adaptor.nil();
 
-                pushFollow(FOLLOW_reference_in_postfixExpressionSuffix624);
-                reference18 = reference();
+                    }
+                    break;
+                case 2 :
+                    // CTFParser.g:279:5: reference
+                    {
+                    root_0 = (CommonTree)adaptor.nil();
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    adaptor.addChild(root_0, reference18.getTree());
-                }
+                    pushFollow(FOLLOW_reference_in_postfixExpressionSuffix628);
+                    reference18=reference();
 
-            }
-                break;
+                    state._fsp--;
+                    if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        adaptor.addChild(root_0, reference18.getTree());
+                    }
+
+                    }
+                    break;
 
             }
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 exit("postfixExpressionSuffix");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "postfixExpressionSuffix"
 
     public static class postfixExpression_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "postfixExpression"
-    // Grammar/CTFParser.g:281:1: postfixExpression : ( ( primaryExpression ) (
-    // postfixExpressionSuffix )* | ( ( ctfSpecifierHead ) (
-    // postfixExpressionSuffix )+ ) );
-    public final CTFParser.postfixExpression_return postfixExpression()
-            throws RecognitionException {
+    // CTFParser.g:282:1: postfixExpression : ( ( primaryExpression ) ( postfixExpressionSuffix )* | ( ( ctfSpecifierHead ) ( postfixExpressionSuffix )+ ) );
+    public final CTFParser.postfixExpression_return postfixExpression() throws RecognitionException {
         CTFParser.postfixExpression_return retval = new CTFParser.postfixExpression_return();
         retval.start = input.LT(1);
 
@@ -1637,186 +1421,180 @@ public class CTFParser extends Parser {
 
         CTFParser.postfixExpressionSuffix_return postfixExpressionSuffix22 = null;
 
-        enter("postfixExpression");
+
+
+
+          enter("postfixExpression");
 
         try {
-            // Grammar/CTFParser.g:288:1: ( ( primaryExpression ) (
-            // postfixExpressionSuffix )* | ( ( ctfSpecifierHead ) (
-            // postfixExpressionSuffix )+ ) )
-            int alt10 = 2;
+            // CTFParser.g:289:1: ( ( primaryExpression ) ( postfixExpressionSuffix )* | ( ( ctfSpecifierHead ) ( postfixExpressionSuffix )+ ) )
+            int alt10=2;
             alt10 = dfa10.predict(input);
             switch (alt10) {
-            case 1:
-            // Grammar/CTFParser.g:289:3: ( primaryExpression ) (
-            // postfixExpressionSuffix )*
-            {
-                root_0 = (CommonTree) adaptor.nil();
+                case 1 :
+                    // CTFParser.g:290:3: ( primaryExpression ) ( postfixExpressionSuffix )*
+                    {
+                    root_0 = (CommonTree)adaptor.nil();
 
-                // Grammar/CTFParser.g:289:3: ( primaryExpression )
-                // Grammar/CTFParser.g:289:4: primaryExpression
-                {
-                    pushFollow(FOLLOW_primaryExpression_in_postfixExpression648);
-                    primaryExpression19 = primaryExpression();
+                    // CTFParser.g:290:3: ( primaryExpression )
+                    // CTFParser.g:290:4: primaryExpression
+                    {
+                    pushFollow(FOLLOW_primaryExpression_in_postfixExpression652);
+                    primaryExpression19=primaryExpression();
 
                     state._fsp--;
                     if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
+                    if ( state.backtracking==0 ) {
                         adaptor.addChild(root_0, primaryExpression19.getTree());
                     }
 
-                }
-
-                // Grammar/CTFParser.g:289:23: ( postfixExpressionSuffix )*
-                loop8: do {
-                    int alt8 = 2;
-                    int LA8_0 = input.LA(1);
-
-                    if (((LA8_0 == OPENBRAC) || ((LA8_0 >= ARROW) && (LA8_0 <= DOT)))) {
-                        alt8 = 1;
                     }
 
-                    switch (alt8) {
-                    case 1:
-                    // Grammar/CTFParser.g:289:24: postfixExpressionSuffix
-                    {
-                        pushFollow(FOLLOW_postfixExpressionSuffix_in_postfixExpression652);
-                        postfixExpressionSuffix20 = postfixExpressionSuffix();
+                    // CTFParser.g:290:23: ( postfixExpressionSuffix )*
+                    loop8:
+                    do {
+                        int alt8=2;
+                        int LA8_0 = input.LA(1);
 
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
+                        if ( (LA8_0==OPENBRAC||(LA8_0>=ARROW && LA8_0<=DOT)) ) {
+                            alt8=1;
                         }
-                        if (state.backtracking == 0) {
-                            adaptor.addChild(root_0,
-                                    postfixExpressionSuffix20.getTree());
+
+
+                        switch (alt8) {
+                       case 1 :
+                           // CTFParser.g:290:24: postfixExpressionSuffix
+                           {
+                           pushFollow(FOLLOW_postfixExpressionSuffix_in_postfixExpression656);
+                           postfixExpressionSuffix20=postfixExpressionSuffix();
+
+                           state._fsp--;
+                           if (state.failed) {
+                                return retval;
+                            }
+                           if ( state.backtracking==0 ) {
+                                adaptor.addChild(root_0, postfixExpressionSuffix20.getTree());
+                            }
+
+                           }
+                           break;
+
+                       default :
+                           break loop8;
                         }
+                    } while (true);
 
-                    }
-                        break;
 
-                    default:
-                        break loop8;
                     }
-                } while (true);
-
-            }
-                break;
-            case 2:
-            // Grammar/CTFParser.g:290:3: ( ( ctfSpecifierHead ) (
-            // postfixExpressionSuffix )+ )
-            {
-                root_0 = (CommonTree) adaptor.nil();
+                    break;
+                case 2 :
+                    // CTFParser.g:291:3: ( ( ctfSpecifierHead ) ( postfixExpressionSuffix )+ )
+                    {
+                    root_0 = (CommonTree)adaptor.nil();
 
-                // Grammar/CTFParser.g:290:3: ( ( ctfSpecifierHead ) (
-                // postfixExpressionSuffix )+ )
-                // Grammar/CTFParser.g:290:4: ( ctfSpecifierHead ) (
-                // postfixExpressionSuffix )+
-                {
-                    // Grammar/CTFParser.g:290:4: ( ctfSpecifierHead )
-                    // Grammar/CTFParser.g:290:5: ctfSpecifierHead
+                    // CTFParser.g:291:3: ( ( ctfSpecifierHead ) ( postfixExpressionSuffix )+ )
+                    // CTFParser.g:291:4: ( ctfSpecifierHead ) ( postfixExpressionSuffix )+
                     {
-                        pushFollow(FOLLOW_ctfSpecifierHead_in_postfixExpression661);
-                        ctfSpecifierHead21 = ctfSpecifierHead();
+                    // CTFParser.g:291:4: ( ctfSpecifierHead )
+                    // CTFParser.g:291:5: ctfSpecifierHead
+                    {
+                    pushFollow(FOLLOW_ctfSpecifierHead_in_postfixExpression665);
+                    ctfSpecifierHead21=ctfSpecifierHead();
 
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            adaptor.addChild(root_0,
-                                    ctfSpecifierHead21.getTree());
-                        }
+                    state._fsp--;
+                    if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        adaptor.addChild(root_0, ctfSpecifierHead21.getTree());
+                    }
 
                     }
 
-                    // Grammar/CTFParser.g:290:24: ( postfixExpressionSuffix )+
-                    int cnt9 = 0;
-                    loop9: do {
-                        int alt9 = 2;
+                    // CTFParser.g:291:24: ( postfixExpressionSuffix )+
+                    int cnt9=0;
+                    loop9:
+                    do {
+                        int alt9=2;
                         int LA9_0 = input.LA(1);
 
-                        if (((LA9_0 == OPENBRAC) || ((LA9_0 >= ARROW) && (LA9_0 <= DOT)))) {
-                            alt9 = 1;
+                        if ( (LA9_0==OPENBRAC||(LA9_0>=ARROW && LA9_0<=DOT)) ) {
+                            alt9=1;
                         }
 
-                        switch (alt9) {
-                        case 1:
-                        // Grammar/CTFParser.g:290:25: postfixExpressionSuffix
-                        {
-                            pushFollow(FOLLOW_postfixExpressionSuffix_in_postfixExpression666);
-                            postfixExpressionSuffix22 = postfixExpressionSuffix();
 
-                            state._fsp--;
-                            if (state.failed) {
+                        switch (alt9) {
+                       case 1 :
+                           // CTFParser.g:291:25: postfixExpressionSuffix
+                           {
+                           pushFollow(FOLLOW_postfixExpressionSuffix_in_postfixExpression670);
+                           postfixExpressionSuffix22=postfixExpressionSuffix();
+
+                           state._fsp--;
+                           if (state.failed) {
                                 return retval;
                             }
-                            if (state.backtracking == 0) {
-                                adaptor.addChild(root_0,
-                                        postfixExpressionSuffix22.getTree());
+                           if ( state.backtracking==0 ) {
+                                adaptor.addChild(root_0, postfixExpressionSuffix22.getTree());
                             }
 
-                        }
-                            break;
+                           }
+                           break;
 
-                        default:
-                            if (cnt9 >= 1) {
+                       default :
+                           if ( cnt9 >= 1 ) {
                                 break loop9;
                             }
-                            if (state.backtracking > 0) {
-                                state.failed = true;
-                                return retval;
-                            }
-                            EarlyExitException eee = new EarlyExitException(9,
-                                    input);
-                            throw eee;
+                           if (state.backtracking>0) {state.failed=true; return retval;}
+                                EarlyExitException eee =
+                                    new EarlyExitException(9, input);
+                                throw eee;
                         }
                         cnt9++;
                     } while (true);
 
-                }
 
-            }
-                break;
+                    }
+
+
+                    }
+                    break;
 
             }
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 exit("postfixExpression");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "postfixExpression"
 
     public static class unaryExpression_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "unaryExpression"
-    // Grammar/CTFParser.g:293:1: unaryExpression : postfixExpression ;
-    public final CTFParser.unaryExpression_return unaryExpression()
-            throws RecognitionException {
+    // CTFParser.g:294:1: unaryExpression : postfixExpression ;
+    public final CTFParser.unaryExpression_return unaryExpression() throws RecognitionException {
         CTFParser.unaryExpression_return retval = new CTFParser.unaryExpression_return();
         retval.start = input.LT(1);
 
@@ -1824,542 +1602,465 @@ public class CTFParser extends Parser {
 
         CTFParser.postfixExpression_return postfixExpression23 = null;
 
-        enter("unaryExpression");
+
+
+
+          enter("unaryExpression");
 
         try {
-            // Grammar/CTFParser.g:300:1: ( postfixExpression )
-            // Grammar/CTFParser.g:303:5: postfixExpression
+            // CTFParser.g:301:1: ( postfixExpression )
+            // CTFParser.g:304:5: postfixExpression
             {
-                root_0 = (CommonTree) adaptor.nil();
+            root_0 = (CommonTree)adaptor.nil();
 
-                pushFollow(FOLLOW_postfixExpression_in_unaryExpression700);
-                postfixExpression23 = postfixExpression();
+            pushFollow(FOLLOW_postfixExpression_in_unaryExpression704);
+            postfixExpression23=postfixExpression();
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    adaptor.addChild(root_0, postfixExpression23.getTree());
-                }
+            state._fsp--;
+            if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                adaptor.addChild(root_0, postfixExpression23.getTree());
+            }
 
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 exit("unaryExpression");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "unaryExpression"
 
     public static class enumConstant_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "enumConstant"
-    // Grammar/CTFParser.g:306:1: enumConstant : ( STRING_LITERAL -> ^(
-    // UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL ) | IDENTIFIER -> ^(
-    // UNARY_EXPRESSION_STRING IDENTIFIER ) | ctfKeyword -> ^(
-    // UNARY_EXPRESSION_STRING ctfKeyword ) );
-    public final CTFParser.enumConstant_return enumConstant()
-            throws RecognitionException {
+    // CTFParser.g:307:1: enumConstant : ( STRING_LITERAL -> ^( UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL ) | IDENTIFIER -> ^( UNARY_EXPRESSION_STRING IDENTIFIER ) | ctfKeyword -> ^( UNARY_EXPRESSION_STRING ctfKeyword ) );
+    public final CTFParser.enumConstant_return enumConstant() throws RecognitionException {
         CTFParser.enumConstant_return retval = new CTFParser.enumConstant_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token STRING_LITERAL24 = null;
-        Token IDENTIFIER25 = null;
+        Token STRING_LITERAL24=null;
+        Token IDENTIFIER25=null;
         CTFParser.ctfKeyword_return ctfKeyword26 = null;
 
-        CommonTree STRING_LITERAL24_tree = null;
-        CommonTree IDENTIFIER25_tree = null;
-        RewriteRuleTokenStream stream_STRING_LITERAL = new RewriteRuleTokenStream(
-                adaptor, "token STRING_LITERAL");
-        RewriteRuleTokenStream stream_IDENTIFIER = new RewriteRuleTokenStream(
-                adaptor, "token IDENTIFIER");
-        RewriteRuleSubtreeStream stream_ctfKeyword = new RewriteRuleSubtreeStream(
-                adaptor, "rule ctfKeyword");
 
-        enter("enumConstant");
+        CommonTree STRING_LITERAL24_tree=null;
+        CommonTree IDENTIFIER25_tree=null;
+        RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL");
+        RewriteRuleTokenStream stream_IDENTIFIER=new RewriteRuleTokenStream(adaptor,"token IDENTIFIER");
+        RewriteRuleSubtreeStream stream_ctfKeyword=new RewriteRuleSubtreeStream(adaptor,"rule ctfKeyword");
+
+          enter("enumConstant");
 
         try {
-            // Grammar/CTFParser.g:314:1: ( STRING_LITERAL -> ^(
-            // UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL ) | IDENTIFIER ->
-            // ^( UNARY_EXPRESSION_STRING IDENTIFIER ) | ctfKeyword -> ^(
-            // UNARY_EXPRESSION_STRING ctfKeyword ) )
-            int alt11 = 3;
-            switch (input.LA(1)) {
-            case STRING_LITERAL: {
-                alt11 = 1;
-            }
+            // CTFParser.g:315:1: ( STRING_LITERAL -> ^( UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL ) | IDENTIFIER -> ^( UNARY_EXPRESSION_STRING IDENTIFIER ) | ctfKeyword -> ^( UNARY_EXPRESSION_STRING ctfKeyword ) )
+            int alt11=3;
+            switch ( input.LA(1) ) {
+            case STRING_LITERAL:
+                {
+                alt11=1;
+                }
                 break;
-            case IDENTIFIER: {
-                alt11 = 2;
-            }
+            case IDENTIFIER:
+                {
+                alt11=2;
+                }
                 break;
             case ALIGNTOK:
             case EVENTTOK:
             case SIGNEDTOK:
-            case STRINGTOK: {
-                alt11 = 3;
-            }
+            case STRINGTOK:
+                {
+                alt11=3;
+                }
                 break;
             default:
-                if (state.backtracking > 0) {
-                    state.failed = true;
-                    return retval;
-                }
-                NoViableAltException nvae = new NoViableAltException("", 11, 0,
-                        input);
+                if (state.backtracking>0) {state.failed=true; return retval;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 11, 0, input);
 
                 throw nvae;
             }
 
             switch (alt11) {
-            case 1:
-            // Grammar/CTFParser.g:315:5: STRING_LITERAL
-            {
-                STRING_LITERAL24 = (Token) match(input, STRING_LITERAL,
-                        FOLLOW_STRING_LITERAL_in_enumConstant725);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_STRING_LITERAL.add(STRING_LITERAL24);
-                }
-
-                // AST REWRITE
-                // elements: STRING_LITERAL
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
-
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 315:20: -> ^( UNARY_EXPRESSION_STRING_QUOTES
-                    // STRING_LITERAL )
+                case 1 :
+                    // CTFParser.g:316:5: STRING_LITERAL
                     {
-                        // Grammar/CTFParser.g:315:23: ^(
-                        // UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL )
-                        {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(adaptor
-                                    .create(UNARY_EXPRESSION_STRING_QUOTES,
-                                            "UNARY_EXPRESSION_STRING_QUOTES"),
-                                    root_1);
-
-                            adaptor.addChild(root_1,
-                                    stream_STRING_LITERAL.nextNode());
-
-                            adaptor.addChild(root_0, root_1);
+                    STRING_LITERAL24=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_enumConstant729); if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        stream_STRING_LITERAL.add(STRING_LITERAL24);
+                    }
+
+
+
+                    // AST REWRITE
+                    // elements: STRING_LITERAL
+                    // token labels:
+                    // rule labels: retval
+                    // token list labels:
+                    // rule list labels:
+                    // wildcard labels:
+                    if ( state.backtracking==0 ) {
+                    retval.tree = root_0;
+                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+                    root_0 = (CommonTree)adaptor.nil();
+                    // 316:20: -> ^( UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL )
+                    {
+                        // CTFParser.g:316:23: ^( UNARY_EXPRESSION_STRING_QUOTES STRING_LITERAL )
+                        {
+                        CommonTree root_1 = (CommonTree)adaptor.nil();
+                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(UNARY_EXPRESSION_STRING_QUOTES, "UNARY_EXPRESSION_STRING_QUOTES"), root_1);
+
+                        adaptor.addChild(root_1, stream_STRING_LITERAL.nextNode());
+
+                        adaptor.addChild(root_0, root_1);
                         }
 
                     }
 
+                    retval.tree = root_0;}
+                    }
+                    break;
+                case 2 :
+                    // CTFParser.g:317:7: IDENTIFIER
+                    {
+                    IDENTIFIER25=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_enumConstant745); if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        stream_IDENTIFIER.add(IDENTIFIER25);
+                    }
+
+
+
+                    // AST REWRITE
+                    // elements: IDENTIFIER
+                    // token labels:
+                    // rule labels: retval
+                    // token list labels:
+                    // rule list labels:
+                    // wildcard labels:
+                    if ( state.backtracking==0 ) {
                     retval.tree = root_0;
-                }
-            }
-                break;
-            case 2:
-            // Grammar/CTFParser.g:316:7: IDENTIFIER
-            {
-                IDENTIFIER25 = (Token) match(input, IDENTIFIER,
-                        FOLLOW_IDENTIFIER_in_enumConstant741);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_IDENTIFIER.add(IDENTIFIER25);
-                }
-
-                // AST REWRITE
-                // elements: IDENTIFIER
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
+                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 316:18: -> ^( UNARY_EXPRESSION_STRING IDENTIFIER )
+                    root_0 = (CommonTree)adaptor.nil();
+                    // 317:18: -> ^( UNARY_EXPRESSION_STRING IDENTIFIER )
                     {
-                        // Grammar/CTFParser.g:316:21: ^(
-                        // UNARY_EXPRESSION_STRING IDENTIFIER )
+                        // CTFParser.g:317:21: ^( UNARY_EXPRESSION_STRING IDENTIFIER )
                         {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(adaptor
-                                    .create(UNARY_EXPRESSION_STRING,
-                                            "UNARY_EXPRESSION_STRING"), root_1);
+                        CommonTree root_1 = (CommonTree)adaptor.nil();
+                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(UNARY_EXPRESSION_STRING, "UNARY_EXPRESSION_STRING"), root_1);
 
-                            adaptor.addChild(root_1,
-                                    stream_IDENTIFIER.nextNode());
+                        adaptor.addChild(root_1, stream_IDENTIFIER.nextNode());
 
-                            adaptor.addChild(root_0, root_1);
+                        adaptor.addChild(root_0, root_1);
                         }
 
                     }
 
-                    retval.tree = root_0;
-                }
-            }
-                break;
-            case 3:
-            // Grammar/CTFParser.g:317:7: ctfKeyword
-            {
-                pushFollow(FOLLOW_ctfKeyword_in_enumConstant757);
-                ctfKeyword26 = ctfKeyword();
+                    retval.tree = root_0;}
+                    }
+                    break;
+                case 3 :
+                    // CTFParser.g:318:7: ctfKeyword
+                    {
+                    pushFollow(FOLLOW_ctfKeyword_in_enumConstant761);
+                    ctfKeyword26=ctfKeyword();
+
+                    state._fsp--;
+                    if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        stream_ctfKeyword.add(ctfKeyword26.getTree());
+                    }
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_ctfKeyword.add(ctfKeyword26.getTree());
-                }
 
-                // AST REWRITE
-                // elements: ctfKeyword
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
+                    // AST REWRITE
+                    // elements: ctfKeyword
+                    // token labels:
+                    // rule labels: retval
+                    // token list labels:
+                    // rule list labels:
+                    // wildcard labels:
+                    if ( state.backtracking==0 ) {
                     retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
+                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 317:18: -> ^( UNARY_EXPRESSION_STRING ctfKeyword )
+                    root_0 = (CommonTree)adaptor.nil();
+                    // 318:18: -> ^( UNARY_EXPRESSION_STRING ctfKeyword )
                     {
-                        // Grammar/CTFParser.g:317:21: ^(
-                        // UNARY_EXPRESSION_STRING ctfKeyword )
+                        // CTFParser.g:318:21: ^( UNARY_EXPRESSION_STRING ctfKeyword )
                         {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(adaptor
-                                    .create(UNARY_EXPRESSION_STRING,
-                                            "UNARY_EXPRESSION_STRING"), root_1);
+                        CommonTree root_1 = (CommonTree)adaptor.nil();
+                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(UNARY_EXPRESSION_STRING, "UNARY_EXPRESSION_STRING"), root_1);
 
-                            adaptor.addChild(root_1,
-                                    stream_ctfKeyword.nextTree());
+                        adaptor.addChild(root_1, stream_ctfKeyword.nextTree());
 
-                            adaptor.addChild(root_0, root_1);
+                        adaptor.addChild(root_0, root_1);
                         }
 
                     }
 
-                    retval.tree = root_0;
-                }
-            }
-                break;
+                    retval.tree = root_0;}
+                    }
+                    break;
 
             }
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                debug_print(input.toString(retval.start, input.LT(-1)));
+                debug_print(input.toString(retval.start,input.LT(-1)));
                 exit("enumConstant");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "enumConstant"
 
     public static class declaration_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "declaration"
-    // Grammar/CTFParser.g:321:1: declaration : ( ( declarationSpecifiers (
-    // declaratorList )? TERM ) -> {inTypedef()}? ^( DECLARATION ^( TYPEDEF
-    // declaratorList declarationSpecifiers ) ) -> ^( DECLARATION
-    // declarationSpecifiers ( declaratorList )? ) | ( ctfSpecifier TERM ) );
-    public final CTFParser.declaration_return declaration()
-            throws RecognitionException {
+    // CTFParser.g:322:1: declaration : ( ( declarationSpecifiers ( declaratorList )? TERM ) -> {inTypedef()}? ^( DECLARATION ^( TYPEDEF declaratorList declarationSpecifiers ) ) -> ^( DECLARATION declarationSpecifiers ( declaratorList )? ) | ( ctfSpecifier TERM ) );
+    public final CTFParser.declaration_return declaration() throws RecognitionException {
         CTFParser.declaration_return retval = new CTFParser.declaration_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token TERM29 = null;
-        Token TERM31 = null;
+        Token TERM29=null;
+        Token TERM31=null;
         CTFParser.declarationSpecifiers_return declarationSpecifiers27 = null;
 
         CTFParser.declaratorList_return declaratorList28 = null;
 
         CTFParser.ctfSpecifier_return ctfSpecifier30 = null;
 
-        CommonTree TERM29_tree = null;
-        CommonTree TERM31_tree = null;
-        RewriteRuleTokenStream stream_TERM = new RewriteRuleTokenStream(
-                adaptor, "token TERM");
-        RewriteRuleSubtreeStream stream_declaratorList = new RewriteRuleSubtreeStream(
-                adaptor, "rule declaratorList");
-        RewriteRuleSubtreeStream stream_declarationSpecifiers = new RewriteRuleSubtreeStream(
-                adaptor, "rule declarationSpecifiers");
 
-        enter("declaration");
+        CommonTree TERM29_tree=null;
+        CommonTree TERM31_tree=null;
+        RewriteRuleTokenStream stream_TERM=new RewriteRuleTokenStream(adaptor,"token TERM");
+        RewriteRuleSubtreeStream stream_declaratorList=new RewriteRuleSubtreeStream(adaptor,"rule declaratorList");
+        RewriteRuleSubtreeStream stream_declarationSpecifiers=new RewriteRuleSubtreeStream(adaptor,"rule declarationSpecifiers");
+
+          enter("declaration");
 
         try {
-            // Grammar/CTFParser.g:330:1: ( ( declarationSpecifiers (
-            // declaratorList )? TERM ) -> {inTypedef()}? ^( DECLARATION ^(
-            // TYPEDEF declaratorList declarationSpecifiers ) ) -> ^(
-            // DECLARATION declarationSpecifiers ( declaratorList )? ) | (
-            // ctfSpecifier TERM ) )
-            int alt13 = 2;
+            // CTFParser.g:331:1: ( ( declarationSpecifiers ( declaratorList )? TERM ) -> {inTypedef()}? ^( DECLARATION ^( TYPEDEF declaratorList declarationSpecifiers ) ) -> ^( DECLARATION declarationSpecifiers ( declaratorList )? ) | ( ctfSpecifier TERM ) )
+            int alt13=2;
             int LA13_0 = input.LA(1);
 
-            if ((((LA13_0 >= CONSTTOK) && (LA13_0 <= ENUMTOK))
-                    || ((LA13_0 >= FLOATINGPOINTTOK) && (LA13_0 <= SIGNEDTOK))
-                    || ((LA13_0 >= STRINGTOK) && (LA13_0 <= STRUCTTOK)) || ((LA13_0 >= TYPEDEFTOK) && (LA13_0 <= IMAGINARYTOK)))) {
-                alt13 = 1;
-            } else if ((LA13_0 == IDENTIFIER)
-                    && ((inTypealiasAlias() || isTypeName(input.LT(1).getText())))) {
-                alt13 = 1;
-            } else if (((LA13_0 == EVENTTOK) || (LA13_0 == STREAMTOK)
-                    || ((LA13_0 >= TRACETOK) && (LA13_0 <= TYPEALIASTOK)) || ((LA13_0 >= ENVTOK) && (LA13_0 <= CLOCKTOK)))) {
-                alt13 = 2;
-            } else {
-                if (state.backtracking > 0) {
-                    state.failed = true;
-                    return retval;
-                }
-                NoViableAltException nvae = new NoViableAltException("", 13, 0,
-                        input);
+            if ( ((LA13_0>=CONSTTOK && LA13_0<=ENUMTOK)||(LA13_0>=FLOATINGPOINTTOK && LA13_0<=SIGNEDTOK)||(LA13_0>=STRINGTOK && LA13_0<=STRUCTTOK)||(LA13_0>=TYPEDEFTOK && LA13_0<=IMAGINARYTOK)) ) {
+                alt13=1;
+            }
+            else if ( (LA13_0==IDENTIFIER) && ((inTypealiasAlias() || isTypeName(input.LT(1).getText())))) {
+                alt13=1;
+            }
+            else if ( (LA13_0==EVENTTOK||LA13_0==STREAMTOK||(LA13_0>=TRACETOK && LA13_0<=TYPEALIASTOK)||(LA13_0>=ENVTOK && LA13_0<=CALLSITETOK)) ) {
+                alt13=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return retval;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 13, 0, input);
 
                 throw nvae;
             }
             switch (alt13) {
-            case 1:
-            // Grammar/CTFParser.g:331:3: ( declarationSpecifiers (
-            // declaratorList )? TERM )
-            {
-                // Grammar/CTFParser.g:331:3: ( declarationSpecifiers (
-                // declaratorList )? TERM )
-                // Grammar/CTFParser.g:331:4: declarationSpecifiers (
-                // declaratorList )? TERM
-                {
-                    pushFollow(FOLLOW_declarationSpecifiers_in_declaration790);
-                    declarationSpecifiers27 = declarationSpecifiers();
+                case 1 :
+                    // CTFParser.g:332:3: ( declarationSpecifiers ( declaratorList )? TERM )
+                    {
+                    // CTFParser.g:332:3: ( declarationSpecifiers ( declaratorList )? TERM )
+                    // CTFParser.g:332:4: declarationSpecifiers ( declaratorList )? TERM
+                    {
+                    pushFollow(FOLLOW_declarationSpecifiers_in_declaration794);
+                    declarationSpecifiers27=declarationSpecifiers();
 
                     state._fsp--;
                     if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
-                        stream_declarationSpecifiers
-                                .add(declarationSpecifiers27.getTree());
+                    if ( state.backtracking==0 ) {
+                        stream_declarationSpecifiers.add(declarationSpecifiers27.getTree());
                     }
-                    // Grammar/CTFParser.g:331:26: ( declaratorList )?
-                    int alt12 = 2;
+                    // CTFParser.g:332:26: ( declaratorList )?
+                    int alt12=2;
                     int LA12_0 = input.LA(1);
 
-                    if (((LA12_0 == POINTER) || (LA12_0 == IDENTIFIER))) {
-                        alt12 = 1;
+                    if ( (LA12_0==POINTER||LA12_0==IDENTIFIER) ) {
+                        alt12=1;
                     }
                     switch (alt12) {
-                    case 1:
-                    // Grammar/CTFParser.g:331:26: declaratorList
-                    {
-                        pushFollow(FOLLOW_declaratorList_in_declaration792);
-                        declaratorList28 = declaratorList();
+                        case 1 :
+                            // CTFParser.g:332:26: declaratorList
+                            {
+                            pushFollow(FOLLOW_declaratorList_in_declaration796);
+                            declaratorList28=declaratorList();
 
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_declaratorList.add(declaratorList28
-                                    .getTree());
-                        }
+                            state._fsp--;
+                            if (state.failed) {
+                                return retval;
+                            }
+                            if ( state.backtracking==0 ) {
+                                stream_declaratorList.add(declaratorList28.getTree());
+                            }
 
-                    }
-                        break;
+                            }
+                            break;
 
                     }
 
-                    TERM29 = (Token) match(input, TERM,
-                            FOLLOW_TERM_in_declaration795);
-                    if (state.failed) {
+                    TERM29=(Token)match(input,TERM,FOLLOW_TERM_in_declaration799); if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
+                    if ( state.backtracking==0 ) {
                         stream_TERM.add(TERM29);
                     }
 
-                }
 
-                // AST REWRITE
-                // elements: declaratorList, declaratorList,
-                // declarationSpecifiers, declarationSpecifiers
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
+                    }
+
+
+
+                    // AST REWRITE
+                    // elements: declaratorList, declarationSpecifiers, declaratorList, declarationSpecifiers
+                    // token labels:
+                    // rule labels: retval
+                    // token list labels:
+                    // rule list labels:
+                    // wildcard labels:
+                    if ( state.backtracking==0 ) {
                     retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
-
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 334:3: -> {inTypedef()}? ^( DECLARATION ^( TYPEDEF
-                    // declaratorList declarationSpecifiers ) )
+                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+                    root_0 = (CommonTree)adaptor.nil();
+                    // 335:3: -> {inTypedef()}? ^( DECLARATION ^( TYPEDEF declaratorList declarationSpecifiers ) )
                     if (inTypedef()) {
-                        // Grammar/CTFParser.g:334:21: ^( DECLARATION ^( TYPEDEF
-                        // declaratorList declarationSpecifiers ) )
+                        // CTFParser.g:335:21: ^( DECLARATION ^( TYPEDEF declaratorList declarationSpecifiers ) )
                         {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(
-                                    adaptor.create(DECLARATION, "DECLARATION"),
-                                    root_1);
+                        CommonTree root_1 = (CommonTree)adaptor.nil();
+                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(DECLARATION, "DECLARATION"), root_1);
 
-                            // Grammar/CTFParser.g:334:35: ^( TYPEDEF
-                            // declaratorList declarationSpecifiers )
-                            {
-                                CommonTree root_2 = (CommonTree) adaptor.nil();
-                                root_2 = (CommonTree) adaptor.becomeRoot(
-                                        adaptor.create(TYPEDEF, "TYPEDEF"),
-                                        root_2);
+                        // CTFParser.g:335:35: ^( TYPEDEF declaratorList declarationSpecifiers )
+                        {
+                        CommonTree root_2 = (CommonTree)adaptor.nil();
+                        root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TYPEDEF, "TYPEDEF"), root_2);
 
-                                adaptor.addChild(root_2,
-                                        stream_declaratorList.nextTree());
-                                adaptor.addChild(root_2,
-                                        stream_declarationSpecifiers.nextTree());
+                        adaptor.addChild(root_2, stream_declaratorList.nextTree());
+                        adaptor.addChild(root_2, stream_declarationSpecifiers.nextTree());
 
-                                adaptor.addChild(root_1, root_2);
-                            }
+                        adaptor.addChild(root_1, root_2);
+                        }
 
-                            adaptor.addChild(root_0, root_1);
+                        adaptor.addChild(root_0, root_1);
                         }
 
-                    } else // 335:3: -> ^( DECLARATION declarationSpecifiers (
-                           // declaratorList )? )
+                    }
+                    else // 336:3: -> ^( DECLARATION declarationSpecifiers ( declaratorList )? )
                     {
-                        // Grammar/CTFParser.g:335:6: ^( DECLARATION
-                        // declarationSpecifiers ( declaratorList )? )
+                        // CTFParser.g:336:6: ^( DECLARATION declarationSpecifiers ( declaratorList )? )
                         {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(
-                                    adaptor.create(DECLARATION, "DECLARATION"),
-                                    root_1);
-
-                            adaptor.addChild(root_1,
-                                    stream_declarationSpecifiers.nextTree());
-                            // Grammar/CTFParser.g:335:42: ( declaratorList )?
-                            if (stream_declaratorList.hasNext()) {
-                                adaptor.addChild(root_1,
-                                        stream_declaratorList.nextTree());
+                        CommonTree root_1 = (CommonTree)adaptor.nil();
+                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(DECLARATION, "DECLARATION"), root_1);
 
-                            }
-                            stream_declaratorList.reset();
+                        adaptor.addChild(root_1, stream_declarationSpecifiers.nextTree());
+                        // CTFParser.g:336:42: ( declaratorList )?
+                        if ( stream_declaratorList.hasNext() ) {
+                            adaptor.addChild(root_1, stream_declaratorList.nextTree());
+
+                        }
+                        stream_declaratorList.reset();
 
-                            adaptor.addChild(root_0, root_1);
+                        adaptor.addChild(root_0, root_1);
                         }
 
                     }
 
-                    retval.tree = root_0;
-                }
-            }
-                break;
-            case 2:
-            // Grammar/CTFParser.g:337:5: ( ctfSpecifier TERM )
-            {
-                root_0 = (CommonTree) adaptor.nil();
+                    retval.tree = root_0;}
+                    }
+                    break;
+                case 2 :
+                    // CTFParser.g:338:5: ( ctfSpecifier TERM )
+                    {
+                    root_0 = (CommonTree)adaptor.nil();
 
-                // Grammar/CTFParser.g:337:5: ( ctfSpecifier TERM )
-                // Grammar/CTFParser.g:337:6: ctfSpecifier TERM
-                {
-                    pushFollow(FOLLOW_ctfSpecifier_in_declaration844);
-                    ctfSpecifier30 = ctfSpecifier();
+                    // CTFParser.g:338:5: ( ctfSpecifier TERM )
+                    // CTFParser.g:338:6: ctfSpecifier TERM
+                    {
+                    pushFollow(FOLLOW_ctfSpecifier_in_declaration848);
+                    ctfSpecifier30=ctfSpecifier();
 
                     state._fsp--;
                     if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
+                    if ( state.backtracking==0 ) {
                         adaptor.addChild(root_0, ctfSpecifier30.getTree());
                     }
-//                    TERM31 = (Token)
-                            match(input, TERM,
-                            FOLLOW_TERM_in_declaration846);
-                    if (state.failed) {
+                    TERM31=(Token)match(input,TERM,FOLLOW_TERM_in_declaration850); if (state.failed) {
                         return retval;
                     }
 
-                }
+                    }
 
-            }
-                break;
+
+                    }
+                    break;
 
             }
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 exit("declaration");
                 if (inTypedef()) {
@@ -2369,30 +2070,24 @@ public class CTFParser extends Parser {
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "declaration"
 
-    public static class declarationSpecifiers_return extends
-            ParserRuleReturnScope {
+    public static class declarationSpecifiers_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "declarationSpecifiers"
-    // Grammar/CTFParser.g:340:1: declarationSpecifiers : (
-    // storageClassSpecifier | typeQualifier | typeSpecifier )+ -> ^(
-    // TYPE_SPECIFIER_LIST ( typeQualifier )* ( typeSpecifier )* ) ;
-    public final CTFParser.declarationSpecifiers_return declarationSpecifiers()
-            throws RecognitionException {
+    // CTFParser.g:341:1: declarationSpecifiers : ( storageClassSpecifier | typeQualifier | typeSpecifier )+ -> ^( TYPE_SPECIFIER_LIST ( typeQualifier )* ( typeSpecifier )* ) ;
+    public final CTFParser.declarationSpecifiers_return declarationSpecifiers() throws RecognitionException {
         CTFParser.declarationSpecifiers_return retval = new CTFParser.declarationSpecifiers_return();
         retval.start = input.LT(1);
 
@@ -2404,626 +2099,562 @@ public class CTFParser extends Parser {
 
         CTFParser.typeSpecifier_return typeSpecifier34 = null;
 
-        RewriteRuleSubtreeStream stream_typeSpecifier = new RewriteRuleSubtreeStream(
-                adaptor, "rule typeSpecifier");
-        RewriteRuleSubtreeStream stream_typeQualifier = new RewriteRuleSubtreeStream(
-                adaptor, "rule typeQualifier");
-        RewriteRuleSubtreeStream stream_storageClassSpecifier = new RewriteRuleSubtreeStream(
-                adaptor, "rule storageClassSpecifier");
 
-        enter("declarationSpecifiers");
+        RewriteRuleSubtreeStream stream_typeSpecifier=new RewriteRuleSubtreeStream(adaptor,"rule typeSpecifier");
+        RewriteRuleSubtreeStream stream_typeQualifier=new RewriteRuleSubtreeStream(adaptor,"rule typeQualifier");
+        RewriteRuleSubtreeStream stream_storageClassSpecifier=new RewriteRuleSubtreeStream(adaptor,"rule storageClassSpecifier");
+
+          enter("declarationSpecifiers");
 
         try {
-            // Grammar/CTFParser.g:348:1: ( ( storageClassSpecifier |
-            // typeQualifier | typeSpecifier )+ -> ^( TYPE_SPECIFIER_LIST (
-            // typeQualifier )* ( typeSpecifier )* ) )
-            // Grammar/CTFParser.g:349:3: ( storageClassSpecifier |
-            // typeQualifier | typeSpecifier )+
+            // CTFParser.g:349:1: ( ( storageClassSpecifier | typeQualifier | typeSpecifier )+ -> ^( TYPE_SPECIFIER_LIST ( typeQualifier )* ( typeSpecifier )* ) )
+            // CTFParser.g:350:3: ( storageClassSpecifier | typeQualifier | typeSpecifier )+
             {
-                // Grammar/CTFParser.g:349:3: ( storageClassSpecifier |
-                // typeQualifier | typeSpecifier )+
-                int cnt14 = 0;
-                loop14: do {
-                    int alt14 = 4;
-                    switch (input.LA(1)) {
-                    case IDENTIFIER: {
-                        int LA14_2 = input.LA(2);
-
-                        if (((inTypealiasAlias() || isTypeName(input.LT(1)
-                                .getText())))) {
-                            alt14 = 3;
-                        }
+            // CTFParser.g:350:3: ( storageClassSpecifier | typeQualifier | typeSpecifier )+
+            int cnt14=0;
+            loop14:
+            do {
+                int alt14=4;
+                switch ( input.LA(1) ) {
+                case IDENTIFIER:
+                    {
+                    int LA14_2 = input.LA(2);
 
+                    if ( ((inTypealiasAlias() || isTypeName(input.LT(1).getText()))) ) {
+                        alt14=3;
                     }
-                        break;
-                    case TYPEDEFTOK: {
-                        alt14 = 1;
+
+
                     }
-                        break;
-                    case CONSTTOK: {
-                        alt14 = 2;
+                    break;
+                case TYPEDEFTOK:
+                    {
+                    alt14=1;
                     }
-                        break;
-                    case CHARTOK:
-                    case DOUBLETOK:
-                    case ENUMTOK:
-                    case FLOATINGPOINTTOK:
-                    case FLOATTOK:
-                    case INTEGERTOK:
-                    case INTTOK:
-                    case LONGTOK:
-                    case SHORTTOK:
-                    case SIGNEDTOK:
-                    case STRINGTOK:
-                    case STRUCTTOK:
-                    case UNSIGNEDTOK:
-                    case VARIANTTOK:
-                    case VOIDTOK:
-                    case BOOLTOK:
-                    case COMPLEXTOK:
-                    case IMAGINARYTOK: {
-                        alt14 = 3;
+                    break;
+                case CONSTTOK:
+                    {
+                    alt14=2;
                     }
-                        break;
-
+                    break;
+                case CHARTOK:
+                case DOUBLETOK:
+                case ENUMTOK:
+                case FLOATINGPOINTTOK:
+                case FLOATTOK:
+                case INTEGERTOK:
+                case INTTOK:
+                case LONGTOK:
+                case SHORTTOK:
+                case SIGNEDTOK:
+                case STRINGTOK:
+                case STRUCTTOK:
+                case UNSIGNEDTOK:
+                case VARIANTTOK:
+                case VOIDTOK:
+                case BOOLTOK:
+                case COMPLEXTOK:
+                case IMAGINARYTOK:
+                    {
+                    alt14=3;
                     }
+                    break;
 
-                    switch (alt14) {
-                    case 1:
-                    // Grammar/CTFParser.g:352:6: storageClassSpecifier
-                    {
-                        pushFollow(FOLLOW_storageClassSpecifier_in_declarationSpecifiers891);
-                        storageClassSpecifier32 = storageClassSpecifier();
+                }
 
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_storageClassSpecifier
-                                    .add(storageClassSpecifier32.getTree());
-                        }
+                switch (alt14) {
+               case 1 :
+                   // CTFParser.g:353:6: storageClassSpecifier
+                   {
+                   pushFollow(FOLLOW_storageClassSpecifier_in_declarationSpecifiers895);
+                   storageClassSpecifier32=storageClassSpecifier();
 
+                   state._fsp--;
+                   if (state.failed) {
+                        return retval;
+                    }
+                   if ( state.backtracking==0 ) {
+                        stream_storageClassSpecifier.add(storageClassSpecifier32.getTree());
                     }
-                        break;
-                    case 2:
-                    // Grammar/CTFParser.g:353:6: typeQualifier
-                    {
-                        pushFollow(FOLLOW_typeQualifier_in_declarationSpecifiers898);
-                        typeQualifier33 = typeQualifier();
 
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_typeQualifier.add(typeQualifier33.getTree());
-                        }
+                   }
+                   break;
+               case 2 :
+                   // CTFParser.g:354:6: typeQualifier
+                   {
+                   pushFollow(FOLLOW_typeQualifier_in_declarationSpecifiers902);
+                   typeQualifier33=typeQualifier();
 
+                   state._fsp--;
+                   if (state.failed) {
+                        return retval;
+                    }
+                   if ( state.backtracking==0 ) {
+                        stream_typeQualifier.add(typeQualifier33.getTree());
                     }
-                        break;
-                    case 3:
-                    // Grammar/CTFParser.g:354:6: typeSpecifier
-                    {
-                        pushFollow(FOLLOW_typeSpecifier_in_declarationSpecifiers905);
-                        typeSpecifier34 = typeSpecifier();
 
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_typeSpecifier.add(typeSpecifier34.getTree());
-                        }
+                   }
+                   break;
+               case 3 :
+                   // CTFParser.g:355:6: typeSpecifier
+                   {
+                   pushFollow(FOLLOW_typeSpecifier_in_declarationSpecifiers909);
+                   typeSpecifier34=typeSpecifier();
 
+                   state._fsp--;
+                   if (state.failed) {
+                        return retval;
+                    }
+                   if ( state.backtracking==0 ) {
+                        stream_typeSpecifier.add(typeSpecifier34.getTree());
                     }
-                        break;
 
-                    default:
-                        if (cnt14 >= 1) {
-                            break loop14;
-                        }
-                        if (state.backtracking > 0) {
-                            state.failed = true;
-                            return retval;
-                        }
-                        EarlyExitException eee = new EarlyExitException(14,
-                                input);
-                        throw eee;
+                   }
+                   break;
+
+               default :
+                   if ( cnt14 >= 1 ) {
+                        break loop14;
                     }
-                    cnt14++;
-                } while (true);
-
-                // AST REWRITE
-                // elements: typeQualifier, typeSpecifier
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
+                   if (state.backtracking>0) {state.failed=true; return retval;}
+                        EarlyExitException eee =
+                            new EarlyExitException(14, input);
+                        throw eee;
+                }
+                cnt14++;
+            } while (true);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 355:6: -> ^( TYPE_SPECIFIER_LIST ( typeQualifier )* (
-                    // typeSpecifier )* )
-                    {
-                        // Grammar/CTFParser.g:355:9: ^( TYPE_SPECIFIER_LIST (
-                        // typeQualifier )* ( typeSpecifier )* )
-                        {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(adaptor
-                                    .create(TYPE_SPECIFIER_LIST,
-                                            "TYPE_SPECIFIER_LIST"), root_1);
 
-                            // Grammar/CTFParser.g:355:31: ( typeQualifier )*
-                            while (stream_typeQualifier.hasNext()) {
-                                adaptor.addChild(root_1,
-                                        stream_typeQualifier.nextTree());
 
-                            }
-                            stream_typeQualifier.reset();
-                            // Grammar/CTFParser.g:355:46: ( typeSpecifier )*
-                            while (stream_typeSpecifier.hasNext()) {
-                                adaptor.addChild(root_1,
-                                        stream_typeSpecifier.nextTree());
+            // AST REWRITE
+            // elements: typeSpecifier, typeQualifier
+            // token labels:
+            // rule labels: retval
+            // token list labels:
+            // rule list labels:
+            // wildcard labels:
+            if ( state.backtracking==0 ) {
+            retval.tree = root_0;
+            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                            }
-                            stream_typeSpecifier.reset();
+            root_0 = (CommonTree)adaptor.nil();
+            // 356:6: -> ^( TYPE_SPECIFIER_LIST ( typeQualifier )* ( typeSpecifier )* )
+            {
+                // CTFParser.g:356:9: ^( TYPE_SPECIFIER_LIST ( typeQualifier )* ( typeSpecifier )* )
+                {
+                CommonTree root_1 = (CommonTree)adaptor.nil();
+                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TYPE_SPECIFIER_LIST, "TYPE_SPECIFIER_LIST"), root_1);
 
-                            adaptor.addChild(root_0, root_1);
-                        }
+                // CTFParser.g:356:31: ( typeQualifier )*
+                while ( stream_typeQualifier.hasNext() ) {
+                    adaptor.addChild(root_1, stream_typeQualifier.nextTree());
 
-                    }
+                }
+                stream_typeQualifier.reset();
+                // CTFParser.g:356:46: ( typeSpecifier )*
+                while ( stream_typeSpecifier.hasNext() ) {
+                    adaptor.addChild(root_1, stream_typeSpecifier.nextTree());
 
-                    retval.tree = root_0;
                 }
+                stream_typeSpecifier.reset();
+
+                adaptor.addChild(root_0, root_1);
+                }
+
+            }
+
+            retval.tree = root_0;}
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                debug_print(input.toString(retval.start, input.LT(-1)));
+                debug_print(input.toString(retval.start,input.LT(-1)));
                 exit("declarationSpecifiers");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "declarationSpecifiers"
 
     public static class declaratorList_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "declaratorList"
-    // Grammar/CTFParser.g:358:1: declaratorList : declarator ( SEPARATOR
-    // declarator )* -> ^( TYPE_DECLARATOR_LIST ( declarator )+ ) ;
-    public final CTFParser.declaratorList_return declaratorList()
-            throws RecognitionException {
+    // CTFParser.g:359:1: declaratorList : declarator ( SEPARATOR declarator )* -> ^( TYPE_DECLARATOR_LIST ( declarator )+ ) ;
+    public final CTFParser.declaratorList_return declaratorList() throws RecognitionException {
         CTFParser.declaratorList_return retval = new CTFParser.declaratorList_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token SEPARATOR36 = null;
+        Token SEPARATOR36=null;
         CTFParser.declarator_return declarator35 = null;
 
         CTFParser.declarator_return declarator37 = null;
 
-        CommonTree SEPARATOR36_tree = null;
-        RewriteRuleTokenStream stream_SEPARATOR = new RewriteRuleTokenStream(
-                adaptor, "token SEPARATOR");
-        RewriteRuleSubtreeStream stream_declarator = new RewriteRuleSubtreeStream(
-                adaptor, "rule declarator");
 
-        enter("declaratorList");
+        CommonTree SEPARATOR36_tree=null;
+        RewriteRuleTokenStream stream_SEPARATOR=new RewriteRuleTokenStream(adaptor,"token SEPARATOR");
+        RewriteRuleSubtreeStream stream_declarator=new RewriteRuleSubtreeStream(adaptor,"rule declarator");
+
+          enter("declaratorList");
 
         try {
-            // Grammar/CTFParser.g:365:1: ( declarator ( SEPARATOR declarator )*
-            // -> ^( TYPE_DECLARATOR_LIST ( declarator )+ ) )
-            // Grammar/CTFParser.g:366:3: declarator ( SEPARATOR declarator )*
+            // CTFParser.g:366:1: ( declarator ( SEPARATOR declarator )* -> ^( TYPE_DECLARATOR_LIST ( declarator )+ ) )
+            // CTFParser.g:367:3: declarator ( SEPARATOR declarator )*
             {
-                pushFollow(FOLLOW_declarator_in_declaratorList946);
-                declarator35 = declarator();
+            pushFollow(FOLLOW_declarator_in_declaratorList950);
+            declarator35=declarator();
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_declarator.add(declarator35.getTree());
-                }
-                // Grammar/CTFParser.g:366:14: ( SEPARATOR declarator )*
-                loop15: do {
-                    int alt15 = 2;
-                    int LA15_0 = input.LA(1);
+            state._fsp--;
+            if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_declarator.add(declarator35.getTree());
+            }
+            // CTFParser.g:367:14: ( SEPARATOR declarator )*
+            loop15:
+            do {
+                int alt15=2;
+                int LA15_0 = input.LA(1);
 
-                    if ((LA15_0 == SEPARATOR)) {
-                        alt15 = 1;
-                    }
+                if ( (LA15_0==SEPARATOR) ) {
+                    alt15=1;
+                }
 
-                    switch (alt15) {
-                    case 1:
-                    // Grammar/CTFParser.g:366:15: SEPARATOR declarator
-                    {
-                        SEPARATOR36 = (Token) match(input, SEPARATOR,
-                                FOLLOW_SEPARATOR_in_declaratorList949);
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_SEPARATOR.add(SEPARATOR36);
-                        }
 
-                        pushFollow(FOLLOW_declarator_in_declaratorList951);
-                        declarator37 = declarator();
+                switch (alt15) {
+               case 1 :
+                   // CTFParser.g:367:15: SEPARATOR declarator
+                   {
+                   SEPARATOR36=(Token)match(input,SEPARATOR,FOLLOW_SEPARATOR_in_declaratorList953); if (state.failed) {
+                        return retval;
+                    }
+                   if ( state.backtracking==0 ) {
+                        stream_SEPARATOR.add(SEPARATOR36);
+                    }
 
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_declarator.add(declarator37.getTree());
-                        }
+                   pushFollow(FOLLOW_declarator_in_declaratorList955);
+                   declarator37=declarator();
 
+                   state._fsp--;
+                   if (state.failed) {
+                        return retval;
+                    }
+                   if ( state.backtracking==0 ) {
+                        stream_declarator.add(declarator37.getTree());
                     }
-                        break;
 
-                    default:
-                        break loop15;
-                    }
-                } while (true);
-
-                // AST REWRITE
-                // elements: declarator
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
+                   }
+                   break;
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 366:38: -> ^( TYPE_DECLARATOR_LIST ( declarator )+ )
-                    {
-                        // Grammar/CTFParser.g:366:41: ^( TYPE_DECLARATOR_LIST (
-                        // declarator )+ )
-                        {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(adaptor
-                                    .create(TYPE_DECLARATOR_LIST,
-                                            "TYPE_DECLARATOR_LIST"), root_1);
+               default :
+                   break loop15;
+                }
+            } while (true);
 
-                            if (!(stream_declarator.hasNext())) {
-                                throw new RewriteEarlyExitException();
-                            }
-                            while (stream_declarator.hasNext()) {
-                                adaptor.addChild(root_1,
-                                        stream_declarator.nextTree());
 
-                            }
-                            stream_declarator.reset();
 
-                            adaptor.addChild(root_0, root_1);
-                        }
+            // AST REWRITE
+            // elements: declarator
+            // token labels:
+            // rule labels: retval
+            // token list labels:
+            // rule list labels:
+            // wildcard labels:
+            if ( state.backtracking==0 ) {
+            retval.tree = root_0;
+            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                    }
+            root_0 = (CommonTree)adaptor.nil();
+            // 367:38: -> ^( TYPE_DECLARATOR_LIST ( declarator )+ )
+            {
+                // CTFParser.g:367:41: ^( TYPE_DECLARATOR_LIST ( declarator )+ )
+                {
+                CommonTree root_1 = (CommonTree)adaptor.nil();
+                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TYPE_DECLARATOR_LIST, "TYPE_DECLARATOR_LIST"), root_1);
 
-                    retval.tree = root_0;
+                if ( !(stream_declarator.hasNext()) ) {
+                    throw new RewriteEarlyExitException();
+                }
+                while ( stream_declarator.hasNext() ) {
+                    adaptor.addChild(root_1, stream_declarator.nextTree());
+
+                }
+                stream_declarator.reset();
+
+                adaptor.addChild(root_0, root_1);
                 }
+
+            }
+
+            retval.tree = root_0;}
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 exit("declaratorList");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "declaratorList"
 
-    public static class abstractDeclaratorList_return extends
-            ParserRuleReturnScope {
+    public static class abstractDeclaratorList_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "abstractDeclaratorList"
-    // Grammar/CTFParser.g:369:1: abstractDeclaratorList : abstractDeclarator (
-    // SEPARATOR abstractDeclarator )* -> ^( TYPE_DECLARATOR_LIST (
-    // abstractDeclarator )+ ) ;
-    public final CTFParser.abstractDeclaratorList_return abstractDeclaratorList()
-            throws RecognitionException {
+    // CTFParser.g:370:1: abstractDeclaratorList : abstractDeclarator ( SEPARATOR abstractDeclarator )* -> ^( TYPE_DECLARATOR_LIST ( abstractDeclarator )+ ) ;
+    public final CTFParser.abstractDeclaratorList_return abstractDeclaratorList() throws RecognitionException {
         CTFParser.abstractDeclaratorList_return retval = new CTFParser.abstractDeclaratorList_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token SEPARATOR39 = null;
+        Token SEPARATOR39=null;
         CTFParser.abstractDeclarator_return abstractDeclarator38 = null;
 
         CTFParser.abstractDeclarator_return abstractDeclarator40 = null;
 
-        CommonTree SEPARATOR39_tree = null;
-        RewriteRuleTokenStream stream_SEPARATOR = new RewriteRuleTokenStream(
-                adaptor, "token SEPARATOR");
-        RewriteRuleSubtreeStream stream_abstractDeclarator = new RewriteRuleSubtreeStream(
-                adaptor, "rule abstractDeclarator");
 
-        enter("abstractDeclaratorList");
+        CommonTree SEPARATOR39_tree=null;
+        RewriteRuleTokenStream stream_SEPARATOR=new RewriteRuleTokenStream(adaptor,"token SEPARATOR");
+        RewriteRuleSubtreeStream stream_abstractDeclarator=new RewriteRuleSubtreeStream(adaptor,"rule abstractDeclarator");
+
+          enter("abstractDeclaratorList");
 
         try {
-            // Grammar/CTFParser.g:376:1: ( abstractDeclarator ( SEPARATOR
-            // abstractDeclarator )* -> ^( TYPE_DECLARATOR_LIST (
-            // abstractDeclarator )+ ) )
-            // Grammar/CTFParser.g:377:3: abstractDeclarator ( SEPARATOR
-            // abstractDeclarator )*
+            // CTFParser.g:377:1: ( abstractDeclarator ( SEPARATOR abstractDeclarator )* -> ^( TYPE_DECLARATOR_LIST ( abstractDeclarator )+ ) )
+            // CTFParser.g:378:3: abstractDeclarator ( SEPARATOR abstractDeclarator )*
             {
-                pushFollow(FOLLOW_abstractDeclarator_in_abstractDeclaratorList985);
-                abstractDeclarator38 = abstractDeclarator();
+            pushFollow(FOLLOW_abstractDeclarator_in_abstractDeclaratorList989);
+            abstractDeclarator38=abstractDeclarator();
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_abstractDeclarator.add(abstractDeclarator38
-                            .getTree());
+            state._fsp--;
+            if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_abstractDeclarator.add(abstractDeclarator38.getTree());
+            }
+            // CTFParser.g:378:22: ( SEPARATOR abstractDeclarator )*
+            loop16:
+            do {
+                int alt16=2;
+                int LA16_0 = input.LA(1);
+
+                if ( (LA16_0==SEPARATOR) ) {
+                    alt16=1;
                 }
-                // Grammar/CTFParser.g:377:22: ( SEPARATOR abstractDeclarator )*
-                loop16: do {
-                    int alt16 = 2;
-                    int LA16_0 = input.LA(1);
 
-                    if ((LA16_0 == SEPARATOR)) {
-                        alt16 = 1;
+
+                switch (alt16) {
+               case 1 :
+                   // CTFParser.g:378:23: SEPARATOR abstractDeclarator
+                   {
+                   SEPARATOR39=(Token)match(input,SEPARATOR,FOLLOW_SEPARATOR_in_abstractDeclaratorList992); if (state.failed) {
+                        return retval;
+                    }
+                   if ( state.backtracking==0 ) {
+                        stream_SEPARATOR.add(SEPARATOR39);
                     }
 
-                    switch (alt16) {
-                    case 1:
-                    // Grammar/CTFParser.g:377:23: SEPARATOR abstractDeclarator
-                    {
-                        SEPARATOR39 = (Token) match(input, SEPARATOR,
-                                FOLLOW_SEPARATOR_in_abstractDeclaratorList988);
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_SEPARATOR.add(SEPARATOR39);
-                        }
+                   pushFollow(FOLLOW_abstractDeclarator_in_abstractDeclaratorList994);
+                   abstractDeclarator40=abstractDeclarator();
 
-                        pushFollow(FOLLOW_abstractDeclarator_in_abstractDeclaratorList990);
-                        abstractDeclarator40 = abstractDeclarator();
+                   state._fsp--;
+                   if (state.failed) {
+                        return retval;
+                    }
+                   if ( state.backtracking==0 ) {
+                        stream_abstractDeclarator.add(abstractDeclarator40.getTree());
+                    }
 
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_abstractDeclarator.add(abstractDeclarator40
-                                    .getTree());
-                        }
+                   }
+                   break;
 
-                    }
-                        break;
+               default :
+                   break loop16;
+                }
+            } while (true);
 
-                    default:
-                        break loop16;
-                    }
-                } while (true);
-
-                // AST REWRITE
-                // elements: abstractDeclarator
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 377:54: -> ^( TYPE_DECLARATOR_LIST ( abstractDeclarator
-                    // )+ )
-                    {
-                        // Grammar/CTFParser.g:377:57: ^( TYPE_DECLARATOR_LIST (
-                        // abstractDeclarator )+ )
-                        {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(adaptor
-                                    .create(TYPE_DECLARATOR_LIST,
-                                            "TYPE_DECLARATOR_LIST"), root_1);
 
-                            if (!(stream_abstractDeclarator.hasNext())) {
-                                throw new RewriteEarlyExitException();
-                            }
-                            while (stream_abstractDeclarator.hasNext()) {
-                                adaptor.addChild(root_1,
-                                        stream_abstractDeclarator.nextTree());
+            // AST REWRITE
+            // elements: abstractDeclarator
+            // token labels:
+            // rule labels: retval
+            // token list labels:
+            // rule list labels:
+            // wildcard labels:
+            if ( state.backtracking==0 ) {
+            retval.tree = root_0;
+            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                            }
-                            stream_abstractDeclarator.reset();
+            root_0 = (CommonTree)adaptor.nil();
+            // 378:54: -> ^( TYPE_DECLARATOR_LIST ( abstractDeclarator )+ )
+            {
+                // CTFParser.g:378:57: ^( TYPE_DECLARATOR_LIST ( abstractDeclarator )+ )
+                {
+                CommonTree root_1 = (CommonTree)adaptor.nil();
+                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TYPE_DECLARATOR_LIST, "TYPE_DECLARATOR_LIST"), root_1);
 
-                            adaptor.addChild(root_0, root_1);
-                        }
+                if ( !(stream_abstractDeclarator.hasNext()) ) {
+                    throw new RewriteEarlyExitException();
+                }
+                while ( stream_abstractDeclarator.hasNext() ) {
+                    adaptor.addChild(root_1, stream_abstractDeclarator.nextTree());
 
-                    }
+                }
+                stream_abstractDeclarator.reset();
 
-                    retval.tree = root_0;
+                adaptor.addChild(root_0, root_1);
                 }
+
+            }
+
+            retval.tree = root_0;}
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 exit("abstractDeclaratorList");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "abstractDeclaratorList"
 
-    public static class storageClassSpecifier_return extends
-            ParserRuleReturnScope {
+    public static class storageClassSpecifier_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "storageClassSpecifier"
-    // Grammar/CTFParser.g:380:1: storageClassSpecifier : TYPEDEFTOK ;
-    public final CTFParser.storageClassSpecifier_return storageClassSpecifier()
-            throws RecognitionException {
+    // CTFParser.g:381:1: storageClassSpecifier : TYPEDEFTOK ;
+    public final CTFParser.storageClassSpecifier_return storageClassSpecifier() throws RecognitionException {
         CTFParser.storageClassSpecifier_return retval = new CTFParser.storageClassSpecifier_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token TYPEDEFTOK41 = null;
+        Token TYPEDEFTOK41=null;
 
-        CommonTree TYPEDEFTOK41_tree = null;
+        CommonTree TYPEDEFTOK41_tree=null;
 
         try {
-            // Grammar/CTFParser.g:380:23: ( TYPEDEFTOK )
-            // Grammar/CTFParser.g:381:3: TYPEDEFTOK
+            // CTFParser.g:381:23: ( TYPEDEFTOK )
+            // CTFParser.g:382:3: TYPEDEFTOK
             {
-                root_0 = (CommonTree) adaptor.nil();
+            root_0 = (CommonTree)adaptor.nil();
 
-                TYPEDEFTOK41 = (Token) match(input, TYPEDEFTOK,
-                        FOLLOW_TYPEDEFTOK_in_storageClassSpecifier1014);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    TYPEDEFTOK41_tree = (CommonTree) adaptor
-                            .create(TYPEDEFTOK41);
-                    adaptor.addChild(root_0, TYPEDEFTOK41_tree);
-                }
-                if (state.backtracking == 0) {
-                    typedefOn();
-                }
+            TYPEDEFTOK41=(Token)match(input,TYPEDEFTOK,FOLLOW_TYPEDEFTOK_in_storageClassSpecifier1018); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+            TYPEDEFTOK41_tree = (CommonTree)adaptor.create(TYPEDEFTOK41);
+            adaptor.addChild(root_0, TYPEDEFTOK41_tree);
+            }
+            if ( state.backtracking==0 ) {
+              typedefOn();
+            }
 
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "storageClassSpecifier"
 
     public static class typeSpecifier_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "typeSpecifier"
-    // Grammar/CTFParser.g:384:1: typeSpecifier : ( FLOATTOK | INTTOK | LONGTOK
-    // | SHORTTOK | SIGNEDTOK | UNSIGNEDTOK | CHARTOK | DOUBLETOK | VOIDTOK |
-    // BOOLTOK | COMPLEXTOK | IMAGINARYTOK | structSpecifier | variantSpecifier
-    // | enumSpecifier | ctfTypeSpecifier | {...}? => typedefName );
-    public final CTFParser.typeSpecifier_return typeSpecifier()
-            throws RecognitionException {
+    // CTFParser.g:385:1: typeSpecifier : ( FLOATTOK | INTTOK | LONGTOK | SHORTTOK | SIGNEDTOK | UNSIGNEDTOK | CHARTOK | DOUBLETOK | VOIDTOK | BOOLTOK | COMPLEXTOK | IMAGINARYTOK | structSpecifier | variantSpecifier | enumSpecifier | ctfTypeSpecifier | {...}? => typedefName );
+    public final CTFParser.typeSpecifier_return typeSpecifier() throws RecognitionException {
         CTFParser.typeSpecifier_return retval = new CTFParser.typeSpecifier_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token FLOATTOK42 = null;
-        Token INTTOK43 = null;
-        Token LONGTOK44 = null;
-        Token SHORTTOK45 = null;
-        Token SIGNEDTOK46 = null;
-        Token UNSIGNEDTOK47 = null;
-        Token CHARTOK48 = null;
-        Token DOUBLETOK49 = null;
-        Token VOIDTOK50 = null;
-        Token BOOLTOK51 = null;
-        Token COMPLEXTOK52 = null;
-        Token IMAGINARYTOK53 = null;
+        Token FLOATTOK42=null;
+        Token INTTOK43=null;
+        Token LONGTOK44=null;
+        Token SHORTTOK45=null;
+        Token SIGNEDTOK46=null;
+        Token UNSIGNEDTOK47=null;
+        Token CHARTOK48=null;
+        Token DOUBLETOK49=null;
+        Token VOIDTOK50=null;
+        Token BOOLTOK51=null;
+        Token COMPLEXTOK52=null;
+        Token IMAGINARYTOK53=null;
         CTFParser.structSpecifier_return structSpecifier54 = null;
 
         CTFParser.variantSpecifier_return variantSpecifier55 = null;
@@ -3034,576 +2665,509 @@ public class CTFParser extends Parser {
 
         CTFParser.typedefName_return typedefName58 = null;
 
-        CommonTree FLOATTOK42_tree = null;
-        CommonTree INTTOK43_tree = null;
-        CommonTree LONGTOK44_tree = null;
-        CommonTree SHORTTOK45_tree = null;
-        CommonTree SIGNEDTOK46_tree = null;
-        CommonTree UNSIGNEDTOK47_tree = null;
-        CommonTree CHARTOK48_tree = null;
-        CommonTree DOUBLETOK49_tree = null;
-        CommonTree VOIDTOK50_tree = null;
-        CommonTree BOOLTOK51_tree = null;
-        CommonTree COMPLEXTOK52_tree = null;
-        CommonTree IMAGINARYTOK53_tree = null;
-
-        enter("typeSpecifier");
+
+        CommonTree FLOATTOK42_tree=null;
+        CommonTree INTTOK43_tree=null;
+        CommonTree LONGTOK44_tree=null;
+        CommonTree SHORTTOK45_tree=null;
+        CommonTree SIGNEDTOK46_tree=null;
+        CommonTree UNSIGNEDTOK47_tree=null;
+        CommonTree CHARTOK48_tree=null;
+        CommonTree DOUBLETOK49_tree=null;
+        CommonTree VOIDTOK50_tree=null;
+        CommonTree BOOLTOK51_tree=null;
+        CommonTree COMPLEXTOK52_tree=null;
+        CommonTree IMAGINARYTOK53_tree=null;
+
+
+          enter("typeSpecifier");
 
         try {
-            // Grammar/CTFParser.g:392:1: ( FLOATTOK | INTTOK | LONGTOK |
-            // SHORTTOK | SIGNEDTOK | UNSIGNEDTOK | CHARTOK | DOUBLETOK |
-            // VOIDTOK | BOOLTOK | COMPLEXTOK | IMAGINARYTOK | structSpecifier |
-            // variantSpecifier | enumSpecifier | ctfTypeSpecifier | {...}? =>
-            // typedefName )
-            int alt17 = 17;
+            // CTFParser.g:393:1: ( FLOATTOK | INTTOK | LONGTOK | SHORTTOK | SIGNEDTOK | UNSIGNEDTOK | CHARTOK | DOUBLETOK | VOIDTOK | BOOLTOK | COMPLEXTOK | IMAGINARYTOK | structSpecifier | variantSpecifier | enumSpecifier | ctfTypeSpecifier | {...}? => typedefName )
+            int alt17=17;
             alt17 = dfa17.predict(input);
             switch (alt17) {
-            case 1:
-            // Grammar/CTFParser.g:393:3: FLOATTOK
-            {
-                root_0 = (CommonTree) adaptor.nil();
+                case 1 :
+                    // CTFParser.g:394:3: FLOATTOK
+                    {
+                    root_0 = (CommonTree)adaptor.nil();
 
-                FLOATTOK42 = (Token) match(input, FLOATTOK,
-                        FOLLOW_FLOATTOK_in_typeSpecifier1040);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    FLOATTOK42_tree = (CommonTree) adaptor.create(FLOATTOK42);
+                    FLOATTOK42=(Token)match(input,FLOATTOK,FOLLOW_FLOATTOK_in_typeSpecifier1044); if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                    FLOATTOK42_tree = (CommonTree)adaptor.create(FLOATTOK42);
                     adaptor.addChild(root_0, FLOATTOK42_tree);
-                }
+                    }
 
-            }
-                break;
-            case 2:
-            // Grammar/CTFParser.g:394:5: INTTOK
-            {
-                root_0 = (CommonTree) adaptor.nil();
+                    }
+                    break;
+                case 2 :
+                    // CTFParser.g:395:5: INTTOK
+                    {
+                    root_0 = (CommonTree)adaptor.nil();
 
-                INTTOK43 = (Token) match(input, INTTOK,
-                        FOLLOW_INTTOK_in_typeSpecifier1046);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    INTTOK43_tree = (CommonTree) adaptor.create(INTTOK43);
+                    INTTOK43=(Token)match(input,INTTOK,FOLLOW_INTTOK_in_typeSpecifier1050); if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                    INTTOK43_tree = (CommonTree)adaptor.create(INTTOK43);
                     adaptor.addChild(root_0, INTTOK43_tree);
-                }
+                    }
 
-            }
-                break;
-            case 3:
-            // Grammar/CTFParser.g:395:5: LONGTOK
-            {
-                root_0 = (CommonTree) adaptor.nil();
+                    }
+                    break;
+                case 3 :
+                    // CTFParser.g:396:5: LONGTOK
+                    {
+                    root_0 = (CommonTree)adaptor.nil();
 
-                LONGTOK44 = (Token) match(input, LONGTOK,
-                        FOLLOW_LONGTOK_in_typeSpecifier1052);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    LONGTOK44_tree = (CommonTree) adaptor.create(LONGTOK44);
+                    LONGTOK44=(Token)match(input,LONGTOK,FOLLOW_LONGTOK_in_typeSpecifier1056); if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                    LONGTOK44_tree = (CommonTree)adaptor.create(LONGTOK44);
                     adaptor.addChild(root_0, LONGTOK44_tree);
-                }
+                    }
 
-            }
-                break;
-            case 4:
-            // Grammar/CTFParser.g:396:5: SHORTTOK
-            {
-                root_0 = (CommonTree) adaptor.nil();
+                    }
+                    break;
+                case 4 :
+                    // CTFParser.g:397:5: SHORTTOK
+                    {
+                    root_0 = (CommonTree)adaptor.nil();
 
-                SHORTTOK45 = (Token) match(input, SHORTTOK,
-                        FOLLOW_SHORTTOK_in_typeSpecifier1058);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    SHORTTOK45_tree = (CommonTree) adaptor.create(SHORTTOK45);
+                    SHORTTOK45=(Token)match(input,SHORTTOK,FOLLOW_SHORTTOK_in_typeSpecifier1062); if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                    SHORTTOK45_tree = (CommonTree)adaptor.create(SHORTTOK45);
                     adaptor.addChild(root_0, SHORTTOK45_tree);
-                }
+                    }
 
-            }
-                break;
-            case 5:
-            // Grammar/CTFParser.g:397:5: SIGNEDTOK
-            {
-                root_0 = (CommonTree) adaptor.nil();
+                    }
+                    break;
+                case 5 :
+                    // CTFParser.g:398:5: SIGNEDTOK
+                    {
+                    root_0 = (CommonTree)adaptor.nil();
 
-                SIGNEDTOK46 = (Token) match(input, SIGNEDTOK,
-                        FOLLOW_SIGNEDTOK_in_typeSpecifier1064);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    SIGNEDTOK46_tree = (CommonTree) adaptor.create(SIGNEDTOK46);
+                    SIGNEDTOK46=(Token)match(input,SIGNEDTOK,FOLLOW_SIGNEDTOK_in_typeSpecifier1068); if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                    SIGNEDTOK46_tree = (CommonTree)adaptor.create(SIGNEDTOK46);
                     adaptor.addChild(root_0, SIGNEDTOK46_tree);
-                }
+                    }
 
-            }
-                break;
-            case 6:
-            // Grammar/CTFParser.g:398:5: UNSIGNEDTOK
-            {
-                root_0 = (CommonTree) adaptor.nil();
+                    }
+                    break;
+                case 6 :
+                    // CTFParser.g:399:5: UNSIGNEDTOK
+                    {
+                    root_0 = (CommonTree)adaptor.nil();
 
-                UNSIGNEDTOK47 = (Token) match(input, UNSIGNEDTOK,
-                        FOLLOW_UNSIGNEDTOK_in_typeSpecifier1070);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    UNSIGNEDTOK47_tree = (CommonTree) adaptor
-                            .create(UNSIGNEDTOK47);
+                    UNSIGNEDTOK47=(Token)match(input,UNSIGNEDTOK,FOLLOW_UNSIGNEDTOK_in_typeSpecifier1074); if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                    UNSIGNEDTOK47_tree = (CommonTree)adaptor.create(UNSIGNEDTOK47);
                     adaptor.addChild(root_0, UNSIGNEDTOK47_tree);
-                }
+                    }
 
-            }
-                break;
-            case 7:
-            // Grammar/CTFParser.g:399:5: CHARTOK
-            {
-                root_0 = (CommonTree) adaptor.nil();
+                    }
+                    break;
+                case 7 :
+                    // CTFParser.g:400:5: CHARTOK
+                    {
+                    root_0 = (CommonTree)adaptor.nil();
 
-                CHARTOK48 = (Token) match(input, CHARTOK,
-                        FOLLOW_CHARTOK_in_typeSpecifier1076);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    CHARTOK48_tree = (CommonTree) adaptor.create(CHARTOK48);
+                    CHARTOK48=(Token)match(input,CHARTOK,FOLLOW_CHARTOK_in_typeSpecifier1080); if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                    CHARTOK48_tree = (CommonTree)adaptor.create(CHARTOK48);
                     adaptor.addChild(root_0, CHARTOK48_tree);
-                }
+                    }
 
-            }
-                break;
-            case 8:
-            // Grammar/CTFParser.g:400:5: DOUBLETOK
-            {
-                root_0 = (CommonTree) adaptor.nil();
+                    }
+                    break;
+                case 8 :
+                    // CTFParser.g:401:5: DOUBLETOK
+                    {
+                    root_0 = (CommonTree)adaptor.nil();
 
-                DOUBLETOK49 = (Token) match(input, DOUBLETOK,
-                        FOLLOW_DOUBLETOK_in_typeSpecifier1082);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    DOUBLETOK49_tree = (CommonTree) adaptor.create(DOUBLETOK49);
+                    DOUBLETOK49=(Token)match(input,DOUBLETOK,FOLLOW_DOUBLETOK_in_typeSpecifier1086); if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                    DOUBLETOK49_tree = (CommonTree)adaptor.create(DOUBLETOK49);
                     adaptor.addChild(root_0, DOUBLETOK49_tree);
-                }
+                    }
 
-            }
-                break;
-            case 9:
-            // Grammar/CTFParser.g:401:5: VOIDTOK
-            {
-                root_0 = (CommonTree) adaptor.nil();
+                    }
+                    break;
+                case 9 :
+                    // CTFParser.g:402:5: VOIDTOK
+                    {
+                    root_0 = (CommonTree)adaptor.nil();
 
-                VOIDTOK50 = (Token) match(input, VOIDTOK,
-                        FOLLOW_VOIDTOK_in_typeSpecifier1088);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    VOIDTOK50_tree = (CommonTree) adaptor.create(VOIDTOK50);
+                    VOIDTOK50=(Token)match(input,VOIDTOK,FOLLOW_VOIDTOK_in_typeSpecifier1092); if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                    VOIDTOK50_tree = (CommonTree)adaptor.create(VOIDTOK50);
                     adaptor.addChild(root_0, VOIDTOK50_tree);
-                }
+                    }
 
-            }
-                break;
-            case 10:
-            // Grammar/CTFParser.g:402:5: BOOLTOK
-            {
-                root_0 = (CommonTree) adaptor.nil();
+                    }
+                    break;
+                case 10 :
+                    // CTFParser.g:403:5: BOOLTOK
+                    {
+                    root_0 = (CommonTree)adaptor.nil();
 
-                BOOLTOK51 = (Token) match(input, BOOLTOK,
-                        FOLLOW_BOOLTOK_in_typeSpecifier1094);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    BOOLTOK51_tree = (CommonTree) adaptor.create(BOOLTOK51);
+                    BOOLTOK51=(Token)match(input,BOOLTOK,FOLLOW_BOOLTOK_in_typeSpecifier1098); if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                    BOOLTOK51_tree = (CommonTree)adaptor.create(BOOLTOK51);
                     adaptor.addChild(root_0, BOOLTOK51_tree);
-                }
+                    }
 
-            }
-                break;
-            case 11:
-            // Grammar/CTFParser.g:403:5: COMPLEXTOK
-            {
-                root_0 = (CommonTree) adaptor.nil();
+                    }
+                    break;
+                case 11 :
+                    // CTFParser.g:404:5: COMPLEXTOK
+                    {
+                    root_0 = (CommonTree)adaptor.nil();
 
-                COMPLEXTOK52 = (Token) match(input, COMPLEXTOK,
-                        FOLLOW_COMPLEXTOK_in_typeSpecifier1100);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    COMPLEXTOK52_tree = (CommonTree) adaptor
-                            .create(COMPLEXTOK52);
+                    COMPLEXTOK52=(Token)match(input,COMPLEXTOK,FOLLOW_COMPLEXTOK_in_typeSpecifier1104); if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                    COMPLEXTOK52_tree = (CommonTree)adaptor.create(COMPLEXTOK52);
                     adaptor.addChild(root_0, COMPLEXTOK52_tree);
-                }
+                    }
 
-            }
-                break;
-            case 12:
-            // Grammar/CTFParser.g:404:5: IMAGINARYTOK
-            {
-                root_0 = (CommonTree) adaptor.nil();
+                    }
+                    break;
+                case 12 :
+                    // CTFParser.g:405:5: IMAGINARYTOK
+                    {
+                    root_0 = (CommonTree)adaptor.nil();
 
-                IMAGINARYTOK53 = (Token) match(input, IMAGINARYTOK,
-                        FOLLOW_IMAGINARYTOK_in_typeSpecifier1106);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    IMAGINARYTOK53_tree = (CommonTree) adaptor
-                            .create(IMAGINARYTOK53);
+                    IMAGINARYTOK53=(Token)match(input,IMAGINARYTOK,FOLLOW_IMAGINARYTOK_in_typeSpecifier1110); if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                    IMAGINARYTOK53_tree = (CommonTree)adaptor.create(IMAGINARYTOK53);
                     adaptor.addChild(root_0, IMAGINARYTOK53_tree);
-                }
+                    }
 
-            }
-                break;
-            case 13:
-            // Grammar/CTFParser.g:405:5: structSpecifier
-            {
-                root_0 = (CommonTree) adaptor.nil();
+                    }
+                    break;
+                case 13 :
+                    // CTFParser.g:406:5: structSpecifier
+                    {
+                    root_0 = (CommonTree)adaptor.nil();
 
-                pushFollow(FOLLOW_structSpecifier_in_typeSpecifier1112);
-                structSpecifier54 = structSpecifier();
+                    pushFollow(FOLLOW_structSpecifier_in_typeSpecifier1116);
+                    structSpecifier54=structSpecifier();
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    adaptor.addChild(root_0, structSpecifier54.getTree());
-                }
+                    state._fsp--;
+                    if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        adaptor.addChild(root_0, structSpecifier54.getTree());
+                    }
 
-            }
-                break;
-            case 14:
-            // Grammar/CTFParser.g:406:5: variantSpecifier
-            {
-                root_0 = (CommonTree) adaptor.nil();
+                    }
+                    break;
+                case 14 :
+                    // CTFParser.g:407:5: variantSpecifier
+                    {
+                    root_0 = (CommonTree)adaptor.nil();
 
-                pushFollow(FOLLOW_variantSpecifier_in_typeSpecifier1118);
-                variantSpecifier55 = variantSpecifier();
+                    pushFollow(FOLLOW_variantSpecifier_in_typeSpecifier1122);
+                    variantSpecifier55=variantSpecifier();
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    adaptor.addChild(root_0, variantSpecifier55.getTree());
-                }
+                    state._fsp--;
+                    if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        adaptor.addChild(root_0, variantSpecifier55.getTree());
+                    }
 
-            }
-                break;
-            case 15:
-            // Grammar/CTFParser.g:407:5: enumSpecifier
-            {
-                root_0 = (CommonTree) adaptor.nil();
+                    }
+                    break;
+                case 15 :
+                    // CTFParser.g:408:5: enumSpecifier
+                    {
+                    root_0 = (CommonTree)adaptor.nil();
 
-                pushFollow(FOLLOW_enumSpecifier_in_typeSpecifier1124);
-                enumSpecifier56 = enumSpecifier();
+                    pushFollow(FOLLOW_enumSpecifier_in_typeSpecifier1128);
+                    enumSpecifier56=enumSpecifier();
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    adaptor.addChild(root_0, enumSpecifier56.getTree());
-                }
+                    state._fsp--;
+                    if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        adaptor.addChild(root_0, enumSpecifier56.getTree());
+                    }
 
-            }
-                break;
-            case 16:
-            // Grammar/CTFParser.g:408:5: ctfTypeSpecifier
-            {
-                root_0 = (CommonTree) adaptor.nil();
+                    }
+                    break;
+                case 16 :
+                    // CTFParser.g:409:5: ctfTypeSpecifier
+                    {
+                    root_0 = (CommonTree)adaptor.nil();
 
-                pushFollow(FOLLOW_ctfTypeSpecifier_in_typeSpecifier1130);
-                ctfTypeSpecifier57 = ctfTypeSpecifier();
+                    pushFollow(FOLLOW_ctfTypeSpecifier_in_typeSpecifier1134);
+                    ctfTypeSpecifier57=ctfTypeSpecifier();
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    adaptor.addChild(root_0, ctfTypeSpecifier57.getTree());
-                }
+                    state._fsp--;
+                    if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        adaptor.addChild(root_0, ctfTypeSpecifier57.getTree());
+                    }
 
-            }
-                break;
-            case 17:
-            // Grammar/CTFParser.g:409:5: {...}? => typedefName
-            {
-                root_0 = (CommonTree) adaptor.nil();
+                    }
+                    break;
+                case 17 :
+                    // CTFParser.g:410:5: {...}? => typedefName
+                    {
+                    root_0 = (CommonTree)adaptor.nil();
 
-                if (!((inTypealiasAlias() || isTypeName(input.LT(1).getText())))) {
-                    if (state.backtracking > 0) {
-                        state.failed = true;
-                        return retval;
+                    if ( !((inTypealiasAlias() || isTypeName(input.LT(1).getText()))) ) {
+                        if (state.backtracking>0) {state.failed=true; return retval;}
+                        throw new FailedPredicateException(input, "typeSpecifier", "inTypealiasAlias() || isTypeName(input.LT(1).getText())");
                     }
-                    throw new FailedPredicateException(input, "typeSpecifier",
-                            "inTypealiasAlias() || isTypeName(input.LT(1).getText())");
-                }
-                pushFollow(FOLLOW_typedefName_in_typeSpecifier1140);
-                typedefName58 = typedefName();
+                    pushFollow(FOLLOW_typedefName_in_typeSpecifier1144);
+                    typedefName58=typedefName();
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    adaptor.addChild(root_0, typedefName58.getTree());
-                }
+                    state._fsp--;
+                    if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        adaptor.addChild(root_0, typedefName58.getTree());
+                    }
 
-            }
-                break;
+                    }
+                    break;
 
             }
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                debug_print(input.toString(retval.start, input.LT(-1)));
+                debug_print(input.toString(retval.start,input.LT(-1)));
                 exit("typeSpecifier");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "typeSpecifier"
 
     public static class typeQualifier_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "typeQualifier"
-    // Grammar/CTFParser.g:412:1: typeQualifier : CONSTTOK ;
-    public final CTFParser.typeQualifier_return typeQualifier()
-            throws RecognitionException {
+    // CTFParser.g:413:1: typeQualifier : CONSTTOK ;
+    public final CTFParser.typeQualifier_return typeQualifier() throws RecognitionException {
         CTFParser.typeQualifier_return retval = new CTFParser.typeQualifier_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token CONSTTOK59 = null;
+        Token CONSTTOK59=null;
 
-        CommonTree CONSTTOK59_tree = null;
+        CommonTree CONSTTOK59_tree=null;
 
-        enter("typeQualifier");
+
+          enter("typeQualifier");
 
         try {
-            // Grammar/CTFParser.g:420:1: ( CONSTTOK )
-            // Grammar/CTFParser.g:421:3: CONSTTOK
+            // CTFParser.g:421:1: ( CONSTTOK )
+            // CTFParser.g:422:3: CONSTTOK
             {
-                root_0 = (CommonTree) adaptor.nil();
+            root_0 = (CommonTree)adaptor.nil();
 
-                CONSTTOK59 = (Token) match(input, CONSTTOK,
-                        FOLLOW_CONSTTOK_in_typeQualifier1163);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    CONSTTOK59_tree = (CommonTree) adaptor.create(CONSTTOK59);
-                    adaptor.addChild(root_0, CONSTTOK59_tree);
-                }
+            CONSTTOK59=(Token)match(input,CONSTTOK,FOLLOW_CONSTTOK_in_typeQualifier1167); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+            CONSTTOK59_tree = (CommonTree)adaptor.create(CONSTTOK59);
+            adaptor.addChild(root_0, CONSTTOK59_tree);
+            }
 
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                debug_print(input.toString(retval.start, input.LT(-1)));
+                debug_print(input.toString(retval.start,input.LT(-1)));
                 exit("typeQualifier");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
-
         return retval;
     }
-
     // $ANTLR end "typeQualifier"
 
     public static class alignAttribute_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "alignAttribute"
-    // Grammar/CTFParser.g:424:1: alignAttribute : ALIGNTOK LPAREN
-    // unaryExpression RPAREN -> ^( ALIGN unaryExpression ) ;
-    public final CTFParser.alignAttribute_return alignAttribute()
-            throws RecognitionException {
+    // CTFParser.g:425:1: alignAttribute : ALIGNTOK LPAREN unaryExpression RPAREN -> ^( ALIGN unaryExpression ) ;
+    public final CTFParser.alignAttribute_return alignAttribute() throws RecognitionException {
         CTFParser.alignAttribute_return retval = new CTFParser.alignAttribute_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token ALIGNTOK60 = null;
-        Token LPAREN61 = null;
-        Token RPAREN63 = null;
+        Token ALIGNTOK60=null;
+        Token LPAREN61=null;
+        Token RPAREN63=null;
         CTFParser.unaryExpression_return unaryExpression62 = null;
 
-        CommonTree ALIGNTOK60_tree = null;
-        CommonTree LPAREN61_tree = null;
-        CommonTree RPAREN63_tree = null;
-        RewriteRuleTokenStream stream_RPAREN = new RewriteRuleTokenStream(
-                adaptor, "token RPAREN");
-        RewriteRuleTokenStream stream_ALIGNTOK = new RewriteRuleTokenStream(
-                adaptor, "token ALIGNTOK");
-        RewriteRuleTokenStream stream_LPAREN = new RewriteRuleTokenStream(
-                adaptor, "token LPAREN");
-        RewriteRuleSubtreeStream stream_unaryExpression = new RewriteRuleSubtreeStream(
-                adaptor, "rule unaryExpression");
+
+        CommonTree ALIGNTOK60_tree=null;
+        CommonTree LPAREN61_tree=null;
+        CommonTree RPAREN63_tree=null;
+        RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
+        RewriteRuleTokenStream stream_ALIGNTOK=new RewriteRuleTokenStream(adaptor,"token ALIGNTOK");
+        RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
+        RewriteRuleSubtreeStream stream_unaryExpression=new RewriteRuleSubtreeStream(adaptor,"rule unaryExpression");
         try {
-            // Grammar/CTFParser.g:424:16: ( ALIGNTOK LPAREN unaryExpression
-            // RPAREN -> ^( ALIGN unaryExpression ) )
-            // Grammar/CTFParser.g:425:3: ALIGNTOK LPAREN unaryExpression RPAREN
+            // CTFParser.g:425:16: ( ALIGNTOK LPAREN unaryExpression RPAREN -> ^( ALIGN unaryExpression ) )
+            // CTFParser.g:426:3: ALIGNTOK LPAREN unaryExpression RPAREN
             {
-                ALIGNTOK60 = (Token) match(input, ALIGNTOK,
-                        FOLLOW_ALIGNTOK_in_alignAttribute1176);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_ALIGNTOK.add(ALIGNTOK60);
-                }
+            ALIGNTOK60=(Token)match(input,ALIGNTOK,FOLLOW_ALIGNTOK_in_alignAttribute1180); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_ALIGNTOK.add(ALIGNTOK60);
+            }
 
-                LPAREN61 = (Token) match(input, LPAREN,
-                        FOLLOW_LPAREN_in_alignAttribute1178);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_LPAREN.add(LPAREN61);
-                }
+            LPAREN61=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_alignAttribute1182); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_LPAREN.add(LPAREN61);
+            }
 
-                pushFollow(FOLLOW_unaryExpression_in_alignAttribute1180);
-                unaryExpression62 = unaryExpression();
+            pushFollow(FOLLOW_unaryExpression_in_alignAttribute1184);
+            unaryExpression62=unaryExpression();
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_unaryExpression.add(unaryExpression62.getTree());
-                }
-                RPAREN63 = (Token) match(input, RPAREN,
-                        FOLLOW_RPAREN_in_alignAttribute1182);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_RPAREN.add(RPAREN63);
-                }
+            state._fsp--;
+            if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_unaryExpression.add(unaryExpression62.getTree());
+            }
+            RPAREN63=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_alignAttribute1186); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_RPAREN.add(RPAREN63);
+            }
 
-                // AST REWRITE
-                // elements: unaryExpression
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 425:42: -> ^( ALIGN unaryExpression )
-                    {
-                        // Grammar/CTFParser.g:425:45: ^( ALIGN unaryExpression
-                        // )
-                        {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(
-                                    adaptor.create(ALIGN, "ALIGN"), root_1);
 
-                            adaptor.addChild(root_1,
-                                    stream_unaryExpression.nextTree());
+            // AST REWRITE
+            // elements: unaryExpression
+            // token labels:
+            // rule labels: retval
+            // token list labels:
+            // rule list labels:
+            // wildcard labels:
+            if ( state.backtracking==0 ) {
+            retval.tree = root_0;
+            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                            adaptor.addChild(root_0, root_1);
-                        }
+            root_0 = (CommonTree)adaptor.nil();
+            // 426:42: -> ^( ALIGN unaryExpression )
+            {
+                // CTFParser.g:426:45: ^( ALIGN unaryExpression )
+                {
+                CommonTree root_1 = (CommonTree)adaptor.nil();
+                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ALIGN, "ALIGN"), root_1);
 
-                    }
+                adaptor.addChild(root_1, stream_unaryExpression.nextTree());
 
-                    retval.tree = root_0;
+                adaptor.addChild(root_0, root_1);
                 }
+
+            }
+
+            retval.tree = root_0;}
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
-
         return retval;
     }
-
     // $ANTLR end "alignAttribute"
 
     public static class structBody_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "structBody"
-    // Grammar/CTFParser.g:429:1: structBody : LCURL (
-    // structOrVariantDeclarationList )? RCURL -> ^( STRUCT_BODY (
-    // structOrVariantDeclarationList )? ) ;
-    public final CTFParser.structBody_return structBody()
-            throws RecognitionException {
+    // CTFParser.g:430:1: structBody : LCURL ( structOrVariantDeclarationList )? RCURL -> ^( STRUCT_BODY ( structOrVariantDeclarationList )? ) ;
+    public final CTFParser.structBody_return structBody() throws RecognitionException {
         Symbols_stack.push(new Symbols_scope());
 
         CTFParser.structBody_return retval = new CTFParser.structBody_return();
@@ -3611,139 +3175,116 @@ public class CTFParser extends Parser {
 
         CommonTree root_0 = null;
 
-        Token LCURL64 = null;
-        Token RCURL66 = null;
+        Token LCURL64=null;
+        Token RCURL66=null;
         CTFParser.structOrVariantDeclarationList_return structOrVariantDeclarationList65 = null;
 
-        CommonTree LCURL64_tree = null;
-        CommonTree RCURL66_tree = null;
-        RewriteRuleTokenStream stream_LCURL = new RewriteRuleTokenStream(
-                adaptor, "token LCURL");
-        RewriteRuleTokenStream stream_RCURL = new RewriteRuleTokenStream(
-                adaptor, "token RCURL");
-        RewriteRuleSubtreeStream stream_structOrVariantDeclarationList = new RewriteRuleSubtreeStream(
-                adaptor, "rule structOrVariantDeclarationList");
 
-        enter("structBody");
-        debug_print("Scope push " + Symbols_stack.size());
-        ((Symbols_scope) Symbols_stack.peek()).types = new HashSet<String>();
+        CommonTree LCURL64_tree=null;
+        CommonTree RCURL66_tree=null;
+        RewriteRuleTokenStream stream_LCURL=new RewriteRuleTokenStream(adaptor,"token LCURL");
+        RewriteRuleTokenStream stream_RCURL=new RewriteRuleTokenStream(adaptor,"token RCURL");
+        RewriteRuleSubtreeStream stream_structOrVariantDeclarationList=new RewriteRuleSubtreeStream(adaptor,"rule structOrVariantDeclarationList");
+
+          enter("structBody");
+          debug_print("Scope push " + Symbols_stack.size());
+          ((Symbols_scope)Symbols_stack.peek()).types = new HashSet<String>();
 
         try {
-            // Grammar/CTFParser.g:440:1: ( LCURL (
-            // structOrVariantDeclarationList )? RCURL -> ^( STRUCT_BODY (
-            // structOrVariantDeclarationList )? ) )
-            // Grammar/CTFParser.g:441:3: LCURL ( structOrVariantDeclarationList
-            // )? RCURL
+            // CTFParser.g:441:1: ( LCURL ( structOrVariantDeclarationList )? RCURL -> ^( STRUCT_BODY ( structOrVariantDeclarationList )? ) )
+            // CTFParser.g:442:3: LCURL ( structOrVariantDeclarationList )? RCURL
             {
-                LCURL64 = (Token) match(input, LCURL,
-                        FOLLOW_LCURL_in_structBody1223);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_LCURL.add(LCURL64);
-                }
-
-                // Grammar/CTFParser.g:441:9: ( structOrVariantDeclarationList
-                // )?
-                int alt18 = 2;
-                int LA18_0 = input.LA(1);
-
-                if ((((LA18_0 >= CONSTTOK) && (LA18_0 <= ENUMTOK))
-                        || ((LA18_0 >= FLOATINGPOINTTOK) && (LA18_0 <= SIGNEDTOK))
-                        || ((LA18_0 >= STRINGTOK) && (LA18_0 <= STRUCTTOK)) || ((LA18_0 >= TYPEDEFTOK) && (LA18_0 <= IMAGINARYTOK)))) {
-                    alt18 = 1;
-                } else if ((LA18_0 == IDENTIFIER)
-                        && ((inTypealiasAlias() || isTypeName(input.LT(1)
-                                .getText())))) {
-                    alt18 = 1;
-                } else if ((LA18_0 == TYPEALIASTOK)) {
-                    alt18 = 1;
-                }
-                switch (alt18) {
-                case 1:
-                // Grammar/CTFParser.g:441:9: structOrVariantDeclarationList
-                {
-                    pushFollow(FOLLOW_structOrVariantDeclarationList_in_structBody1225);
-                    structOrVariantDeclarationList65 = structOrVariantDeclarationList();
+            LCURL64=(Token)match(input,LCURL,FOLLOW_LCURL_in_structBody1227); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_LCURL.add(LCURL64);
+            }
+
+            // CTFParser.g:442:9: ( structOrVariantDeclarationList )?
+            int alt18=2;
+            int LA18_0 = input.LA(1);
+
+            if ( ((LA18_0>=CONSTTOK && LA18_0<=ENUMTOK)||(LA18_0>=FLOATINGPOINTTOK && LA18_0<=SIGNEDTOK)||(LA18_0>=STRINGTOK && LA18_0<=STRUCTTOK)||(LA18_0>=TYPEDEFTOK && LA18_0<=IMAGINARYTOK)) ) {
+                alt18=1;
+            }
+            else if ( (LA18_0==IDENTIFIER) && ((inTypealiasAlias() || isTypeName(input.LT(1).getText())))) {
+                alt18=1;
+            }
+            else if ( (LA18_0==TYPEALIASTOK) ) {
+                alt18=1;
+            }
+            switch (alt18) {
+                case 1 :
+                    // CTFParser.g:442:9: structOrVariantDeclarationList
+                    {
+                    pushFollow(FOLLOW_structOrVariantDeclarationList_in_structBody1229);
+                    structOrVariantDeclarationList65=structOrVariantDeclarationList();
 
                     state._fsp--;
                     if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
-                        stream_structOrVariantDeclarationList
-                                .add(structOrVariantDeclarationList65.getTree());
+                    if ( state.backtracking==0 ) {
+                        stream_structOrVariantDeclarationList.add(structOrVariantDeclarationList65.getTree());
                     }
 
-                }
+                    }
                     break;
 
-                }
+            }
 
-                RCURL66 = (Token) match(input, RCURL,
-                        FOLLOW_RCURL_in_structBody1228);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_RCURL.add(RCURL66);
-                }
+            RCURL66=(Token)match(input,RCURL,FOLLOW_RCURL_in_structBody1232); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_RCURL.add(RCURL66);
+            }
 
-                // AST REWRITE
-                // elements: structOrVariantDeclarationList
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 441:47: -> ^( STRUCT_BODY (
-                    // structOrVariantDeclarationList )? )
-                    {
-                        // Grammar/CTFParser.g:441:50: ^( STRUCT_BODY (
-                        // structOrVariantDeclarationList )? )
-                        {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(
-                                    adaptor.create(STRUCT_BODY, "STRUCT_BODY"),
-                                    root_1);
-
-                            // Grammar/CTFParser.g:441:64: (
-                            // structOrVariantDeclarationList )?
-                            if (stream_structOrVariantDeclarationList.hasNext()) {
-                                adaptor.addChild(root_1,
-                                        stream_structOrVariantDeclarationList
-                                                .nextTree());
 
-                            }
-                            stream_structOrVariantDeclarationList.reset();
+            // AST REWRITE
+            // elements: structOrVariantDeclarationList
+            // token labels:
+            // rule labels: retval
+            // token list labels:
+            // rule list labels:
+            // wildcard labels:
+            if ( state.backtracking==0 ) {
+            retval.tree = root_0;
+            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                            adaptor.addChild(root_0, root_1);
-                        }
+            root_0 = (CommonTree)adaptor.nil();
+            // 442:47: -> ^( STRUCT_BODY ( structOrVariantDeclarationList )? )
+            {
+                // CTFParser.g:442:50: ^( STRUCT_BODY ( structOrVariantDeclarationList )? )
+                {
+                CommonTree root_1 = (CommonTree)adaptor.nil();
+                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(STRUCT_BODY, "STRUCT_BODY"), root_1);
 
-                    }
+                // CTFParser.g:442:64: ( structOrVariantDeclarationList )?
+                if ( stream_structOrVariantDeclarationList.hasNext() ) {
+                    adaptor.addChild(root_1, stream_structOrVariantDeclarationList.nextTree());
 
-                    retval.tree = root_0;
                 }
+                stream_structOrVariantDeclarationList.reset();
+
+                adaptor.addChild(root_0, root_1);
+                }
+
+            }
+
+            retval.tree = root_0;}
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 debug_print("Scope pop " + Symbols_stack.size());
                 exit("structBody");
@@ -3751,39 +3292,32 @@ public class CTFParser extends Parser {
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-        } finally {
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
             Symbols_stack.pop();
 
         }
         return retval;
     }
-
     // $ANTLR end "structBody"
 
     public static class structSpecifier_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "structSpecifier"
-    // Grammar/CTFParser.g:446:1: structSpecifier : STRUCTTOK ( ( structName (
-    // alignAttribute | ( structBody ( alignAttribute | ) ) | ) ) | ( structBody
-    // ( alignAttribute | ) ) ) -> ^( STRUCT ( structName )? ( structBody )? (
-    // alignAttribute )? ) ;
-    public final CTFParser.structSpecifier_return structSpecifier()
-            throws RecognitionException {
+    // CTFParser.g:447:1: structSpecifier : STRUCTTOK ( ( structName ( alignAttribute | ( structBody ( alignAttribute | ) ) | ) ) | ( structBody ( alignAttribute | ) ) ) -> ^( STRUCT ( structName )? ( structBody )? ( alignAttribute )? ) ;
+    public final CTFParser.structSpecifier_return structSpecifier() throws RecognitionException {
         CTFParser.structSpecifier_return retval = new CTFParser.structSpecifier_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token STRUCTTOK67 = null;
+        Token STRUCTTOK67=null;
         CTFParser.structName_return structName68 = null;
 
         CTFParser.alignAttribute_return alignAttribute69 = null;
@@ -3796,202 +3330,71 @@ public class CTFParser extends Parser {
 
         CTFParser.alignAttribute_return alignAttribute73 = null;
 
-        CommonTree STRUCTTOK67_tree = null;
-        RewriteRuleTokenStream stream_STRUCTTOK = new RewriteRuleTokenStream(
-                adaptor, "token STRUCTTOK");
-        RewriteRuleSubtreeStream stream_structName = new RewriteRuleSubtreeStream(
-                adaptor, "rule structName");
-        RewriteRuleSubtreeStream stream_structBody = new RewriteRuleSubtreeStream(
-                adaptor, "rule structBody");
-        RewriteRuleSubtreeStream stream_alignAttribute = new RewriteRuleSubtreeStream(
-                adaptor, "rule alignAttribute");
 
-        enter("structSpecifier");
+        CommonTree STRUCTTOK67_tree=null;
+        RewriteRuleTokenStream stream_STRUCTTOK=new RewriteRuleTokenStream(adaptor,"token STRUCTTOK");
+        RewriteRuleSubtreeStream stream_structName=new RewriteRuleSubtreeStream(adaptor,"rule structName");
+        RewriteRuleSubtreeStream stream_structBody=new RewriteRuleSubtreeStream(adaptor,"rule structBody");
+        RewriteRuleSubtreeStream stream_alignAttribute=new RewriteRuleSubtreeStream(adaptor,"rule alignAttribute");
+
+          enter("structSpecifier");
 
         try {
-            // Grammar/CTFParser.g:453:1: ( STRUCTTOK ( ( structName (
-            // alignAttribute | ( structBody ( alignAttribute | ) ) | ) ) | (
-            // structBody ( alignAttribute | ) ) ) -> ^( STRUCT ( structName )?
-            // ( structBody )? ( alignAttribute )? ) )
-            // Grammar/CTFParser.g:454:3: STRUCTTOK ( ( structName (
-            // alignAttribute | ( structBody ( alignAttribute | ) ) | ) ) | (
-            // structBody ( alignAttribute | ) ) )
+            // CTFParser.g:454:1: ( STRUCTTOK ( ( structName ( alignAttribute | ( structBody ( alignAttribute | ) ) | ) ) | ( structBody ( alignAttribute | ) ) ) -> ^( STRUCT ( structName )? ( structBody )? ( alignAttribute )? ) )
+            // CTFParser.g:455:3: STRUCTTOK ( ( structName ( alignAttribute | ( structBody ( alignAttribute | ) ) | ) ) | ( structBody ( alignAttribute | ) ) )
             {
-                STRUCTTOK67 = (Token) match(input, STRUCTTOK,
-                        FOLLOW_STRUCTTOK_in_structSpecifier1266);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_STRUCTTOK.add(STRUCTTOK67);
-                }
-
-                // Grammar/CTFParser.g:455:3: ( ( structName ( alignAttribute |
-                // ( structBody ( alignAttribute | ) ) | ) ) | ( structBody (
-                // alignAttribute | ) ) )
-                int alt22 = 2;
-                int LA22_0 = input.LA(1);
-
-                if ((LA22_0 == IDENTIFIER)) {
-                    alt22 = 1;
-                } else if ((LA22_0 == LCURL)) {
-                    alt22 = 2;
-                } else {
-                    if (state.backtracking > 0) {
-                        state.failed = true;
-                        return retval;
-                    }
-                    NoViableAltException nvae = new NoViableAltException("",
-                            22, 0, input);
-
-                    throw nvae;
-                }
-                switch (alt22) {
-                case 1:
-                // Grammar/CTFParser.g:457:5: ( structName ( alignAttribute | (
-                // structBody ( alignAttribute | ) ) | ) )
-                {
-                    // Grammar/CTFParser.g:457:5: ( structName ( alignAttribute
-                    // | ( structBody ( alignAttribute | ) ) | ) )
-                    // Grammar/CTFParser.g:458:6: structName ( alignAttribute |
-                    // ( structBody ( alignAttribute | ) ) | )
-                    {
-                        pushFollow(FOLLOW_structName_in_structSpecifier1288);
-                        structName68 = structName();
-
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_structName.add(structName68.getTree());
-                        }
-                        // Grammar/CTFParser.g:459:6: ( alignAttribute | (
-                        // structBody ( alignAttribute | ) ) | )
-                        int alt20 = 3;
-                        switch (input.LA(1)) {
-                        case ALIGNTOK: {
-                            alt20 = 1;
-                        }
-                            break;
-                        case LCURL: {
-                            switch (input.LA(2)) {
-                            case CONSTTOK:
-                            case CHARTOK:
-                            case DOUBLETOK:
-                            case ENUMTOK:
-                            case FLOATINGPOINTTOK:
-                            case FLOATTOK:
-                            case INTEGERTOK:
-                            case INTTOK:
-                            case LONGTOK:
-                            case SHORTTOK:
-                            case STRUCTTOK:
-                            case TYPEALIASTOK:
-                            case TYPEDEFTOK:
-                            case UNSIGNEDTOK:
-                            case VARIANTTOK:
-                            case VOIDTOK:
-                            case BOOLTOK:
-                            case COMPLEXTOK:
-                            case IMAGINARYTOK:
-                            case RCURL: {
-                                alt20 = 2;
-                            }
-                                break;
-                            case SIGNEDTOK: {
-                                int LA20_5 = input.LA(3);
-
-                                if ((((LA20_5 >= CONSTTOK) && (LA20_5 <= ENUMTOK))
-                                        || ((LA20_5 >= FLOATINGPOINTTOK) && (LA20_5 <= SIGNEDTOK))
-                                        || ((LA20_5 >= STRINGTOK) && (LA20_5 <= STRUCTTOK))
-                                        || ((LA20_5 >= TYPEDEFTOK) && (LA20_5 <= IMAGINARYTOK))
-                                        || (LA20_5 == POINTER) || (LA20_5 == IDENTIFIER))) {
-                                    alt20 = 2;
-                                } else if (((LA20_5 == SEPARATOR)
-                                        || (LA20_5 == ASSIGNMENT) || (LA20_5 == RCURL))) {
-                                    alt20 = 3;
-                                } else {
-                                    if (state.backtracking > 0) {
-                                        state.failed = true;
-                                        return retval;
-                                    }
-                                    NoViableAltException nvae = new NoViableAltException(
-                                            "", 20, 5, input);
-
-                                    throw nvae;
-                                }
-                            }
-                                break;
-                            case STRINGTOK: {
-                                int LA20_6 = input.LA(3);
-
-                                if ((((LA20_6 >= CONSTTOK) && (LA20_6 <= ENUMTOK))
-                                        || ((LA20_6 >= FLOATINGPOINTTOK) && (LA20_6 <= SIGNEDTOK))
-                                        || ((LA20_6 >= STRINGTOK) && (LA20_6 <= STRUCTTOK))
-                                        || ((LA20_6 >= TYPEDEFTOK) && (LA20_6 <= IMAGINARYTOK))
-                                        || (LA20_6 == LCURL)
-                                        || (LA20_6 == POINTER) || (LA20_6 == IDENTIFIER))) {
-                                    alt20 = 2;
-                                } else if (((LA20_6 == SEPARATOR)
-                                        || (LA20_6 == ASSIGNMENT) || (LA20_6 == RCURL))) {
-                                    alt20 = 3;
-                                } else {
-                                    if (state.backtracking > 0) {
-                                        state.failed = true;
-                                        return retval;
-                                    }
-                                    NoViableAltException nvae = new NoViableAltException(
-                                            "", 20, 6, input);
+            STRUCTTOK67=(Token)match(input,STRUCTTOK,FOLLOW_STRUCTTOK_in_structSpecifier1270); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_STRUCTTOK.add(STRUCTTOK67);
+            }
 
-                                    throw nvae;
-                                }
-                            }
-                                break;
-                            case IDENTIFIER: {
-                                int LA20_7 = input.LA(3);
-
-                                if (((LA20_7 == SEPARATOR)
-                                        || (LA20_7 == ASSIGNMENT) || (LA20_7 == RCURL))) {
-                                    alt20 = 3;
-                                } else if ((((LA20_7 >= CONSTTOK) && (LA20_7 <= ENUMTOK))
-                                        || ((LA20_7 >= FLOATINGPOINTTOK) && (LA20_7 <= SIGNEDTOK))
-                                        || ((LA20_7 >= STRINGTOK) && (LA20_7 <= STRUCTTOK))
-                                        || ((LA20_7 >= TYPEDEFTOK) && (LA20_7 <= IMAGINARYTOK))
-                                        || (LA20_7 == POINTER) || (LA20_7 == IDENTIFIER))) {
-                                    alt20 = 2;
-                                } else {
-                                    if (state.backtracking > 0) {
-                                        state.failed = true;
-                                        return retval;
-                                    }
-                                    NoViableAltException nvae = new NoViableAltException(
-                                            "", 20, 7, input);
+            // CTFParser.g:456:3: ( ( structName ( alignAttribute | ( structBody ( alignAttribute | ) ) | ) ) | ( structBody ( alignAttribute | ) ) )
+            int alt22=2;
+            int LA22_0 = input.LA(1);
 
-                                    throw nvae;
-                                }
-                            }
-                                break;
-                            case ALIGNTOK:
-                            case EVENTTOK:
-                            case STRING_LITERAL: {
-                                alt20 = 3;
-                            }
-                                break;
-                            default:
-                                if (state.backtracking > 0) {
-                                    state.failed = true;
-                                    return retval;
-                                }
-                                NoViableAltException nvae = new NoViableAltException(
-                                        "", 20, 2, input);
+            if ( (LA22_0==IDENTIFIER) ) {
+                alt22=1;
+            }
+            else if ( (LA22_0==LCURL) ) {
+                alt22=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return retval;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 22, 0, input);
 
-                                throw nvae;
-                            }
+                throw nvae;
+            }
+            switch (alt22) {
+                case 1 :
+                    // CTFParser.g:458:5: ( structName ( alignAttribute | ( structBody ( alignAttribute | ) ) | ) )
+                    {
+                    // CTFParser.g:458:5: ( structName ( alignAttribute | ( structBody ( alignAttribute | ) ) | ) )
+                    // CTFParser.g:459:6: structName ( alignAttribute | ( structBody ( alignAttribute | ) ) | )
+                    {
+                    pushFollow(FOLLOW_structName_in_structSpecifier1292);
+                    structName68=structName();
 
+                    state._fsp--;
+                    if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        stream_structName.add(structName68.getTree());
+                    }
+                    // CTFParser.g:460:6: ( alignAttribute | ( structBody ( alignAttribute | ) ) | )
+                    int alt20=3;
+                    switch ( input.LA(1) ) {
+                    case ALIGNTOK:
+                        {
+                        alt20=1;
                         }
-                            break;
-                        case EOF:
+                        break;
+                    case LCURL:
+                        {
+                        switch ( input.LA(2) ) {
                         case CONSTTOK:
                         case CHARTOK:
                         case DOUBLETOK:
@@ -4002,9 +3405,8 @@ public class CTFParser extends Parser {
                         case INTTOK:
                         case LONGTOK:
                         case SHORTTOK:
-                        case SIGNEDTOK:
-                        case STRINGTOK:
                         case STRUCTTOK:
+                        case TYPEALIASTOK:
                         case TYPEDEFTOK:
                         case UNSIGNEDTOK:
                         case VARIANTTOK:
@@ -4012,397 +3414,453 @@ public class CTFParser extends Parser {
                         case BOOLTOK:
                         case COMPLEXTOK:
                         case IMAGINARYTOK:
-                        case TYPE_ASSIGNMENT:
-                        case LPAREN:
-                        case TERM:
-                        case POINTER:
-                        case IDENTIFIER: {
-                            alt20 = 3;
-                        }
+                        case RCURL:
+                            {
+                            alt20=2;
+                            }
                             break;
-                        default:
-                            if (state.backtracking > 0) {
-                                state.failed = true;
-                                return retval;
+                        case SIGNEDTOK:
+                            {
+                            int LA20_5 = input.LA(3);
+
+                            if ( ((LA20_5>=CONSTTOK && LA20_5<=ENUMTOK)||(LA20_5>=FLOATINGPOINTTOK && LA20_5<=SIGNEDTOK)||(LA20_5>=STRINGTOK && LA20_5<=STRUCTTOK)||(LA20_5>=TYPEDEFTOK && LA20_5<=IMAGINARYTOK)||LA20_5==POINTER||LA20_5==IDENTIFIER) ) {
+                                alt20=2;
+                            }
+                            else if ( (LA20_5==SEPARATOR||LA20_5==ASSIGNMENT||LA20_5==RCURL) ) {
+                                alt20=3;
+                            }
+                            else {
+                                if (state.backtracking>0) {state.failed=true; return retval;}
+                                NoViableAltException nvae =
+                                    new NoViableAltException("", 20, 5, input);
+
+                                throw nvae;
+                            }
                             }
-                            NoViableAltException nvae = new NoViableAltException(
-                                    "", 20, 0, input);
+                            break;
+                        case STRINGTOK:
+                            {
+                            int LA20_6 = input.LA(3);
+
+                            if ( (LA20_6==SEPARATOR||LA20_6==ASSIGNMENT||LA20_6==RCURL) ) {
+                                alt20=3;
+                            }
+                            else if ( ((LA20_6>=CONSTTOK && LA20_6<=ENUMTOK)||(LA20_6>=FLOATINGPOINTTOK && LA20_6<=SIGNEDTOK)||(LA20_6>=STRINGTOK && LA20_6<=STRUCTTOK)||(LA20_6>=TYPEDEFTOK && LA20_6<=IMAGINARYTOK)||LA20_6==LCURL||LA20_6==POINTER||LA20_6==IDENTIFIER) ) {
+                                alt20=2;
+                            }
+                            else {
+                                if (state.backtracking>0) {state.failed=true; return retval;}
+                                NoViableAltException nvae =
+                                    new NoViableAltException("", 20, 6, input);
+
+                                throw nvae;
+                            }
+                            }
+                            break;
+                        case IDENTIFIER:
+                            {
+                            int LA20_7 = input.LA(3);
+
+                            if ( (LA20_7==SEPARATOR||LA20_7==ASSIGNMENT||LA20_7==RCURL) ) {
+                                alt20=3;
+                            }
+                            else if ( ((LA20_7>=CONSTTOK && LA20_7<=ENUMTOK)||(LA20_7>=FLOATINGPOINTTOK && LA20_7<=SIGNEDTOK)||(LA20_7>=STRINGTOK && LA20_7<=STRUCTTOK)||(LA20_7>=TYPEDEFTOK && LA20_7<=IMAGINARYTOK)||LA20_7==POINTER||LA20_7==IDENTIFIER) ) {
+                                alt20=2;
+                            }
+                            else {
+                                if (state.backtracking>0) {state.failed=true; return retval;}
+                                NoViableAltException nvae =
+                                    new NoViableAltException("", 20, 7, input);
+
+                                throw nvae;
+                            }
+                            }
+                            break;
+                        case ALIGNTOK:
+                        case EVENTTOK:
+                        case STRING_LITERAL:
+                            {
+                            alt20=3;
+                            }
+                            break;
+                        default:
+                            if (state.backtracking>0) {state.failed=true; return retval;}
+                            NoViableAltException nvae =
+                                new NoViableAltException("", 20, 2, input);
 
                             throw nvae;
                         }
 
-                        switch (alt20) {
-                        case 1:
-                        // Grammar/CTFParser.g:460:8: alignAttribute
+                        }
+                        break;
+                    case EOF:
+                    case CONSTTOK:
+                    case CHARTOK:
+                    case DOUBLETOK:
+                    case ENUMTOK:
+                    case FLOATINGPOINTTOK:
+                    case FLOATTOK:
+                    case INTEGERTOK:
+                    case INTTOK:
+                    case LONGTOK:
+                    case SHORTTOK:
+                    case SIGNEDTOK:
+                    case STRINGTOK:
+                    case STRUCTTOK:
+                    case TYPEDEFTOK:
+                    case UNSIGNEDTOK:
+                    case VARIANTTOK:
+                    case VOIDTOK:
+                    case BOOLTOK:
+                    case COMPLEXTOK:
+                    case IMAGINARYTOK:
+                    case TYPE_ASSIGNMENT:
+                    case LPAREN:
+                    case TERM:
+                    case POINTER:
+                    case IDENTIFIER:
                         {
-                            pushFollow(FOLLOW_alignAttribute_in_structSpecifier1304);
-                            alignAttribute69 = alignAttribute();
+                        alt20=3;
+                        }
+                        break;
+                    default:
+                        if (state.backtracking>0) {state.failed=true; return retval;}
+                        NoViableAltException nvae =
+                            new NoViableAltException("", 20, 0, input);
+
+                        throw nvae;
+                    }
+
+                    switch (alt20) {
+                        case 1 :
+                            // CTFParser.g:461:8: alignAttribute
+                            {
+                            pushFollow(FOLLOW_alignAttribute_in_structSpecifier1308);
+                            alignAttribute69=alignAttribute();
 
                             state._fsp--;
                             if (state.failed) {
                                 return retval;
                             }
-                            if (state.backtracking == 0) {
-                                stream_alignAttribute.add(alignAttribute69
-                                        .getTree());
+                            if ( state.backtracking==0 ) {
+                                stream_alignAttribute.add(alignAttribute69.getTree());
                             }
 
-                        }
+                            }
                             break;
-                        case 2:
-                        // Grammar/CTFParser.g:462:8: ( structBody (
-                        // alignAttribute | ) )
-                        {
-                            // Grammar/CTFParser.g:462:8: ( structBody (
-                            // alignAttribute | ) )
-                            // Grammar/CTFParser.g:463:10: structBody (
-                            // alignAttribute | )
+                        case 2 :
+                            // CTFParser.g:463:8: ( structBody ( alignAttribute | ) )
                             {
-                                pushFollow(FOLLOW_structBody_in_structSpecifier1333);
-                                structBody70 = structBody();
+                            // CTFParser.g:463:8: ( structBody ( alignAttribute | ) )
+                            // CTFParser.g:464:10: structBody ( alignAttribute | )
+                            {
+                            pushFollow(FOLLOW_structBody_in_structSpecifier1337);
+                            structBody70=structBody();
+
+                            state._fsp--;
+                            if (state.failed) {
+                                return retval;
+                            }
+                            if ( state.backtracking==0 ) {
+                                stream_structBody.add(structBody70.getTree());
+                            }
+                            // CTFParser.g:465:10: ( alignAttribute | )
+                            int alt19=2;
+                            int LA19_0 = input.LA(1);
 
-                                state._fsp--;
-                                if (state.failed) {
-                                    return retval;
-                                }
-                                if (state.backtracking == 0) {
-                                    stream_structBody.add(structBody70
-                                            .getTree());
-                                }
-                                // Grammar/CTFParser.g:464:10: ( alignAttribute
-                                // | )
-                                int alt19 = 2;
-                                int LA19_0 = input.LA(1);
-
-                                if ((LA19_0 == ALIGNTOK)) {
-                                    alt19 = 1;
-                                } else if (((LA19_0 == EOF)
-                                        || ((LA19_0 >= CONSTTOK) && (LA19_0 <= ENUMTOK))
-                                        || ((LA19_0 >= FLOATINGPOINTTOK) && (LA19_0 <= SIGNEDTOK))
-                                        || ((LA19_0 >= STRINGTOK) && (LA19_0 <= STRUCTTOK))
-                                        || ((LA19_0 >= TYPEDEFTOK) && (LA19_0 <= IMAGINARYTOK))
-                                        || (LA19_0 == TYPE_ASSIGNMENT)
-                                        || (LA19_0 == LPAREN)
-                                        || (LA19_0 == LCURL)
-                                        || ((LA19_0 >= TERM) && (LA19_0 <= POINTER)) || (LA19_0 == IDENTIFIER))) {
-                                    alt19 = 2;
-                                } else {
-                                    if (state.backtracking > 0) {
-                                        state.failed = true;
-                                        return retval;
-                                    }
-                                    NoViableAltException nvae = new NoViableAltException(
-                                            "", 19, 0, input);
+                            if ( (LA19_0==ALIGNTOK) ) {
+                                alt19=1;
+                            }
+                            else if ( (LA19_0==EOF||(LA19_0>=CONSTTOK && LA19_0<=ENUMTOK)||(LA19_0>=FLOATINGPOINTTOK && LA19_0<=SIGNEDTOK)||(LA19_0>=STRINGTOK && LA19_0<=STRUCTTOK)||(LA19_0>=TYPEDEFTOK && LA19_0<=IMAGINARYTOK)||LA19_0==TYPE_ASSIGNMENT||LA19_0==LPAREN||LA19_0==LCURL||(LA19_0>=TERM && LA19_0<=POINTER)||LA19_0==IDENTIFIER) ) {
+                                alt19=2;
+                            }
+                            else {
+                                if (state.backtracking>0) {state.failed=true; return retval;}
+                                NoViableAltException nvae =
+                                    new NoViableAltException("", 19, 0, input);
 
-                                    throw nvae;
-                                }
-                                switch (alt19) {
-                                case 1:
-                                // Grammar/CTFParser.g:465:11: alignAttribute
-                                {
-                                    pushFollow(FOLLOW_alignAttribute_in_structSpecifier1358);
-                                    alignAttribute71 = alignAttribute();
+                                throw nvae;
+                            }
+                            switch (alt19) {
+                                case 1 :
+                                    // CTFParser.g:466:11: alignAttribute
+                                    {
+                                    pushFollow(FOLLOW_alignAttribute_in_structSpecifier1362);
+                                    alignAttribute71=alignAttribute();
 
                                     state._fsp--;
                                     if (state.failed) {
                                         return retval;
                                     }
-                                    if (state.backtracking == 0) {
-                                        stream_alignAttribute
-                                                .add(alignAttribute71.getTree());
+                                    if ( state.backtracking==0 ) {
+                                        stream_alignAttribute.add(alignAttribute71.getTree());
                                     }
 
-                                }
+                                    }
                                     break;
-                                case 2:
-                                // Grammar/CTFParser.g:468:10:
+                                case 2 :
+                                    // CTFParser.g:469:10:
+                                    {
+                                    }
                                     break;
 
-                                }
+                            }
+
 
                             }
 
-                        }
+
+                            }
                             break;
-                        case 3:
-                        // Grammar/CTFParser.g:472:6:
+                        case 3 :
+                            // CTFParser.g:473:6:
+                            {
+                            }
                             break;
 
-                        }
+                    }
+
 
                     }
 
-                }
+
+                    }
                     break;
-                case 2:
-                // Grammar/CTFParser.g:476:5: ( structBody ( alignAttribute | )
-                // )
-                {
-                    // Grammar/CTFParser.g:476:5: ( structBody ( alignAttribute
-                    // | ) )
-                    // Grammar/CTFParser.g:477:7: structBody ( alignAttribute |
-                    // )
+                case 2 :
+                    // CTFParser.g:477:5: ( structBody ( alignAttribute | ) )
+                    {
+                    // CTFParser.g:477:5: ( structBody ( alignAttribute | ) )
+                    // CTFParser.g:478:7: structBody ( alignAttribute | )
                     {
-                        pushFollow(FOLLOW_structBody_in_structSpecifier1456);
-                        structBody72 = structBody();
+                    pushFollow(FOLLOW_structBody_in_structSpecifier1460);
+                    structBody72=structBody();
 
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_structBody.add(structBody72.getTree());
-                        }
-                        // Grammar/CTFParser.g:478:7: ( alignAttribute | )
-                        int alt21 = 2;
-                        int LA21_0 = input.LA(1);
-
-                        if ((LA21_0 == ALIGNTOK)) {
-                            alt21 = 1;
-                        } else if (((LA21_0 == EOF)
-                                || ((LA21_0 >= CONSTTOK) && (LA21_0 <= ENUMTOK))
-                                || ((LA21_0 >= FLOATINGPOINTTOK) && (LA21_0 <= SIGNEDTOK))
-                                || ((LA21_0 >= STRINGTOK) && (LA21_0 <= STRUCTTOK))
-                                || ((LA21_0 >= TYPEDEFTOK) && (LA21_0 <= IMAGINARYTOK))
-                                || (LA21_0 == TYPE_ASSIGNMENT)
-                                || (LA21_0 == LPAREN) || (LA21_0 == LCURL)
-                                || ((LA21_0 >= TERM) && (LA21_0 <= POINTER)) || (LA21_0 == IDENTIFIER))) {
-                            alt21 = 2;
-                        } else {
-                            if (state.backtracking > 0) {
-                                state.failed = true;
-                                return retval;
-                            }
-                            NoViableAltException nvae = new NoViableAltException(
-                                    "", 21, 0, input);
+                    state._fsp--;
+                    if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        stream_structBody.add(structBody72.getTree());
+                    }
+                    // CTFParser.g:479:7: ( alignAttribute | )
+                    int alt21=2;
+                    int LA21_0 = input.LA(1);
 
-                            throw nvae;
-                        }
-                        switch (alt21) {
-                        case 1:
-                        // Grammar/CTFParser.g:479:9: alignAttribute
-                        {
-                            pushFollow(FOLLOW_alignAttribute_in_structSpecifier1474);
-                            alignAttribute73 = alignAttribute();
+                    if ( (LA21_0==ALIGNTOK) ) {
+                        alt21=1;
+                    }
+                    else if ( (LA21_0==EOF||(LA21_0>=CONSTTOK && LA21_0<=ENUMTOK)||(LA21_0>=FLOATINGPOINTTOK && LA21_0<=SIGNEDTOK)||(LA21_0>=STRINGTOK && LA21_0<=STRUCTTOK)||(LA21_0>=TYPEDEFTOK && LA21_0<=IMAGINARYTOK)||LA21_0==TYPE_ASSIGNMENT||LA21_0==LPAREN||LA21_0==LCURL||(LA21_0>=TERM && LA21_0<=POINTER)||LA21_0==IDENTIFIER) ) {
+                        alt21=2;
+                    }
+                    else {
+                        if (state.backtracking>0) {state.failed=true; return retval;}
+                        NoViableAltException nvae =
+                            new NoViableAltException("", 21, 0, input);
+
+                        throw nvae;
+                    }
+                    switch (alt21) {
+                        case 1 :
+                            // CTFParser.g:480:9: alignAttribute
+                            {
+                            pushFollow(FOLLOW_alignAttribute_in_structSpecifier1478);
+                            alignAttribute73=alignAttribute();
 
                             state._fsp--;
                             if (state.failed) {
                                 return retval;
                             }
-                            if (state.backtracking == 0) {
-                                stream_alignAttribute.add(alignAttribute73
-                                        .getTree());
+                            if ( state.backtracking==0 ) {
+                                stream_alignAttribute.add(alignAttribute73.getTree());
                             }
 
-                        }
+                            }
                             break;
-                        case 2:
+                        case 2 :
+                            // CTFParser.g:483:7:
+                            {
+                            }
                             break;
 
-                        }
+                    }
+
 
                     }
 
-                }
+
+                    }
                     break;
 
-                }
+            }
 
-                // AST REWRITE
-                // elements: alignAttribute, structName, structBody
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 484:5: -> ^( STRUCT ( structName )? ( structBody )? (
-                    // alignAttribute )? )
-                    {
-                        // Grammar/CTFParser.g:484:8: ^( STRUCT ( structName )?
-                        // ( structBody )? ( alignAttribute )? )
-                        {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(
-                                    adaptor.create(STRUCT, "STRUCT"), root_1);
 
-                            // Grammar/CTFParser.g:484:17: ( structName )?
-                            if (stream_structName.hasNext()) {
-                                adaptor.addChild(root_1,
-                                        stream_structName.nextTree());
+            // AST REWRITE
+            // elements: alignAttribute, structBody, structName
+            // token labels:
+            // rule labels: retval
+            // token list labels:
+            // rule list labels:
+            // wildcard labels:
+            if ( state.backtracking==0 ) {
+            retval.tree = root_0;
+            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                            }
-                            stream_structName.reset();
-                            // Grammar/CTFParser.g:484:29: ( structBody )?
-                            if (stream_structBody.hasNext()) {
-                                adaptor.addChild(root_1,
-                                        stream_structBody.nextTree());
+            root_0 = (CommonTree)adaptor.nil();
+            // 485:5: -> ^( STRUCT ( structName )? ( structBody )? ( alignAttribute )? )
+            {
+                // CTFParser.g:485:8: ^( STRUCT ( structName )? ( structBody )? ( alignAttribute )? )
+                {
+                CommonTree root_1 = (CommonTree)adaptor.nil();
+                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(STRUCT, "STRUCT"), root_1);
 
-                            }
-                            stream_structBody.reset();
-                            // Grammar/CTFParser.g:484:41: ( alignAttribute )?
-                            if (stream_alignAttribute.hasNext()) {
-                                adaptor.addChild(root_1,
-                                        stream_alignAttribute.nextTree());
+                // CTFParser.g:485:17: ( structName )?
+                if ( stream_structName.hasNext() ) {
+                    adaptor.addChild(root_1, stream_structName.nextTree());
 
-                            }
-                            stream_alignAttribute.reset();
+                }
+                stream_structName.reset();
+                // CTFParser.g:485:29: ( structBody )?
+                if ( stream_structBody.hasNext() ) {
+                    adaptor.addChild(root_1, stream_structBody.nextTree());
 
-                            adaptor.addChild(root_0, root_1);
-                        }
+                }
+                stream_structBody.reset();
+                // CTFParser.g:485:41: ( alignAttribute )?
+                if ( stream_alignAttribute.hasNext() ) {
+                    adaptor.addChild(root_1, stream_alignAttribute.nextTree());
 
-                    }
+                }
+                stream_alignAttribute.reset();
 
-                    retval.tree = root_0;
+                adaptor.addChild(root_0, root_1);
                 }
+
+            }
+
+            retval.tree = root_0;}
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 exit("structSpecifier");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "structSpecifier"
 
     public static class structName_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "structName"
-    // Grammar/CTFParser.g:487:1: structName : IDENTIFIER -> ^( STRUCT_NAME
-    // IDENTIFIER ) ;
-    public final CTFParser.structName_return structName()
-            throws RecognitionException {
+    // CTFParser.g:488:1: structName : IDENTIFIER -> ^( STRUCT_NAME IDENTIFIER ) ;
+    public final CTFParser.structName_return structName() throws RecognitionException {
         CTFParser.structName_return retval = new CTFParser.structName_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token IDENTIFIER74 = null;
+        Token IDENTIFIER74=null;
+
+        CommonTree IDENTIFIER74_tree=null;
+        RewriteRuleTokenStream stream_IDENTIFIER=new RewriteRuleTokenStream(adaptor,"token IDENTIFIER");
 
-        CommonTree IDENTIFIER74_tree = null;
-        RewriteRuleTokenStream stream_IDENTIFIER = new RewriteRuleTokenStream(
-                adaptor, "token IDENTIFIER");
 
-        enter("structName");
+          enter("structName");
 
         try {
-            // Grammar/CTFParser.g:495:1: ( IDENTIFIER -> ^( STRUCT_NAME
-            // IDENTIFIER ) )
-            // Grammar/CTFParser.g:496:3: IDENTIFIER
+            // CTFParser.g:496:1: ( IDENTIFIER -> ^( STRUCT_NAME IDENTIFIER ) )
+            // CTFParser.g:497:3: IDENTIFIER
             {
-                IDENTIFIER74 = (Token) match(input, IDENTIFIER,
-                        FOLLOW_IDENTIFIER_in_structName1550);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_IDENTIFIER.add(IDENTIFIER74);
-                }
-
-                // AST REWRITE
-                // elements: IDENTIFIER
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
+            IDENTIFIER74=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_structName1554); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_IDENTIFIER.add(IDENTIFIER74);
+            }
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 496:14: -> ^( STRUCT_NAME IDENTIFIER )
-                    {
-                        // Grammar/CTFParser.g:496:17: ^( STRUCT_NAME IDENTIFIER
-                        // )
-                        {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(
-                                    adaptor.create(STRUCT_NAME, "STRUCT_NAME"),
-                                    root_1);
 
-                            adaptor.addChild(root_1,
-                                    stream_IDENTIFIER.nextNode());
 
-                            adaptor.addChild(root_0, root_1);
-                        }
+            // AST REWRITE
+            // elements: IDENTIFIER
+            // token labels:
+            // rule labels: retval
+            // token list labels:
+            // rule list labels:
+            // wildcard labels:
+            if ( state.backtracking==0 ) {
+            retval.tree = root_0;
+            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                    }
+            root_0 = (CommonTree)adaptor.nil();
+            // 497:14: -> ^( STRUCT_NAME IDENTIFIER )
+            {
+                // CTFParser.g:497:17: ^( STRUCT_NAME IDENTIFIER )
+                {
+                CommonTree root_1 = (CommonTree)adaptor.nil();
+                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(STRUCT_NAME, "STRUCT_NAME"), root_1);
 
-                    retval.tree = root_0;
+                adaptor.addChild(root_1, stream_IDENTIFIER.nextNode());
+
+                adaptor.addChild(root_0, root_1);
                 }
+
+            }
+
+            retval.tree = root_0;}
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                debug_print(input.toString(retval.start, input.LT(-1)));
+                debug_print(input.toString(retval.start,input.LT(-1)));
                 exit("structName");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "structName"
 
-    public static class structOrVariantDeclarationList_return extends
-            ParserRuleReturnScope {
+    public static class structOrVariantDeclarationList_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "structOrVariantDeclarationList"
-    // Grammar/CTFParser.g:499:1: structOrVariantDeclarationList : (
-    // structOrVariantDeclaration )+ ;
-    public final CTFParser.structOrVariantDeclarationList_return structOrVariantDeclarationList()
-            throws RecognitionException {
+    // CTFParser.g:500:1: structOrVariantDeclarationList : ( structOrVariantDeclaration )+ ;
+    public final CTFParser.structOrVariantDeclarationList_return structOrVariantDeclarationList() throws RecognitionException {
         CTFParser.structOrVariantDeclarationList_return retval = new CTFParser.structOrVariantDeclarationList_return();
         retval.start = input.LT(1);
 
@@ -4410,116 +3868,106 @@ public class CTFParser extends Parser {
 
         CTFParser.structOrVariantDeclaration_return structOrVariantDeclaration75 = null;
 
-        enter("structOrVariantDeclarationList");
+
+
+
+          enter("structOrVariantDeclarationList");
 
         try {
-            // Grammar/CTFParser.g:506:1: ( ( structOrVariantDeclaration )+ )
-            // Grammar/CTFParser.g:507:3: ( structOrVariantDeclaration )+
+            // CTFParser.g:507:1: ( ( structOrVariantDeclaration )+ )
+            // CTFParser.g:508:3: ( structOrVariantDeclaration )+
             {
-                root_0 = (CommonTree) adaptor.nil();
-
-                // Grammar/CTFParser.g:507:3: ( structOrVariantDeclaration )+
-                int cnt23 = 0;
-                loop23: do {
-                    int alt23 = 2;
-                    int LA23_0 = input.LA(1);
-
-                    if ((((LA23_0 >= CONSTTOK) && (LA23_0 <= ENUMTOK))
-                            || ((LA23_0 >= FLOATINGPOINTTOK) && (LA23_0 <= SIGNEDTOK))
-                            || ((LA23_0 >= STRINGTOK) && (LA23_0 <= STRUCTTOK)) || ((LA23_0 >= TYPEDEFTOK) && (LA23_0 <= IMAGINARYTOK)))) {
-                        alt23 = 1;
-                    } else if ((LA23_0 == IDENTIFIER)
-                            && ((inTypealiasAlias() || isTypeName(input.LT(1)
-                                    .getText())))) {
-                        alt23 = 1;
-                    } else if ((LA23_0 == TYPEALIASTOK)) {
-                        alt23 = 1;
-                    }
-
-                    switch (alt23) {
-                    case 1:
-                    // Grammar/CTFParser.g:507:3: structOrVariantDeclaration
-                    {
-                        pushFollow(FOLLOW_structOrVariantDeclaration_in_structOrVariantDeclarationList1581);
-                        structOrVariantDeclaration75 = structOrVariantDeclaration();
-
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            adaptor.addChild(root_0,
-                                    structOrVariantDeclaration75.getTree());
-                        }
+            root_0 = (CommonTree)adaptor.nil();
+
+            // CTFParser.g:508:3: ( structOrVariantDeclaration )+
+            int cnt23=0;
+            loop23:
+            do {
+                int alt23=2;
+                int LA23_0 = input.LA(1);
+
+                if ( ((LA23_0>=CONSTTOK && LA23_0<=ENUMTOK)||(LA23_0>=FLOATINGPOINTTOK && LA23_0<=SIGNEDTOK)||(LA23_0>=STRINGTOK && LA23_0<=STRUCTTOK)||(LA23_0>=TYPEDEFTOK && LA23_0<=IMAGINARYTOK)) ) {
+                    alt23=1;
+                }
+                else if ( (LA23_0==IDENTIFIER) && ((inTypealiasAlias() || isTypeName(input.LT(1).getText())))) {
+                    alt23=1;
+                }
+                else if ( (LA23_0==TYPEALIASTOK) ) {
+                    alt23=1;
+                }
 
+
+                switch (alt23) {
+               case 1 :
+                   // CTFParser.g:508:3: structOrVariantDeclaration
+                   {
+                   pushFollow(FOLLOW_structOrVariantDeclaration_in_structOrVariantDeclarationList1585);
+                   structOrVariantDeclaration75=structOrVariantDeclaration();
+
+                   state._fsp--;
+                   if (state.failed) {
+                        return retval;
+                    }
+                   if ( state.backtracking==0 ) {
+                        adaptor.addChild(root_0, structOrVariantDeclaration75.getTree());
                     }
-                        break;
 
-                    default:
-                        if (cnt23 >= 1) {
-                            break loop23;
-                        }
-                        if (state.backtracking > 0) {
-                            state.failed = true;
-                            return retval;
-                        }
-                        EarlyExitException eee = new EarlyExitException(23,
-                                input);
-                        throw eee;
+                   }
+                   break;
+
+               default :
+                   if ( cnt23 >= 1 ) {
+                        break loop23;
                     }
-                    cnt23++;
-                } while (true);
+                   if (state.backtracking>0) {state.failed=true; return retval;}
+                        EarlyExitException eee =
+                            new EarlyExitException(23, input);
+                        throw eee;
+                }
+                cnt23++;
+            } while (true);
+
 
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 exit("structOrVariantDeclarationList");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "structOrVariantDeclarationList"
 
-    public static class structOrVariantDeclaration_return extends
-            ParserRuleReturnScope {
+    public static class structOrVariantDeclaration_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "structOrVariantDeclaration"
-    // Grammar/CTFParser.g:510:1: structOrVariantDeclaration : ( (
-    // declarationSpecifiers ({...}? => declaratorList -> ^( TYPEDEF
-    // declaratorList declarationSpecifiers ) | structOrVariantDeclaratorList ->
-    // ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList ) )
-    // ) | typealiasDecl -> typealiasDecl ) TERM ;
-    public final CTFParser.structOrVariantDeclaration_return structOrVariantDeclaration()
-            throws RecognitionException {
+    // CTFParser.g:511:1: structOrVariantDeclaration : ( ( declarationSpecifiers ({...}? => declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList ) ) ) | typealiasDecl -> typealiasDecl ) TERM ;
+    public final CTFParser.structOrVariantDeclaration_return structOrVariantDeclaration() throws RecognitionException {
         CTFParser.structOrVariantDeclaration_return retval = new CTFParser.structOrVariantDeclaration_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token TERM80 = null;
+        Token TERM80=null;
         CTFParser.declarationSpecifiers_return declarationSpecifiers76 = null;
 
         CTFParser.declaratorList_return declaratorList77 = null;
@@ -4528,256 +3976,182 @@ public class CTFParser extends Parser {
 
         CTFParser.typealiasDecl_return typealiasDecl79 = null;
 
-        CommonTree TERM80_tree = null;
-        RewriteRuleTokenStream stream_TERM = new RewriteRuleTokenStream(
-                adaptor, "token TERM");
-        RewriteRuleSubtreeStream stream_declaratorList = new RewriteRuleSubtreeStream(
-                adaptor, "rule declaratorList");
-        RewriteRuleSubtreeStream stream_typealiasDecl = new RewriteRuleSubtreeStream(
-                adaptor, "rule typealiasDecl");
-        RewriteRuleSubtreeStream stream_declarationSpecifiers = new RewriteRuleSubtreeStream(
-                adaptor, "rule declarationSpecifiers");
-        RewriteRuleSubtreeStream stream_structOrVariantDeclaratorList = new RewriteRuleSubtreeStream(
-                adaptor, "rule structOrVariantDeclaratorList");
 
-        enter("structOrVariantDeclaration");
+        CommonTree TERM80_tree=null;
+        RewriteRuleTokenStream stream_TERM=new RewriteRuleTokenStream(adaptor,"token TERM");
+        RewriteRuleSubtreeStream stream_declaratorList=new RewriteRuleSubtreeStream(adaptor,"rule declaratorList");
+        RewriteRuleSubtreeStream stream_typealiasDecl=new RewriteRuleSubtreeStream(adaptor,"rule typealiasDecl");
+        RewriteRuleSubtreeStream stream_declarationSpecifiers=new RewriteRuleSubtreeStream(adaptor,"rule declarationSpecifiers");
+        RewriteRuleSubtreeStream stream_structOrVariantDeclaratorList=new RewriteRuleSubtreeStream(adaptor,"rule structOrVariantDeclaratorList");
+
+          enter("structOrVariantDeclaration");
 
         try {
-            // Grammar/CTFParser.g:517:1: ( ( ( declarationSpecifiers ({...}? =>
-            // declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers
-            // ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION
-            // declarationSpecifiers structOrVariantDeclaratorList ) ) ) |
-            // typealiasDecl -> typealiasDecl ) TERM )
-            // Grammar/CTFParser.g:518:3: ( ( declarationSpecifiers ({...}? =>
-            // declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers
-            // ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION
-            // declarationSpecifiers structOrVariantDeclaratorList ) ) ) |
-            // typealiasDecl -> typealiasDecl ) TERM
+            // CTFParser.g:518:1: ( ( ( declarationSpecifiers ({...}? => declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList ) ) ) | typealiasDecl -> typealiasDecl ) TERM )
+            // CTFParser.g:519:3: ( ( declarationSpecifiers ({...}? => declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList ) ) ) | typealiasDecl -> typealiasDecl ) TERM
             {
-                // Grammar/CTFParser.g:518:3: ( ( declarationSpecifiers ({...}?
-                // => declaratorList -> ^( TYPEDEF declaratorList
-                // declarationSpecifiers ) | structOrVariantDeclaratorList -> ^(
-                // SV_DECLARATION declarationSpecifiers
-                // structOrVariantDeclaratorList ) ) ) | typealiasDecl ->
-                // typealiasDecl )
-                int alt25 = 2;
-                int LA25_0 = input.LA(1);
-
-                if ((((LA25_0 >= CONSTTOK) && (LA25_0 <= ENUMTOK))
-                        || ((LA25_0 >= FLOATINGPOINTTOK) && (LA25_0 <= SIGNEDTOK))
-                        || ((LA25_0 >= STRINGTOK) && (LA25_0 <= STRUCTTOK)) || ((LA25_0 >= TYPEDEFTOK) && (LA25_0 <= IMAGINARYTOK)))) {
-                    alt25 = 1;
-                } else if ((LA25_0 == IDENTIFIER)
-                        && ((inTypealiasAlias() || isTypeName(input.LT(1)
-                                .getText())))) {
-                    alt25 = 1;
-                } else if ((LA25_0 == TYPEALIASTOK)) {
-                    alt25 = 2;
-                } else {
-                    if (state.backtracking > 0) {
-                        state.failed = true;
+            // CTFParser.g:519:3: ( ( declarationSpecifiers ({...}? => declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList ) ) ) | typealiasDecl -> typealiasDecl )
+            int alt25=2;
+            int LA25_0 = input.LA(1);
+
+            if ( ((LA25_0>=CONSTTOK && LA25_0<=ENUMTOK)||(LA25_0>=FLOATINGPOINTTOK && LA25_0<=SIGNEDTOK)||(LA25_0>=STRINGTOK && LA25_0<=STRUCTTOK)||(LA25_0>=TYPEDEFTOK && LA25_0<=IMAGINARYTOK)) ) {
+                alt25=1;
+            }
+            else if ( (LA25_0==IDENTIFIER) && ((inTypealiasAlias() || isTypeName(input.LT(1).getText())))) {
+                alt25=1;
+            }
+            else if ( (LA25_0==TYPEALIASTOK) ) {
+                alt25=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return retval;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 25, 0, input);
+
+                throw nvae;
+            }
+            switch (alt25) {
+                case 1 :
+                    // CTFParser.g:520:4: ( declarationSpecifiers ({...}? => declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList ) ) )
+                    {
+                    // CTFParser.g:520:4: ( declarationSpecifiers ({...}? => declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList ) ) )
+                    // CTFParser.g:521:5: declarationSpecifiers ({...}? => declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList ) )
+                    {
+                    pushFollow(FOLLOW_declarationSpecifiers_in_structOrVariantDeclaration1623);
+                    declarationSpecifiers76=declarationSpecifiers();
+
+                    state._fsp--;
+                    if (state.failed) {
                         return retval;
                     }
-                    NoViableAltException nvae = new NoViableAltException("",
-                            25, 0, input);
-
-                    throw nvae;
-                }
-                switch (alt25) {
-                case 1:
-                // Grammar/CTFParser.g:519:4: ( declarationSpecifiers ({...}? =>
-                // declaratorList -> ^( TYPEDEF declaratorList
-                // declarationSpecifiers ) | structOrVariantDeclaratorList -> ^(
-                // SV_DECLARATION declarationSpecifiers
-                // structOrVariantDeclaratorList ) ) )
-                {
-                    // Grammar/CTFParser.g:519:4: ( declarationSpecifiers
-                    // ({...}? => declaratorList -> ^( TYPEDEF declaratorList
-                    // declarationSpecifiers ) | structOrVariantDeclaratorList
-                    // -> ^( SV_DECLARATION declarationSpecifiers
-                    // structOrVariantDeclaratorList ) ) )
-                    // Grammar/CTFParser.g:520:5: declarationSpecifiers ({...}?
-                    // => declaratorList -> ^( TYPEDEF declaratorList
-                    // declarationSpecifiers ) | structOrVariantDeclaratorList
-                    // -> ^( SV_DECLARATION declarationSpecifiers
-                    // structOrVariantDeclaratorList ) )
-                    {
-                        pushFollow(FOLLOW_declarationSpecifiers_in_structOrVariantDeclaration1619);
-                        declarationSpecifiers76 = declarationSpecifiers();
-
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_declarationSpecifiers
-                                    .add(declarationSpecifiers76.getTree());
-                        }
-                        // Grammar/CTFParser.g:521:7: ({...}? => declaratorList
-                        // -> ^( TYPEDEF declaratorList declarationSpecifiers )
-                        // | structOrVariantDeclaratorList -> ^( SV_DECLARATION
-                        // declarationSpecifiers structOrVariantDeclaratorList )
-                        // )
-                        int alt24 = 2;
-                        alt24 = dfa24.predict(input);
-                        switch (alt24) {
-                        case 1:
-                        // Grammar/CTFParser.g:523:9: {...}? => declaratorList
-                        {
-                            if (!((inTypedef()))) {
-                                if (state.backtracking > 0) {
-                                    state.failed = true;
-                                    return retval;
-                                }
-                                throw new FailedPredicateException(input,
-                                        "structOrVariantDeclaration",
-                                        "inTypedef()");
+                    if ( state.backtracking==0 ) {
+                        stream_declarationSpecifiers.add(declarationSpecifiers76.getTree());
+                    }
+                    // CTFParser.g:522:7: ({...}? => declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList ) )
+                    int alt24=2;
+                    alt24 = dfa24.predict(input);
+                    switch (alt24) {
+                        case 1 :
+                            // CTFParser.g:524:9: {...}? => declaratorList
+                            {
+                            if ( !((inTypedef())) ) {
+                                if (state.backtracking>0) {state.failed=true; return retval;}
+                                throw new FailedPredicateException(input, "structOrVariantDeclaration", "inTypedef()");
                             }
-                            pushFollow(FOLLOW_declaratorList_in_structOrVariantDeclaration1651);
-                            declaratorList77 = declaratorList();
+                            pushFollow(FOLLOW_declaratorList_in_structOrVariantDeclaration1655);
+                            declaratorList77=declaratorList();
 
                             state._fsp--;
                             if (state.failed) {
                                 return retval;
                             }
-                            if (state.backtracking == 0) {
-                                stream_declaratorList.add(declaratorList77
-                                        .getTree());
+                            if ( state.backtracking==0 ) {
+                                stream_declaratorList.add(declaratorList77.getTree());
                             }
-                            if (state.backtracking == 0) {
-                                typedefOff();
+                            if ( state.backtracking==0 ) {
+                              typedefOff();
                             }
 
+
                             // AST REWRITE
-                            // elements: declarationSpecifiers, declaratorList
+                            // elements: declaratorList, declarationSpecifiers
                             // token labels:
                             // rule labels: retval
                             // token list labels:
                             // rule list labels:
                             // wildcard labels:
-                            if (state.backtracking == 0) {
-                                retval.tree = root_0;
-//                                RewriteRuleSubtreeStream stream_retval =
-                                        new RewriteRuleSubtreeStream(
-                                        adaptor, "rule retval",
-                                        retval != null ? retval.tree : null);
-
-                                root_0 = (CommonTree) adaptor.nil();
-                                // 524:11: -> ^( TYPEDEF declaratorList
-                                // declarationSpecifiers )
+                            if ( state.backtracking==0 ) {
+                            retval.tree = root_0;
+                            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+                            root_0 = (CommonTree)adaptor.nil();
+                            // 525:11: -> ^( TYPEDEF declaratorList declarationSpecifiers )
+                            {
+                                // CTFParser.g:525:14: ^( TYPEDEF declaratorList declarationSpecifiers )
                                 {
-                                    // Grammar/CTFParser.g:524:14: ^( TYPEDEF
-                                    // declaratorList declarationSpecifiers )
-                                    {
-                                        CommonTree root_1 = (CommonTree) adaptor
-                                                .nil();
-                                        root_1 = (CommonTree) adaptor
-                                                .becomeRoot(adaptor.create(
-                                                        TYPEDEF, "TYPEDEF"),
-                                                        root_1);
-
-                                        adaptor.addChild(root_1,
-                                                stream_declaratorList
-                                                        .nextTree());
-                                        adaptor.addChild(root_1,
-                                                stream_declarationSpecifiers
-                                                        .nextTree());
-
-                                        adaptor.addChild(root_0, root_1);
-                                    }
+                                CommonTree root_1 = (CommonTree)adaptor.nil();
+                                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TYPEDEF, "TYPEDEF"), root_1);
+
+                                adaptor.addChild(root_1, stream_declaratorList.nextTree());
+                                adaptor.addChild(root_1, stream_declarationSpecifiers.nextTree());
 
+                                adaptor.addChild(root_0, root_1);
                                 }
 
-                                retval.tree = root_0;
                             }
-                        }
+
+                            retval.tree = root_0;}
+                            }
                             break;
-                        case 2:
-                        // Grammar/CTFParser.g:525:11:
-                        // structOrVariantDeclaratorList
-                        {
-                            pushFollow(FOLLOW_structOrVariantDeclaratorList_in_structOrVariantDeclaration1685);
-                            structOrVariantDeclaratorList78 = structOrVariantDeclaratorList();
+                        case 2 :
+                            // CTFParser.g:526:11: structOrVariantDeclaratorList
+                            {
+                            pushFollow(FOLLOW_structOrVariantDeclaratorList_in_structOrVariantDeclaration1689);
+                            structOrVariantDeclaratorList78=structOrVariantDeclaratorList();
 
                             state._fsp--;
                             if (state.failed) {
                                 return retval;
                             }
-                            if (state.backtracking == 0) {
-                                stream_structOrVariantDeclaratorList
-                                        .add(structOrVariantDeclaratorList78
-                                                .getTree());
+                            if ( state.backtracking==0 ) {
+                                stream_structOrVariantDeclaratorList.add(structOrVariantDeclaratorList78.getTree());
                             }
 
+
                             // AST REWRITE
-                            // elements: structOrVariantDeclaratorList,
-                            // declarationSpecifiers
+                            // elements: declarationSpecifiers, structOrVariantDeclaratorList
                             // token labels:
                             // rule labels: retval
                             // token list labels:
                             // rule list labels:
                             // wildcard labels:
-                            if (state.backtracking == 0) {
-                                retval.tree = root_0;
-//                                RewriteRuleSubtreeStream stream_retval =
-                                        new RewriteRuleSubtreeStream(
-                                        adaptor, "rule retval",
-                                        retval != null ? retval.tree : null);
-
-                                root_0 = (CommonTree) adaptor.nil();
-                                // 526:11: -> ^( SV_DECLARATION
-                                // declarationSpecifiers
-                                // structOrVariantDeclaratorList )
+                            if ( state.backtracking==0 ) {
+                            retval.tree = root_0;
+                            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+                            root_0 = (CommonTree)adaptor.nil();
+                            // 527:11: -> ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList )
+                            {
+                                // CTFParser.g:527:14: ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList )
                                 {
-                                    // Grammar/CTFParser.g:526:14: ^(
-                                    // SV_DECLARATION declarationSpecifiers
-                                    // structOrVariantDeclaratorList )
-                                    {
-                                        CommonTree root_1 = (CommonTree) adaptor
-                                                .nil();
-                                        root_1 = (CommonTree) adaptor
-                                                .becomeRoot(adaptor.create(
-                                                        SV_DECLARATION,
-                                                        "SV_DECLARATION"),
-                                                        root_1);
-
-                                        adaptor.addChild(root_1,
-                                                stream_declarationSpecifiers
-                                                        .nextTree());
-                                        adaptor.addChild(root_1,
-                                                stream_structOrVariantDeclaratorList
-                                                        .nextTree());
-
-                                        adaptor.addChild(root_0, root_1);
-                                    }
+                                CommonTree root_1 = (CommonTree)adaptor.nil();
+                                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(SV_DECLARATION, "SV_DECLARATION"), root_1);
 
+                                adaptor.addChild(root_1, stream_declarationSpecifiers.nextTree());
+                                adaptor.addChild(root_1, stream_structOrVariantDeclaratorList.nextTree());
+
+                                adaptor.addChild(root_0, root_1);
                                 }
 
-                                retval.tree = root_0;
                             }
-                        }
+
+                            retval.tree = root_0;}
+                            }
                             break;
 
-                        }
+                    }
+
 
                     }
 
-                }
+
+                    }
                     break;
-                case 2:
-                // Grammar/CTFParser.g:531:5: typealiasDecl
-                {
-                    pushFollow(FOLLOW_typealiasDecl_in_structOrVariantDeclaration1735);
-                    typealiasDecl79 = typealiasDecl();
+                case 2 :
+                    // CTFParser.g:532:5: typealiasDecl
+                    {
+                    pushFollow(FOLLOW_typealiasDecl_in_structOrVariantDeclaration1739);
+                    typealiasDecl79=typealiasDecl();
 
                     state._fsp--;
                     if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
+                    if ( state.backtracking==0 ) {
                         stream_typealiasDecl.add(typealiasDecl79.getTree());
                     }
 
+
                     // AST REWRITE
                     // elements: typealiasDecl
                     // token labels:
@@ -4785,79 +4159,65 @@ public class CTFParser extends Parser {
                     // token list labels:
                     // rule list labels:
                     // wildcard labels:
-                    if (state.backtracking == 0) {
-                        retval.tree = root_0;
-//                        RewriteRuleSubtreeStream stream_retval =
-                                new RewriteRuleSubtreeStream(
-                                adaptor, "rule retval",
-                                retval != null ? retval.tree : null);
-
-                        root_0 = (CommonTree) adaptor.nil();
-                        // 531:19: -> typealiasDecl
-                        {
-                            adaptor.addChild(root_0,
-                                    stream_typealiasDecl.nextTree());
+                    if ( state.backtracking==0 ) {
+                    retval.tree = root_0;
+                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                        }
+                    root_0 = (CommonTree)adaptor.nil();
+                    // 532:19: -> typealiasDecl
+                    {
+                        adaptor.addChild(root_0, stream_typealiasDecl.nextTree());
 
-                        retval.tree = root_0;
                     }
-                }
+
+                    retval.tree = root_0;}
+                    }
                     break;
 
-                }
+            }
+
+            TERM80=(Token)match(input,TERM,FOLLOW_TERM_in_structOrVariantDeclaration1751); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_TERM.add(TERM80);
+            }
 
-                TERM80 = (Token) match(input, TERM,
-                        FOLLOW_TERM_in_structOrVariantDeclaration1747);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_TERM.add(TERM80);
-                }
 
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 exit("structOrVariantDeclaration");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "structOrVariantDeclaration"
 
-    public static class specifierQualifierList_return extends
-            ParserRuleReturnScope {
+    public static class specifierQualifierList_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "specifierQualifierList"
-    // Grammar/CTFParser.g:536:1: specifierQualifierList : ( typeQualifier |
-    // typeSpecifier )+ -> ^( TYPE_SPECIFIER_LIST ( typeQualifier )* (
-    // typeSpecifier )* ) ;
-    public final CTFParser.specifierQualifierList_return specifierQualifierList()
-            throws RecognitionException {
+    // CTFParser.g:537:1: specifierQualifierList : ( typeQualifier | typeSpecifier )+ -> ^( TYPE_SPECIFIER_LIST ( typeQualifier )* ( typeSpecifier )* ) ;
+    public final CTFParser.specifierQualifierList_return specifierQualifierList() throws RecognitionException {
         CTFParser.specifierQualifierList_return retval = new CTFParser.specifierQualifierList_return();
         retval.start = input.LT(1);
 
@@ -4867,489 +4227,429 @@ public class CTFParser extends Parser {
 
         CTFParser.typeSpecifier_return typeSpecifier82 = null;
 
-        RewriteRuleSubtreeStream stream_typeSpecifier = new RewriteRuleSubtreeStream(
-                adaptor, "rule typeSpecifier");
-        RewriteRuleSubtreeStream stream_typeQualifier = new RewriteRuleSubtreeStream(
-                adaptor, "rule typeQualifier");
 
-        enter("specifierQualifierList");
+        RewriteRuleSubtreeStream stream_typeSpecifier=new RewriteRuleSubtreeStream(adaptor,"rule typeSpecifier");
+        RewriteRuleSubtreeStream stream_typeQualifier=new RewriteRuleSubtreeStream(adaptor,"rule typeQualifier");
+
+          enter("specifierQualifierList");
 
         try {
-            // Grammar/CTFParser.g:543:1: ( ( typeQualifier | typeSpecifier )+
-            // -> ^( TYPE_SPECIFIER_LIST ( typeQualifier )* ( typeSpecifier )* )
-            // )
-            // Grammar/CTFParser.g:544:3: ( typeQualifier | typeSpecifier )+
+            // CTFParser.g:544:1: ( ( typeQualifier | typeSpecifier )+ -> ^( TYPE_SPECIFIER_LIST ( typeQualifier )* ( typeSpecifier )* ) )
+            // CTFParser.g:545:3: ( typeQualifier | typeSpecifier )+
             {
-                // Grammar/CTFParser.g:544:3: ( typeQualifier | typeSpecifier )+
-                int cnt26 = 0;
-                loop26: do {
-                    int alt26 = 3;
-                    int LA26_0 = input.LA(1);
-
-                    if ((LA26_0 == CONSTTOK)) {
-                        alt26 = 1;
-                    } else if ((((LA26_0 >= CHARTOK) && (LA26_0 <= ENUMTOK))
-                            || ((LA26_0 >= FLOATINGPOINTTOK) && (LA26_0 <= SIGNEDTOK))
-                            || ((LA26_0 >= STRINGTOK) && (LA26_0 <= STRUCTTOK)) || ((LA26_0 >= UNSIGNEDTOK) && (LA26_0 <= IMAGINARYTOK)))) {
-                        alt26 = 2;
-                    } else if ((LA26_0 == IDENTIFIER)
-                            && ((inTypealiasAlias() || isTypeName(input.LT(1)
-                                    .getText())))) {
-                        alt26 = 2;
-                    }
-
-                    switch (alt26) {
-                    case 1:
-                    // Grammar/CTFParser.g:544:4: typeQualifier
-                    {
-                        pushFollow(FOLLOW_typeQualifier_in_specifierQualifierList1771);
-                        typeQualifier81 = typeQualifier();
-
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_typeQualifier.add(typeQualifier81.getTree());
-                        }
+            // CTFParser.g:545:3: ( typeQualifier | typeSpecifier )+
+            int cnt26=0;
+            loop26:
+            do {
+                int alt26=3;
+                int LA26_0 = input.LA(1);
 
+                if ( (LA26_0==CONSTTOK) ) {
+                    alt26=1;
+                }
+                else if ( ((LA26_0>=CHARTOK && LA26_0<=ENUMTOK)||(LA26_0>=FLOATINGPOINTTOK && LA26_0<=SIGNEDTOK)||(LA26_0>=STRINGTOK && LA26_0<=STRUCTTOK)||(LA26_0>=UNSIGNEDTOK && LA26_0<=IMAGINARYTOK)) ) {
+                    alt26=2;
+                }
+                else if ( (LA26_0==IDENTIFIER) && ((inTypealiasAlias() || isTypeName(input.LT(1).getText())))) {
+                    alt26=2;
+                }
+
+
+                switch (alt26) {
+               case 1 :
+                   // CTFParser.g:545:4: typeQualifier
+                   {
+                   pushFollow(FOLLOW_typeQualifier_in_specifierQualifierList1775);
+                   typeQualifier81=typeQualifier();
+
+                   state._fsp--;
+                   if (state.failed) {
+                        return retval;
+                    }
+                   if ( state.backtracking==0 ) {
+                        stream_typeQualifier.add(typeQualifier81.getTree());
                     }
-                        break;
-                    case 2:
-                    // Grammar/CTFParser.g:544:20: typeSpecifier
-                    {
-                        pushFollow(FOLLOW_typeSpecifier_in_specifierQualifierList1775);
-                        typeSpecifier82 = typeSpecifier();
 
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_typeSpecifier.add(typeSpecifier82.getTree());
-                        }
+                   }
+                   break;
+               case 2 :
+                   // CTFParser.g:545:20: typeSpecifier
+                   {
+                   pushFollow(FOLLOW_typeSpecifier_in_specifierQualifierList1779);
+                   typeSpecifier82=typeSpecifier();
 
+                   state._fsp--;
+                   if (state.failed) {
+                        return retval;
+                    }
+                   if ( state.backtracking==0 ) {
+                        stream_typeSpecifier.add(typeSpecifier82.getTree());
                     }
-                        break;
 
-                    default:
-                        if (cnt26 >= 1) {
-                            break loop26;
-                        }
-                        if (state.backtracking > 0) {
-                            state.failed = true;
-                            return retval;
-                        }
-                        EarlyExitException eee = new EarlyExitException(26,
-                                input);
-                        throw eee;
+                   }
+                   break;
+
+               default :
+                   if ( cnt26 >= 1 ) {
+                        break loop26;
                     }
-                    cnt26++;
-                } while (true);
-
-                // AST REWRITE
-                // elements: typeSpecifier, typeQualifier
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
+                   if (state.backtracking>0) {state.failed=true; return retval;}
+                        EarlyExitException eee =
+                            new EarlyExitException(26, input);
+                        throw eee;
+                }
+                cnt26++;
+            } while (true);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 544:36: -> ^( TYPE_SPECIFIER_LIST ( typeQualifier )* (
-                    // typeSpecifier )* )
-                    {
-                        // Grammar/CTFParser.g:544:39: ^( TYPE_SPECIFIER_LIST (
-                        // typeQualifier )* ( typeSpecifier )* )
-                        {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(adaptor
-                                    .create(TYPE_SPECIFIER_LIST,
-                                            "TYPE_SPECIFIER_LIST"), root_1);
 
-                            // Grammar/CTFParser.g:544:61: ( typeQualifier )*
-                            while (stream_typeQualifier.hasNext()) {
-                                adaptor.addChild(root_1,
-                                        stream_typeQualifier.nextTree());
 
-                            }
-                            stream_typeQualifier.reset();
-                            // Grammar/CTFParser.g:544:76: ( typeSpecifier )*
-                            while (stream_typeSpecifier.hasNext()) {
-                                adaptor.addChild(root_1,
-                                        stream_typeSpecifier.nextTree());
+            // AST REWRITE
+            // elements: typeQualifier, typeSpecifier
+            // token labels:
+            // rule labels: retval
+            // token list labels:
+            // rule list labels:
+            // wildcard labels:
+            if ( state.backtracking==0 ) {
+            retval.tree = root_0;
+            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                            }
-                            stream_typeSpecifier.reset();
+            root_0 = (CommonTree)adaptor.nil();
+            // 545:36: -> ^( TYPE_SPECIFIER_LIST ( typeQualifier )* ( typeSpecifier )* )
+            {
+                // CTFParser.g:545:39: ^( TYPE_SPECIFIER_LIST ( typeQualifier )* ( typeSpecifier )* )
+                {
+                CommonTree root_1 = (CommonTree)adaptor.nil();
+                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TYPE_SPECIFIER_LIST, "TYPE_SPECIFIER_LIST"), root_1);
 
-                            adaptor.addChild(root_0, root_1);
-                        }
+                // CTFParser.g:545:61: ( typeQualifier )*
+                while ( stream_typeQualifier.hasNext() ) {
+                    adaptor.addChild(root_1, stream_typeQualifier.nextTree());
 
-                    }
+                }
+                stream_typeQualifier.reset();
+                // CTFParser.g:545:76: ( typeSpecifier )*
+                while ( stream_typeSpecifier.hasNext() ) {
+                    adaptor.addChild(root_1, stream_typeSpecifier.nextTree());
 
-                    retval.tree = root_0;
                 }
+                stream_typeSpecifier.reset();
+
+                adaptor.addChild(root_0, root_1);
+                }
+
+            }
+
+            retval.tree = root_0;}
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 exit("specifierQualifierList");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "specifierQualifierList"
 
-    public static class structOrVariantDeclaratorList_return extends
-            ParserRuleReturnScope {
+    public static class structOrVariantDeclaratorList_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "structOrVariantDeclaratorList"
-    // Grammar/CTFParser.g:547:1: structOrVariantDeclaratorList :
-    // structOrVariantDeclarator ( SEPARATOR structOrVariantDeclarator )* -> ^(
-    // TYPE_DECLARATOR_LIST ( structOrVariantDeclarator )+ ) ;
-    public final CTFParser.structOrVariantDeclaratorList_return structOrVariantDeclaratorList()
-            throws RecognitionException {
+    // CTFParser.g:548:1: structOrVariantDeclaratorList : structOrVariantDeclarator ( SEPARATOR structOrVariantDeclarator )* -> ^( TYPE_DECLARATOR_LIST ( structOrVariantDeclarator )+ ) ;
+    public final CTFParser.structOrVariantDeclaratorList_return structOrVariantDeclaratorList() throws RecognitionException {
         CTFParser.structOrVariantDeclaratorList_return retval = new CTFParser.structOrVariantDeclaratorList_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token SEPARATOR84 = null;
+        Token SEPARATOR84=null;
         CTFParser.structOrVariantDeclarator_return structOrVariantDeclarator83 = null;
 
         CTFParser.structOrVariantDeclarator_return structOrVariantDeclarator85 = null;
 
-        CommonTree SEPARATOR84_tree = null;
-        RewriteRuleTokenStream stream_SEPARATOR = new RewriteRuleTokenStream(
-                adaptor, "token SEPARATOR");
-        RewriteRuleSubtreeStream stream_structOrVariantDeclarator = new RewriteRuleSubtreeStream(
-                adaptor, "rule structOrVariantDeclarator");
 
-        enter("structOrVariantDeclaratorList");
+        CommonTree SEPARATOR84_tree=null;
+        RewriteRuleTokenStream stream_SEPARATOR=new RewriteRuleTokenStream(adaptor,"token SEPARATOR");
+        RewriteRuleSubtreeStream stream_structOrVariantDeclarator=new RewriteRuleSubtreeStream(adaptor,"rule structOrVariantDeclarator");
+
+          enter("structOrVariantDeclaratorList");
 
         try {
-            // Grammar/CTFParser.g:554:1: ( structOrVariantDeclarator (
-            // SEPARATOR structOrVariantDeclarator )* -> ^( TYPE_DECLARATOR_LIST
-            // ( structOrVariantDeclarator )+ ) )
-            // Grammar/CTFParser.g:555:3: structOrVariantDeclarator ( SEPARATOR
-            // structOrVariantDeclarator )*
+            // CTFParser.g:555:1: ( structOrVariantDeclarator ( SEPARATOR structOrVariantDeclarator )* -> ^( TYPE_DECLARATOR_LIST ( structOrVariantDeclarator )+ ) )
+            // CTFParser.g:556:3: structOrVariantDeclarator ( SEPARATOR structOrVariantDeclarator )*
             {
-                pushFollow(FOLLOW_structOrVariantDeclarator_in_structOrVariantDeclaratorList1812);
-                structOrVariantDeclarator83 = structOrVariantDeclarator();
+            pushFollow(FOLLOW_structOrVariantDeclarator_in_structOrVariantDeclaratorList1816);
+            structOrVariantDeclarator83=structOrVariantDeclarator();
+
+            state._fsp--;
+            if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_structOrVariantDeclarator.add(structOrVariantDeclarator83.getTree());
+            }
+            // CTFParser.g:556:29: ( SEPARATOR structOrVariantDeclarator )*
+            loop27:
+            do {
+                int alt27=2;
+                int LA27_0 = input.LA(1);
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_structOrVariantDeclarator
-                            .add(structOrVariantDeclarator83.getTree());
+                if ( (LA27_0==SEPARATOR) ) {
+                    alt27=1;
                 }
-                // Grammar/CTFParser.g:555:29: ( SEPARATOR
-                // structOrVariantDeclarator )*
-                loop27: do {
-                    int alt27 = 2;
-                    int LA27_0 = input.LA(1);
 
-                    if ((LA27_0 == SEPARATOR)) {
-                        alt27 = 1;
+
+                switch (alt27) {
+               case 1 :
+                   // CTFParser.g:556:30: SEPARATOR structOrVariantDeclarator
+                   {
+                   SEPARATOR84=(Token)match(input,SEPARATOR,FOLLOW_SEPARATOR_in_structOrVariantDeclaratorList1819); if (state.failed) {
+                        return retval;
+                    }
+                   if ( state.backtracking==0 ) {
+                        stream_SEPARATOR.add(SEPARATOR84);
                     }
 
-                    switch (alt27) {
-                    case 1:
-                    // Grammar/CTFParser.g:555:30: SEPARATOR
-                    // structOrVariantDeclarator
-                    {
-                        SEPARATOR84 = (Token) match(input, SEPARATOR,
-                                FOLLOW_SEPARATOR_in_structOrVariantDeclaratorList1815);
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_SEPARATOR.add(SEPARATOR84);
-                        }
+                   pushFollow(FOLLOW_structOrVariantDeclarator_in_structOrVariantDeclaratorList1821);
+                   structOrVariantDeclarator85=structOrVariantDeclarator();
 
-                        pushFollow(FOLLOW_structOrVariantDeclarator_in_structOrVariantDeclaratorList1817);
-                        structOrVariantDeclarator85 = structOrVariantDeclarator();
+                   state._fsp--;
+                   if (state.failed) {
+                        return retval;
+                    }
+                   if ( state.backtracking==0 ) {
+                        stream_structOrVariantDeclarator.add(structOrVariantDeclarator85.getTree());
+                    }
 
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_structOrVariantDeclarator
-                                    .add(structOrVariantDeclarator85.getTree());
-                        }
+                   }
+                   break;
 
-                    }
-                        break;
+               default :
+                   break loop27;
+                }
+            } while (true);
 
-                    default:
-                        break loop27;
-                    }
-                } while (true);
-
-                // AST REWRITE
-                // elements: structOrVariantDeclarator
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 555:68: -> ^( TYPE_DECLARATOR_LIST (
-                    // structOrVariantDeclarator )+ )
-                    {
-                        // Grammar/CTFParser.g:555:71: ^( TYPE_DECLARATOR_LIST (
-                        // structOrVariantDeclarator )+ )
-                        {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(adaptor
-                                    .create(TYPE_DECLARATOR_LIST,
-                                            "TYPE_DECLARATOR_LIST"), root_1);
 
-                            if (!(stream_structOrVariantDeclarator.hasNext())) {
-                                throw new RewriteEarlyExitException();
-                            }
-                            while (stream_structOrVariantDeclarator.hasNext()) {
-                                adaptor.addChild(root_1,
-                                        stream_structOrVariantDeclarator
-                                                .nextTree());
+            // AST REWRITE
+            // elements: structOrVariantDeclarator
+            // token labels:
+            // rule labels: retval
+            // token list labels:
+            // rule list labels:
+            // wildcard labels:
+            if ( state.backtracking==0 ) {
+            retval.tree = root_0;
+            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                            }
-                            stream_structOrVariantDeclarator.reset();
+            root_0 = (CommonTree)adaptor.nil();
+            // 556:68: -> ^( TYPE_DECLARATOR_LIST ( structOrVariantDeclarator )+ )
+            {
+                // CTFParser.g:556:71: ^( TYPE_DECLARATOR_LIST ( structOrVariantDeclarator )+ )
+                {
+                CommonTree root_1 = (CommonTree)adaptor.nil();
+                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TYPE_DECLARATOR_LIST, "TYPE_DECLARATOR_LIST"), root_1);
 
-                            adaptor.addChild(root_0, root_1);
-                        }
+                if ( !(stream_structOrVariantDeclarator.hasNext()) ) {
+                    throw new RewriteEarlyExitException();
+                }
+                while ( stream_structOrVariantDeclarator.hasNext() ) {
+                    adaptor.addChild(root_1, stream_structOrVariantDeclarator.nextTree());
 
-                    }
+                }
+                stream_structOrVariantDeclarator.reset();
 
-                    retval.tree = root_0;
+                adaptor.addChild(root_0, root_1);
                 }
+
+            }
+
+            retval.tree = root_0;}
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 exit("structOrVariantDeclaratorList");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "structOrVariantDeclaratorList"
 
-    public static class structOrVariantDeclarator_return extends
-            ParserRuleReturnScope {
+    public static class structOrVariantDeclarator_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "structOrVariantDeclarator"
-    // Grammar/CTFParser.g:558:1: structOrVariantDeclarator : ( declarator (
-    // COLON numberLiteral )? ) -> declarator ;
-    public final CTFParser.structOrVariantDeclarator_return structOrVariantDeclarator()
-            throws RecognitionException {
+    // CTFParser.g:559:1: structOrVariantDeclarator : ( declarator ( COLON numberLiteral )? ) -> declarator ;
+    public final CTFParser.structOrVariantDeclarator_return structOrVariantDeclarator() throws RecognitionException {
         CTFParser.structOrVariantDeclarator_return retval = new CTFParser.structOrVariantDeclarator_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token COLON87 = null;
+        Token COLON87=null;
         CTFParser.declarator_return declarator86 = null;
 
         CTFParser.numberLiteral_return numberLiteral88 = null;
 
-        CommonTree COLON87_tree = null;
-        RewriteRuleTokenStream stream_COLON = new RewriteRuleTokenStream(
-                adaptor, "token COLON");
-        RewriteRuleSubtreeStream stream_declarator = new RewriteRuleSubtreeStream(
-                adaptor, "rule declarator");
-        RewriteRuleSubtreeStream stream_numberLiteral = new RewriteRuleSubtreeStream(
-                adaptor, "rule numberLiteral");
 
-        enter("structOrVariantDeclarator");
+        CommonTree COLON87_tree=null;
+        RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON");
+        RewriteRuleSubtreeStream stream_declarator=new RewriteRuleSubtreeStream(adaptor,"rule declarator");
+        RewriteRuleSubtreeStream stream_numberLiteral=new RewriteRuleSubtreeStream(adaptor,"rule numberLiteral");
+
+          enter("structOrVariantDeclarator");
 
         try {
-            // Grammar/CTFParser.g:565:1: ( ( declarator ( COLON numberLiteral
-            // )? ) -> declarator )
-            // Grammar/CTFParser.g:567:5: ( declarator ( COLON numberLiteral )?
-            // )
+            // CTFParser.g:566:1: ( ( declarator ( COLON numberLiteral )? ) -> declarator )
+            // CTFParser.g:568:5: ( declarator ( COLON numberLiteral )? )
             {
-                // Grammar/CTFParser.g:567:5: ( declarator ( COLON numberLiteral
-                // )? )
-                // Grammar/CTFParser.g:567:6: declarator ( COLON numberLiteral
-                // )?
-                {
-                    pushFollow(FOLLOW_declarator_in_structOrVariantDeclarator1858);
-                    declarator86 = declarator();
+            // CTFParser.g:568:5: ( declarator ( COLON numberLiteral )? )
+            // CTFParser.g:568:6: declarator ( COLON numberLiteral )?
+            {
+            pushFollow(FOLLOW_declarator_in_structOrVariantDeclarator1862);
+            declarator86=declarator();
+
+            state._fsp--;
+            if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_declarator.add(declarator86.getTree());
+            }
+            // CTFParser.g:568:17: ( COLON numberLiteral )?
+            int alt28=2;
+            int LA28_0 = input.LA(1);
+
+            if ( (LA28_0==COLON) ) {
+                alt28=1;
+            }
+            switch (alt28) {
+                case 1 :
+                    // CTFParser.g:568:18: COLON numberLiteral
+                    {
+                    COLON87=(Token)match(input,COLON,FOLLOW_COLON_in_structOrVariantDeclarator1865); if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        stream_COLON.add(COLON87);
+                    }
+
+                    pushFollow(FOLLOW_numberLiteral_in_structOrVariantDeclarator1867);
+                    numberLiteral88=numberLiteral();
 
                     state._fsp--;
                     if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
-                        stream_declarator.add(declarator86.getTree());
+                    if ( state.backtracking==0 ) {
+                        stream_numberLiteral.add(numberLiteral88.getTree());
                     }
-                    // Grammar/CTFParser.g:567:17: ( COLON numberLiteral )?
-                    int alt28 = 2;
-                    int LA28_0 = input.LA(1);
 
-                    if ((LA28_0 == COLON)) {
-                        alt28 = 1;
                     }
-                    switch (alt28) {
-                    case 1:
-                    // Grammar/CTFParser.g:567:18: COLON numberLiteral
-                    {
-                        COLON87 = (Token) match(input, COLON,
-                                FOLLOW_COLON_in_structOrVariantDeclarator1861);
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_COLON.add(COLON87);
-                        }
+                    break;
 
-                        pushFollow(FOLLOW_numberLiteral_in_structOrVariantDeclarator1863);
-                        numberLiteral88 = numberLiteral();
+            }
 
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_numberLiteral.add(numberLiteral88.getTree());
-                        }
 
-                    }
-                        break;
+            }
 
-                    }
 
-                }
 
-                // AST REWRITE
-                // elements: declarator
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
+            // AST REWRITE
+            // elements: declarator
+            // token labels:
+            // rule labels: retval
+            // token list labels:
+            // rule list labels:
+            // wildcard labels:
+            if ( state.backtracking==0 ) {
+            retval.tree = root_0;
+            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 567:41: -> declarator
-                    {
-                        adaptor.addChild(root_0, stream_declarator.nextTree());
+            root_0 = (CommonTree)adaptor.nil();
+            // 568:41: -> declarator
+            {
+                adaptor.addChild(root_0, stream_declarator.nextTree());
 
-                    }
+            }
 
-                    retval.tree = root_0;
-                }
+            retval.tree = root_0;}
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 exit("structOrVariantDeclarator");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "structOrVariantDeclarator"
 
     public static class variantSpecifier_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "variantSpecifier"
-    // Grammar/CTFParser.g:571:1: variantSpecifier : VARIANTTOK ( ( variantName
-    // ( ( variantTag ( variantBody | ) ) | variantBody ) ) | ( variantTag
-    // variantBody ) | variantBody ) -> ^( VARIANT ( variantName )? ( variantTag
-    // )? ( variantBody )? ) ;
-    public final CTFParser.variantSpecifier_return variantSpecifier()
-            throws RecognitionException {
+    // CTFParser.g:572:1: variantSpecifier : VARIANTTOK ( ( variantName ( ( variantTag ( variantBody | ) ) | variantBody ) ) | ( variantTag variantBody ) | variantBody ) -> ^( VARIANT ( variantName )? ( variantTag )? ( variantBody )? ) ;
+    public final CTFParser.variantSpecifier_return variantSpecifier() throws RecognitionException {
         CTFParser.variantSpecifier_return retval = new CTFParser.variantSpecifier_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token VARIANTTOK89 = null;
+        Token VARIANTTOK89=null;
         CTFParser.variantName_return variantName90 = null;
 
         CTFParser.variantTag_return variantTag91 = null;
@@ -5364,556 +4664,490 @@ public class CTFParser extends Parser {
 
         CTFParser.variantBody_return variantBody96 = null;
 
-        CommonTree VARIANTTOK89_tree = null;
-        RewriteRuleTokenStream stream_VARIANTTOK = new RewriteRuleTokenStream(
-                adaptor, "token VARIANTTOK");
-        RewriteRuleSubtreeStream stream_variantName = new RewriteRuleSubtreeStream(
-                adaptor, "rule variantName");
-        RewriteRuleSubtreeStream stream_variantTag = new RewriteRuleSubtreeStream(
-                adaptor, "rule variantTag");
-        RewriteRuleSubtreeStream stream_variantBody = new RewriteRuleSubtreeStream(
-                adaptor, "rule variantBody");
 
-        enter("variantSpecifier");
+        CommonTree VARIANTTOK89_tree=null;
+        RewriteRuleTokenStream stream_VARIANTTOK=new RewriteRuleTokenStream(adaptor,"token VARIANTTOK");
+        RewriteRuleSubtreeStream stream_variantName=new RewriteRuleSubtreeStream(adaptor,"rule variantName");
+        RewriteRuleSubtreeStream stream_variantTag=new RewriteRuleSubtreeStream(adaptor,"rule variantTag");
+        RewriteRuleSubtreeStream stream_variantBody=new RewriteRuleSubtreeStream(adaptor,"rule variantBody");
+
+          enter("variantSpecifier");
 
         try {
-            // Grammar/CTFParser.g:578:1: ( VARIANTTOK ( ( variantName ( (
-            // variantTag ( variantBody | ) ) | variantBody ) ) | ( variantTag
-            // variantBody ) | variantBody ) -> ^( VARIANT ( variantName )? (
-            // variantTag )? ( variantBody )? ) )
-            // Grammar/CTFParser.g:579:3: VARIANTTOK ( ( variantName ( (
-            // variantTag ( variantBody | ) ) | variantBody ) ) | ( variantTag
-            // variantBody ) | variantBody )
+            // CTFParser.g:579:1: ( VARIANTTOK ( ( variantName ( ( variantTag ( variantBody | ) ) | variantBody ) ) | ( variantTag variantBody ) | variantBody ) -> ^( VARIANT ( variantName )? ( variantTag )? ( variantBody )? ) )
+            // CTFParser.g:580:3: VARIANTTOK ( ( variantName ( ( variantTag ( variantBody | ) ) | variantBody ) ) | ( variantTag variantBody ) | variantBody )
             {
-                VARIANTTOK89 = (Token) match(input, VARIANTTOK,
-                        FOLLOW_VARIANTTOK_in_variantSpecifier1897);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_VARIANTTOK.add(VARIANTTOK89);
-                }
+            VARIANTTOK89=(Token)match(input,VARIANTTOK,FOLLOW_VARIANTTOK_in_variantSpecifier1901); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_VARIANTTOK.add(VARIANTTOK89);
+            }
 
-                // Grammar/CTFParser.g:580:3: ( ( variantName ( ( variantTag (
-                // variantBody | ) ) | variantBody ) ) | ( variantTag
-                // variantBody ) | variantBody )
-                int alt31 = 3;
-                switch (input.LA(1)) {
-                case IDENTIFIER: {
-                    alt31 = 1;
+            // CTFParser.g:581:3: ( ( variantName ( ( variantTag ( variantBody | ) ) | variantBody ) ) | ( variantTag variantBody ) | variantBody )
+            int alt31=3;
+            switch ( input.LA(1) ) {
+            case IDENTIFIER:
+                {
+                alt31=1;
                 }
-                    break;
-                case LT: {
-                    alt31 = 2;
+                break;
+            case LT:
+                {
+                alt31=2;
                 }
-                    break;
-                case LCURL: {
-                    alt31 = 3;
+                break;
+            case LCURL:
+                {
+                alt31=3;
                 }
-                    break;
-                default:
-                    if (state.backtracking > 0) {
-                        state.failed = true;
+                break;
+            default:
+                if (state.backtracking>0) {state.failed=true; return retval;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 31, 0, input);
+
+                throw nvae;
+            }
+
+            switch (alt31) {
+                case 1 :
+                    // CTFParser.g:582:5: ( variantName ( ( variantTag ( variantBody | ) ) | variantBody ) )
+                    {
+                    // CTFParser.g:582:5: ( variantName ( ( variantTag ( variantBody | ) ) | variantBody ) )
+                    // CTFParser.g:583:7: variantName ( ( variantTag ( variantBody | ) ) | variantBody )
+                    {
+                    pushFollow(FOLLOW_variantName_in_variantSpecifier1919);
+                    variantName90=variantName();
+
+                    state._fsp--;
+                    if (state.failed) {
                         return retval;
                     }
-                    NoViableAltException nvae = new NoViableAltException("",
-                            31, 0, input);
+                    if ( state.backtracking==0 ) {
+                        stream_variantName.add(variantName90.getTree());
+                    }
+                    // CTFParser.g:584:7: ( ( variantTag ( variantBody | ) ) | variantBody )
+                    int alt30=2;
+                    int LA30_0 = input.LA(1);
 
-                    throw nvae;
-                }
+                    if ( (LA30_0==LT) ) {
+                        alt30=1;
+                    }
+                    else if ( (LA30_0==LCURL) ) {
+                        alt30=2;
+                    }
+                    else {
+                        if (state.backtracking>0) {state.failed=true; return retval;}
+                        NoViableAltException nvae =
+                            new NoViableAltException("", 30, 0, input);
 
-                switch (alt31) {
-                case 1:
-                // Grammar/CTFParser.g:581:5: ( variantName ( ( variantTag (
-                // variantBody | ) ) | variantBody ) )
-                {
-                    // Grammar/CTFParser.g:581:5: ( variantName ( ( variantTag (
-                    // variantBody | ) ) | variantBody ) )
-                    // Grammar/CTFParser.g:582:7: variantName ( ( variantTag (
-                    // variantBody | ) ) | variantBody )
-                    {
-                        pushFollow(FOLLOW_variantName_in_variantSpecifier1915);
-                        variantName90 = variantName();
+                        throw nvae;
+                    }
+                    switch (alt30) {
+                        case 1 :
+                            // CTFParser.g:585:9: ( variantTag ( variantBody | ) )
+                            {
+                            // CTFParser.g:585:9: ( variantTag ( variantBody | ) )
+                            // CTFParser.g:586:11: variantTag ( variantBody | )
+                            {
+                            pushFollow(FOLLOW_variantTag_in_variantSpecifier1950);
+                            variantTag91=variantTag();
 
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_variantName.add(variantName90.getTree());
-                        }
-                        // Grammar/CTFParser.g:583:7: ( ( variantTag (
-                        // variantBody | ) ) | variantBody )
-                        int alt30 = 2;
-                        int LA30_0 = input.LA(1);
-
-                        if ((LA30_0 == LT)) {
-                            alt30 = 1;
-                        } else if ((LA30_0 == LCURL)) {
-                            alt30 = 2;
-                        } else {
-                            if (state.backtracking > 0) {
-                                state.failed = true;
+                            state._fsp--;
+                            if (state.failed) {
                                 return retval;
                             }
-                            NoViableAltException nvae = new NoViableAltException(
-                                    "", 30, 0, input);
-
-                            throw nvae;
-                        }
-                        switch (alt30) {
-                        case 1:
-                        // Grammar/CTFParser.g:584:9: ( variantTag ( variantBody
-                        // | ) )
-                        {
-                            // Grammar/CTFParser.g:584:9: ( variantTag (
-                            // variantBody | ) )
-                            // Grammar/CTFParser.g:585:11: variantTag (
-                            // variantBody | )
-                            {
-                                pushFollow(FOLLOW_variantTag_in_variantSpecifier1946);
-                                variantTag91 = variantTag();
+                            if ( state.backtracking==0 ) {
+                                stream_variantTag.add(variantTag91.getTree());
+                            }
+                            // CTFParser.g:587:11: ( variantBody | )
+                            int alt29=2;
+                            int LA29_0 = input.LA(1);
+
+                            if ( (LA29_0==LCURL) ) {
+                                switch ( input.LA(2) ) {
+                                case CONSTTOK:
+                                case CHARTOK:
+                                case DOUBLETOK:
+                                case ENUMTOK:
+                                case FLOATINGPOINTTOK:
+                                case FLOATTOK:
+                                case INTEGERTOK:
+                                case INTTOK:
+                                case LONGTOK:
+                                case SHORTTOK:
+                                case STRUCTTOK:
+                                case TYPEALIASTOK:
+                                case TYPEDEFTOK:
+                                case UNSIGNEDTOK:
+                                case VARIANTTOK:
+                                case VOIDTOK:
+                                case BOOLTOK:
+                                case COMPLEXTOK:
+                                case IMAGINARYTOK:
+                                    {
+                                    alt29=1;
+                                    }
+                                    break;
+                                case SIGNEDTOK:
+                                    {
+                                    int LA29_4 = input.LA(3);
 
-                                state._fsp--;
-                                if (state.failed) {
-                                    return retval;
-                                }
-                                if (state.backtracking == 0) {
-                                    stream_variantTag.add(variantTag91
-                                            .getTree());
-                                }
-                                // Grammar/CTFParser.g:586:11: ( variantBody | )
-                                int alt29 = 2;
-                                int LA29_0 = input.LA(1);
-
-                                if ((LA29_0 == LCURL)) {
-                                    switch (input.LA(2)) {
-                                    case CONSTTOK:
-                                    case CHARTOK:
-                                    case DOUBLETOK:
-                                    case ENUMTOK:
-                                    case FLOATINGPOINTTOK:
-                                    case FLOATTOK:
-                                    case INTEGERTOK:
-                                    case INTTOK:
-                                    case LONGTOK:
-                                    case SHORTTOK:
-                                    case STRUCTTOK:
-                                    case TYPEALIASTOK:
-                                    case TYPEDEFTOK:
-                                    case UNSIGNEDTOK:
-                                    case VARIANTTOK:
-                                    case VOIDTOK:
-                                    case BOOLTOK:
-                                    case COMPLEXTOK:
-                                    case IMAGINARYTOK: {
-                                        alt29 = 1;
+                                    if ( ((LA29_4>=CONSTTOK && LA29_4<=ENUMTOK)||(LA29_4>=FLOATINGPOINTTOK && LA29_4<=SIGNEDTOK)||(LA29_4>=STRINGTOK && LA29_4<=STRUCTTOK)||(LA29_4>=TYPEDEFTOK && LA29_4<=IMAGINARYTOK)||LA29_4==POINTER||LA29_4==IDENTIFIER) ) {
+                                        alt29=1;
                                     }
-                                        break;
-                                    case SIGNEDTOK: {
-                                        int LA29_4 = input.LA(3);
-
-                                        if ((((LA29_4 >= CONSTTOK) && (LA29_4 <= ENUMTOK))
-                                                || ((LA29_4 >= FLOATINGPOINTTOK) && (LA29_4 <= SIGNEDTOK))
-                                                || ((LA29_4 >= STRINGTOK) && (LA29_4 <= STRUCTTOK))
-                                                || ((LA29_4 >= TYPEDEFTOK) && (LA29_4 <= IMAGINARYTOK))
-                                                || (LA29_4 == POINTER) || (LA29_4 == IDENTIFIER))) {
-                                            alt29 = 1;
-                                        } else if (((LA29_4 == SEPARATOR)
-                                                || (LA29_4 == ASSIGNMENT) || (LA29_4 == RCURL))) {
-                                            alt29 = 2;
-                                        } else {
-                                            if (state.backtracking > 0) {
-                                                state.failed = true;
-                                                return retval;
-                                            }
-                                            NoViableAltException nvae = new NoViableAltException(
-                                                    "", 29, 4, input);
-
-                                            throw nvae;
-                                        }
+                                    else if ( (LA29_4==SEPARATOR||LA29_4==ASSIGNMENT||LA29_4==RCURL) ) {
+                                        alt29=2;
+                                    }
+                                    else {
+                                        if (state.backtracking>0) {state.failed=true; return retval;}
+                                        NoViableAltException nvae =
+                                            new NoViableAltException("", 29, 4, input);
+
+                                        throw nvae;
                                     }
-                                        break;
-                                    case STRINGTOK: {
-                                        int LA29_5 = input.LA(3);
-
-                                        if (((LA29_5 == SEPARATOR)
-                                                || (LA29_5 == ASSIGNMENT) || (LA29_5 == RCURL))) {
-                                            alt29 = 2;
-                                        } else if ((((LA29_5 >= CONSTTOK) && (LA29_5 <= ENUMTOK))
-                                                || ((LA29_5 >= FLOATINGPOINTTOK) && (LA29_5 <= SIGNEDTOK))
-                                                || ((LA29_5 >= STRINGTOK) && (LA29_5 <= STRUCTTOK))
-                                                || ((LA29_5 >= TYPEDEFTOK) && (LA29_5 <= IMAGINARYTOK))
-                                                || (LA29_5 == LCURL)
-                                                || (LA29_5 == POINTER) || (LA29_5 == IDENTIFIER))) {
-                                            alt29 = 1;
-                                        } else {
-                                            if (state.backtracking > 0) {
-                                                state.failed = true;
-                                                return retval;
-                                            }
-                                            NoViableAltException nvae = new NoViableAltException(
-                                                    "", 29, 5, input);
-
-                                            throw nvae;
-                                        }
                                     }
-                                        break;
-                                    case IDENTIFIER: {
-                                        int LA29_6 = input.LA(3);
-
-                                        if (((LA29_6 == SEPARATOR)
-                                                || (LA29_6 == ASSIGNMENT) || (LA29_6 == RCURL))) {
-                                            alt29 = 2;
-                                        } else if ((((LA29_6 >= CONSTTOK) && (LA29_6 <= ENUMTOK))
-                                                || ((LA29_6 >= FLOATINGPOINTTOK) && (LA29_6 <= SIGNEDTOK))
-                                                || ((LA29_6 >= STRINGTOK) && (LA29_6 <= STRUCTTOK))
-                                                || ((LA29_6 >= TYPEDEFTOK) && (LA29_6 <= IMAGINARYTOK))
-                                                || (LA29_6 == POINTER) || (LA29_6 == IDENTIFIER))) {
-                                            alt29 = 1;
-                                        } else {
-                                            if (state.backtracking > 0) {
-                                                state.failed = true;
-                                                return retval;
-                                            }
-                                            NoViableAltException nvae = new NoViableAltException(
-                                                    "", 29, 6, input);
-
-                                            throw nvae;
-                                        }
+                                    break;
+                                case STRINGTOK:
+                                    {
+                                    int LA29_5 = input.LA(3);
+
+                                    if ( ((LA29_5>=CONSTTOK && LA29_5<=ENUMTOK)||(LA29_5>=FLOATINGPOINTTOK && LA29_5<=SIGNEDTOK)||(LA29_5>=STRINGTOK && LA29_5<=STRUCTTOK)||(LA29_5>=TYPEDEFTOK && LA29_5<=IMAGINARYTOK)||LA29_5==LCURL||LA29_5==POINTER||LA29_5==IDENTIFIER) ) {
+                                        alt29=1;
                                     }
-                                        break;
-                                    case ALIGNTOK:
-                                    case EVENTTOK:
-                                    case STRING_LITERAL: {
-                                        alt29 = 2;
+                                    else if ( (LA29_5==SEPARATOR||LA29_5==ASSIGNMENT||LA29_5==RCURL) ) {
+                                        alt29=2;
                                     }
-                                        break;
-                                    default:
-                                        if (state.backtracking > 0) {
-                                            state.failed = true;
-                                            return retval;
-                                        }
-                                        NoViableAltException nvae = new NoViableAltException(
-                                                "", 29, 1, input);
+                                    else {
+                                        if (state.backtracking>0) {state.failed=true; return retval;}
+                                        NoViableAltException nvae =
+                                            new NoViableAltException("", 29, 5, input);
 
                                         throw nvae;
                                     }
+                                    }
+                                    break;
+                                case IDENTIFIER:
+                                    {
+                                    int LA29_6 = input.LA(3);
 
-                                } else if (((LA29_0 == EOF)
-                                        || ((LA29_0 >= CONSTTOK) && (LA29_0 <= ENUMTOK))
-                                        || ((LA29_0 >= FLOATINGPOINTTOK) && (LA29_0 <= SIGNEDTOK))
-                                        || ((LA29_0 >= STRINGTOK) && (LA29_0 <= STRUCTTOK))
-                                        || ((LA29_0 >= TYPEDEFTOK) && (LA29_0 <= IMAGINARYTOK))
-                                        || (LA29_0 == TYPE_ASSIGNMENT)
-                                        || (LA29_0 == LPAREN)
-                                        || ((LA29_0 >= TERM) && (LA29_0 <= POINTER)) || (LA29_0 == IDENTIFIER))) {
-                                    alt29 = 2;
-                                } else {
-                                    if (state.backtracking > 0) {
-                                        state.failed = true;
-                                        return retval;
+                                    if ( (LA29_6==SEPARATOR||LA29_6==ASSIGNMENT||LA29_6==RCURL) ) {
+                                        alt29=2;
+                                    }
+                                    else if ( ((LA29_6>=CONSTTOK && LA29_6<=ENUMTOK)||(LA29_6>=FLOATINGPOINTTOK && LA29_6<=SIGNEDTOK)||(LA29_6>=STRINGTOK && LA29_6<=STRUCTTOK)||(LA29_6>=TYPEDEFTOK && LA29_6<=IMAGINARYTOK)||LA29_6==POINTER||LA29_6==IDENTIFIER) ) {
+                                        alt29=1;
+                                    }
+                                    else {
+                                        if (state.backtracking>0) {state.failed=true; return retval;}
+                                        NoViableAltException nvae =
+                                            new NoViableAltException("", 29, 6, input);
+
+                                        throw nvae;
+                                    }
+                                    }
+                                    break;
+                                case ALIGNTOK:
+                                case EVENTTOK:
+                                case STRING_LITERAL:
+                                    {
+                                    alt29=2;
                                     }
-                                    NoViableAltException nvae = new NoViableAltException(
-                                            "", 29, 0, input);
+                                    break;
+                                default:
+                                    if (state.backtracking>0) {state.failed=true; return retval;}
+                                    NoViableAltException nvae =
+                                        new NoViableAltException("", 29, 1, input);
 
                                     throw nvae;
                                 }
-                                switch (alt29) {
-                                case 1:
-                                // Grammar/CTFParser.g:587:13: variantBody
-                                {
-                                    pushFollow(FOLLOW_variantBody_in_variantSpecifier1972);
-                                    variantBody92 = variantBody();
+
+                            }
+                            else if ( (LA29_0==EOF||(LA29_0>=CONSTTOK && LA29_0<=ENUMTOK)||(LA29_0>=FLOATINGPOINTTOK && LA29_0<=SIGNEDTOK)||(LA29_0>=STRINGTOK && LA29_0<=STRUCTTOK)||(LA29_0>=TYPEDEFTOK && LA29_0<=IMAGINARYTOK)||LA29_0==TYPE_ASSIGNMENT||LA29_0==LPAREN||(LA29_0>=TERM && LA29_0<=POINTER)||LA29_0==IDENTIFIER) ) {
+                                alt29=2;
+                            }
+                            else {
+                                if (state.backtracking>0) {state.failed=true; return retval;}
+                                NoViableAltException nvae =
+                                    new NoViableAltException("", 29, 0, input);
+
+                                throw nvae;
+                            }
+                            switch (alt29) {
+                                case 1 :
+                                    // CTFParser.g:588:13: variantBody
+                                    {
+                                    pushFollow(FOLLOW_variantBody_in_variantSpecifier1976);
+                                    variantBody92=variantBody();
 
                                     state._fsp--;
                                     if (state.failed) {
                                         return retval;
                                     }
-                                    if (state.backtracking == 0) {
-                                        stream_variantBody.add(variantBody92
-                                                .getTree());
+                                    if ( state.backtracking==0 ) {
+                                        stream_variantBody.add(variantBody92.getTree());
                                     }
 
-                                }
+                                    }
                                     break;
-                                case 2:
+                                case 2 :
+                                    // CTFParser.g:591:11:
+                                    {
+                                    }
                                     break;
 
-                                }
+                            }
+
 
                             }
 
-                        }
+
+                            }
                             break;
-                        case 2:
-                        // Grammar/CTFParser.g:593:9: variantBody
-                        {
-                            pushFollow(FOLLOW_variantBody_in_variantSpecifier2040);
-                            variantBody93 = variantBody();
+                        case 2 :
+                            // CTFParser.g:594:9: variantBody
+                            {
+                            pushFollow(FOLLOW_variantBody_in_variantSpecifier2044);
+                            variantBody93=variantBody();
 
                             state._fsp--;
                             if (state.failed) {
                                 return retval;
                             }
-                            if (state.backtracking == 0) {
+                            if ( state.backtracking==0 ) {
                                 stream_variantBody.add(variantBody93.getTree());
                             }
 
-                        }
+                            }
                             break;
 
-                        }
+                    }
+
 
                     }
 
-                }
+
+                    }
                     break;
-                case 2:
-                // Grammar/CTFParser.g:597:5: ( variantTag variantBody )
-                {
-                    // Grammar/CTFParser.g:597:5: ( variantTag variantBody )
-                    // Grammar/CTFParser.g:597:6: variantTag variantBody
+                case 2 :
+                    // CTFParser.g:598:5: ( variantTag variantBody )
                     {
-                        pushFollow(FOLLOW_variantTag_in_variantSpecifier2065);
-                        variantTag94 = variantTag();
+                    // CTFParser.g:598:5: ( variantTag variantBody )
+                    // CTFParser.g:598:6: variantTag variantBody
+                    {
+                    pushFollow(FOLLOW_variantTag_in_variantSpecifier2069);
+                    variantTag94=variantTag();
 
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_variantTag.add(variantTag94.getTree());
-                        }
-                        pushFollow(FOLLOW_variantBody_in_variantSpecifier2067);
-                        variantBody95 = variantBody();
+                    state._fsp--;
+                    if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        stream_variantTag.add(variantTag94.getTree());
+                    }
+                    pushFollow(FOLLOW_variantBody_in_variantSpecifier2071);
+                    variantBody95=variantBody();
 
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_variantBody.add(variantBody95.getTree());
-                        }
+                    state._fsp--;
+                    if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        stream_variantBody.add(variantBody95.getTree());
+                    }
 
                     }
 
-                }
+
+                    }
                     break;
-                case 3:
-                // Grammar/CTFParser.g:599:5: variantBody
-                {
-                    pushFollow(FOLLOW_variantBody_in_variantSpecifier2078);
-                    variantBody96 = variantBody();
+                case 3 :
+                    // CTFParser.g:600:5: variantBody
+                    {
+                    pushFollow(FOLLOW_variantBody_in_variantSpecifier2082);
+                    variantBody96=variantBody();
 
                     state._fsp--;
                     if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
+                    if ( state.backtracking==0 ) {
                         stream_variantBody.add(variantBody96.getTree());
                     }
 
-                }
+                    }
                     break;
 
-                }
+            }
 
-                // AST REWRITE
-                // elements: variantBody, variantTag, variantName
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 600:5: -> ^( VARIANT ( variantName )? ( variantTag )? (
-                    // variantBody )? )
-                    {
-                        // Grammar/CTFParser.g:600:8: ^( VARIANT ( variantName
-                        // )? ( variantTag )? ( variantBody )? )
-                        {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(
-                                    adaptor.create(VARIANT, "VARIANT"), root_1);
 
-                            // Grammar/CTFParser.g:600:18: ( variantName )?
-                            if (stream_variantName.hasNext()) {
-                                adaptor.addChild(root_1,
-                                        stream_variantName.nextTree());
+            // AST REWRITE
+            // elements: variantTag, variantName, variantBody
+            // token labels:
+            // rule labels: retval
+            // token list labels:
+            // rule list labels:
+            // wildcard labels:
+            if ( state.backtracking==0 ) {
+            retval.tree = root_0;
+            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                            }
-                            stream_variantName.reset();
-                            // Grammar/CTFParser.g:600:31: ( variantTag )?
-                            if (stream_variantTag.hasNext()) {
-                                adaptor.addChild(root_1,
-                                        stream_variantTag.nextTree());
+            root_0 = (CommonTree)adaptor.nil();
+            // 601:5: -> ^( VARIANT ( variantName )? ( variantTag )? ( variantBody )? )
+            {
+                // CTFParser.g:601:8: ^( VARIANT ( variantName )? ( variantTag )? ( variantBody )? )
+                {
+                CommonTree root_1 = (CommonTree)adaptor.nil();
+                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(VARIANT, "VARIANT"), root_1);
 
-                            }
-                            stream_variantTag.reset();
-                            // Grammar/CTFParser.g:600:43: ( variantBody )?
-                            if (stream_variantBody.hasNext()) {
-                                adaptor.addChild(root_1,
-                                        stream_variantBody.nextTree());
+                // CTFParser.g:601:18: ( variantName )?
+                if ( stream_variantName.hasNext() ) {
+                    adaptor.addChild(root_1, stream_variantName.nextTree());
 
-                            }
-                            stream_variantBody.reset();
+                }
+                stream_variantName.reset();
+                // CTFParser.g:601:31: ( variantTag )?
+                if ( stream_variantTag.hasNext() ) {
+                    adaptor.addChild(root_1, stream_variantTag.nextTree());
 
-                            adaptor.addChild(root_0, root_1);
-                        }
+                }
+                stream_variantTag.reset();
+                // CTFParser.g:601:43: ( variantBody )?
+                if ( stream_variantBody.hasNext() ) {
+                    adaptor.addChild(root_1, stream_variantBody.nextTree());
 
-                    }
+                }
+                stream_variantBody.reset();
 
-                    retval.tree = root_0;
+                adaptor.addChild(root_0, root_1);
                 }
+
+            }
+
+            retval.tree = root_0;}
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 exit("variantSpecifier");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "variantSpecifier"
 
     public static class variantName_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "variantName"
-    // Grammar/CTFParser.g:603:1: variantName : IDENTIFIER -> ^( VARIANT_NAME
-    // IDENTIFIER ) ;
-    public final CTFParser.variantName_return variantName()
-            throws RecognitionException {
+    // CTFParser.g:604:1: variantName : IDENTIFIER -> ^( VARIANT_NAME IDENTIFIER ) ;
+    public final CTFParser.variantName_return variantName() throws RecognitionException {
         CTFParser.variantName_return retval = new CTFParser.variantName_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token IDENTIFIER97 = null;
+        Token IDENTIFIER97=null;
+
+        CommonTree IDENTIFIER97_tree=null;
+        RewriteRuleTokenStream stream_IDENTIFIER=new RewriteRuleTokenStream(adaptor,"token IDENTIFIER");
 
-        CommonTree IDENTIFIER97_tree = null;
-        RewriteRuleTokenStream stream_IDENTIFIER = new RewriteRuleTokenStream(
-                adaptor, "token IDENTIFIER");
 
-        enter("variantName");
+          enter("variantName");
 
         try {
-            // Grammar/CTFParser.g:611:1: ( IDENTIFIER -> ^( VARIANT_NAME
-            // IDENTIFIER ) )
-            // Grammar/CTFParser.g:612:3: IDENTIFIER
+            // CTFParser.g:612:1: ( IDENTIFIER -> ^( VARIANT_NAME IDENTIFIER ) )
+            // CTFParser.g:613:3: IDENTIFIER
             {
-                IDENTIFIER97 = (Token) match(input, IDENTIFIER,
-                        FOLLOW_IDENTIFIER_in_variantName2120);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_IDENTIFIER.add(IDENTIFIER97);
-                }
-
-                // AST REWRITE
-                // elements: IDENTIFIER
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
+            IDENTIFIER97=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_variantName2124); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_IDENTIFIER.add(IDENTIFIER97);
+            }
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 612:14: -> ^( VARIANT_NAME IDENTIFIER )
-                    {
-                        // Grammar/CTFParser.g:612:17: ^( VARIANT_NAME
-                        // IDENTIFIER )
-                        {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(adaptor
-                                    .create(VARIANT_NAME, "VARIANT_NAME"),
-                                    root_1);
 
-                            adaptor.addChild(root_1,
-                                    stream_IDENTIFIER.nextNode());
 
-                            adaptor.addChild(root_0, root_1);
-                        }
+            // AST REWRITE
+            // elements: IDENTIFIER
+            // token labels:
+            // rule labels: retval
+            // token list labels:
+            // rule list labels:
+            // wildcard labels:
+            if ( state.backtracking==0 ) {
+            retval.tree = root_0;
+            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                    }
+            root_0 = (CommonTree)adaptor.nil();
+            // 613:14: -> ^( VARIANT_NAME IDENTIFIER )
+            {
+                // CTFParser.g:613:17: ^( VARIANT_NAME IDENTIFIER )
+                {
+                CommonTree root_1 = (CommonTree)adaptor.nil();
+                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(VARIANT_NAME, "VARIANT_NAME"), root_1);
 
-                    retval.tree = root_0;
+                adaptor.addChild(root_1, stream_IDENTIFIER.nextNode());
+
+                adaptor.addChild(root_0, root_1);
                 }
+
+            }
+
+            retval.tree = root_0;}
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                debug_print(input.toString(retval.start, input.LT(-1)));
+                debug_print(input.toString(retval.start,input.LT(-1)));
                 exit("variantName");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "variantName"
 
     public static class variantBody_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "variantBody"
-    // Grammar/CTFParser.g:615:1: variantBody : LCURL
-    // structOrVariantDeclarationList RCURL -> ^( VARIANT_BODY
-    // structOrVariantDeclarationList ) ;
-    public final CTFParser.variantBody_return variantBody()
-            throws RecognitionException {
+    // CTFParser.g:616:1: variantBody : LCURL structOrVariantDeclarationList RCURL -> ^( VARIANT_BODY structOrVariantDeclarationList ) ;
+    public final CTFParser.variantBody_return variantBody() throws RecognitionException {
         Symbols_stack.push(new Symbols_scope());
 
         CTFParser.variantBody_return retval = new CTFParser.variantBody_return();
@@ -5921,106 +5155,88 @@ public class CTFParser extends Parser {
 
         CommonTree root_0 = null;
 
-        Token LCURL98 = null;
-        Token RCURL100 = null;
+        Token LCURL98=null;
+        Token RCURL100=null;
         CTFParser.structOrVariantDeclarationList_return structOrVariantDeclarationList99 = null;
 
-        CommonTree LCURL98_tree = null;
-        CommonTree RCURL100_tree = null;
-        RewriteRuleTokenStream stream_LCURL = new RewriteRuleTokenStream(
-                adaptor, "token LCURL");
-        RewriteRuleTokenStream stream_RCURL = new RewriteRuleTokenStream(
-                adaptor, "token RCURL");
-        RewriteRuleSubtreeStream stream_structOrVariantDeclarationList = new RewriteRuleSubtreeStream(
-                adaptor, "rule structOrVariantDeclarationList");
 
-        enter("variantBody");
-        debug_print("Scope push " + Symbols_stack.size());
-        ((Symbols_scope) Symbols_stack.peek()).types = new HashSet<String>();
+        CommonTree LCURL98_tree=null;
+        CommonTree RCURL100_tree=null;
+        RewriteRuleTokenStream stream_LCURL=new RewriteRuleTokenStream(adaptor,"token LCURL");
+        RewriteRuleTokenStream stream_RCURL=new RewriteRuleTokenStream(adaptor,"token RCURL");
+        RewriteRuleSubtreeStream stream_structOrVariantDeclarationList=new RewriteRuleSubtreeStream(adaptor,"rule structOrVariantDeclarationList");
+
+          enter("variantBody");
+          debug_print("Scope push " + Symbols_stack.size());
+          ((Symbols_scope)Symbols_stack.peek()).types = new HashSet<String>();
 
         try {
-            // Grammar/CTFParser.g:626:1: ( LCURL structOrVariantDeclarationList
-            // RCURL -> ^( VARIANT_BODY structOrVariantDeclarationList ) )
-            // Grammar/CTFParser.g:627:3: LCURL structOrVariantDeclarationList
-            // RCURL
+            // CTFParser.g:627:1: ( LCURL structOrVariantDeclarationList RCURL -> ^( VARIANT_BODY structOrVariantDeclarationList ) )
+            // CTFParser.g:628:3: LCURL structOrVariantDeclarationList RCURL
             {
-                LCURL98 = (Token) match(input, LCURL,
-                        FOLLOW_LCURL_in_variantBody2156);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_LCURL.add(LCURL98);
-                }
+            LCURL98=(Token)match(input,LCURL,FOLLOW_LCURL_in_variantBody2160); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_LCURL.add(LCURL98);
+            }
 
-                pushFollow(FOLLOW_structOrVariantDeclarationList_in_variantBody2158);
-                structOrVariantDeclarationList99 = structOrVariantDeclarationList();
+            pushFollow(FOLLOW_structOrVariantDeclarationList_in_variantBody2162);
+            structOrVariantDeclarationList99=structOrVariantDeclarationList();
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_structOrVariantDeclarationList
-                            .add(structOrVariantDeclarationList99.getTree());
-                }
-                RCURL100 = (Token) match(input, RCURL,
-                        FOLLOW_RCURL_in_variantBody2160);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_RCURL.add(RCURL100);
-                }
+            state._fsp--;
+            if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_structOrVariantDeclarationList.add(structOrVariantDeclarationList99.getTree());
+            }
+            RCURL100=(Token)match(input,RCURL,FOLLOW_RCURL_in_variantBody2164); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_RCURL.add(RCURL100);
+            }
 
-                // AST REWRITE
-                // elements: structOrVariantDeclarationList
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 627:46: -> ^( VARIANT_BODY structOrVariantDeclarationList
-                    // )
-                    {
-                        // Grammar/CTFParser.g:627:49: ^( VARIANT_BODY
-                        // structOrVariantDeclarationList )
-                        {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(adaptor
-                                    .create(VARIANT_BODY, "VARIANT_BODY"),
-                                    root_1);
 
-                            adaptor.addChild(root_1,
-                                    stream_structOrVariantDeclarationList
-                                            .nextTree());
+            // AST REWRITE
+            // elements: structOrVariantDeclarationList
+            // token labels:
+            // rule labels: retval
+            // token list labels:
+            // rule list labels:
+            // wildcard labels:
+            if ( state.backtracking==0 ) {
+            retval.tree = root_0;
+            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                            adaptor.addChild(root_0, root_1);
-                        }
+            root_0 = (CommonTree)adaptor.nil();
+            // 628:46: -> ^( VARIANT_BODY structOrVariantDeclarationList )
+            {
+                // CTFParser.g:628:49: ^( VARIANT_BODY structOrVariantDeclarationList )
+                {
+                CommonTree root_1 = (CommonTree)adaptor.nil();
+                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(VARIANT_BODY, "VARIANT_BODY"), root_1);
 
-                    }
+                adaptor.addChild(root_1, stream_structOrVariantDeclarationList.nextTree());
 
-                    retval.tree = root_0;
+                adaptor.addChild(root_0, root_1);
                 }
+
+            }
+
+            retval.tree = root_0;}
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 debug_print("Scope pop " + Symbols_stack.size());
                 exit("variantBody");
@@ -6028,166 +5244,140 @@ public class CTFParser extends Parser {
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-        } finally {
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
             Symbols_stack.pop();
 
         }
         return retval;
     }
-
     // $ANTLR end "variantBody"
 
     public static class variantTag_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "variantTag"
-    // Grammar/CTFParser.g:630:1: variantTag : LT IDENTIFIER GT -> ^(
-    // VARIANT_TAG IDENTIFIER ) ;
-    public final CTFParser.variantTag_return variantTag()
-            throws RecognitionException {
+    // CTFParser.g:631:1: variantTag : LT IDENTIFIER GT -> ^( VARIANT_TAG IDENTIFIER ) ;
+    public final CTFParser.variantTag_return variantTag() throws RecognitionException {
         CTFParser.variantTag_return retval = new CTFParser.variantTag_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token LT101 = null;
-        Token IDENTIFIER102 = null;
-        Token GT103 = null;
+        Token LT101=null;
+        Token IDENTIFIER102=null;
+        Token GT103=null;
 
-        CommonTree LT101_tree = null;
-        CommonTree IDENTIFIER102_tree = null;
-        CommonTree GT103_tree = null;
-        RewriteRuleTokenStream stream_GT = new RewriteRuleTokenStream(adaptor,
-                "token GT");
-        RewriteRuleTokenStream stream_LT = new RewriteRuleTokenStream(adaptor,
-                "token LT");
-        RewriteRuleTokenStream stream_IDENTIFIER = new RewriteRuleTokenStream(
-                adaptor, "token IDENTIFIER");
+        CommonTree LT101_tree=null;
+        CommonTree IDENTIFIER102_tree=null;
+        CommonTree GT103_tree=null;
+        RewriteRuleTokenStream stream_GT=new RewriteRuleTokenStream(adaptor,"token GT");
+        RewriteRuleTokenStream stream_LT=new RewriteRuleTokenStream(adaptor,"token LT");
+        RewriteRuleTokenStream stream_IDENTIFIER=new RewriteRuleTokenStream(adaptor,"token IDENTIFIER");
 
-        enter("variantTag");
+
+          enter("variantTag");
 
         try {
-            // Grammar/CTFParser.g:638:1: ( LT IDENTIFIER GT -> ^( VARIANT_TAG
-            // IDENTIFIER ) )
-            // Grammar/CTFParser.g:639:3: LT IDENTIFIER GT
+            // CTFParser.g:639:1: ( LT IDENTIFIER GT -> ^( VARIANT_TAG IDENTIFIER ) )
+            // CTFParser.g:640:3: LT IDENTIFIER GT
             {
-                LT101 = (Token) match(input, LT, FOLLOW_LT_in_variantTag2191);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_LT.add(LT101);
-                }
+            LT101=(Token)match(input,LT,FOLLOW_LT_in_variantTag2195); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_LT.add(LT101);
+            }
 
-                IDENTIFIER102 = (Token) match(input, IDENTIFIER,
-                        FOLLOW_IDENTIFIER_in_variantTag2193);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_IDENTIFIER.add(IDENTIFIER102);
-                }
+            IDENTIFIER102=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_variantTag2197); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_IDENTIFIER.add(IDENTIFIER102);
+            }
 
-                GT103 = (Token) match(input, GT, FOLLOW_GT_in_variantTag2195);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_GT.add(GT103);
-                }
+            GT103=(Token)match(input,GT,FOLLOW_GT_in_variantTag2199); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_GT.add(GT103);
+            }
 
-                // AST REWRITE
-                // elements: IDENTIFIER
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 639:20: -> ^( VARIANT_TAG IDENTIFIER )
-                    {
-                        // Grammar/CTFParser.g:639:23: ^( VARIANT_TAG IDENTIFIER
-                        // )
-                        {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(
-                                    adaptor.create(VARIANT_TAG, "VARIANT_TAG"),
-                                    root_1);
 
-                            adaptor.addChild(root_1,
-                                    stream_IDENTIFIER.nextNode());
+            // AST REWRITE
+            // elements: IDENTIFIER
+            // token labels:
+            // rule labels: retval
+            // token list labels:
+            // rule list labels:
+            // wildcard labels:
+            if ( state.backtracking==0 ) {
+            retval.tree = root_0;
+            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                            adaptor.addChild(root_0, root_1);
-                        }
+            root_0 = (CommonTree)adaptor.nil();
+            // 640:20: -> ^( VARIANT_TAG IDENTIFIER )
+            {
+                // CTFParser.g:640:23: ^( VARIANT_TAG IDENTIFIER )
+                {
+                CommonTree root_1 = (CommonTree)adaptor.nil();
+                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(VARIANT_TAG, "VARIANT_TAG"), root_1);
 
-                    }
+                adaptor.addChild(root_1, stream_IDENTIFIER.nextNode());
 
-                    retval.tree = root_0;
+                adaptor.addChild(root_0, root_1);
                 }
+
+            }
+
+            retval.tree = root_0;}
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                debug_print(input.toString(retval.start, input.LT(-1)));
+                debug_print(input.toString(retval.start,input.LT(-1)));
                 exit("variantTag");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "variantTag"
 
     public static class enumSpecifier_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "enumSpecifier"
-    // Grammar/CTFParser.g:642:1: enumSpecifier : ENUMTOK ( ( enumName (
-    // enumContainerType enumBody | enumBody | ) ) | ( enumContainerType
-    // enumBody | enumBody ) ) -> ^( ENUM ( enumName )? ( enumContainerType )? (
-    // enumBody )? ) ;
-    public final CTFParser.enumSpecifier_return enumSpecifier()
-            throws RecognitionException {
+    // CTFParser.g:643:1: enumSpecifier : ENUMTOK ( ( enumName ( enumContainerType enumBody | enumBody | ) ) | ( enumContainerType enumBody | enumBody ) ) -> ^( ENUM ( enumName )? ( enumContainerType )? ( enumBody )? ) ;
+    public final CTFParser.enumSpecifier_return enumSpecifier() throws RecognitionException {
         CTFParser.enumSpecifier_return retval = new CTFParser.enumSpecifier_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token ENUMTOK104 = null;
+        Token ENUMTOK104=null;
         CTFParser.enumName_return enumName105 = null;
 
         CTFParser.enumContainerType_return enumContainerType106 = null;
@@ -6202,867 +5392,768 @@ public class CTFParser extends Parser {
 
         CTFParser.enumBody_return enumBody111 = null;
 
-        CommonTree ENUMTOK104_tree = null;
-        RewriteRuleTokenStream stream_ENUMTOK = new RewriteRuleTokenStream(
-                adaptor, "token ENUMTOK");
-        RewriteRuleSubtreeStream stream_enumName = new RewriteRuleSubtreeStream(
-                adaptor, "rule enumName");
-        RewriteRuleSubtreeStream stream_enumContainerType = new RewriteRuleSubtreeStream(
-                adaptor, "rule enumContainerType");
-        RewriteRuleSubtreeStream stream_enumBody = new RewriteRuleSubtreeStream(
-                adaptor, "rule enumBody");
 
-        enter("enumSpecifier");
+        CommonTree ENUMTOK104_tree=null;
+        RewriteRuleTokenStream stream_ENUMTOK=new RewriteRuleTokenStream(adaptor,"token ENUMTOK");
+        RewriteRuleSubtreeStream stream_enumName=new RewriteRuleSubtreeStream(adaptor,"rule enumName");
+        RewriteRuleSubtreeStream stream_enumContainerType=new RewriteRuleSubtreeStream(adaptor,"rule enumContainerType");
+        RewriteRuleSubtreeStream stream_enumBody=new RewriteRuleSubtreeStream(adaptor,"rule enumBody");
+
+          enter("enumSpecifier");
 
         try {
-            // Grammar/CTFParser.g:649:1: ( ENUMTOK ( ( enumName (
-            // enumContainerType enumBody | enumBody | ) ) | ( enumContainerType
-            // enumBody | enumBody ) ) -> ^( ENUM ( enumName )? (
-            // enumContainerType )? ( enumBody )? ) )
-            // Grammar/CTFParser.g:650:2: ENUMTOK ( ( enumName (
-            // enumContainerType enumBody | enumBody | ) ) | ( enumContainerType
-            // enumBody | enumBody ) )
+            // CTFParser.g:650:1: ( ENUMTOK ( ( enumName ( enumContainerType enumBody | enumBody | ) ) | ( enumContainerType enumBody | enumBody ) ) -> ^( ENUM ( enumName )? ( enumContainerType )? ( enumBody )? ) )
+            // CTFParser.g:651:2: ENUMTOK ( ( enumName ( enumContainerType enumBody | enumBody | ) ) | ( enumContainerType enumBody | enumBody ) )
             {
-                ENUMTOK104 = (Token) match(input, ENUMTOK,
-                        FOLLOW_ENUMTOK_in_enumSpecifier2225);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_ENUMTOK.add(ENUMTOK104);
-                }
-
-                // Grammar/CTFParser.g:651:2: ( ( enumName ( enumContainerType
-                // enumBody | enumBody | ) ) | ( enumContainerType enumBody |
-                // enumBody ) )
-                int alt34 = 2;
-                int LA34_0 = input.LA(1);
-
-                if ((LA34_0 == IDENTIFIER)) {
-                    alt34 = 1;
-                } else if (((LA34_0 == COLON) || (LA34_0 == LCURL))) {
-                    alt34 = 2;
-                } else {
-                    if (state.backtracking > 0) {
-                        state.failed = true;
-                        return retval;
-                    }
-                    NoViableAltException nvae = new NoViableAltException("",
-                            34, 0, input);
+            ENUMTOK104=(Token)match(input,ENUMTOK,FOLLOW_ENUMTOK_in_enumSpecifier2229); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_ENUMTOK.add(ENUMTOK104);
+            }
 
-                    throw nvae;
-                }
-                switch (alt34) {
-                case 1:
-                // Grammar/CTFParser.g:653:3: ( enumName ( enumContainerType
-                // enumBody | enumBody | ) )
-                {
-                    // Grammar/CTFParser.g:653:3: ( enumName ( enumContainerType
-                    // enumBody | enumBody | ) )
-                    // Grammar/CTFParser.g:654:4: enumName ( enumContainerType
-                    // enumBody | enumBody | )
+            // CTFParser.g:652:2: ( ( enumName ( enumContainerType enumBody | enumBody | ) ) | ( enumContainerType enumBody | enumBody ) )
+            int alt34=2;
+            int LA34_0 = input.LA(1);
+
+            if ( (LA34_0==IDENTIFIER) ) {
+                alt34=1;
+            }
+            else if ( (LA34_0==COLON||LA34_0==LCURL) ) {
+                alt34=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return retval;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 34, 0, input);
+
+                throw nvae;
+            }
+            switch (alt34) {
+                case 1 :
+                    // CTFParser.g:654:3: ( enumName ( enumContainerType enumBody | enumBody | ) )
+                    {
+                    // CTFParser.g:654:3: ( enumName ( enumContainerType enumBody | enumBody | ) )
+                    // CTFParser.g:655:4: enumName ( enumContainerType enumBody | enumBody | )
                     {
-                        pushFollow(FOLLOW_enumName_in_enumSpecifier2240);
-                        enumName105 = enumName();
+                    pushFollow(FOLLOW_enumName_in_enumSpecifier2244);
+                    enumName105=enumName();
 
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_enumName.add(enumName105.getTree());
-                        }
-                        // Grammar/CTFParser.g:655:4: ( enumContainerType
-                        // enumBody | enumBody | )
-                        int alt32 = 3;
-                        alt32 = dfa32.predict(input);
-                        switch (alt32) {
-                        case 1:
-                        // Grammar/CTFParser.g:656:5: enumContainerType enumBody
-                        {
-                            pushFollow(FOLLOW_enumContainerType_in_enumSpecifier2251);
-                            enumContainerType106 = enumContainerType();
+                    state._fsp--;
+                    if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        stream_enumName.add(enumName105.getTree());
+                    }
+                    // CTFParser.g:656:4: ( enumContainerType enumBody | enumBody | )
+                    int alt32=3;
+                    alt32 = dfa32.predict(input);
+                    switch (alt32) {
+                        case 1 :
+                            // CTFParser.g:657:5: enumContainerType enumBody
+                            {
+                            pushFollow(FOLLOW_enumContainerType_in_enumSpecifier2255);
+                            enumContainerType106=enumContainerType();
 
                             state._fsp--;
                             if (state.failed) {
                                 return retval;
                             }
-                            if (state.backtracking == 0) {
-                                stream_enumContainerType
-                                        .add(enumContainerType106.getTree());
+                            if ( state.backtracking==0 ) {
+                                stream_enumContainerType.add(enumContainerType106.getTree());
                             }
-                            pushFollow(FOLLOW_enumBody_in_enumSpecifier2253);
-                            enumBody107 = enumBody();
+                            pushFollow(FOLLOW_enumBody_in_enumSpecifier2257);
+                            enumBody107=enumBody();
 
                             state._fsp--;
                             if (state.failed) {
                                 return retval;
                             }
-                            if (state.backtracking == 0) {
+                            if ( state.backtracking==0 ) {
                                 stream_enumBody.add(enumBody107.getTree());
                             }
 
-                        }
+                            }
                             break;
-                        case 2:
-                        // Grammar/CTFParser.g:658:5: enumBody
-                        {
-                            pushFollow(FOLLOW_enumBody_in_enumSpecifier2265);
-                            enumBody108 = enumBody();
+                        case 2 :
+                            // CTFParser.g:659:5: enumBody
+                            {
+                            pushFollow(FOLLOW_enumBody_in_enumSpecifier2269);
+                            enumBody108=enumBody();
 
                             state._fsp--;
                             if (state.failed) {
                                 return retval;
                             }
-                            if (state.backtracking == 0) {
+                            if ( state.backtracking==0 ) {
                                 stream_enumBody.add(enumBody108.getTree());
                             }
 
-                        }
+                            }
                             break;
-                        case 3:
+                        case 3 :
+                            // CTFParser.g:662:4:
+                            {
+                            }
                             break;
-                        }
+
+                    }
+
+
+                    }
+
+
                     }
-                }
                     break;
-                case 2:
-                // Grammar/CTFParser.g:665:3: ( enumContainerType enumBody |
-                // enumBody )
-                {
-                    // Grammar/CTFParser.g:665:3: ( enumContainerType enumBody |
-                    // enumBody )
-                    int alt33 = 2;
+                case 2 :
+                    // CTFParser.g:666:3: ( enumContainerType enumBody | enumBody )
+                    {
+                    // CTFParser.g:666:3: ( enumContainerType enumBody | enumBody )
+                    int alt33=2;
                     int LA33_0 = input.LA(1);
 
-                    if ((LA33_0 == COLON)) {
-                        alt33 = 1;
-                    } else if ((LA33_0 == LCURL)) {
-                        alt33 = 2;
-                    } else {
-                        if (state.backtracking > 0) {
-                            state.failed = true;
-                            return retval;
-                        }
-                        NoViableAltException nvae = new NoViableAltException(
-                                "", 33, 0, input);
+                    if ( (LA33_0==COLON) ) {
+                        alt33=1;
+                    }
+                    else if ( (LA33_0==LCURL) ) {
+                        alt33=2;
+                    }
+                    else {
+                        if (state.backtracking>0) {state.failed=true; return retval;}
+                        NoViableAltException nvae =
+                            new NoViableAltException("", 33, 0, input);
 
                         throw nvae;
                     }
                     switch (alt33) {
-                    case 1:
-                    // Grammar/CTFParser.g:666:4: enumContainerType enumBody
-                    {
-                        pushFollow(FOLLOW_enumContainerType_in_enumSpecifier2300);
-                        enumContainerType109 = enumContainerType();
+                        case 1 :
+                            // CTFParser.g:667:4: enumContainerType enumBody
+                            {
+                            pushFollow(FOLLOW_enumContainerType_in_enumSpecifier2304);
+                            enumContainerType109=enumContainerType();
 
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_enumContainerType.add(enumContainerType109
-                                    .getTree());
-                        }
-                        pushFollow(FOLLOW_enumBody_in_enumSpecifier2302);
-                        enumBody110 = enumBody();
+                            state._fsp--;
+                            if (state.failed) {
+                                return retval;
+                            }
+                            if ( state.backtracking==0 ) {
+                                stream_enumContainerType.add(enumContainerType109.getTree());
+                            }
+                            pushFollow(FOLLOW_enumBody_in_enumSpecifier2306);
+                            enumBody110=enumBody();
 
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_enumBody.add(enumBody110.getTree());
-                        }
+                            state._fsp--;
+                            if (state.failed) {
+                                return retval;
+                            }
+                            if ( state.backtracking==0 ) {
+                                stream_enumBody.add(enumBody110.getTree());
+                            }
 
-                    }
-                        break;
-                    case 2:
-                    // Grammar/CTFParser.g:668:4: enumBody
-                    {
-                        pushFollow(FOLLOW_enumBody_in_enumSpecifier2311);
-                        enumBody111 = enumBody();
+                            }
+                            break;
+                        case 2 :
+                            // CTFParser.g:669:4: enumBody
+                            {
+                            pushFollow(FOLLOW_enumBody_in_enumSpecifier2315);
+                            enumBody111=enumBody();
 
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_enumBody.add(enumBody111.getTree());
-                        }
+                            state._fsp--;
+                            if (state.failed) {
+                                return retval;
+                            }
+                            if ( state.backtracking==0 ) {
+                                stream_enumBody.add(enumBody111.getTree());
+                            }
 
-                    }
-                        break;
+                            }
+                            break;
 
                     }
 
-                }
+
+                    }
                     break;
 
-                }
+            }
 
-                // AST REWRITE
-                // elements: enumContainerType, enumName, enumBody
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 670:4: -> ^( ENUM ( enumName )? ( enumContainerType )? (
-                    // enumBody )? )
-                    {
-                        // Grammar/CTFParser.g:670:7: ^( ENUM ( enumName )? (
-                        // enumContainerType )? ( enumBody )? )
-                        {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(
-                                    adaptor.create(ENUM, "ENUM"), root_1);
 
-                            // Grammar/CTFParser.g:670:14: ( enumName )?
-                            if (stream_enumName.hasNext()) {
-                                adaptor.addChild(root_1,
-                                        stream_enumName.nextTree());
+            // AST REWRITE
+            // elements: enumBody, enumContainerType, enumName
+            // token labels:
+            // rule labels: retval
+            // token list labels:
+            // rule list labels:
+            // wildcard labels:
+            if ( state.backtracking==0 ) {
+            retval.tree = root_0;
+            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                            }
-                            stream_enumName.reset();
-                            // Grammar/CTFParser.g:670:24: ( enumContainerType
-                            // )?
-                            if (stream_enumContainerType.hasNext()) {
-                                adaptor.addChild(root_1,
-                                        stream_enumContainerType.nextTree());
+            root_0 = (CommonTree)adaptor.nil();
+            // 671:4: -> ^( ENUM ( enumName )? ( enumContainerType )? ( enumBody )? )
+            {
+                // CTFParser.g:671:7: ^( ENUM ( enumName )? ( enumContainerType )? ( enumBody )? )
+                {
+                CommonTree root_1 = (CommonTree)adaptor.nil();
+                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ENUM, "ENUM"), root_1);
 
-                            }
-                            stream_enumContainerType.reset();
-                            // Grammar/CTFParser.g:670:43: ( enumBody )?
-                            if (stream_enumBody.hasNext()) {
-                                adaptor.addChild(root_1,
-                                        stream_enumBody.nextTree());
+                // CTFParser.g:671:14: ( enumName )?
+                if ( stream_enumName.hasNext() ) {
+                    adaptor.addChild(root_1, stream_enumName.nextTree());
 
-                            }
-                            stream_enumBody.reset();
+                }
+                stream_enumName.reset();
+                // CTFParser.g:671:24: ( enumContainerType )?
+                if ( stream_enumContainerType.hasNext() ) {
+                    adaptor.addChild(root_1, stream_enumContainerType.nextTree());
 
-                            adaptor.addChild(root_0, root_1);
-                        }
+                }
+                stream_enumContainerType.reset();
+                // CTFParser.g:671:43: ( enumBody )?
+                if ( stream_enumBody.hasNext() ) {
+                    adaptor.addChild(root_1, stream_enumBody.nextTree());
 
-                    }
+                }
+                stream_enumBody.reset();
 
-                    retval.tree = root_0;
+                adaptor.addChild(root_0, root_1);
                 }
+
+            }
+
+            retval.tree = root_0;}
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 exit("enumSpecifier");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "enumSpecifier"
 
     public static class enumName_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "enumName"
-    // Grammar/CTFParser.g:673:1: enumName : IDENTIFIER -> ^( ENUM_NAME
-    // IDENTIFIER ) ;
-    public final CTFParser.enumName_return enumName()
-            throws RecognitionException {
+    // CTFParser.g:674:1: enumName : IDENTIFIER -> ^( ENUM_NAME IDENTIFIER ) ;
+    public final CTFParser.enumName_return enumName() throws RecognitionException {
         CTFParser.enumName_return retval = new CTFParser.enumName_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token IDENTIFIER112 = null;
+        Token IDENTIFIER112=null;
+
+        CommonTree IDENTIFIER112_tree=null;
+        RewriteRuleTokenStream stream_IDENTIFIER=new RewriteRuleTokenStream(adaptor,"token IDENTIFIER");
 
-        CommonTree IDENTIFIER112_tree = null;
-        RewriteRuleTokenStream stream_IDENTIFIER = new RewriteRuleTokenStream(
-                adaptor, "token IDENTIFIER");
 
-        enter("enumName");
+          enter("enumName");
 
         try {
-            // Grammar/CTFParser.g:681:1: ( IDENTIFIER -> ^( ENUM_NAME
-            // IDENTIFIER ) )
-            // Grammar/CTFParser.g:682:3: IDENTIFIER
+            // CTFParser.g:682:1: ( IDENTIFIER -> ^( ENUM_NAME IDENTIFIER ) )
+            // CTFParser.g:683:3: IDENTIFIER
             {
-                IDENTIFIER112 = (Token) match(input, IDENTIFIER,
-                        FOLLOW_IDENTIFIER_in_enumName2356);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_IDENTIFIER.add(IDENTIFIER112);
-                }
-
-                // AST REWRITE
-                // elements: IDENTIFIER
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
+            IDENTIFIER112=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_enumName2360); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_IDENTIFIER.add(IDENTIFIER112);
+            }
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 682:14: -> ^( ENUM_NAME IDENTIFIER )
-                    {
-                        // Grammar/CTFParser.g:682:17: ^( ENUM_NAME IDENTIFIER )
-                        {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(
-                                    adaptor.create(ENUM_NAME, "ENUM_NAME"),
-                                    root_1);
 
-                            adaptor.addChild(root_1,
-                                    stream_IDENTIFIER.nextNode());
 
-                            adaptor.addChild(root_0, root_1);
-                        }
+            // AST REWRITE
+            // elements: IDENTIFIER
+            // token labels:
+            // rule labels: retval
+            // token list labels:
+            // rule list labels:
+            // wildcard labels:
+            if ( state.backtracking==0 ) {
+            retval.tree = root_0;
+            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                    }
+            root_0 = (CommonTree)adaptor.nil();
+            // 683:14: -> ^( ENUM_NAME IDENTIFIER )
+            {
+                // CTFParser.g:683:17: ^( ENUM_NAME IDENTIFIER )
+                {
+                CommonTree root_1 = (CommonTree)adaptor.nil();
+                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ENUM_NAME, "ENUM_NAME"), root_1);
 
-                    retval.tree = root_0;
+                adaptor.addChild(root_1, stream_IDENTIFIER.nextNode());
+
+                adaptor.addChild(root_0, root_1);
                 }
+
+            }
+
+            retval.tree = root_0;}
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                debug_print(input.toString(retval.start, input.LT(-1)));
+                debug_print(input.toString(retval.start,input.LT(-1)));
                 exit("enumName");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "enumName"
 
     public static class enumBody_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "enumBody"
-    // Grammar/CTFParser.g:685:1: enumBody : LCURL enumeratorList ( SEPARATOR
-    // RCURL | RCURL ) -> ^( ENUM_BODY enumeratorList ) ;
-    public final CTFParser.enumBody_return enumBody()
-            throws RecognitionException {
+    // CTFParser.g:686:1: enumBody : LCURL enumeratorList ( SEPARATOR RCURL | RCURL ) -> ^( ENUM_BODY enumeratorList ) ;
+    public final CTFParser.enumBody_return enumBody() throws RecognitionException {
         CTFParser.enumBody_return retval = new CTFParser.enumBody_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token LCURL113 = null;
-        Token SEPARATOR115 = null;
-        Token RCURL116 = null;
-        Token RCURL117 = null;
+        Token LCURL113=null;
+        Token SEPARATOR115=null;
+        Token RCURL116=null;
+        Token RCURL117=null;
         CTFParser.enumeratorList_return enumeratorList114 = null;
 
-        CommonTree LCURL113_tree = null;
-        CommonTree SEPARATOR115_tree = null;
-        CommonTree RCURL116_tree = null;
-        CommonTree RCURL117_tree = null;
-        RewriteRuleTokenStream stream_LCURL = new RewriteRuleTokenStream(
-                adaptor, "token LCURL");
-        RewriteRuleTokenStream stream_SEPARATOR = new RewriteRuleTokenStream(
-                adaptor, "token SEPARATOR");
-        RewriteRuleTokenStream stream_RCURL = new RewriteRuleTokenStream(
-                adaptor, "token RCURL");
-        RewriteRuleSubtreeStream stream_enumeratorList = new RewriteRuleSubtreeStream(
-                adaptor, "rule enumeratorList");
-
-        enter("enumBody");
+
+        CommonTree LCURL113_tree=null;
+        CommonTree SEPARATOR115_tree=null;
+        CommonTree RCURL116_tree=null;
+        CommonTree RCURL117_tree=null;
+        RewriteRuleTokenStream stream_LCURL=new RewriteRuleTokenStream(adaptor,"token LCURL");
+        RewriteRuleTokenStream stream_SEPARATOR=new RewriteRuleTokenStream(adaptor,"token SEPARATOR");
+        RewriteRuleTokenStream stream_RCURL=new RewriteRuleTokenStream(adaptor,"token RCURL");
+        RewriteRuleSubtreeStream stream_enumeratorList=new RewriteRuleSubtreeStream(adaptor,"rule enumeratorList");
+
+          enter("enumBody");
 
         try {
-            // Grammar/CTFParser.g:692:1: ( LCURL enumeratorList ( SEPARATOR
-            // RCURL | RCURL ) -> ^( ENUM_BODY enumeratorList ) )
-            // Grammar/CTFParser.g:693:3: LCURL enumeratorList ( SEPARATOR RCURL
-            // | RCURL )
+            // CTFParser.g:693:1: ( LCURL enumeratorList ( SEPARATOR RCURL | RCURL ) -> ^( ENUM_BODY enumeratorList ) )
+            // CTFParser.g:694:3: LCURL enumeratorList ( SEPARATOR RCURL | RCURL )
             {
-                LCURL113 = (Token) match(input, LCURL,
-                        FOLLOW_LCURL_in_enumBody2389);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_LCURL.add(LCURL113);
-                }
+            LCURL113=(Token)match(input,LCURL,FOLLOW_LCURL_in_enumBody2393); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_LCURL.add(LCURL113);
+            }
 
-                pushFollow(FOLLOW_enumeratorList_in_enumBody2391);
-                enumeratorList114 = enumeratorList();
+            pushFollow(FOLLOW_enumeratorList_in_enumBody2395);
+            enumeratorList114=enumeratorList();
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_enumeratorList.add(enumeratorList114.getTree());
-                }
-                // Grammar/CTFParser.g:693:24: ( SEPARATOR RCURL | RCURL )
-                int alt35 = 2;
-                int LA35_0 = input.LA(1);
+            state._fsp--;
+            if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_enumeratorList.add(enumeratorList114.getTree());
+            }
+            // CTFParser.g:694:24: ( SEPARATOR RCURL | RCURL )
+            int alt35=2;
+            int LA35_0 = input.LA(1);
 
-                if ((LA35_0 == SEPARATOR)) {
-                    alt35 = 1;
-                } else if ((LA35_0 == RCURL)) {
-                    alt35 = 2;
-                } else {
-                    if (state.backtracking > 0) {
-                        state.failed = true;
-                        return retval;
-                    }
-                    NoViableAltException nvae = new NoViableAltException("",
-                            35, 0, input);
+            if ( (LA35_0==SEPARATOR) ) {
+                alt35=1;
+            }
+            else if ( (LA35_0==RCURL) ) {
+                alt35=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return retval;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 35, 0, input);
 
-                    throw nvae;
-                }
-                switch (alt35) {
-                case 1:
-                // Grammar/CTFParser.g:693:25: SEPARATOR RCURL
-                {
-                    SEPARATOR115 = (Token) match(input, SEPARATOR,
-                            FOLLOW_SEPARATOR_in_enumBody2394);
-                    if (state.failed) {
+                throw nvae;
+            }
+            switch (alt35) {
+                case 1 :
+                    // CTFParser.g:694:25: SEPARATOR RCURL
+                    {
+                    SEPARATOR115=(Token)match(input,SEPARATOR,FOLLOW_SEPARATOR_in_enumBody2398); if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
+                    if ( state.backtracking==0 ) {
                         stream_SEPARATOR.add(SEPARATOR115);
                     }
 
-                    RCURL116 = (Token) match(input, RCURL,
-                            FOLLOW_RCURL_in_enumBody2396);
-                    if (state.failed) {
+                    RCURL116=(Token)match(input,RCURL,FOLLOW_RCURL_in_enumBody2400); if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
+                    if ( state.backtracking==0 ) {
                         stream_RCURL.add(RCURL116);
                     }
 
-                }
+
+                    }
                     break;
-                case 2:
-                // Grammar/CTFParser.g:693:43: RCURL
-                {
-                    RCURL117 = (Token) match(input, RCURL,
-                            FOLLOW_RCURL_in_enumBody2400);
-                    if (state.failed) {
+                case 2 :
+                    // CTFParser.g:694:43: RCURL
+                    {
+                    RCURL117=(Token)match(input,RCURL,FOLLOW_RCURL_in_enumBody2404); if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
+                    if ( state.backtracking==0 ) {
                         stream_RCURL.add(RCURL117);
                     }
 
-                }
+
+                    }
                     break;
 
-                }
+            }
 
-                // AST REWRITE
-                // elements: enumeratorList
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 693:50: -> ^( ENUM_BODY enumeratorList )
-                    {
-                        // Grammar/CTFParser.g:693:53: ^( ENUM_BODY
-                        // enumeratorList )
-                        {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(
-                                    adaptor.create(ENUM_BODY, "ENUM_BODY"),
-                                    root_1);
 
-                            adaptor.addChild(root_1,
-                                    stream_enumeratorList.nextTree());
+            // AST REWRITE
+            // elements: enumeratorList
+            // token labels:
+            // rule labels: retval
+            // token list labels:
+            // rule list labels:
+            // wildcard labels:
+            if ( state.backtracking==0 ) {
+            retval.tree = root_0;
+            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                            adaptor.addChild(root_0, root_1);
-                        }
+            root_0 = (CommonTree)adaptor.nil();
+            // 694:50: -> ^( ENUM_BODY enumeratorList )
+            {
+                // CTFParser.g:694:53: ^( ENUM_BODY enumeratorList )
+                {
+                CommonTree root_1 = (CommonTree)adaptor.nil();
+                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ENUM_BODY, "ENUM_BODY"), root_1);
 
-                    }
+                adaptor.addChild(root_1, stream_enumeratorList.nextTree());
 
-                    retval.tree = root_0;
+                adaptor.addChild(root_0, root_1);
                 }
+
+            }
+
+            retval.tree = root_0;}
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 exit("enumBody");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "enumBody"
 
     public static class enumContainerType_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "enumContainerType"
-    // Grammar/CTFParser.g:696:1: enumContainerType : COLON
-    // declarationSpecifiers -> ^( ENUM_CONTAINER_TYPE declarationSpecifiers ) ;
-    public final CTFParser.enumContainerType_return enumContainerType()
-            throws RecognitionException {
+    // CTFParser.g:697:1: enumContainerType : COLON declarationSpecifiers -> ^( ENUM_CONTAINER_TYPE declarationSpecifiers ) ;
+    public final CTFParser.enumContainerType_return enumContainerType() throws RecognitionException {
         CTFParser.enumContainerType_return retval = new CTFParser.enumContainerType_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token COLON118 = null;
+        Token COLON118=null;
         CTFParser.declarationSpecifiers_return declarationSpecifiers119 = null;
 
-        CommonTree COLON118_tree = null;
-        RewriteRuleTokenStream stream_COLON = new RewriteRuleTokenStream(
-                adaptor, "token COLON");
-        RewriteRuleSubtreeStream stream_declarationSpecifiers = new RewriteRuleSubtreeStream(
-                adaptor, "rule declarationSpecifiers");
 
-        enter("enumContainerType");
+        CommonTree COLON118_tree=null;
+        RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON");
+        RewriteRuleSubtreeStream stream_declarationSpecifiers=new RewriteRuleSubtreeStream(adaptor,"rule declarationSpecifiers");
+
+          enter("enumContainerType");
 
         try {
-            // Grammar/CTFParser.g:703:1: ( COLON declarationSpecifiers -> ^(
-            // ENUM_CONTAINER_TYPE declarationSpecifiers ) )
-            // Grammar/CTFParser.g:704:3: COLON declarationSpecifiers
+            // CTFParser.g:704:1: ( COLON declarationSpecifiers -> ^( ENUM_CONTAINER_TYPE declarationSpecifiers ) )
+            // CTFParser.g:705:3: COLON declarationSpecifiers
             {
-                COLON118 = (Token) match(input, COLON,
-                        FOLLOW_COLON_in_enumContainerType2432);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_COLON.add(COLON118);
-                }
-
-                pushFollow(FOLLOW_declarationSpecifiers_in_enumContainerType2434);
-                declarationSpecifiers119 = declarationSpecifiers();
+            COLON118=(Token)match(input,COLON,FOLLOW_COLON_in_enumContainerType2436); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_COLON.add(COLON118);
+            }
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_declarationSpecifiers.add(declarationSpecifiers119
-                            .getTree());
-                }
+            pushFollow(FOLLOW_declarationSpecifiers_in_enumContainerType2438);
+            declarationSpecifiers119=declarationSpecifiers();
 
-                // AST REWRITE
-                // elements: declarationSpecifiers
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
+            state._fsp--;
+            if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_declarationSpecifiers.add(declarationSpecifiers119.getTree());
+            }
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 704:31: -> ^( ENUM_CONTAINER_TYPE declarationSpecifiers )
-                    {
-                        // Grammar/CTFParser.g:704:34: ^( ENUM_CONTAINER_TYPE
-                        // declarationSpecifiers )
-                        {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(adaptor
-                                    .create(ENUM_CONTAINER_TYPE,
-                                            "ENUM_CONTAINER_TYPE"), root_1);
 
-                            adaptor.addChild(root_1,
-                                    stream_declarationSpecifiers.nextTree());
+            // AST REWRITE
+            // elements: declarationSpecifiers
+            // token labels:
+            // rule labels: retval
+            // token list labels:
+            // rule list labels:
+            // wildcard labels:
+            if ( state.backtracking==0 ) {
+            retval.tree = root_0;
+            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                            adaptor.addChild(root_0, root_1);
-                        }
+            root_0 = (CommonTree)adaptor.nil();
+            // 705:31: -> ^( ENUM_CONTAINER_TYPE declarationSpecifiers )
+            {
+                // CTFParser.g:705:34: ^( ENUM_CONTAINER_TYPE declarationSpecifiers )
+                {
+                CommonTree root_1 = (CommonTree)adaptor.nil();
+                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ENUM_CONTAINER_TYPE, "ENUM_CONTAINER_TYPE"), root_1);
 
-                    }
+                adaptor.addChild(root_1, stream_declarationSpecifiers.nextTree());
 
-                    retval.tree = root_0;
+                adaptor.addChild(root_0, root_1);
                 }
+
+            }
+
+            retval.tree = root_0;}
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 exit("enumContainerType");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "enumContainerType"
 
     public static class enumeratorList_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "enumeratorList"
-    // Grammar/CTFParser.g:707:1: enumeratorList : enumerator ( SEPARATOR
-    // enumerator )* -> ( ^( ENUM_ENUMERATOR enumerator ) )+ ;
-    public final CTFParser.enumeratorList_return enumeratorList()
-            throws RecognitionException {
+    // CTFParser.g:708:1: enumeratorList : enumerator ( SEPARATOR enumerator )* -> ( ^( ENUM_ENUMERATOR enumerator ) )+ ;
+    public final CTFParser.enumeratorList_return enumeratorList() throws RecognitionException {
         CTFParser.enumeratorList_return retval = new CTFParser.enumeratorList_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token SEPARATOR121 = null;
+        Token SEPARATOR121=null;
         CTFParser.enumerator_return enumerator120 = null;
 
         CTFParser.enumerator_return enumerator122 = null;
 
-        CommonTree SEPARATOR121_tree = null;
-        RewriteRuleTokenStream stream_SEPARATOR = new RewriteRuleTokenStream(
-                adaptor, "token SEPARATOR");
-        RewriteRuleSubtreeStream stream_enumerator = new RewriteRuleSubtreeStream(
-                adaptor, "rule enumerator");
 
-        enter("enumeratorList");
+        CommonTree SEPARATOR121_tree=null;
+        RewriteRuleTokenStream stream_SEPARATOR=new RewriteRuleTokenStream(adaptor,"token SEPARATOR");
+        RewriteRuleSubtreeStream stream_enumerator=new RewriteRuleSubtreeStream(adaptor,"rule enumerator");
+
+          enter("enumeratorList");
 
         try {
-            // Grammar/CTFParser.g:714:1: ( enumerator ( SEPARATOR enumerator )*
-            // -> ( ^( ENUM_ENUMERATOR enumerator ) )+ )
-            // Grammar/CTFParser.g:715:3: enumerator ( SEPARATOR enumerator )*
+            // CTFParser.g:715:1: ( enumerator ( SEPARATOR enumerator )* -> ( ^( ENUM_ENUMERATOR enumerator ) )+ )
+            // CTFParser.g:716:3: enumerator ( SEPARATOR enumerator )*
             {
-                pushFollow(FOLLOW_enumerator_in_enumeratorList2465);
-                enumerator120 = enumerator();
+            pushFollow(FOLLOW_enumerator_in_enumeratorList2469);
+            enumerator120=enumerator();
+
+            state._fsp--;
+            if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_enumerator.add(enumerator120.getTree());
+            }
+            // CTFParser.g:716:14: ( SEPARATOR enumerator )*
+            loop36:
+            do {
+                int alt36=2;
+                int LA36_0 = input.LA(1);
+
+                if ( (LA36_0==SEPARATOR) ) {
+                    int LA36_1 = input.LA(2);
+
+                    if ( (LA36_1==ALIGNTOK||LA36_1==EVENTTOK||LA36_1==SIGNEDTOK||LA36_1==STRINGTOK||LA36_1==STRING_LITERAL||LA36_1==IDENTIFIER) ) {
+                        alt36=1;
+                    }
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_enumerator.add(enumerator120.getTree());
-                }
-                // Grammar/CTFParser.g:715:14: ( SEPARATOR enumerator )*
-                loop36: do {
-                    int alt36 = 2;
-                    int LA36_0 = input.LA(1);
 
-                    if ((LA36_0 == SEPARATOR)) {
-                        int LA36_1 = input.LA(2);
+                }
 
-                        if (((LA36_1 == ALIGNTOK) || (LA36_1 == EVENTTOK)
-                                || (LA36_1 == SIGNEDTOK)
-                                || (LA36_1 == STRINGTOK)
-                                || (LA36_1 == STRING_LITERAL) || (LA36_1 == IDENTIFIER))) {
-                            alt36 = 1;
-                        }
 
+                switch (alt36) {
+               case 1 :
+                   // CTFParser.g:716:15: SEPARATOR enumerator
+                   {
+                   SEPARATOR121=(Token)match(input,SEPARATOR,FOLLOW_SEPARATOR_in_enumeratorList2472); if (state.failed) {
+                        return retval;
+                    }
+                   if ( state.backtracking==0 ) {
+                        stream_SEPARATOR.add(SEPARATOR121);
                     }
 
-                    switch (alt36) {
-                    case 1:
-                    // Grammar/CTFParser.g:715:15: SEPARATOR enumerator
-                    {
-                        SEPARATOR121 = (Token) match(input, SEPARATOR,
-                                FOLLOW_SEPARATOR_in_enumeratorList2468);
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_SEPARATOR.add(SEPARATOR121);
-                        }
+                   pushFollow(FOLLOW_enumerator_in_enumeratorList2474);
+                   enumerator122=enumerator();
 
-                        pushFollow(FOLLOW_enumerator_in_enumeratorList2470);
-                        enumerator122 = enumerator();
+                   state._fsp--;
+                   if (state.failed) {
+                        return retval;
+                    }
+                   if ( state.backtracking==0 ) {
+                        stream_enumerator.add(enumerator122.getTree());
+                    }
 
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_enumerator.add(enumerator122.getTree());
-                        }
+                   }
+                   break;
 
-                    }
-                        break;
+               default :
+                   break loop36;
+                }
+            } while (true);
 
-                    default:
-                        break loop36;
-                    }
-                } while (true);
-
-                // AST REWRITE
-                // elements: enumerator
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 715:38: -> ( ^( ENUM_ENUMERATOR enumerator ) )+
-                    {
-                        if (!(stream_enumerator.hasNext())) {
-                            throw new RewriteEarlyExitException();
-                        }
-                        while (stream_enumerator.hasNext()) {
-                            // Grammar/CTFParser.g:715:42: ^( ENUM_ENUMERATOR
-                            // enumerator )
-                            {
-                                CommonTree root_1 = (CommonTree) adaptor.nil();
-                                root_1 = (CommonTree) adaptor.becomeRoot(
-                                        adaptor.create(ENUM_ENUMERATOR,
-                                                "ENUM_ENUMERATOR"), root_1);
 
-                                adaptor.addChild(root_1,
-                                        stream_enumerator.nextTree());
+            // AST REWRITE
+            // elements: enumerator
+            // token labels:
+            // rule labels: retval
+            // token list labels:
+            // rule list labels:
+            // wildcard labels:
+            if ( state.backtracking==0 ) {
+            retval.tree = root_0;
+            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                                adaptor.addChild(root_0, root_1);
-                            }
+            root_0 = (CommonTree)adaptor.nil();
+            // 716:38: -> ( ^( ENUM_ENUMERATOR enumerator ) )+
+            {
+                if ( !(stream_enumerator.hasNext()) ) {
+                    throw new RewriteEarlyExitException();
+                }
+                while ( stream_enumerator.hasNext() ) {
+                    // CTFParser.g:716:42: ^( ENUM_ENUMERATOR enumerator )
+                    {
+                    CommonTree root_1 = (CommonTree)adaptor.nil();
+                    root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ENUM_ENUMERATOR, "ENUM_ENUMERATOR"), root_1);
 
-                        }
-                        stream_enumerator.reset();
+                    adaptor.addChild(root_1, stream_enumerator.nextTree());
 
+                    adaptor.addChild(root_0, root_1);
                     }
 
-                    retval.tree = root_0;
                 }
+                stream_enumerator.reset();
+
+            }
+
+            retval.tree = root_0;}
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 exit("enumeratorList");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "enumeratorList"
 
     public static class enumerator_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "enumerator"
-    // Grammar/CTFParser.g:718:1: enumerator : enumConstant ( enumeratorValue )?
-    // ;
-    public final CTFParser.enumerator_return enumerator()
-            throws RecognitionException {
+    // CTFParser.g:719:1: enumerator : enumConstant ( enumeratorValue )? ;
+    public final CTFParser.enumerator_return enumerator() throws RecognitionException {
         CTFParser.enumerator_return retval = new CTFParser.enumerator_return();
         retval.start = input.LT(1);
 
@@ -7072,164 +6163,151 @@ public class CTFParser extends Parser {
 
         CTFParser.enumeratorValue_return enumeratorValue124 = null;
 
-        enter("enumerator");
+
+
+
+          enter("enumerator");
 
         try {
-            // Grammar/CTFParser.g:725:1: ( enumConstant ( enumeratorValue )? )
-            // Grammar/CTFParser.g:726:3: enumConstant ( enumeratorValue )?
+            // CTFParser.g:726:1: ( enumConstant ( enumeratorValue )? )
+            // CTFParser.g:727:3: enumConstant ( enumeratorValue )?
             {
-                root_0 = (CommonTree) adaptor.nil();
+            root_0 = (CommonTree)adaptor.nil();
 
-                pushFollow(FOLLOW_enumConstant_in_enumerator2506);
-                enumConstant123 = enumConstant();
+            pushFollow(FOLLOW_enumConstant_in_enumerator2510);
+            enumConstant123=enumConstant();
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    adaptor.addChild(root_0, enumConstant123.getTree());
-                }
-                // Grammar/CTFParser.g:726:16: ( enumeratorValue )?
-                int alt37 = 2;
-                int LA37_0 = input.LA(1);
+            state._fsp--;
+            if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                adaptor.addChild(root_0, enumConstant123.getTree());
+            }
+            // CTFParser.g:727:16: ( enumeratorValue )?
+            int alt37=2;
+            int LA37_0 = input.LA(1);
 
-                if ((LA37_0 == ASSIGNMENT)) {
-                    alt37 = 1;
-                }
-                switch (alt37) {
-                case 1:
-                // Grammar/CTFParser.g:726:16: enumeratorValue
-                {
-                    pushFollow(FOLLOW_enumeratorValue_in_enumerator2508);
-                    enumeratorValue124 = enumeratorValue();
+            if ( (LA37_0==ASSIGNMENT) ) {
+                alt37=1;
+            }
+            switch (alt37) {
+                case 1 :
+                    // CTFParser.g:727:16: enumeratorValue
+                    {
+                    pushFollow(FOLLOW_enumeratorValue_in_enumerator2512);
+                    enumeratorValue124=enumeratorValue();
 
                     state._fsp--;
                     if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
+                    if ( state.backtracking==0 ) {
                         adaptor.addChild(root_0, enumeratorValue124.getTree());
                     }
 
-                }
+                    }
                     break;
 
-                }
+            }
+
 
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 exit("enumerator");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "enumerator"
 
     public static class enumeratorValue_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "enumeratorValue"
-    // Grammar/CTFParser.g:729:1: enumeratorValue : ASSIGNMENT e1=
-    // unaryExpression ( -> ^( ENUM_VALUE $e1) | ELIPSES e2= unaryExpression ->
-    // ^( ENUM_VALUE_RANGE $e1 $e2) ) ;
-    public final CTFParser.enumeratorValue_return enumeratorValue()
-            throws RecognitionException {
+    // CTFParser.g:730:1: enumeratorValue : ASSIGNMENT e1= unaryExpression ( -> ^( ENUM_VALUE $e1) | ELIPSES e2= unaryExpression -> ^( ENUM_VALUE_RANGE $e1 $e2) ) ;
+    public final CTFParser.enumeratorValue_return enumeratorValue() throws RecognitionException {
         CTFParser.enumeratorValue_return retval = new CTFParser.enumeratorValue_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token ASSIGNMENT125 = null;
-        Token ELIPSES126 = null;
+        Token ASSIGNMENT125=null;
+        Token ELIPSES126=null;
         CTFParser.unaryExpression_return e1 = null;
 
         CTFParser.unaryExpression_return e2 = null;
 
-        CommonTree ASSIGNMENT125_tree = null;
-        CommonTree ELIPSES126_tree = null;
-        RewriteRuleTokenStream stream_ASSIGNMENT = new RewriteRuleTokenStream(
-                adaptor, "token ASSIGNMENT");
-        RewriteRuleTokenStream stream_ELIPSES = new RewriteRuleTokenStream(
-                adaptor, "token ELIPSES");
-        RewriteRuleSubtreeStream stream_unaryExpression = new RewriteRuleSubtreeStream(
-                adaptor, "rule unaryExpression");
 
-        enter("enumeratorValue");
+        CommonTree ASSIGNMENT125_tree=null;
+        CommonTree ELIPSES126_tree=null;
+        RewriteRuleTokenStream stream_ASSIGNMENT=new RewriteRuleTokenStream(adaptor,"token ASSIGNMENT");
+        RewriteRuleTokenStream stream_ELIPSES=new RewriteRuleTokenStream(adaptor,"token ELIPSES");
+        RewriteRuleSubtreeStream stream_unaryExpression=new RewriteRuleSubtreeStream(adaptor,"rule unaryExpression");
+
+          enter("enumeratorValue");
 
         try {
-            // Grammar/CTFParser.g:736:1: ( ASSIGNMENT e1= unaryExpression ( ->
-            // ^( ENUM_VALUE $e1) | ELIPSES e2= unaryExpression -> ^(
-            // ENUM_VALUE_RANGE $e1 $e2) ) )
-            // Grammar/CTFParser.g:737:3: ASSIGNMENT e1= unaryExpression ( -> ^(
-            // ENUM_VALUE $e1) | ELIPSES e2= unaryExpression -> ^(
-            // ENUM_VALUE_RANGE $e1 $e2) )
+            // CTFParser.g:737:1: ( ASSIGNMENT e1= unaryExpression ( -> ^( ENUM_VALUE $e1) | ELIPSES e2= unaryExpression -> ^( ENUM_VALUE_RANGE $e1 $e2) ) )
+            // CTFParser.g:738:3: ASSIGNMENT e1= unaryExpression ( -> ^( ENUM_VALUE $e1) | ELIPSES e2= unaryExpression -> ^( ENUM_VALUE_RANGE $e1 $e2) )
             {
-                ASSIGNMENT125 = (Token) match(input, ASSIGNMENT,
-                        FOLLOW_ASSIGNMENT_in_enumeratorValue2532);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_ASSIGNMENT.add(ASSIGNMENT125);
-                }
+            ASSIGNMENT125=(Token)match(input,ASSIGNMENT,FOLLOW_ASSIGNMENT_in_enumeratorValue2536); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_ASSIGNMENT.add(ASSIGNMENT125);
+            }
 
-                pushFollow(FOLLOW_unaryExpression_in_enumeratorValue2536);
-                e1 = unaryExpression();
+            pushFollow(FOLLOW_unaryExpression_in_enumeratorValue2540);
+            e1=unaryExpression();
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_unaryExpression.add(e1.getTree());
-                }
-                // Grammar/CTFParser.g:738:3: ( -> ^( ENUM_VALUE $e1) | ELIPSES
-                // e2= unaryExpression -> ^( ENUM_VALUE_RANGE $e1 $e2) )
-                int alt38 = 2;
-                int LA38_0 = input.LA(1);
+            state._fsp--;
+            if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_unaryExpression.add(e1.getTree());
+            }
+            // CTFParser.g:739:3: ( -> ^( ENUM_VALUE $e1) | ELIPSES e2= unaryExpression -> ^( ENUM_VALUE_RANGE $e1 $e2) )
+            int alt38=2;
+            int LA38_0 = input.LA(1);
 
-                if (((LA38_0 == SEPARATOR) || (LA38_0 == RCURL))) {
-                    alt38 = 1;
-                } else if ((LA38_0 == ELIPSES)) {
-                    alt38 = 2;
-                } else {
-                    if (state.backtracking > 0) {
-                        state.failed = true;
-                        return retval;
-                    }
-                    NoViableAltException nvae = new NoViableAltException("",
-                            38, 0, input);
+            if ( (LA38_0==SEPARATOR||LA38_0==RCURL) ) {
+                alt38=1;
+            }
+            else if ( (LA38_0==ELIPSES) ) {
+                alt38=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return retval;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 38, 0, input);
 
-                    throw nvae;
-                }
-                switch (alt38) {
-                case 1:
-                // Grammar/CTFParser.g:739:5:
-                {
+                throw nvae;
+            }
+            switch (alt38) {
+                case 1 :
+                    // CTFParser.g:740:5:
+                    {
 
                     // AST REWRITE
                     // elements: e1
@@ -7238,143 +6316,121 @@ public class CTFParser extends Parser {
                     // token list labels:
                     // rule list labels:
                     // wildcard labels:
-                    if (state.backtracking == 0) {
-                        retval.tree = root_0;
-//                        RewriteRuleSubtreeStream stream_retval =
-                                new RewriteRuleSubtreeStream(
-                                adaptor, "rule retval",
-                                retval != null ? retval.tree : null);
-                        RewriteRuleSubtreeStream stream_e1 = new RewriteRuleSubtreeStream(
-                                adaptor, "rule e1", e1 != null ? e1.tree : null);
-
-                        root_0 = (CommonTree) adaptor.nil();
-                        // 739:5: -> ^( ENUM_VALUE $e1)
-                        {
-                            // Grammar/CTFParser.g:739:8: ^( ENUM_VALUE $e1)
-                            {
-                                CommonTree root_1 = (CommonTree) adaptor.nil();
-                                root_1 = (CommonTree) adaptor
-                                        .becomeRoot(adaptor.create(ENUM_VALUE,
-                                                "ENUM_VALUE"), root_1);
+                    if ( state.backtracking==0 ) {
+                    retval.tree = root_0;
+                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+                    RewriteRuleSubtreeStream stream_e1=new RewriteRuleSubtreeStream(adaptor,"rule e1",e1!=null?e1.tree:null);
 
-                                adaptor.addChild(root_1, stream_e1.nextTree());
+                    root_0 = (CommonTree)adaptor.nil();
+                    // 740:5: -> ^( ENUM_VALUE $e1)
+                    {
+                        // CTFParser.g:740:8: ^( ENUM_VALUE $e1)
+                        {
+                        CommonTree root_1 = (CommonTree)adaptor.nil();
+                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ENUM_VALUE, "ENUM_VALUE"), root_1);
 
-                                adaptor.addChild(root_0, root_1);
-                            }
+                        adaptor.addChild(root_1, stream_e1.nextTree());
 
+                        adaptor.addChild(root_0, root_1);
                         }
 
-                        retval.tree = root_0;
                     }
-                }
+
+                    retval.tree = root_0;}
+                    }
                     break;
-                case 2:
-                // Grammar/CTFParser.g:740:7: ELIPSES e2= unaryExpression
-                {
-                    ELIPSES126 = (Token) match(input, ELIPSES,
-                            FOLLOW_ELIPSES_in_enumeratorValue2562);
-                    if (state.failed) {
+                case 2 :
+                    // CTFParser.g:741:7: ELIPSES e2= unaryExpression
+                    {
+                    ELIPSES126=(Token)match(input,ELIPSES,FOLLOW_ELIPSES_in_enumeratorValue2566); if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
+                    if ( state.backtracking==0 ) {
                         stream_ELIPSES.add(ELIPSES126);
                     }
 
-                    pushFollow(FOLLOW_unaryExpression_in_enumeratorValue2566);
-                    e2 = unaryExpression();
+                    pushFollow(FOLLOW_unaryExpression_in_enumeratorValue2570);
+                    e2=unaryExpression();
 
                     state._fsp--;
                     if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
+                    if ( state.backtracking==0 ) {
                         stream_unaryExpression.add(e2.getTree());
                     }
 
+
                     // AST REWRITE
-                    // elements: e2, e1
+                    // elements: e1, e2
                     // token labels:
                     // rule labels: retval, e1, e2
                     // token list labels:
                     // rule list labels:
                     // wildcard labels:
-                    if (state.backtracking == 0) {
-                        retval.tree = root_0;
-//                        RewriteRuleSubtreeStream stream_retval =
-                                new RewriteRuleSubtreeStream(
-                                adaptor, "rule retval",
-                                retval != null ? retval.tree : null);
-                        RewriteRuleSubtreeStream stream_e1 = new RewriteRuleSubtreeStream(
-                                adaptor, "rule e1", e1 != null ? e1.tree : null);
-                        RewriteRuleSubtreeStream stream_e2 = new RewriteRuleSubtreeStream(
-                                adaptor, "rule e2", e2 != null ? e2.tree : null);
-
-                        root_0 = (CommonTree) adaptor.nil();
-                        // 740:34: -> ^( ENUM_VALUE_RANGE $e1 $e2)
-                        {
-                            // Grammar/CTFParser.g:740:37: ^( ENUM_VALUE_RANGE
-                            // $e1 $e2)
-                            {
-                                CommonTree root_1 = (CommonTree) adaptor.nil();
-                                root_1 = (CommonTree) adaptor.becomeRoot(
-                                        adaptor.create(ENUM_VALUE_RANGE,
-                                                "ENUM_VALUE_RANGE"), root_1);
+                    if ( state.backtracking==0 ) {
+                    retval.tree = root_0;
+                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+                    RewriteRuleSubtreeStream stream_e1=new RewriteRuleSubtreeStream(adaptor,"rule e1",e1!=null?e1.tree:null);
+                    RewriteRuleSubtreeStream stream_e2=new RewriteRuleSubtreeStream(adaptor,"rule e2",e2!=null?e2.tree:null);
 
-                                adaptor.addChild(root_1, stream_e1.nextTree());
-                                adaptor.addChild(root_1, stream_e2.nextTree());
+                    root_0 = (CommonTree)adaptor.nil();
+                    // 741:34: -> ^( ENUM_VALUE_RANGE $e1 $e2)
+                    {
+                        // CTFParser.g:741:37: ^( ENUM_VALUE_RANGE $e1 $e2)
+                        {
+                        CommonTree root_1 = (CommonTree)adaptor.nil();
+                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(ENUM_VALUE_RANGE, "ENUM_VALUE_RANGE"), root_1);
 
-                                adaptor.addChild(root_0, root_1);
-                            }
+                        adaptor.addChild(root_1, stream_e1.nextTree());
+                        adaptor.addChild(root_1, stream_e2.nextTree());
 
+                        adaptor.addChild(root_0, root_1);
                         }
 
-                        retval.tree = root_0;
                     }
-                }
+
+                    retval.tree = root_0;}
+                    }
                     break;
 
-                }
+            }
+
 
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 exit("enumeratorValue");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "enumeratorValue"
 
     public static class declarator_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "declarator"
-    // Grammar/CTFParser.g:745:1: declarator : ( pointer )* directDeclarator ->
-    // ^( TYPE_DECLARATOR ( pointer )* directDeclarator ) ;
-    public final CTFParser.declarator_return declarator()
-            throws RecognitionException {
+    // CTFParser.g:746:1: declarator : ( pointer )* directDeclarator -> ^( TYPE_DECLARATOR ( pointer )* directDeclarator ) ;
+    public final CTFParser.declarator_return declarator() throws RecognitionException {
         CTFParser.declarator_return retval = new CTFParser.declarator_return();
         retval.start = input.LT(1);
 
@@ -7384,385 +6440,340 @@ public class CTFParser extends Parser {
 
         CTFParser.directDeclarator_return directDeclarator128 = null;
 
-        RewriteRuleSubtreeStream stream_directDeclarator = new RewriteRuleSubtreeStream(
-                adaptor, "rule directDeclarator");
-        RewriteRuleSubtreeStream stream_pointer = new RewriteRuleSubtreeStream(
-                adaptor, "rule pointer");
 
-        enter("declarator");
+        RewriteRuleSubtreeStream stream_directDeclarator=new RewriteRuleSubtreeStream(adaptor,"rule directDeclarator");
+        RewriteRuleSubtreeStream stream_pointer=new RewriteRuleSubtreeStream(adaptor,"rule pointer");
+
+          enter("declarator");
 
         try {
-            // Grammar/CTFParser.g:752:1: ( ( pointer )* directDeclarator -> ^(
-            // TYPE_DECLARATOR ( pointer )* directDeclarator ) )
-            // Grammar/CTFParser.g:753:3: ( pointer )* directDeclarator
+            // CTFParser.g:753:1: ( ( pointer )* directDeclarator -> ^( TYPE_DECLARATOR ( pointer )* directDeclarator ) )
+            // CTFParser.g:754:3: ( pointer )* directDeclarator
             {
-                // Grammar/CTFParser.g:753:3: ( pointer )*
-                loop39: do {
-                    int alt39 = 2;
-                    int LA39_0 = input.LA(1);
+            // CTFParser.g:754:3: ( pointer )*
+            loop39:
+            do {
+                int alt39=2;
+                int LA39_0 = input.LA(1);
 
-                    if ((LA39_0 == POINTER)) {
-                        alt39 = 1;
-                    }
+                if ( (LA39_0==POINTER) ) {
+                    alt39=1;
+                }
 
-                    switch (alt39) {
-                    case 1:
-                    // Grammar/CTFParser.g:753:3: pointer
-                    {
-                        pushFollow(FOLLOW_pointer_in_declarator2608);
-                        pointer127 = pointer();
 
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_pointer.add(pointer127.getTree());
-                        }
+                switch (alt39) {
+               case 1 :
+                   // CTFParser.g:754:3: pointer
+                   {
+                   pushFollow(FOLLOW_pointer_in_declarator2612);
+                   pointer127=pointer();
 
+                   state._fsp--;
+                   if (state.failed) {
+                        return retval;
                     }
-                        break;
-
-                    default:
-                        break loop39;
+                   if ( state.backtracking==0 ) {
+                        stream_pointer.add(pointer127.getTree());
                     }
-                } while (true);
 
-                pushFollow(FOLLOW_directDeclarator_in_declarator2611);
-                directDeclarator128 = directDeclarator();
+                   }
+                   break;
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_directDeclarator.add(directDeclarator128.getTree());
+               default :
+                   break loop39;
                 }
+            } while (true);
 
-                // AST REWRITE
-                // elements: directDeclarator, pointer
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
+            pushFollow(FOLLOW_directDeclarator_in_declarator2615);
+            directDeclarator128=directDeclarator();
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 753:29: -> ^( TYPE_DECLARATOR ( pointer )*
-                    // directDeclarator )
-                    {
-                        // Grammar/CTFParser.g:753:32: ^( TYPE_DECLARATOR (
-                        // pointer )* directDeclarator )
-                        {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(
-                                    adaptor.create(TYPE_DECLARATOR,
-                                            "TYPE_DECLARATOR"), root_1);
+            state._fsp--;
+            if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_directDeclarator.add(directDeclarator128.getTree());
+            }
 
-                            // Grammar/CTFParser.g:753:50: ( pointer )*
-                            while (stream_pointer.hasNext()) {
-                                adaptor.addChild(root_1,
-                                        stream_pointer.nextTree());
 
-                            }
-                            stream_pointer.reset();
-                            adaptor.addChild(root_1,
-                                    stream_directDeclarator.nextTree());
+            // AST REWRITE
+            // elements: directDeclarator, pointer
+            // token labels:
+            // rule labels: retval
+            // token list labels:
+            // rule list labels:
+            // wildcard labels:
+            if ( state.backtracking==0 ) {
+            retval.tree = root_0;
+            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                            adaptor.addChild(root_0, root_1);
-                        }
+            root_0 = (CommonTree)adaptor.nil();
+            // 754:29: -> ^( TYPE_DECLARATOR ( pointer )* directDeclarator )
+            {
+                // CTFParser.g:754:32: ^( TYPE_DECLARATOR ( pointer )* directDeclarator )
+                {
+                CommonTree root_1 = (CommonTree)adaptor.nil();
+                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TYPE_DECLARATOR, "TYPE_DECLARATOR"), root_1);
 
-                    }
+                // CTFParser.g:754:50: ( pointer )*
+                while ( stream_pointer.hasNext() ) {
+                    adaptor.addChild(root_1, stream_pointer.nextTree());
 
-                    retval.tree = root_0;
                 }
+                stream_pointer.reset();
+                adaptor.addChild(root_1, stream_directDeclarator.nextTree());
+
+                adaptor.addChild(root_0, root_1);
+                }
+
+            }
+
+            retval.tree = root_0;}
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 exit("declarator");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "declarator"
 
     public static class directDeclarator_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "directDeclarator"
-    // Grammar/CTFParser.g:756:1: directDeclarator : ( IDENTIFIER ) (
-    // directDeclaratorSuffix )* ;
-    public final CTFParser.directDeclarator_return directDeclarator()
-            throws RecognitionException {
+    // CTFParser.g:757:1: directDeclarator : ( IDENTIFIER ) ( directDeclaratorSuffix )* ;
+    public final CTFParser.directDeclarator_return directDeclarator() throws RecognitionException {
         CTFParser.directDeclarator_return retval = new CTFParser.directDeclarator_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token IDENTIFIER129 = null;
+        Token IDENTIFIER129=null;
         CTFParser.directDeclaratorSuffix_return directDeclaratorSuffix130 = null;
 
-        CommonTree IDENTIFIER129_tree = null;
 
-        enter("directDeclarator");
+        CommonTree IDENTIFIER129_tree=null;
+
+
+          enter("directDeclarator");
 
         try {
-            // Grammar/CTFParser.g:763:1: ( ( IDENTIFIER ) (
-            // directDeclaratorSuffix )* )
-            // Grammar/CTFParser.g:764:3: ( IDENTIFIER ) (
-            // directDeclaratorSuffix )*
+            // CTFParser.g:764:1: ( ( IDENTIFIER ) ( directDeclaratorSuffix )* )
+            // CTFParser.g:765:3: ( IDENTIFIER ) ( directDeclaratorSuffix )*
             {
-                root_0 = (CommonTree) adaptor.nil();
+            root_0 = (CommonTree)adaptor.nil();
 
-                // Grammar/CTFParser.g:764:3: ( IDENTIFIER )
-                // Grammar/CTFParser.g:765:6: IDENTIFIER
-                {
-                    IDENTIFIER129 = (Token) match(input, IDENTIFIER,
-                            FOLLOW_IDENTIFIER_in_directDeclarator2655);
-                    if (state.failed) {
-                        return retval;
-                    }
-                    if (state.backtracking == 0) {
-                        IDENTIFIER129_tree = (CommonTree) adaptor
-                                .create(IDENTIFIER129);
-                        adaptor.addChild(root_0, IDENTIFIER129_tree);
-                    }
-                    if (state.backtracking == 0) {
-                        if (inTypedef()) {
-                            addTypeName((IDENTIFIER129 != null ? IDENTIFIER129
-                                    .getText() : null));
-                        }
-                    }
-                    if (state.backtracking == 0) {
-                        debug_print((IDENTIFIER129 != null ? IDENTIFIER129
-                                .getText() : null));
-                    }
+            // CTFParser.g:765:3: ( IDENTIFIER )
+            // CTFParser.g:766:6: IDENTIFIER
+            {
+            IDENTIFIER129=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_directDeclarator2659); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+            IDENTIFIER129_tree = (CommonTree)adaptor.create(IDENTIFIER129);
+            adaptor.addChild(root_0, IDENTIFIER129_tree);
+            }
+            if ( state.backtracking==0 ) {
+               if (inTypedef()) {
+                addTypeName((IDENTIFIER129!=null?IDENTIFIER129.getText():null));
+            }
+            }
+            if ( state.backtracking==0 ) {
+              debug_print((IDENTIFIER129!=null?IDENTIFIER129.getText():null));
+            }
 
-                }
+            }
 
-                // Grammar/CTFParser.g:768:2: ( directDeclaratorSuffix )*
-                loop40: do {
-                    int alt40 = 2;
-                    int LA40_0 = input.LA(1);
+            // CTFParser.g:769:2: ( directDeclaratorSuffix )*
+            loop40:
+            do {
+                int alt40=2;
+                int LA40_0 = input.LA(1);
 
-                    if ((LA40_0 == OPENBRAC)) {
-                        alt40 = 1;
-                    }
+                if ( (LA40_0==OPENBRAC) ) {
+                    alt40=1;
+                }
 
-                    switch (alt40) {
-                    case 1:
-                    // Grammar/CTFParser.g:768:2: directDeclaratorSuffix
-                    {
-                        pushFollow(FOLLOW_directDeclaratorSuffix_in_directDeclarator2673);
-                        directDeclaratorSuffix130 = directDeclaratorSuffix();
 
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            adaptor.addChild(root_0,
-                                    directDeclaratorSuffix130.getTree());
-                        }
+                switch (alt40) {
+               case 1 :
+                   // CTFParser.g:769:2: directDeclaratorSuffix
+                   {
+                   pushFollow(FOLLOW_directDeclaratorSuffix_in_directDeclarator2677);
+                   directDeclaratorSuffix130=directDeclaratorSuffix();
 
+                   state._fsp--;
+                   if (state.failed) {
+                        return retval;
                     }
-                        break;
-
-                    default:
-                        break loop40;
+                   if ( state.backtracking==0 ) {
+                        adaptor.addChild(root_0, directDeclaratorSuffix130.getTree());
                     }
-                } while (true);
+
+                   }
+                   break;
+
+               default :
+                   break loop40;
+                }
+            } while (true);
+
 
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 exit("directDeclarator");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "directDeclarator"
 
-    public static class directDeclaratorSuffix_return extends
-            ParserRuleReturnScope {
+    public static class directDeclaratorSuffix_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "directDeclaratorSuffix"
-    // Grammar/CTFParser.g:771:1: directDeclaratorSuffix : OPENBRAC
-    // directDeclaratorLength CLOSEBRAC -> ^( LENGTH directDeclaratorLength ) ;
-    public final CTFParser.directDeclaratorSuffix_return directDeclaratorSuffix()
-            throws RecognitionException {
+    // CTFParser.g:772:1: directDeclaratorSuffix : OPENBRAC directDeclaratorLength CLOSEBRAC -> ^( LENGTH directDeclaratorLength ) ;
+    public final CTFParser.directDeclaratorSuffix_return directDeclaratorSuffix() throws RecognitionException {
         CTFParser.directDeclaratorSuffix_return retval = new CTFParser.directDeclaratorSuffix_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token OPENBRAC131 = null;
-        Token CLOSEBRAC133 = null;
+        Token OPENBRAC131=null;
+        Token CLOSEBRAC133=null;
         CTFParser.directDeclaratorLength_return directDeclaratorLength132 = null;
 
-        CommonTree OPENBRAC131_tree = null;
-        CommonTree CLOSEBRAC133_tree = null;
-        RewriteRuleTokenStream stream_OPENBRAC = new RewriteRuleTokenStream(
-                adaptor, "token OPENBRAC");
-        RewriteRuleTokenStream stream_CLOSEBRAC = new RewriteRuleTokenStream(
-                adaptor, "token CLOSEBRAC");
-        RewriteRuleSubtreeStream stream_directDeclaratorLength = new RewriteRuleSubtreeStream(
-                adaptor, "rule directDeclaratorLength");
+
+        CommonTree OPENBRAC131_tree=null;
+        CommonTree CLOSEBRAC133_tree=null;
+        RewriteRuleTokenStream stream_OPENBRAC=new RewriteRuleTokenStream(adaptor,"token OPENBRAC");
+        RewriteRuleTokenStream stream_CLOSEBRAC=new RewriteRuleTokenStream(adaptor,"token CLOSEBRAC");
+        RewriteRuleSubtreeStream stream_directDeclaratorLength=new RewriteRuleSubtreeStream(adaptor,"rule directDeclaratorLength");
         try {
-            // Grammar/CTFParser.g:771:23: ( OPENBRAC directDeclaratorLength
-            // CLOSEBRAC -> ^( LENGTH directDeclaratorLength ) )
-            // Grammar/CTFParser.g:772:3: OPENBRAC directDeclaratorLength
-            // CLOSEBRAC
+            // CTFParser.g:772:23: ( OPENBRAC directDeclaratorLength CLOSEBRAC -> ^( LENGTH directDeclaratorLength ) )
+            // CTFParser.g:773:3: OPENBRAC directDeclaratorLength CLOSEBRAC
             {
-                OPENBRAC131 = (Token) match(input, OPENBRAC,
-                        FOLLOW_OPENBRAC_in_directDeclaratorSuffix2686);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_OPENBRAC.add(OPENBRAC131);
-                }
+            OPENBRAC131=(Token)match(input,OPENBRAC,FOLLOW_OPENBRAC_in_directDeclaratorSuffix2690); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_OPENBRAC.add(OPENBRAC131);
+            }
 
-                pushFollow(FOLLOW_directDeclaratorLength_in_directDeclaratorSuffix2688);
-                directDeclaratorLength132 = directDeclaratorLength();
+            pushFollow(FOLLOW_directDeclaratorLength_in_directDeclaratorSuffix2692);
+            directDeclaratorLength132=directDeclaratorLength();
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_directDeclaratorLength.add(directDeclaratorLength132
-                            .getTree());
-                }
-                CLOSEBRAC133 = (Token) match(input, CLOSEBRAC,
-                        FOLLOW_CLOSEBRAC_in_directDeclaratorSuffix2690);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_CLOSEBRAC.add(CLOSEBRAC133);
-                }
+            state._fsp--;
+            if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_directDeclaratorLength.add(directDeclaratorLength132.getTree());
+            }
+            CLOSEBRAC133=(Token)match(input,CLOSEBRAC,FOLLOW_CLOSEBRAC_in_directDeclaratorSuffix2694); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_CLOSEBRAC.add(CLOSEBRAC133);
+            }
 
-                // AST REWRITE
-                // elements: directDeclaratorLength
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 772:45: -> ^( LENGTH directDeclaratorLength )
-                    {
-                        // Grammar/CTFParser.g:772:48: ^( LENGTH
-                        // directDeclaratorLength )
-                        {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(
-                                    adaptor.create(LENGTH, "LENGTH"), root_1);
 
-                            adaptor.addChild(root_1,
-                                    stream_directDeclaratorLength.nextTree());
+            // AST REWRITE
+            // elements: directDeclaratorLength
+            // token labels:
+            // rule labels: retval
+            // token list labels:
+            // rule list labels:
+            // wildcard labels:
+            if ( state.backtracking==0 ) {
+            retval.tree = root_0;
+            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                            adaptor.addChild(root_0, root_1);
-                        }
+            root_0 = (CommonTree)adaptor.nil();
+            // 773:45: -> ^( LENGTH directDeclaratorLength )
+            {
+                // CTFParser.g:773:48: ^( LENGTH directDeclaratorLength )
+                {
+                CommonTree root_1 = (CommonTree)adaptor.nil();
+                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(LENGTH, "LENGTH"), root_1);
 
-                    }
+                adaptor.addChild(root_1, stream_directDeclaratorLength.nextTree());
 
-                    retval.tree = root_0;
+                adaptor.addChild(root_0, root_1);
                 }
+
+            }
+
+            retval.tree = root_0;}
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "directDeclaratorSuffix"
 
-    public static class directDeclaratorLength_return extends
-            ParserRuleReturnScope {
+    public static class directDeclaratorLength_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "directDeclaratorLength"
-    // Grammar/CTFParser.g:775:1: directDeclaratorLength : unaryExpression ;
-    public final CTFParser.directDeclaratorLength_return directDeclaratorLength()
-            throws RecognitionException {
+    // CTFParser.g:776:1: directDeclaratorLength : unaryExpression ;
+    public final CTFParser.directDeclaratorLength_return directDeclaratorLength() throws RecognitionException {
         CTFParser.directDeclaratorLength_return retval = new CTFParser.directDeclaratorLength_return();
         retval.start = input.LT(1);
 
@@ -7770,60 +6781,54 @@ public class CTFParser extends Parser {
 
         CTFParser.unaryExpression_return unaryExpression134 = null;
 
+
+
         try {
-            // Grammar/CTFParser.g:775:24: ( unaryExpression )
-            // Grammar/CTFParser.g:776:3: unaryExpression
+            // CTFParser.g:776:24: ( unaryExpression )
+            // CTFParser.g:777:3: unaryExpression
             {
-                root_0 = (CommonTree) adaptor.nil();
+            root_0 = (CommonTree)adaptor.nil();
 
-                pushFollow(FOLLOW_unaryExpression_in_directDeclaratorLength2711);
-                unaryExpression134 = unaryExpression();
+            pushFollow(FOLLOW_unaryExpression_in_directDeclaratorLength2715);
+            unaryExpression134=unaryExpression();
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    adaptor.addChild(root_0, unaryExpression134.getTree());
-                }
+            state._fsp--;
+            if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                adaptor.addChild(root_0, unaryExpression134.getTree());
+            }
 
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "directDeclaratorLength"
 
     public static class abstractDeclarator_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "abstractDeclarator"
-    // Grammar/CTFParser.g:780:1: abstractDeclarator : ( ( ( pointer )+ (
-    // directAbstractDeclarator )? ) -> ^( TYPE_DECLARATOR ( pointer )+ (
-    // directAbstractDeclarator )? ) | directAbstractDeclarator -> ^(
-    // TYPE_DECLARATOR directAbstractDeclarator ) );
-    public final CTFParser.abstractDeclarator_return abstractDeclarator()
-            throws RecognitionException {
+    // CTFParser.g:781:1: abstractDeclarator : ( ( ( pointer )+ ( directAbstractDeclarator )? ) -> ^( TYPE_DECLARATOR ( pointer )+ ( directAbstractDeclarator )? ) | directAbstractDeclarator -> ^( TYPE_DECLARATOR directAbstractDeclarator ) );
+    public final CTFParser.abstractDeclarator_return abstractDeclarator() throws RecognitionException {
         CTFParser.abstractDeclarator_return retval = new CTFParser.abstractDeclarator_return();
         retval.start = input.LT(1);
 
@@ -7835,635 +6840,547 @@ public class CTFParser extends Parser {
 
         CTFParser.directAbstractDeclarator_return directAbstractDeclarator137 = null;
 
-        RewriteRuleSubtreeStream stream_pointer = new RewriteRuleSubtreeStream(
-                adaptor, "rule pointer");
-        RewriteRuleSubtreeStream stream_directAbstractDeclarator = new RewriteRuleSubtreeStream(
-                adaptor, "rule directAbstractDeclarator");
 
-        enter("abstractDeclarator");
+        RewriteRuleSubtreeStream stream_pointer=new RewriteRuleSubtreeStream(adaptor,"rule pointer");
+        RewriteRuleSubtreeStream stream_directAbstractDeclarator=new RewriteRuleSubtreeStream(adaptor,"rule directAbstractDeclarator");
+
+          enter("abstractDeclarator");
 
         try {
-            // Grammar/CTFParser.g:787:1: ( ( ( pointer )+ (
-            // directAbstractDeclarator )? ) -> ^( TYPE_DECLARATOR ( pointer )+
-            // ( directAbstractDeclarator )? ) | directAbstractDeclarator -> ^(
-            // TYPE_DECLARATOR directAbstractDeclarator ) )
-            int alt43 = 2;
+            // CTFParser.g:788:1: ( ( ( pointer )+ ( directAbstractDeclarator )? ) -> ^( TYPE_DECLARATOR ( pointer )+ ( directAbstractDeclarator )? ) | directAbstractDeclarator -> ^( TYPE_DECLARATOR directAbstractDeclarator ) )
+            int alt43=2;
             int LA43_0 = input.LA(1);
 
-            if ((LA43_0 == POINTER)) {
-                alt43 = 1;
-            } else if (((LA43_0 == LPAREN) || (LA43_0 == IDENTIFIER))) {
-                alt43 = 2;
-            } else {
-                if (state.backtracking > 0) {
-                    state.failed = true;
-                    return retval;
-                }
-                NoViableAltException nvae = new NoViableAltException("", 43, 0,
-                        input);
+            if ( (LA43_0==POINTER) ) {
+                alt43=1;
+            }
+            else if ( (LA43_0==LPAREN||LA43_0==IDENTIFIER) ) {
+                alt43=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return retval;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 43, 0, input);
 
                 throw nvae;
             }
             switch (alt43) {
-            case 1:
-            // Grammar/CTFParser.g:788:5: ( ( pointer )+ (
-            // directAbstractDeclarator )? )
-            {
-                // Grammar/CTFParser.g:788:5: ( ( pointer )+ (
-                // directAbstractDeclarator )? )
-                // Grammar/CTFParser.g:788:6: ( pointer )+ (
-                // directAbstractDeclarator )?
-                {
-                    // Grammar/CTFParser.g:788:6: ( pointer )+
-                    int cnt41 = 0;
-                    loop41: do {
-                        int alt41 = 2;
+                case 1 :
+                    // CTFParser.g:789:5: ( ( pointer )+ ( directAbstractDeclarator )? )
+                    {
+                    // CTFParser.g:789:5: ( ( pointer )+ ( directAbstractDeclarator )? )
+                    // CTFParser.g:789:6: ( pointer )+ ( directAbstractDeclarator )?
+                    {
+                    // CTFParser.g:789:6: ( pointer )+
+                    int cnt41=0;
+                    loop41:
+                    do {
+                        int alt41=2;
                         int LA41_0 = input.LA(1);
 
-                        if ((LA41_0 == POINTER)) {
-                            alt41 = 1;
+                        if ( (LA41_0==POINTER) ) {
+                            alt41=1;
                         }
 
-                        switch (alt41) {
-                        case 1:
-                        // Grammar/CTFParser.g:788:6: pointer
-                        {
-                            pushFollow(FOLLOW_pointer_in_abstractDeclarator2742);
-                            pointer135 = pointer();
 
-                            state._fsp--;
-                            if (state.failed) {
+                        switch (alt41) {
+                       case 1 :
+                           // CTFParser.g:789:6: pointer
+                           {
+                           pushFollow(FOLLOW_pointer_in_abstractDeclarator2746);
+                           pointer135=pointer();
+
+                           state._fsp--;
+                           if (state.failed) {
                                 return retval;
                             }
-                            if (state.backtracking == 0) {
+                           if ( state.backtracking==0 ) {
                                 stream_pointer.add(pointer135.getTree());
                             }
 
-                        }
-                            break;
+                           }
+                           break;
 
-                        default:
-                            if (cnt41 >= 1) {
+                       default :
+                           if ( cnt41 >= 1 ) {
                                 break loop41;
                             }
-                            if (state.backtracking > 0) {
-                                state.failed = true;
-                                return retval;
-                            }
-                            EarlyExitException eee = new EarlyExitException(41,
-                                    input);
-                            throw eee;
+                           if (state.backtracking>0) {state.failed=true; return retval;}
+                                EarlyExitException eee =
+                                    new EarlyExitException(41, input);
+                                throw eee;
                         }
                         cnt41++;
                     } while (true);
 
-                    // Grammar/CTFParser.g:788:15: ( directAbstractDeclarator )?
-                    int alt42 = 2;
-                    int LA42_0 = input.LA(1);
+                    // CTFParser.g:789:15: ( directAbstractDeclarator )?
+                    int alt42=2;
+                    int LA42_0 = input.LA(1);
+
+                    if ( (LA42_0==LPAREN||LA42_0==IDENTIFIER) ) {
+                        alt42=1;
+                    }
+                    switch (alt42) {
+                        case 1 :
+                            // CTFParser.g:789:15: directAbstractDeclarator
+                            {
+                            pushFollow(FOLLOW_directAbstractDeclarator_in_abstractDeclarator2749);
+                            directAbstractDeclarator136=directAbstractDeclarator();
+
+                            state._fsp--;
+                            if (state.failed) {
+                                return retval;
+                            }
+                            if ( state.backtracking==0 ) {
+                                stream_directAbstractDeclarator.add(directAbstractDeclarator136.getTree());
+                            }
+
+                            }
+                            break;
 
-                    if (((LA42_0 == LPAREN) || (LA42_0 == IDENTIFIER))) {
-                        alt42 = 1;
                     }
-                    switch (alt42) {
-                    case 1:
-                    // Grammar/CTFParser.g:788:15: directAbstractDeclarator
-                    {
-                        pushFollow(FOLLOW_directAbstractDeclarator_in_abstractDeclarator2745);
-                        directAbstractDeclarator136 = directAbstractDeclarator();
 
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            stream_directAbstractDeclarator
-                                    .add(directAbstractDeclarator136.getTree());
-                        }
 
                     }
-                        break;
 
-                    }
 
-                }
 
-                // AST REWRITE
-                // elements: pointer, directAbstractDeclarator
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
+                    // AST REWRITE
+                    // elements: pointer, directAbstractDeclarator
+                    // token labels:
+                    // rule labels: retval
+                    // token list labels:
+                    // rule list labels:
+                    // wildcard labels:
+                    if ( state.backtracking==0 ) {
                     retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
+                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 788:42: -> ^( TYPE_DECLARATOR ( pointer )+ (
-                    // directAbstractDeclarator )? )
+                    root_0 = (CommonTree)adaptor.nil();
+                    // 789:42: -> ^( TYPE_DECLARATOR ( pointer )+ ( directAbstractDeclarator )? )
                     {
-                        // Grammar/CTFParser.g:788:45: ^( TYPE_DECLARATOR (
-                        // pointer )+ ( directAbstractDeclarator )? )
+                        // CTFParser.g:789:45: ^( TYPE_DECLARATOR ( pointer )+ ( directAbstractDeclarator )? )
                         {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(
-                                    adaptor.create(TYPE_DECLARATOR,
-                                            "TYPE_DECLARATOR"), root_1);
+                        CommonTree root_1 = (CommonTree)adaptor.nil();
+                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TYPE_DECLARATOR, "TYPE_DECLARATOR"), root_1);
 
-                            if (!(stream_pointer.hasNext())) {
-                                throw new RewriteEarlyExitException();
-                            }
-                            while (stream_pointer.hasNext()) {
-                                adaptor.addChild(root_1,
-                                        stream_pointer.nextTree());
+                        if ( !(stream_pointer.hasNext()) ) {
+                            throw new RewriteEarlyExitException();
+                        }
+                        while ( stream_pointer.hasNext() ) {
+                            adaptor.addChild(root_1, stream_pointer.nextTree());
 
-                            }
-                            stream_pointer.reset();
-                            // Grammar/CTFParser.g:788:72: (
-                            // directAbstractDeclarator )?
-                            if (stream_directAbstractDeclarator.hasNext()) {
-                                adaptor.addChild(root_1,
-                                        stream_directAbstractDeclarator
-                                                .nextTree());
+                        }
+                        stream_pointer.reset();
+                        // CTFParser.g:789:72: ( directAbstractDeclarator )?
+                        if ( stream_directAbstractDeclarator.hasNext() ) {
+                            adaptor.addChild(root_1, stream_directAbstractDeclarator.nextTree());
 
-                            }
-                            stream_directAbstractDeclarator.reset();
+                        }
+                        stream_directAbstractDeclarator.reset();
 
-                            adaptor.addChild(root_0, root_1);
+                        adaptor.addChild(root_0, root_1);
                         }
 
                     }
 
+                    retval.tree = root_0;}
+                    }
+                    break;
+                case 2 :
+                    // CTFParser.g:790:5: directAbstractDeclarator
+                    {
+                    pushFollow(FOLLOW_directAbstractDeclarator_in_abstractDeclarator2769);
+                    directAbstractDeclarator137=directAbstractDeclarator();
+
+                    state._fsp--;
+                    if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        stream_directAbstractDeclarator.add(directAbstractDeclarator137.getTree());
+                    }
+
+
+                    // AST REWRITE
+                    // elements: directAbstractDeclarator
+                    // token labels:
+                    // rule labels: retval
+                    // token list labels:
+                    // rule list labels:
+                    // wildcard labels:
+                    if ( state.backtracking==0 ) {
                     retval.tree = root_0;
-                }
-            }
-                break;
-            case 2:
-            // Grammar/CTFParser.g:789:5: directAbstractDeclarator
-            {
-                pushFollow(FOLLOW_directAbstractDeclarator_in_abstractDeclarator2765);
-                directAbstractDeclarator137 = directAbstractDeclarator();
-
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_directAbstractDeclarator
-                            .add(directAbstractDeclarator137.getTree());
-                }
-
-                // AST REWRITE
-                // elements: directAbstractDeclarator
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
+                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 789:30: -> ^( TYPE_DECLARATOR directAbstractDeclarator )
+                    root_0 = (CommonTree)adaptor.nil();
+                    // 790:30: -> ^( TYPE_DECLARATOR directAbstractDeclarator )
                     {
-                        // Grammar/CTFParser.g:789:33: ^( TYPE_DECLARATOR
-                        // directAbstractDeclarator )
+                        // CTFParser.g:790:33: ^( TYPE_DECLARATOR directAbstractDeclarator )
                         {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(
-                                    adaptor.create(TYPE_DECLARATOR,
-                                            "TYPE_DECLARATOR"), root_1);
+                        CommonTree root_1 = (CommonTree)adaptor.nil();
+                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TYPE_DECLARATOR, "TYPE_DECLARATOR"), root_1);
 
-                            adaptor.addChild(root_1,
-                                    stream_directAbstractDeclarator.nextTree());
+                        adaptor.addChild(root_1, stream_directAbstractDeclarator.nextTree());
 
-                            adaptor.addChild(root_0, root_1);
+                        adaptor.addChild(root_0, root_1);
                         }
 
                     }
 
-                    retval.tree = root_0;
-                }
-            }
-                break;
+                    retval.tree = root_0;}
+                    }
+                    break;
 
             }
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 exit("abstractDeclarator");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "abstractDeclarator"
 
-    public static class directAbstractDeclarator_return extends
-            ParserRuleReturnScope {
+    public static class directAbstractDeclarator_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "directAbstractDeclarator"
-    // Grammar/CTFParser.g:796:1: directAbstractDeclarator : ( IDENTIFIER | (
-    // LPAREN abstractDeclarator RPAREN ) ) ( OPENBRAC ( unaryExpression )?
-    // CLOSEBRAC )? ;
-    public final CTFParser.directAbstractDeclarator_return directAbstractDeclarator()
-            throws RecognitionException {
+    // CTFParser.g:797:1: directAbstractDeclarator : ( IDENTIFIER | ( LPAREN abstractDeclarator RPAREN ) ) ( OPENBRAC ( unaryExpression )? CLOSEBRAC )? ;
+    public final CTFParser.directAbstractDeclarator_return directAbstractDeclarator() throws RecognitionException {
         CTFParser.directAbstractDeclarator_return retval = new CTFParser.directAbstractDeclarator_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token IDENTIFIER138 = null;
-        Token LPAREN139 = null;
-        Token RPAREN141 = null;
-        Token OPENBRAC142 = null;
-        Token CLOSEBRAC144 = null;
+        Token IDENTIFIER138=null;
+        Token LPAREN139=null;
+        Token RPAREN141=null;
+        Token OPENBRAC142=null;
+        Token CLOSEBRAC144=null;
         CTFParser.abstractDeclarator_return abstractDeclarator140 = null;
 
         CTFParser.unaryExpression_return unaryExpression143 = null;
 
-        CommonTree IDENTIFIER138_tree = null;
-        CommonTree LPAREN139_tree = null;
-        CommonTree RPAREN141_tree = null;
-        CommonTree OPENBRAC142_tree = null;
-        CommonTree CLOSEBRAC144_tree = null;
 
-        enter("directAbstractDeclarator");
+        CommonTree IDENTIFIER138_tree=null;
+        CommonTree LPAREN139_tree=null;
+        CommonTree RPAREN141_tree=null;
+        CommonTree OPENBRAC142_tree=null;
+        CommonTree CLOSEBRAC144_tree=null;
+
+
+          enter("directAbstractDeclarator");
 
         try {
-            // Grammar/CTFParser.g:804:1: ( ( IDENTIFIER | ( LPAREN
-            // abstractDeclarator RPAREN ) ) ( OPENBRAC ( unaryExpression )?
-            // CLOSEBRAC )? )
-            // Grammar/CTFParser.g:805:3: ( IDENTIFIER | ( LPAREN
-            // abstractDeclarator RPAREN ) ) ( OPENBRAC ( unaryExpression )?
-            // CLOSEBRAC )?
+            // CTFParser.g:805:1: ( ( IDENTIFIER | ( LPAREN abstractDeclarator RPAREN ) ) ( OPENBRAC ( unaryExpression )? CLOSEBRAC )? )
+            // CTFParser.g:806:3: ( IDENTIFIER | ( LPAREN abstractDeclarator RPAREN ) ) ( OPENBRAC ( unaryExpression )? CLOSEBRAC )?
             {
-                root_0 = (CommonTree) adaptor.nil();
-
-                // Grammar/CTFParser.g:805:3: ( IDENTIFIER | ( LPAREN
-                // abstractDeclarator RPAREN ) )
-                int alt44 = 2;
-                int LA44_0 = input.LA(1);
-
-                if ((LA44_0 == IDENTIFIER)) {
-                    alt44 = 1;
-                } else if ((LA44_0 == LPAREN)) {
-                    alt44 = 2;
-                } else {
-                    if (state.backtracking > 0) {
-                        state.failed = true;
+            root_0 = (CommonTree)adaptor.nil();
+
+            // CTFParser.g:806:3: ( IDENTIFIER | ( LPAREN abstractDeclarator RPAREN ) )
+            int alt44=2;
+            int LA44_0 = input.LA(1);
+
+            if ( (LA44_0==IDENTIFIER) ) {
+                alt44=1;
+            }
+            else if ( (LA44_0==LPAREN) ) {
+                alt44=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return retval;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 44, 0, input);
+
+                throw nvae;
+            }
+            switch (alt44) {
+                case 1 :
+                    // CTFParser.g:807:6: IDENTIFIER
+                    {
+                    IDENTIFIER138=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_directAbstractDeclarator2809); if (state.failed) {
                         return retval;
                     }
-                    NoViableAltException nvae = new NoViableAltException("",
-                            44, 0, input);
+                    if ( state.backtracking==0 ) {
+                    IDENTIFIER138_tree = (CommonTree)adaptor.create(IDENTIFIER138);
+                    adaptor.addChild(root_0, IDENTIFIER138_tree);
+                    }
 
-                    throw nvae;
-                }
-                switch (alt44) {
-                case 1:
-                // Grammar/CTFParser.g:806:6: IDENTIFIER
-                {
-                    IDENTIFIER138 = (Token) match(input, IDENTIFIER,
-                            FOLLOW_IDENTIFIER_in_directAbstractDeclarator2805);
+                    }
+                    break;
+                case 2 :
+                    // CTFParser.g:808:7: ( LPAREN abstractDeclarator RPAREN )
+                    {
+                    // CTFParser.g:808:7: ( LPAREN abstractDeclarator RPAREN )
+                    // CTFParser.g:808:8: LPAREN abstractDeclarator RPAREN
+                    {
+                    LPAREN139=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_directAbstractDeclarator2818); if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                    LPAREN139_tree = (CommonTree)adaptor.create(LPAREN139);
+                    adaptor.addChild(root_0, LPAREN139_tree);
+                    }
+                    pushFollow(FOLLOW_abstractDeclarator_in_directAbstractDeclarator2820);
+                    abstractDeclarator140=abstractDeclarator();
+
+                    state._fsp--;
                     if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
-                        IDENTIFIER138_tree = (CommonTree) adaptor
-                                .create(IDENTIFIER138);
-                        adaptor.addChild(root_0, IDENTIFIER138_tree);
+                    if ( state.backtracking==0 ) {
+                        adaptor.addChild(root_0, abstractDeclarator140.getTree());
+                    }
+                    RPAREN141=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_directAbstractDeclarator2822); if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                    RPAREN141_tree = (CommonTree)adaptor.create(RPAREN141);
+                    adaptor.addChild(root_0, RPAREN141_tree);
                     }
 
-                }
-                    break;
-                case 2:
-                // Grammar/CTFParser.g:807:7: ( LPAREN abstractDeclarator RPAREN
-                // )
-                {
-                    // Grammar/CTFParser.g:807:7: ( LPAREN abstractDeclarator
-                    // RPAREN )
-                    // Grammar/CTFParser.g:807:8: LPAREN abstractDeclarator
-                    // RPAREN
-                    {
-                        LPAREN139 = (Token) match(input, LPAREN,
-                                FOLLOW_LPAREN_in_directAbstractDeclarator2814);
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            LPAREN139_tree = (CommonTree) adaptor
-                                    .create(LPAREN139);
-                            adaptor.addChild(root_0, LPAREN139_tree);
-                        }
-                        pushFollow(FOLLOW_abstractDeclarator_in_directAbstractDeclarator2816);
-                        abstractDeclarator140 = abstractDeclarator();
+                    }
 
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            adaptor.addChild(root_0,
-                                    abstractDeclarator140.getTree());
-                        }
-                        RPAREN141 = (Token) match(input, RPAREN,
-                                FOLLOW_RPAREN_in_directAbstractDeclarator2818);
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            RPAREN141_tree = (CommonTree) adaptor
-                                    .create(RPAREN141);
-                            adaptor.addChild(root_0, RPAREN141_tree);
-                        }
 
                     }
-
-                }
                     break;
 
-                }
+            }
 
-                // Grammar/CTFParser.g:809:3: ( OPENBRAC ( unaryExpression )?
-                // CLOSEBRAC )?
-                int alt46 = 2;
-                int LA46_0 = input.LA(1);
+            // CTFParser.g:810:3: ( OPENBRAC ( unaryExpression )? CLOSEBRAC )?
+            int alt46=2;
+            int LA46_0 = input.LA(1);
 
-                if ((LA46_0 == OPENBRAC)) {
-                    alt46 = 1;
-                }
-                switch (alt46) {
-                case 1:
-                // Grammar/CTFParser.g:810:5: OPENBRAC ( unaryExpression )?
-                // CLOSEBRAC
-                {
-                    OPENBRAC142 = (Token) match(input, OPENBRAC,
-                            FOLLOW_OPENBRAC_in_directAbstractDeclarator2833);
-                    if (state.failed) {
+            if ( (LA46_0==OPENBRAC) ) {
+                alt46=1;
+            }
+            switch (alt46) {
+                case 1 :
+                    // CTFParser.g:811:5: OPENBRAC ( unaryExpression )? CLOSEBRAC
+                    {
+                    OPENBRAC142=(Token)match(input,OPENBRAC,FOLLOW_OPENBRAC_in_directAbstractDeclarator2837); if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
-                        OPENBRAC142_tree = (CommonTree) adaptor
-                                .create(OPENBRAC142);
-                        adaptor.addChild(root_0, OPENBRAC142_tree);
+                    if ( state.backtracking==0 ) {
+                    OPENBRAC142_tree = (CommonTree)adaptor.create(OPENBRAC142);
+                    adaptor.addChild(root_0, OPENBRAC142_tree);
                     }
-                    // Grammar/CTFParser.g:810:14: ( unaryExpression )?
-                    int alt45 = 2;
+                    // CTFParser.g:811:14: ( unaryExpression )?
+                    int alt45=2;
                     int LA45_0 = input.LA(1);
 
-                    if (((LA45_0 == ALIGNTOK) || (LA45_0 == EVENTTOK)
-                            || ((LA45_0 >= SIGNEDTOK) && (LA45_0 <= STRINGTOK))
-                            || (LA45_0 == TRACETOK)
-                            || ((LA45_0 >= ENVTOK) && (LA45_0 <= CLOCKTOK))
-                            || (LA45_0 == SIGN) || (LA45_0 == OCTAL_LITERAL)
-                            || (LA45_0 == DECIMAL_LITERAL)
-                            || (LA45_0 == HEX_LITERAL)
-                            || (LA45_0 == CHARACTER_LITERAL)
-                            || (LA45_0 == STRING_LITERAL) || (LA45_0 == IDENTIFIER))) {
-                        alt45 = 1;
+                    if ( (LA45_0==ALIGNTOK||LA45_0==EVENTTOK||(LA45_0>=SIGNEDTOK && LA45_0<=STRINGTOK)||LA45_0==TRACETOK||(LA45_0>=ENVTOK && LA45_0<=CALLSITETOK)||LA45_0==SIGN||LA45_0==OCTAL_LITERAL||LA45_0==DECIMAL_LITERAL||LA45_0==HEX_LITERAL||LA45_0==CHARACTER_LITERAL||LA45_0==STRING_LITERAL||LA45_0==IDENTIFIER) ) {
+                        alt45=1;
                     }
                     switch (alt45) {
-                    case 1:
-                    // Grammar/CTFParser.g:810:14: unaryExpression
-                    {
-                        pushFollow(FOLLOW_unaryExpression_in_directAbstractDeclarator2835);
-                        unaryExpression143 = unaryExpression();
+                        case 1 :
+                            // CTFParser.g:811:14: unaryExpression
+                            {
+                            pushFollow(FOLLOW_unaryExpression_in_directAbstractDeclarator2839);
+                            unaryExpression143=unaryExpression();
 
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            adaptor.addChild(root_0,
-                                    unaryExpression143.getTree());
-                        }
+                            state._fsp--;
+                            if (state.failed) {
+                                return retval;
+                            }
+                            if ( state.backtracking==0 ) {
+                                adaptor.addChild(root_0, unaryExpression143.getTree());
+                            }
 
-                    }
-                        break;
+                            }
+                            break;
 
                     }
 
-                    CLOSEBRAC144 = (Token) match(input, CLOSEBRAC,
-                            FOLLOW_CLOSEBRAC_in_directAbstractDeclarator2838);
-                    if (state.failed) {
+                    CLOSEBRAC144=(Token)match(input,CLOSEBRAC,FOLLOW_CLOSEBRAC_in_directAbstractDeclarator2842); if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
-                        CLOSEBRAC144_tree = (CommonTree) adaptor
-                                .create(CLOSEBRAC144);
-                        adaptor.addChild(root_0, CLOSEBRAC144_tree);
+                    if ( state.backtracking==0 ) {
+                    CLOSEBRAC144_tree = (CommonTree)adaptor.create(CLOSEBRAC144);
+                    adaptor.addChild(root_0, CLOSEBRAC144_tree);
                     }
 
-                }
+                    }
                     break;
 
-                }
+            }
+
 
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                debug_print(input.toString(retval.start, input.LT(-1)));
+                debug_print(input.toString(retval.start,input.LT(-1)));
                 exit("directAbstractDeclarator");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "directAbstractDeclarator"
 
     public static class pointer_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "pointer"
-    // Grammar/CTFParser.g:814:1: pointer : POINTER ( typeQualifierList )? -> ^(
-    // POINTER ( typeQualifierList )? ) ;
+    // CTFParser.g:815:1: pointer : POINTER ( typeQualifierList )? -> ^( POINTER ( typeQualifierList )? ) ;
     public final CTFParser.pointer_return pointer() throws RecognitionException {
         CTFParser.pointer_return retval = new CTFParser.pointer_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token POINTER145 = null;
+        Token POINTER145=null;
         CTFParser.typeQualifierList_return typeQualifierList146 = null;
 
-        CommonTree POINTER145_tree = null;
-        RewriteRuleTokenStream stream_POINTER = new RewriteRuleTokenStream(
-                adaptor, "token POINTER");
-        RewriteRuleSubtreeStream stream_typeQualifierList = new RewriteRuleSubtreeStream(
-                adaptor, "rule typeQualifierList");
 
-        enter("pointer");
+        CommonTree POINTER145_tree=null;
+        RewriteRuleTokenStream stream_POINTER=new RewriteRuleTokenStream(adaptor,"token POINTER");
+        RewriteRuleSubtreeStream stream_typeQualifierList=new RewriteRuleSubtreeStream(adaptor,"rule typeQualifierList");
+
+          enter("pointer");
 
         try {
-            // Grammar/CTFParser.g:822:1: ( POINTER ( typeQualifierList )? -> ^(
-            // POINTER ( typeQualifierList )? ) )
-            // Grammar/CTFParser.g:823:3: POINTER ( typeQualifierList )?
+            // CTFParser.g:823:1: ( POINTER ( typeQualifierList )? -> ^( POINTER ( typeQualifierList )? ) )
+            // CTFParser.g:824:3: POINTER ( typeQualifierList )?
             {
-                POINTER145 = (Token) match(input, POINTER,
-                        FOLLOW_POINTER_in_pointer2866);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_POINTER.add(POINTER145);
-                }
+            POINTER145=(Token)match(input,POINTER,FOLLOW_POINTER_in_pointer2870); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_POINTER.add(POINTER145);
+            }
 
-                // Grammar/CTFParser.g:823:11: ( typeQualifierList )?
-                int alt47 = 2;
-                int LA47_0 = input.LA(1);
+            // CTFParser.g:824:11: ( typeQualifierList )?
+            int alt47=2;
+            int LA47_0 = input.LA(1);
 
-                if ((LA47_0 == CONSTTOK)) {
-                    alt47 = 1;
-                }
-                switch (alt47) {
-                case 1:
-                // Grammar/CTFParser.g:823:11: typeQualifierList
-                {
-                    pushFollow(FOLLOW_typeQualifierList_in_pointer2868);
-                    typeQualifierList146 = typeQualifierList();
+            if ( (LA47_0==CONSTTOK) ) {
+                alt47=1;
+            }
+            switch (alt47) {
+                case 1 :
+                    // CTFParser.g:824:11: typeQualifierList
+                    {
+                    pushFollow(FOLLOW_typeQualifierList_in_pointer2872);
+                    typeQualifierList146=typeQualifierList();
 
                     state._fsp--;
                     if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
-                        stream_typeQualifierList.add(typeQualifierList146
-                                .getTree());
+                    if ( state.backtracking==0 ) {
+                        stream_typeQualifierList.add(typeQualifierList146.getTree());
                     }
 
-                }
+                    }
                     break;
 
-                }
+            }
 
-                // AST REWRITE
-                // elements: typeQualifierList, POINTER
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 823:30: -> ^( POINTER ( typeQualifierList )? )
-                    {
-                        // Grammar/CTFParser.g:823:33: ^( POINTER (
-                        // typeQualifierList )? )
-                        {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(
-                                    stream_POINTER.nextNode(), root_1);
 
-                            // Grammar/CTFParser.g:823:43: ( typeQualifierList
-                            // )?
-                            if (stream_typeQualifierList.hasNext()) {
-                                adaptor.addChild(root_1,
-                                        stream_typeQualifierList.nextTree());
+            // AST REWRITE
+            // elements: POINTER, typeQualifierList
+            // token labels:
+            // rule labels: retval
+            // token list labels:
+            // rule list labels:
+            // wildcard labels:
+            if ( state.backtracking==0 ) {
+            retval.tree = root_0;
+            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                            }
-                            stream_typeQualifierList.reset();
+            root_0 = (CommonTree)adaptor.nil();
+            // 824:30: -> ^( POINTER ( typeQualifierList )? )
+            {
+                // CTFParser.g:824:33: ^( POINTER ( typeQualifierList )? )
+                {
+                CommonTree root_1 = (CommonTree)adaptor.nil();
+                root_1 = (CommonTree)adaptor.becomeRoot(stream_POINTER.nextNode(), root_1);
 
-                            adaptor.addChild(root_0, root_1);
-                        }
+                // CTFParser.g:824:43: ( typeQualifierList )?
+                if ( stream_typeQualifierList.hasNext() ) {
+                    adaptor.addChild(root_1, stream_typeQualifierList.nextTree());
 
-                    }
+                }
+                stream_typeQualifierList.reset();
 
-                    retval.tree = root_0;
+                adaptor.addChild(root_0, root_1);
                 }
+
+            }
+
+            retval.tree = root_0;}
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                debug_print(input.toString(retval.start, input.LT(-1)));
+                debug_print(input.toString(retval.start,input.LT(-1)));
                 exit("pointer");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "pointer"
 
     public static class typeQualifierList_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "typeQualifierList"
-    // Grammar/CTFParser.g:826:1: typeQualifierList : ( typeQualifier )+ ;
-    public final CTFParser.typeQualifierList_return typeQualifierList()
-            throws RecognitionException {
+    // CTFParser.g:827:1: typeQualifierList : ( typeQualifier )+ ;
+    public final CTFParser.typeQualifierList_return typeQualifierList() throws RecognitionException {
         CTFParser.typeQualifierList_return retval = new CTFParser.typeQualifierList_return();
         retval.start = input.LT(1);
 
@@ -8471,175 +7388,154 @@ public class CTFParser extends Parser {
 
         CTFParser.typeQualifier_return typeQualifier147 = null;
 
+
+
         try {
-            // Grammar/CTFParser.g:826:19: ( ( typeQualifier )+ )
-            // Grammar/CTFParser.g:827:3: ( typeQualifier )+
+            // CTFParser.g:827:19: ( ( typeQualifier )+ )
+            // CTFParser.g:828:3: ( typeQualifier )+
             {
-                root_0 = (CommonTree) adaptor.nil();
+            root_0 = (CommonTree)adaptor.nil();
 
-                // Grammar/CTFParser.g:827:3: ( typeQualifier )+
-                int cnt48 = 0;
-                loop48: do {
-                    int alt48 = 2;
-                    int LA48_0 = input.LA(1);
+            // CTFParser.g:828:3: ( typeQualifier )+
+            int cnt48=0;
+            loop48:
+            do {
+                int alt48=2;
+                int LA48_0 = input.LA(1);
 
-                    if ((LA48_0 == CONSTTOK)) {
-                        alt48 = 1;
-                    }
+                if ( (LA48_0==CONSTTOK) ) {
+                    alt48=1;
+                }
 
-                    switch (alt48) {
-                    case 1:
-                    // Grammar/CTFParser.g:827:3: typeQualifier
-                    {
-                        pushFollow(FOLLOW_typeQualifier_in_typeQualifierList2891);
-                        typeQualifier147 = typeQualifier();
 
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            adaptor.addChild(root_0, typeQualifier147.getTree());
-                        }
+                switch (alt48) {
+               case 1 :
+                   // CTFParser.g:828:3: typeQualifier
+                   {
+                   pushFollow(FOLLOW_typeQualifier_in_typeQualifierList2895);
+                   typeQualifier147=typeQualifier();
 
+                   state._fsp--;
+                   if (state.failed) {
+                        return retval;
+                    }
+                   if ( state.backtracking==0 ) {
+                        adaptor.addChild(root_0, typeQualifier147.getTree());
                     }
-                        break;
 
-                    default:
-                        if (cnt48 >= 1) {
-                            break loop48;
-                        }
-                        if (state.backtracking > 0) {
-                            state.failed = true;
-                            return retval;
-                        }
-                        EarlyExitException eee = new EarlyExitException(48,
-                                input);
-                        throw eee;
+                   }
+                   break;
+
+               default :
+                   if ( cnt48 >= 1 ) {
+                        break loop48;
                     }
-                    cnt48++;
-                } while (true);
+                   if (state.backtracking>0) {state.failed=true; return retval;}
+                        EarlyExitException eee =
+                            new EarlyExitException(48, input);
+                        throw eee;
+                }
+                cnt48++;
+            } while (true);
+
 
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "typeQualifierList"
 
     public static class typedefName_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "typedefName"
-    // Grammar/CTFParser.g:830:1: typedefName : {...}? IDENTIFIER ;
-    public final CTFParser.typedefName_return typedefName()
-            throws RecognitionException {
+    // CTFParser.g:831:1: typedefName : {...}? IDENTIFIER ;
+    public final CTFParser.typedefName_return typedefName() throws RecognitionException {
         CTFParser.typedefName_return retval = new CTFParser.typedefName_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token IDENTIFIER148 = null;
+        Token IDENTIFIER148=null;
+
+        CommonTree IDENTIFIER148_tree=null;
 
-        CommonTree IDENTIFIER148_tree = null;
 
-        enter("typedefName");
+          enter("typedefName");
 
         try {
-            // Grammar/CTFParser.g:838:1: ({...}? IDENTIFIER )
-            // Grammar/CTFParser.g:839:3: {...}? IDENTIFIER
+            // CTFParser.g:839:1: ({...}? IDENTIFIER )
+            // CTFParser.g:840:3: {...}? IDENTIFIER
             {
-                root_0 = (CommonTree) adaptor.nil();
+            root_0 = (CommonTree)adaptor.nil();
 
-                if (!((inTypealiasAlias() || isTypeName(input.LT(1).getText())))) {
-                    if (state.backtracking > 0) {
-                        state.failed = true;
-                        return retval;
-                    }
-                    throw new FailedPredicateException(input, "typedefName",
-                            "inTypealiasAlias() || isTypeName(input.LT(1).getText())");
-                }
-                IDENTIFIER148 = (Token) match(input, IDENTIFIER,
-                        FOLLOW_IDENTIFIER_in_typedefName2917);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    IDENTIFIER148_tree = (CommonTree) adaptor
-                            .create(IDENTIFIER148);
-                    adaptor.addChild(root_0, IDENTIFIER148_tree);
-                }
-                if (state.backtracking == 0) {
-                    if ((inTypedef() || inTypealiasAlias())
-                            && !isTypeName((IDENTIFIER148 != null ? IDENTIFIER148
-                                    .getText() : null))) {
-                        addTypeName((IDENTIFIER148 != null ? IDENTIFIER148
-                                .getText() : null));
-                    }
-                }
+            if ( !((inTypealiasAlias() || isTypeName(input.LT(1).getText()))) ) {
+                if (state.backtracking>0) {state.failed=true; return retval;}
+                throw new FailedPredicateException(input, "typedefName", "inTypealiasAlias() || isTypeName(input.LT(1).getText())");
+            }
+            IDENTIFIER148=(Token)match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_typedefName2921); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+            IDENTIFIER148_tree = (CommonTree)adaptor.create(IDENTIFIER148);
+            adaptor.addChild(root_0, IDENTIFIER148_tree);
+            }
+            if ( state.backtracking==0 ) {
+               if ((inTypedef() || inTypealiasAlias()) && !isTypeName((IDENTIFIER148!=null?IDENTIFIER148.getText():null))) { addTypeName((IDENTIFIER148!=null?IDENTIFIER148.getText():null)); }
+            }
 
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                debug_print("typedefName: "
-                        + input.toString(retval.start, input.LT(-1)));
-                exit("typedefName");
+               debug_print("typedefName: " + input.toString(retval.start,input.LT(-1)));
+               exit("typedefName");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "typedefName"
 
     public static class typealiasTarget_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "typealiasTarget"
-    // Grammar/CTFParser.g:842:1: typealiasTarget : declarationSpecifiers (
-    // abstractDeclaratorList )? ;
-    public final CTFParser.typealiasTarget_return typealiasTarget()
-            throws RecognitionException {
+    // CTFParser.g:843:1: typealiasTarget : declarationSpecifiers ( abstractDeclaratorList )? ;
+    public final CTFParser.typealiasTarget_return typealiasTarget() throws RecognitionException {
         CTFParser.typealiasTarget_return retval = new CTFParser.typealiasTarget_return();
         retval.start = input.LT(1);
 
@@ -8649,94 +7545,89 @@ public class CTFParser extends Parser {
 
         CTFParser.abstractDeclaratorList_return abstractDeclaratorList150 = null;
 
-        enter("typealiasTarget");
+
+
+
+          enter("typealiasTarget");
 
         try {
-            // Grammar/CTFParser.g:855:1: ( declarationSpecifiers (
-            // abstractDeclaratorList )? )
-            // Grammar/CTFParser.g:856:3: declarationSpecifiers (
-            // abstractDeclaratorList )?
+            // CTFParser.g:856:1: ( declarationSpecifiers ( abstractDeclaratorList )? )
+            // CTFParser.g:857:3: declarationSpecifiers ( abstractDeclaratorList )?
             {
-                root_0 = (CommonTree) adaptor.nil();
+            root_0 = (CommonTree)adaptor.nil();
 
-                pushFollow(FOLLOW_declarationSpecifiers_in_typealiasTarget2945);
-                declarationSpecifiers149 = declarationSpecifiers();
+            pushFollow(FOLLOW_declarationSpecifiers_in_typealiasTarget2949);
+            declarationSpecifiers149=declarationSpecifiers();
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    adaptor.addChild(root_0, declarationSpecifiers149.getTree());
-                }
-                // Grammar/CTFParser.g:856:25: ( abstractDeclaratorList )?
-                int alt49 = 2;
-                int LA49_0 = input.LA(1);
+            state._fsp--;
+            if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                adaptor.addChild(root_0, declarationSpecifiers149.getTree());
+            }
+            // CTFParser.g:857:25: ( abstractDeclaratorList )?
+            int alt49=2;
+            int LA49_0 = input.LA(1);
 
-                if (((LA49_0 == LPAREN) || (LA49_0 == POINTER) || (LA49_0 == IDENTIFIER))) {
-                    alt49 = 1;
-                }
-                switch (alt49) {
-                case 1:
-                // Grammar/CTFParser.g:856:25: abstractDeclaratorList
-                {
-                    pushFollow(FOLLOW_abstractDeclaratorList_in_typealiasTarget2947);
-                    abstractDeclaratorList150 = abstractDeclaratorList();
+            if ( (LA49_0==LPAREN||LA49_0==POINTER||LA49_0==IDENTIFIER) ) {
+                alt49=1;
+            }
+            switch (alt49) {
+                case 1 :
+                    // CTFParser.g:857:25: abstractDeclaratorList
+                    {
+                    pushFollow(FOLLOW_abstractDeclaratorList_in_typealiasTarget2951);
+                    abstractDeclaratorList150=abstractDeclaratorList();
 
                     state._fsp--;
                     if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
-                        adaptor.addChild(root_0,
-                                abstractDeclaratorList150.getTree());
+                    if ( state.backtracking==0 ) {
+                        adaptor.addChild(root_0, abstractDeclaratorList150.getTree());
                     }
 
-                }
+                    }
                     break;
 
-                }
+            }
+
 
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                exit("typealiasTarget");
+               exit("typealiasTarget");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "typealiasTarget"
 
     public static class typealiasAlias_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "typealiasAlias"
-    // Grammar/CTFParser.g:859:1: typealiasAlias : ( abstractDeclaratorList | (
-    // declarationSpecifiers ( abstractDeclaratorList )? ) ) ;
-    public final CTFParser.typealiasAlias_return typealiasAlias()
-            throws RecognitionException {
+    // CTFParser.g:860:1: typealiasAlias : ( abstractDeclaratorList | ( declarationSpecifiers ( abstractDeclaratorList )? ) ) ;
+    public final CTFParser.typealiasAlias_return typealiasAlias() throws RecognitionException {
         CTFParser.typealiasAlias_return retval = new CTFParser.typealiasAlias_return();
         retval.start = input.LT(1);
 
@@ -8748,166 +7639,158 @@ public class CTFParser extends Parser {
 
         CTFParser.abstractDeclaratorList_return abstractDeclaratorList153 = null;
 
-        enter("typealiasAlias");
-        typealiasAliasOn();
+
+
+
+          enter("typealiasAlias");
+          typealiasAliasOn();
 
         try {
-            // Grammar/CTFParser.g:874:1: ( ( abstractDeclaratorList | (
-            // declarationSpecifiers ( abstractDeclaratorList )? ) ) )
-            // Grammar/CTFParser.g:875:3: ( abstractDeclaratorList | (
-            // declarationSpecifiers ( abstractDeclaratorList )? ) )
+            // CTFParser.g:875:1: ( ( abstractDeclaratorList | ( declarationSpecifiers ( abstractDeclaratorList )? ) ) )
+            // CTFParser.g:876:3: ( abstractDeclaratorList | ( declarationSpecifiers ( abstractDeclaratorList )? ) )
             {
-                root_0 = (CommonTree) adaptor.nil();
-
-                // Grammar/CTFParser.g:875:3: ( abstractDeclaratorList | (
-                // declarationSpecifiers ( abstractDeclaratorList )? ) )
-                int alt51 = 2;
-                switch (input.LA(1)) {
-                case LPAREN:
-                case POINTER: {
-                    alt51 = 1;
-                }
-                    break;
-                case IDENTIFIER: {
-                    int LA51_2 = input.LA(2);
-
-                    if ((!(((inTypealiasAlias() || isTypeName(input.LT(1)
-                            .getText())))))) {
-                        alt51 = 1;
-                    } else if (((inTypealiasAlias() || isTypeName(input.LT(1)
-                            .getText())))) {
-                        alt51 = 2;
-                    } else {
-                        if (state.backtracking > 0) {
-                            state.failed = true;
-                            return retval;
-                        }
-                        NoViableAltException nvae = new NoViableAltException(
-                                "", 51, 2, input);
+            root_0 = (CommonTree)adaptor.nil();
 
-                        throw nvae;
-                    }
-                }
-                    break;
-                case CONSTTOK:
-                case CHARTOK:
-                case DOUBLETOK:
-                case ENUMTOK:
-                case FLOATINGPOINTTOK:
-                case FLOATTOK:
-                case INTEGERTOK:
-                case INTTOK:
-                case LONGTOK:
-                case SHORTTOK:
-                case SIGNEDTOK:
-                case STRINGTOK:
-                case STRUCTTOK:
-                case TYPEDEFTOK:
-                case UNSIGNEDTOK:
-                case VARIANTTOK:
-                case VOIDTOK:
-                case BOOLTOK:
-                case COMPLEXTOK:
-                case IMAGINARYTOK: {
-                    alt51 = 2;
+            // CTFParser.g:876:3: ( abstractDeclaratorList | ( declarationSpecifiers ( abstractDeclaratorList )? ) )
+            int alt51=2;
+            switch ( input.LA(1) ) {
+            case LPAREN:
+            case POINTER:
+                {
+                alt51=1;
                 }
-                    break;
-                default:
-                    if (state.backtracking > 0) {
-                        state.failed = true;
-                        return retval;
-                    }
-                    NoViableAltException nvae = new NoViableAltException("",
-                            51, 0, input);
+                break;
+            case IDENTIFIER:
+                {
+                int LA51_2 = input.LA(2);
 
-                    throw nvae;
+                if ( (!(((inTypealiasAlias() || isTypeName(input.LT(1).getText()))))) ) {
+                    alt51=1;
+                }
+                else if ( ((inTypealiasAlias() || isTypeName(input.LT(1).getText()))) ) {
+                    alt51=2;
                 }
+                else {
+                    if (state.backtracking>0) {state.failed=true; return retval;}
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 51, 2, input);
 
-                switch (alt51) {
-                case 1:
-                // Grammar/CTFParser.g:876:3: abstractDeclaratorList
+                    throw nvae;
+                }
+                }
+                break;
+            case CONSTTOK:
+            case CHARTOK:
+            case DOUBLETOK:
+            case ENUMTOK:
+            case FLOATINGPOINTTOK:
+            case FLOATTOK:
+            case INTEGERTOK:
+            case INTTOK:
+            case LONGTOK:
+            case SHORTTOK:
+            case SIGNEDTOK:
+            case STRINGTOK:
+            case STRUCTTOK:
+            case TYPEDEFTOK:
+            case UNSIGNEDTOK:
+            case VARIANTTOK:
+            case VOIDTOK:
+            case BOOLTOK:
+            case COMPLEXTOK:
+            case IMAGINARYTOK:
                 {
-                    pushFollow(FOLLOW_abstractDeclaratorList_in_typealiasAlias2980);
-                    abstractDeclaratorList151 = abstractDeclaratorList();
+                alt51=2;
+                }
+                break;
+            default:
+                if (state.backtracking>0) {state.failed=true; return retval;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 51, 0, input);
+
+                throw nvae;
+            }
+
+            switch (alt51) {
+                case 1 :
+                    // CTFParser.g:877:3: abstractDeclaratorList
+                    {
+                    pushFollow(FOLLOW_abstractDeclaratorList_in_typealiasAlias2984);
+                    abstractDeclaratorList151=abstractDeclaratorList();
 
                     state._fsp--;
                     if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
-                        adaptor.addChild(root_0,
-                                abstractDeclaratorList151.getTree());
+                    if ( state.backtracking==0 ) {
+                        adaptor.addChild(root_0, abstractDeclaratorList151.getTree());
                     }
 
-                }
+                    }
                     break;
-                case 2:
-                // Grammar/CTFParser.g:878:3: ( declarationSpecifiers (
-                // abstractDeclaratorList )? )
-                {
-                    // Grammar/CTFParser.g:878:3: ( declarationSpecifiers (
-                    // abstractDeclaratorList )? )
-                    // Grammar/CTFParser.g:878:4: declarationSpecifiers (
-                    // abstractDeclaratorList )?
+                case 2 :
+                    // CTFParser.g:879:3: ( declarationSpecifiers ( abstractDeclaratorList )? )
                     {
-                        pushFollow(FOLLOW_declarationSpecifiers_in_typealiasAlias2989);
-                        declarationSpecifiers152 = declarationSpecifiers();
+                    // CTFParser.g:879:3: ( declarationSpecifiers ( abstractDeclaratorList )? )
+                    // CTFParser.g:879:4: declarationSpecifiers ( abstractDeclaratorList )?
+                    {
+                    pushFollow(FOLLOW_declarationSpecifiers_in_typealiasAlias2993);
+                    declarationSpecifiers152=declarationSpecifiers();
 
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            adaptor.addChild(root_0,
-                                    declarationSpecifiers152.getTree());
-                        }
-                        // Grammar/CTFParser.g:878:26: ( abstractDeclaratorList
-                        // )?
-                        int alt50 = 2;
-                        int LA50_0 = input.LA(1);
+                    state._fsp--;
+                    if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        adaptor.addChild(root_0, declarationSpecifiers152.getTree());
+                    }
+                    // CTFParser.g:879:26: ( abstractDeclaratorList )?
+                    int alt50=2;
+                    int LA50_0 = input.LA(1);
 
-                        if (((LA50_0 == LPAREN) || (LA50_0 == POINTER) || (LA50_0 == IDENTIFIER))) {
-                            alt50 = 1;
-                        }
-                        switch (alt50) {
-                        case 1:
-                        // Grammar/CTFParser.g:878:26: abstractDeclaratorList
-                        {
-                            pushFollow(FOLLOW_abstractDeclaratorList_in_typealiasAlias2991);
-                            abstractDeclaratorList153 = abstractDeclaratorList();
+                    if ( (LA50_0==LPAREN||LA50_0==POINTER||LA50_0==IDENTIFIER) ) {
+                        alt50=1;
+                    }
+                    switch (alt50) {
+                        case 1 :
+                            // CTFParser.g:879:26: abstractDeclaratorList
+                            {
+                            pushFollow(FOLLOW_abstractDeclaratorList_in_typealiasAlias2995);
+                            abstractDeclaratorList153=abstractDeclaratorList();
 
                             state._fsp--;
                             if (state.failed) {
                                 return retval;
                             }
-                            if (state.backtracking == 0) {
-                                adaptor.addChild(root_0,
-                                        abstractDeclaratorList153.getTree());
+                            if ( state.backtracking==0 ) {
+                                adaptor.addChild(root_0, abstractDeclaratorList153.getTree());
                             }
 
-                        }
+                            }
                             break;
 
-                        }
+                    }
+
 
                     }
 
-                }
+
+                    }
                     break;
 
-                }
+            }
+
 
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 exit("typealiasAlias");
                 typealiasAliasOff();
@@ -8915,282 +7798,231 @@ public class CTFParser extends Parser {
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "typealiasAlias"
 
     public static class typealiasDecl_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "typealiasDecl"
-    // Grammar/CTFParser.g:882:1: typealiasDecl : TYPEALIASTOK typealiasTarget
-    // TYPE_ASSIGNMENT typealiasAlias -> ^( TYPEALIAS ^( TYPEALIAS_TARGET
-    // typealiasTarget ) ^( TYPEALIAS_ALIAS typealiasAlias ) ) ;
-    public final CTFParser.typealiasDecl_return typealiasDecl()
-            throws RecognitionException {
+    // CTFParser.g:883:1: typealiasDecl : TYPEALIASTOK typealiasTarget TYPE_ASSIGNMENT typealiasAlias -> ^( TYPEALIAS ^( TYPEALIAS_TARGET typealiasTarget ) ^( TYPEALIAS_ALIAS typealiasAlias ) ) ;
+    public final CTFParser.typealiasDecl_return typealiasDecl() throws RecognitionException {
         CTFParser.typealiasDecl_return retval = new CTFParser.typealiasDecl_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token TYPEALIASTOK154 = null;
-        Token TYPE_ASSIGNMENT156 = null;
+        Token TYPEALIASTOK154=null;
+        Token TYPE_ASSIGNMENT156=null;
         CTFParser.typealiasTarget_return typealiasTarget155 = null;
 
         CTFParser.typealiasAlias_return typealiasAlias157 = null;
 
-        CommonTree TYPEALIASTOK154_tree = null;
-        CommonTree TYPE_ASSIGNMENT156_tree = null;
-        RewriteRuleTokenStream stream_TYPE_ASSIGNMENT = new RewriteRuleTokenStream(
-                adaptor, "token TYPE_ASSIGNMENT");
-        RewriteRuleTokenStream stream_TYPEALIASTOK = new RewriteRuleTokenStream(
-                adaptor, "token TYPEALIASTOK");
-        RewriteRuleSubtreeStream stream_typealiasAlias = new RewriteRuleSubtreeStream(
-                adaptor, "rule typealiasAlias");
-        RewriteRuleSubtreeStream stream_typealiasTarget = new RewriteRuleSubtreeStream(
-                adaptor, "rule typealiasTarget");
 
-        enter("typealiasDecl");
+        CommonTree TYPEALIASTOK154_tree=null;
+        CommonTree TYPE_ASSIGNMENT156_tree=null;
+        RewriteRuleTokenStream stream_TYPE_ASSIGNMENT=new RewriteRuleTokenStream(adaptor,"token TYPE_ASSIGNMENT");
+        RewriteRuleTokenStream stream_TYPEALIASTOK=new RewriteRuleTokenStream(adaptor,"token TYPEALIASTOK");
+        RewriteRuleSubtreeStream stream_typealiasAlias=new RewriteRuleSubtreeStream(adaptor,"rule typealiasAlias");
+        RewriteRuleSubtreeStream stream_typealiasTarget=new RewriteRuleSubtreeStream(adaptor,"rule typealiasTarget");
+
+          enter("typealiasDecl");
 
         try {
-            // Grammar/CTFParser.g:889:1: ( TYPEALIASTOK typealiasTarget
-            // TYPE_ASSIGNMENT typealiasAlias -> ^( TYPEALIAS ^(
-            // TYPEALIAS_TARGET typealiasTarget ) ^( TYPEALIAS_ALIAS
-            // typealiasAlias ) ) )
-            // Grammar/CTFParser.g:890:3: TYPEALIASTOK typealiasTarget
-            // TYPE_ASSIGNMENT typealiasAlias
+            // CTFParser.g:890:1: ( TYPEALIASTOK typealiasTarget TYPE_ASSIGNMENT typealiasAlias -> ^( TYPEALIAS ^( TYPEALIAS_TARGET typealiasTarget ) ^( TYPEALIAS_ALIAS typealiasAlias ) ) )
+            // CTFParser.g:891:3: TYPEALIASTOK typealiasTarget TYPE_ASSIGNMENT typealiasAlias
             {
-                TYPEALIASTOK154 = (Token) match(input, TYPEALIASTOK,
-                        FOLLOW_TYPEALIASTOK_in_typealiasDecl3023);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_TYPEALIASTOK.add(TYPEALIASTOK154);
-                }
+            TYPEALIASTOK154=(Token)match(input,TYPEALIASTOK,FOLLOW_TYPEALIASTOK_in_typealiasDecl3027); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_TYPEALIASTOK.add(TYPEALIASTOK154);
+            }
 
-                pushFollow(FOLLOW_typealiasTarget_in_typealiasDecl3025);
-                typealiasTarget155 = typealiasTarget();
+            pushFollow(FOLLOW_typealiasTarget_in_typealiasDecl3029);
+            typealiasTarget155=typealiasTarget();
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_typealiasTarget.add(typealiasTarget155.getTree());
-                }
-                TYPE_ASSIGNMENT156 = (Token) match(input, TYPE_ASSIGNMENT,
-                        FOLLOW_TYPE_ASSIGNMENT_in_typealiasDecl3027);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_TYPE_ASSIGNMENT.add(TYPE_ASSIGNMENT156);
-                }
+            state._fsp--;
+            if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_typealiasTarget.add(typealiasTarget155.getTree());
+            }
+            TYPE_ASSIGNMENT156=(Token)match(input,TYPE_ASSIGNMENT,FOLLOW_TYPE_ASSIGNMENT_in_typealiasDecl3031); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_TYPE_ASSIGNMENT.add(TYPE_ASSIGNMENT156);
+            }
 
-                pushFollow(FOLLOW_typealiasAlias_in_typealiasDecl3029);
-                typealiasAlias157 = typealiasAlias();
+            pushFollow(FOLLOW_typealiasAlias_in_typealiasDecl3033);
+            typealiasAlias157=typealiasAlias();
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_typealiasAlias.add(typealiasAlias157.getTree());
-                }
+            state._fsp--;
+            if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_typealiasAlias.add(typealiasAlias157.getTree());
+            }
 
-                // AST REWRITE
-                // elements: typealiasTarget, typealiasAlias
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
-
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 891:3: -> ^( TYPEALIAS ^( TYPEALIAS_TARGET
-                    // typealiasTarget ) ^( TYPEALIAS_ALIAS typealiasAlias ) )
-                    {
-                        // Grammar/CTFParser.g:891:6: ^( TYPEALIAS ^(
-                        // TYPEALIAS_TARGET typealiasTarget ) ^( TYPEALIAS_ALIAS
-                        // typealiasAlias ) )
-                        {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(
-                                    adaptor.create(TYPEALIAS, "TYPEALIAS"),
-                                    root_1);
 
-                            // Grammar/CTFParser.g:891:18: ^( TYPEALIAS_TARGET
-                            // typealiasTarget )
-                            {
-                                CommonTree root_2 = (CommonTree) adaptor.nil();
-                                root_2 = (CommonTree) adaptor.becomeRoot(
-                                        adaptor.create(TYPEALIAS_TARGET,
-                                                "TYPEALIAS_TARGET"), root_2);
+            // AST REWRITE
+            // elements: typealiasAlias, typealiasTarget
+            // token labels:
+            // rule labels: retval
+            // token list labels:
+            // rule list labels:
+            // wildcard labels:
+            if ( state.backtracking==0 ) {
+            retval.tree = root_0;
+            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                                adaptor.addChild(root_2,
-                                        stream_typealiasTarget.nextTree());
+            root_0 = (CommonTree)adaptor.nil();
+            // 892:3: -> ^( TYPEALIAS ^( TYPEALIAS_TARGET typealiasTarget ) ^( TYPEALIAS_ALIAS typealiasAlias ) )
+            {
+                // CTFParser.g:892:6: ^( TYPEALIAS ^( TYPEALIAS_TARGET typealiasTarget ) ^( TYPEALIAS_ALIAS typealiasAlias ) )
+                {
+                CommonTree root_1 = (CommonTree)adaptor.nil();
+                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TYPEALIAS, "TYPEALIAS"), root_1);
 
-                                adaptor.addChild(root_1, root_2);
-                            }
-                            // Grammar/CTFParser.g:891:54: ^( TYPEALIAS_ALIAS
-                            // typealiasAlias )
-                            {
-                                CommonTree root_2 = (CommonTree) adaptor.nil();
-                                root_2 = (CommonTree) adaptor.becomeRoot(
-                                        adaptor.create(TYPEALIAS_ALIAS,
-                                                "TYPEALIAS_ALIAS"), root_2);
+                // CTFParser.g:892:18: ^( TYPEALIAS_TARGET typealiasTarget )
+                {
+                CommonTree root_2 = (CommonTree)adaptor.nil();
+                root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TYPEALIAS_TARGET, "TYPEALIAS_TARGET"), root_2);
 
-                                adaptor.addChild(root_2,
-                                        stream_typealiasAlias.nextTree());
+                adaptor.addChild(root_2, stream_typealiasTarget.nextTree());
 
-                                adaptor.addChild(root_1, root_2);
-                            }
+                adaptor.addChild(root_1, root_2);
+                }
+                // CTFParser.g:892:54: ^( TYPEALIAS_ALIAS typealiasAlias )
+                {
+                CommonTree root_2 = (CommonTree)adaptor.nil();
+                root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TYPEALIAS_ALIAS, "TYPEALIAS_ALIAS"), root_2);
 
-                            adaptor.addChild(root_0, root_1);
-                        }
+                adaptor.addChild(root_2, stream_typealiasAlias.nextTree());
 
-                    }
+                adaptor.addChild(root_1, root_2);
+                }
 
-                    retval.tree = root_0;
+                adaptor.addChild(root_0, root_1);
                 }
+
+            }
+
+            retval.tree = root_0;}
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 exit("typealiasDecl");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "typealiasDecl"
 
     public static class ctfKeyword_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "ctfKeyword"
-    // Grammar/CTFParser.g:897:1: ctfKeyword : ( ALIGNTOK | EVENTTOK | SIGNEDTOK
-    // | STRINGTOK );
-    public final CTFParser.ctfKeyword_return ctfKeyword()
-            throws RecognitionException {
+    // CTFParser.g:898:1: ctfKeyword : ( ALIGNTOK | EVENTTOK | SIGNEDTOK | STRINGTOK );
+    public final CTFParser.ctfKeyword_return ctfKeyword() throws RecognitionException {
         CTFParser.ctfKeyword_return retval = new CTFParser.ctfKeyword_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token set158 = null;
+        Token set158=null;
 
-        CommonTree set158_tree = null;
+        CommonTree set158_tree=null;
 
-        enter("ctfKeyword");
+
+          enter("ctfKeyword");
 
         try {
-            // Grammar/CTFParser.g:905:1: ( ALIGNTOK | EVENTTOK | SIGNEDTOK |
-            // STRINGTOK )
-            // Grammar/CTFParser.g:
+            // CTFParser.g:906:1: ( ALIGNTOK | EVENTTOK | SIGNEDTOK | STRINGTOK )
+            // CTFParser.g:
             {
-                root_0 = (CommonTree) adaptor.nil();
-
-                set158 = input.LT(1);
-                if ((input.LA(1) == ALIGNTOK) || (input.LA(1) == EVENTTOK)
-                        || (input.LA(1) == SIGNEDTOK)
-                        || (input.LA(1) == STRINGTOK)) {
-                    input.consume();
-                    if (state.backtracking == 0) {
-                        adaptor.addChild(root_0, adaptor.create(set158));
-                    }
-                    state.errorRecovery = false;
-                    state.failed = false;
-                } else {
-                    if (state.backtracking > 0) {
-                        state.failed = true;
-                        return retval;
-                    }
-                    MismatchedSetException mse = new MismatchedSetException(
-                            null, input);
-                    throw mse;
+            root_0 = (CommonTree)adaptor.nil();
+
+            set158=(Token)input.LT(1);
+            if ( input.LA(1)==ALIGNTOK||input.LA(1)==EVENTTOK||input.LA(1)==SIGNEDTOK||input.LA(1)==STRINGTOK ) {
+                input.consume();
+                if ( state.backtracking==0 ) {
+                    adaptor.addChild(root_0, (CommonTree)adaptor.create(set158));
                 }
+                state.errorRecovery=false;state.failed=false;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return retval;}
+                MismatchedSetException mse = new MismatchedSetException(null,input);
+                throw mse;
+            }
+
 
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                debug_print(input.toString(retval.start, input.LT(-1)));
+                debug_print(input.toString(retval.start,input.LT(-1)));
                 exit("ctfKeyword");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "ctfKeyword"
 
     public static class ctfSpecifier_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "ctfSpecifier"
-    // Grammar/CTFParser.g:912:1: ctfSpecifier : ( ctfSpecifierHead ctfBody ->
-    // ^( ctfSpecifierHead ctfBody ) | typealiasDecl -> ^( DECLARATION
-    // typealiasDecl ) );
-    public final CTFParser.ctfSpecifier_return ctfSpecifier()
-            throws RecognitionException {
+    // CTFParser.g:913:1: ctfSpecifier : ( ctfSpecifierHead ctfBody -> ^( ctfSpecifierHead ctfBody ) | typealiasDecl -> ^( DECLARATION typealiasDecl ) );
+    public final CTFParser.ctfSpecifier_return ctfSpecifier() throws RecognitionException {
         CTFParser.ctfSpecifier_return retval = new CTFParser.ctfSpecifier_return();
         retval.start = input.LT(1);
 
@@ -9202,781 +8034,735 @@ public class CTFParser extends Parser {
 
         CTFParser.typealiasDecl_return typealiasDecl161 = null;
 
-        RewriteRuleSubtreeStream stream_ctfSpecifierHead = new RewriteRuleSubtreeStream(
-                adaptor, "rule ctfSpecifierHead");
-        RewriteRuleSubtreeStream stream_typealiasDecl = new RewriteRuleSubtreeStream(
-                adaptor, "rule typealiasDecl");
-        RewriteRuleSubtreeStream stream_ctfBody = new RewriteRuleSubtreeStream(
-                adaptor, "rule ctfBody");
 
-        enter("ctfSpecifier");
+        RewriteRuleSubtreeStream stream_ctfSpecifierHead=new RewriteRuleSubtreeStream(adaptor,"rule ctfSpecifierHead");
+        RewriteRuleSubtreeStream stream_typealiasDecl=new RewriteRuleSubtreeStream(adaptor,"rule typealiasDecl");
+        RewriteRuleSubtreeStream stream_ctfBody=new RewriteRuleSubtreeStream(adaptor,"rule ctfBody");
+
+          enter("ctfSpecifier");
 
         try {
-            // Grammar/CTFParser.g:919:3: ( ctfSpecifierHead ctfBody -> ^(
-            // ctfSpecifierHead ctfBody ) | typealiasDecl -> ^( DECLARATION
-            // typealiasDecl ) )
-            int alt52 = 2;
+            // CTFParser.g:920:3: ( ctfSpecifierHead ctfBody -> ^( ctfSpecifierHead ctfBody ) | typealiasDecl -> ^( DECLARATION typealiasDecl ) )
+            int alt52=2;
             int LA52_0 = input.LA(1);
 
-            if (((LA52_0 == EVENTTOK) || (LA52_0 == STREAMTOK)
-                    || (LA52_0 == TRACETOK) || ((LA52_0 >= ENVTOK) && (LA52_0 <= CLOCKTOK)))) {
-                alt52 = 1;
-            } else if ((LA52_0 == TYPEALIASTOK)) {
-                alt52 = 2;
-            } else {
-                if (state.backtracking > 0) {
-                    state.failed = true;
-                    return retval;
-                }
-                NoViableAltException nvae = new NoViableAltException("", 52, 0,
-                        input);
+            if ( (LA52_0==EVENTTOK||LA52_0==STREAMTOK||LA52_0==TRACETOK||(LA52_0>=ENVTOK && LA52_0<=CALLSITETOK)) ) {
+                alt52=1;
+            }
+            else if ( (LA52_0==TYPEALIASTOK) ) {
+                alt52=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return retval;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 52, 0, input);
 
                 throw nvae;
             }
             switch (alt52) {
-            case 1:
-            // Grammar/CTFParser.g:921:3: ctfSpecifierHead ctfBody
-            {
-                pushFollow(FOLLOW_ctfSpecifierHead_in_ctfSpecifier3123);
-                ctfSpecifierHead159 = ctfSpecifierHead();
+                case 1 :
+                    // CTFParser.g:922:3: ctfSpecifierHead ctfBody
+                    {
+                    pushFollow(FOLLOW_ctfSpecifierHead_in_ctfSpecifier3127);
+                    ctfSpecifierHead159=ctfSpecifierHead();
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_ctfSpecifierHead.add(ctfSpecifierHead159.getTree());
-                }
-                pushFollow(FOLLOW_ctfBody_in_ctfSpecifier3125);
-                ctfBody160 = ctfBody();
+                    state._fsp--;
+                    if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        stream_ctfSpecifierHead.add(ctfSpecifierHead159.getTree());
+                    }
+                    pushFollow(FOLLOW_ctfBody_in_ctfSpecifier3129);
+                    ctfBody160=ctfBody();
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_ctfBody.add(ctfBody160.getTree());
-                }
+                    state._fsp--;
+                    if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        stream_ctfBody.add(ctfBody160.getTree());
+                    }
 
-                // AST REWRITE
-                // elements: ctfBody, ctfSpecifierHead
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
+
+                    // AST REWRITE
+                    // elements: ctfSpecifierHead, ctfBody
+                    // token labels:
+                    // rule labels: retval
+                    // token list labels:
+                    // rule list labels:
+                    // wildcard labels:
+                    if ( state.backtracking==0 ) {
                     retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
+                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 921:28: -> ^( ctfSpecifierHead ctfBody )
+                    root_0 = (CommonTree)adaptor.nil();
+                    // 922:28: -> ^( ctfSpecifierHead ctfBody )
                     {
-                        // Grammar/CTFParser.g:921:31: ^( ctfSpecifierHead
-                        // ctfBody )
+                        // CTFParser.g:922:31: ^( ctfSpecifierHead ctfBody )
                         {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(
-                                    stream_ctfSpecifierHead.nextNode(), root_1);
+                        CommonTree root_1 = (CommonTree)adaptor.nil();
+                        root_1 = (CommonTree)adaptor.becomeRoot(stream_ctfSpecifierHead.nextNode(), root_1);
 
-                            adaptor.addChild(root_1, stream_ctfBody.nextTree());
+                        adaptor.addChild(root_1, stream_ctfBody.nextTree());
 
-                            adaptor.addChild(root_0, root_1);
+                        adaptor.addChild(root_0, root_1);
                         }
 
                     }
 
-                    retval.tree = root_0;
-                }
-            }
-                break;
-            case 2:
-            // Grammar/CTFParser.g:924:3: typealiasDecl
-            {
-                pushFollow(FOLLOW_typealiasDecl_in_ctfSpecifier3144);
-                typealiasDecl161 = typealiasDecl();
+                    retval.tree = root_0;}
+                    }
+                    break;
+                case 2 :
+                    // CTFParser.g:925:3: typealiasDecl
+                    {
+                    pushFollow(FOLLOW_typealiasDecl_in_ctfSpecifier3148);
+                    typealiasDecl161=typealiasDecl();
+
+                    state._fsp--;
+                    if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        stream_typealiasDecl.add(typealiasDecl161.getTree());
+                    }
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_typealiasDecl.add(typealiasDecl161.getTree());
-                }
 
-                // AST REWRITE
-                // elements: typealiasDecl
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
+                    // AST REWRITE
+                    // elements: typealiasDecl
+                    // token labels:
+                    // rule labels: retval
+                    // token list labels:
+                    // rule list labels:
+                    // wildcard labels:
+                    if ( state.backtracking==0 ) {
                     retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
+                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 924:17: -> ^( DECLARATION typealiasDecl )
+                    root_0 = (CommonTree)adaptor.nil();
+                    // 925:17: -> ^( DECLARATION typealiasDecl )
                     {
-                        // Grammar/CTFParser.g:924:20: ^( DECLARATION
-                        // typealiasDecl )
+                        // CTFParser.g:925:20: ^( DECLARATION typealiasDecl )
                         {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(
-                                    adaptor.create(DECLARATION, "DECLARATION"),
-                                    root_1);
+                        CommonTree root_1 = (CommonTree)adaptor.nil();
+                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(DECLARATION, "DECLARATION"), root_1);
 
-                            adaptor.addChild(root_1,
-                                    stream_typealiasDecl.nextTree());
+                        adaptor.addChild(root_1, stream_typealiasDecl.nextTree());
 
-                            adaptor.addChild(root_0, root_1);
+                        adaptor.addChild(root_0, root_1);
                         }
 
                     }
 
-                    retval.tree = root_0;
-                }
-            }
-                break;
+                    retval.tree = root_0;}
+                    }
+                    break;
 
             }
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 exit("ctfSpecifier");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "ctfSpecifier"
 
     public static class ctfSpecifierHead_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "ctfSpecifierHead"
-    // Grammar/CTFParser.g:927:1: ctfSpecifierHead : ( EVENTTOK -> EVENT |
-    // STREAMTOK -> STREAM | TRACETOK -> TRACE | ENVTOK -> ENV | CLOCKTOK ->
-    // CLOCK );
-    public final CTFParser.ctfSpecifierHead_return ctfSpecifierHead()
-            throws RecognitionException {
+    // CTFParser.g:928:1: ctfSpecifierHead : ( EVENTTOK -> EVENT | STREAMTOK -> STREAM | TRACETOK -> TRACE | ENVTOK -> ENV | CLOCKTOK -> CLOCK | CALLSITETOK -> CALLSITE );
+    public final CTFParser.ctfSpecifierHead_return ctfSpecifierHead() throws RecognitionException {
         CTFParser.ctfSpecifierHead_return retval = new CTFParser.ctfSpecifierHead_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token EVENTTOK162 = null;
-        Token STREAMTOK163 = null;
-        Token TRACETOK164 = null;
-        Token ENVTOK165 = null;
-        Token CLOCKTOK166 = null;
-
-        CommonTree EVENTTOK162_tree = null;
-        CommonTree STREAMTOK163_tree = null;
-        CommonTree TRACETOK164_tree = null;
-        CommonTree ENVTOK165_tree = null;
-        CommonTree CLOCKTOK166_tree = null;
-        RewriteRuleTokenStream stream_EVENTTOK = new RewriteRuleTokenStream(
-                adaptor, "token EVENTTOK");
-        RewriteRuleTokenStream stream_STREAMTOK = new RewriteRuleTokenStream(
-                adaptor, "token STREAMTOK");
-        RewriteRuleTokenStream stream_ENVTOK = new RewriteRuleTokenStream(
-                adaptor, "token ENVTOK");
-        RewriteRuleTokenStream stream_CLOCKTOK = new RewriteRuleTokenStream(
-                adaptor, "token CLOCKTOK");
-        RewriteRuleTokenStream stream_TRACETOK = new RewriteRuleTokenStream(
-                adaptor, "token TRACETOK");
-
-        enter("ctfSpecifierHead");
+        Token EVENTTOK162=null;
+        Token STREAMTOK163=null;
+        Token TRACETOK164=null;
+        Token ENVTOK165=null;
+        Token CLOCKTOK166=null;
+        Token CALLSITETOK167=null;
+
+        CommonTree EVENTTOK162_tree=null;
+        CommonTree STREAMTOK163_tree=null;
+        CommonTree TRACETOK164_tree=null;
+        CommonTree ENVTOK165_tree=null;
+        CommonTree CLOCKTOK166_tree=null;
+        CommonTree CALLSITETOK167_tree=null;
+        RewriteRuleTokenStream stream_EVENTTOK=new RewriteRuleTokenStream(adaptor,"token EVENTTOK");
+        RewriteRuleTokenStream stream_CALLSITETOK=new RewriteRuleTokenStream(adaptor,"token CALLSITETOK");
+        RewriteRuleTokenStream stream_STREAMTOK=new RewriteRuleTokenStream(adaptor,"token STREAMTOK");
+        RewriteRuleTokenStream stream_ENVTOK=new RewriteRuleTokenStream(adaptor,"token ENVTOK");
+        RewriteRuleTokenStream stream_CLOCKTOK=new RewriteRuleTokenStream(adaptor,"token CLOCKTOK");
+        RewriteRuleTokenStream stream_TRACETOK=new RewriteRuleTokenStream(adaptor,"token TRACETOK");
+
+
+          enter("ctfSpecifierHead");
 
         try {
-            // Grammar/CTFParser.g:935:1: ( EVENTTOK -> EVENT | STREAMTOK ->
-            // STREAM | TRACETOK -> TRACE | ENVTOK -> ENV | CLOCKTOK -> CLOCK )
-            int alt53 = 5;
-            switch (input.LA(1)) {
-            case EVENTTOK: {
-                alt53 = 1;
-            }
+            // CTFParser.g:936:1: ( EVENTTOK -> EVENT | STREAMTOK -> STREAM | TRACETOK -> TRACE | ENVTOK -> ENV | CLOCKTOK -> CLOCK | CALLSITETOK -> CALLSITE )
+            int alt53=6;
+            switch ( input.LA(1) ) {
+            case EVENTTOK:
+                {
+                alt53=1;
+                }
                 break;
-            case STREAMTOK: {
-                alt53 = 2;
-            }
+            case STREAMTOK:
+                {
+                alt53=2;
+                }
                 break;
-            case TRACETOK: {
-                alt53 = 3;
-            }
+            case TRACETOK:
+                {
+                alt53=3;
+                }
                 break;
-            case ENVTOK: {
-                alt53 = 4;
-            }
+            case ENVTOK:
+                {
+                alt53=4;
+                }
                 break;
-            case CLOCKTOK: {
-                alt53 = 5;
-            }
+            case CLOCKTOK:
+                {
+                alt53=5;
+                }
                 break;
-            default:
-                if (state.backtracking > 0) {
-                    state.failed = true;
-                    return retval;
+            case CALLSITETOK:
+                {
+                alt53=6;
                 }
-                NoViableAltException nvae = new NoViableAltException("", 53, 0,
-                        input);
+                break;
+            default:
+                if (state.backtracking>0) {state.failed=true; return retval;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 53, 0, input);
+
+                throw nvae;
+            }
+
+            switch (alt53) {
+                case 1 :
+                    // CTFParser.g:937:4: EVENTTOK
+                    {
+                    EVENTTOK162=(Token)match(input,EVENTTOK,FOLLOW_EVENTTOK_in_ctfSpecifierHead3180); if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        stream_EVENTTOK.add(EVENTTOK162);
+                    }
+
+
+
+                    // AST REWRITE
+                    // elements:
+                    // token labels:
+                    // rule labels: retval
+                    // token list labels:
+                    // rule list labels:
+                    // wildcard labels:
+                    if ( state.backtracking==0 ) {
+                    retval.tree = root_0;
+                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+                    root_0 = (CommonTree)adaptor.nil();
+                    // 937:13: -> EVENT
+                    {
+                        adaptor.addChild(root_0, (CommonTree)adaptor.create(EVENT, "EVENT"));
+
+                    }
+
+                    retval.tree = root_0;}
+                    }
+                    break;
+                case 2 :
+                    // CTFParser.g:938:4: STREAMTOK
+                    {
+                    STREAMTOK163=(Token)match(input,STREAMTOK,FOLLOW_STREAMTOK_in_ctfSpecifierHead3189); if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        stream_STREAMTOK.add(STREAMTOK163);
+                    }
+
+
+
+                    // AST REWRITE
+                    // elements:
+                    // token labels:
+                    // rule labels: retval
+                    // token list labels:
+                    // rule list labels:
+                    // wildcard labels:
+                    if ( state.backtracking==0 ) {
+                    retval.tree = root_0;
+                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+
+                    root_0 = (CommonTree)adaptor.nil();
+                    // 938:14: -> STREAM
+                    {
+                        adaptor.addChild(root_0, (CommonTree)adaptor.create(STREAM, "STREAM"));
+
+                    }
+
+                    retval.tree = root_0;}
+                    }
+                    break;
+                case 3 :
+                    // CTFParser.g:939:4: TRACETOK
+                    {
+                    TRACETOK164=(Token)match(input,TRACETOK,FOLLOW_TRACETOK_in_ctfSpecifierHead3198); if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        stream_TRACETOK.add(TRACETOK164);
+                    }
 
-                throw nvae;
-            }
 
-            switch (alt53) {
-            case 1:
-            // Grammar/CTFParser.g:936:4: EVENTTOK
-            {
-                EVENTTOK162 = (Token) match(input, EVENTTOK,
-                        FOLLOW_EVENTTOK_in_ctfSpecifierHead3176);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_EVENTTOK.add(EVENTTOK162);
-                }
-
-                // AST REWRITE
-                // elements:
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
+
+                    // AST REWRITE
+                    // elements:
+                    // token labels:
+                    // rule labels: retval
+                    // token list labels:
+                    // rule list labels:
+                    // wildcard labels:
+                    if ( state.backtracking==0 ) {
                     retval.tree = root_0;
-                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
+                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 936:13: -> EVENT
+                    root_0 = (CommonTree)adaptor.nil();
+                    // 939:13: -> TRACE
                     {
-                        adaptor.addChild(root_0, adaptor.create(EVENT, "EVENT"));
+                        adaptor.addChild(root_0, (CommonTree)adaptor.create(TRACE, "TRACE"));
 
                     }
 
-                    retval.tree = root_0;
-                }
-            }
-                break;
-            case 2:
-            // Grammar/CTFParser.g:937:4: STREAMTOK
-            {
-                STREAMTOK163 = (Token) match(input, STREAMTOK,
-                        FOLLOW_STREAMTOK_in_ctfSpecifierHead3185);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_STREAMTOK.add(STREAMTOK163);
-                }
-
-                // AST REWRITE
-                // elements:
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
-
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 937:14: -> STREAM
+                    retval.tree = root_0;}
+                    }
+                    break;
+                case 4 :
+                    // CTFParser.g:940:4: ENVTOK
                     {
-                        adaptor.addChild(root_0,
-                                adaptor.create(STREAM, "STREAM"));
-
+                    ENVTOK165=(Token)match(input,ENVTOK,FOLLOW_ENVTOK_in_ctfSpecifierHead3207); if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        stream_ENVTOK.add(ENVTOK165);
                     }
 
+
+
+                    // AST REWRITE
+                    // elements:
+                    // token labels:
+                    // rule labels: retval
+                    // token list labels:
+                    // rule list labels:
+                    // wildcard labels:
+                    if ( state.backtracking==0 ) {
                     retval.tree = root_0;
-                }
-            }
-                break;
-            case 3:
-            // Grammar/CTFParser.g:938:4: TRACETOK
-            {
-                TRACETOK164 = (Token) match(input, TRACETOK,
-                        FOLLOW_TRACETOK_in_ctfSpecifierHead3194);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_TRACETOK.add(TRACETOK164);
-                }
-
-                // AST REWRITE
-                // elements:
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
+                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 938:13: -> TRACE
+                    root_0 = (CommonTree)adaptor.nil();
+                    // 940:11: -> ENV
                     {
-                        adaptor.addChild(root_0, adaptor.create(TRACE, "TRACE"));
+                        adaptor.addChild(root_0, (CommonTree)adaptor.create(ENV, "ENV"));
 
                     }
 
+                    retval.tree = root_0;}
+                    }
+                    break;
+                case 5 :
+                    // CTFParser.g:941:4: CLOCKTOK
+                    {
+                    CLOCKTOK166=(Token)match(input,CLOCKTOK,FOLLOW_CLOCKTOK_in_ctfSpecifierHead3216); if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        stream_CLOCKTOK.add(CLOCKTOK166);
+                    }
+
+
+
+                    // AST REWRITE
+                    // elements:
+                    // token labels:
+                    // rule labels: retval
+                    // token list labels:
+                    // rule list labels:
+                    // wildcard labels:
+                    if ( state.backtracking==0 ) {
                     retval.tree = root_0;
-                }
-            }
-                break;
-            case 4:
-            // Grammar/CTFParser.g:939:4: ENVTOK
-            {
-                ENVTOK165 = (Token) match(input, ENVTOK,
-                        FOLLOW_ENVTOK_in_ctfSpecifierHead3203);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_ENVTOK.add(ENVTOK165);
-                }
-
-                // AST REWRITE
-                // elements:
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
+                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 939:11: -> ENV
+                    root_0 = (CommonTree)adaptor.nil();
+                    // 941:13: -> CLOCK
                     {
-                        adaptor.addChild(root_0, adaptor.create(ENV, "ENV"));
+                        adaptor.addChild(root_0, (CommonTree)adaptor.create(CLOCK, "CLOCK"));
 
                     }
 
+                    retval.tree = root_0;}
+                    }
+                    break;
+                case 6 :
+                    // CTFParser.g:942:4: CALLSITETOK
+                    {
+                    CALLSITETOK167=(Token)match(input,CALLSITETOK,FOLLOW_CALLSITETOK_in_ctfSpecifierHead3225); if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        stream_CALLSITETOK.add(CALLSITETOK167);
+                    }
+
+
+
+                    // AST REWRITE
+                    // elements:
+                    // token labels:
+                    // rule labels: retval
+                    // token list labels:
+                    // rule list labels:
+                    // wildcard labels:
+                    if ( state.backtracking==0 ) {
                     retval.tree = root_0;
-                }
-            }
-                break;
-            case 5:
-            // Grammar/CTFParser.g:940:4: CLOCKTOK
-            {
-                CLOCKTOK166 = (Token) match(input, CLOCKTOK,
-                        FOLLOW_CLOCKTOK_in_ctfSpecifierHead3212);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_CLOCKTOK.add(CLOCKTOK166);
-                }
-
-                // AST REWRITE
-                // elements:
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
+                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 940:13: -> CLOCK
+                    root_0 = (CommonTree)adaptor.nil();
+                    // 942:16: -> CALLSITE
                     {
-                        adaptor.addChild(root_0, adaptor.create(CLOCK, "CLOCK"));
+                        adaptor.addChild(root_0, (CommonTree)adaptor.create(CALLSITE, "CALLSITE"));
 
                     }
 
-                    retval.tree = root_0;
-                }
-            }
-                break;
+                    retval.tree = root_0;}
+                    }
+                    break;
 
             }
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                debug_print(input.toString(retval.start, input.LT(-1)));
+                debug_print(input.toString(retval.start,input.LT(-1)));
                 exit("ctfSpecifierHead");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "ctfSpecifierHead"
 
     public static class ctfTypeSpecifier_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "ctfTypeSpecifier"
-    // Grammar/CTFParser.g:943:1: ctfTypeSpecifier : ( FLOATINGPOINTTOK ctfBody
-    // -> ^( FLOATING_POINT ( ctfBody )? ) | INTEGERTOK ctfBody -> ^( INTEGER (
-    // ctfBody )? ) | STRINGTOK ( ctfBody )? -> ^( STRING ( ctfBody )? ) );
-    public final CTFParser.ctfTypeSpecifier_return ctfTypeSpecifier()
-            throws RecognitionException {
+    // CTFParser.g:945:1: ctfTypeSpecifier : ( FLOATINGPOINTTOK ctfBody -> ^( FLOATING_POINT ( ctfBody )? ) | INTEGERTOK ctfBody -> ^( INTEGER ( ctfBody )? ) | STRINGTOK ( ctfBody )? -> ^( STRING ( ctfBody )? ) );
+    public final CTFParser.ctfTypeSpecifier_return ctfTypeSpecifier() throws RecognitionException {
         CTFParser.ctfTypeSpecifier_return retval = new CTFParser.ctfTypeSpecifier_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token FLOATINGPOINTTOK167 = null;
-        Token INTEGERTOK169 = null;
-        Token STRINGTOK171 = null;
-        CTFParser.ctfBody_return ctfBody168 = null;
+        Token FLOATINGPOINTTOK168=null;
+        Token INTEGERTOK170=null;
+        Token STRINGTOK172=null;
+        CTFParser.ctfBody_return ctfBody169 = null;
 
-        CTFParser.ctfBody_return ctfBody170 = null;
+        CTFParser.ctfBody_return ctfBody171 = null;
 
-        CTFParser.ctfBody_return ctfBody172 = null;
+        CTFParser.ctfBody_return ctfBody173 = null;
 
-        CommonTree FLOATINGPOINTTOK167_tree = null;
-        CommonTree INTEGERTOK169_tree = null;
-        CommonTree STRINGTOK171_tree = null;
-        RewriteRuleTokenStream stream_FLOATINGPOINTTOK = new RewriteRuleTokenStream(
-                adaptor, "token FLOATINGPOINTTOK");
-        RewriteRuleTokenStream stream_STRINGTOK = new RewriteRuleTokenStream(
-                adaptor, "token STRINGTOK");
-        RewriteRuleTokenStream stream_INTEGERTOK = new RewriteRuleTokenStream(
-                adaptor, "token INTEGERTOK");
-        RewriteRuleSubtreeStream stream_ctfBody = new RewriteRuleSubtreeStream(
-                adaptor, "rule ctfBody");
 
-        enter("ctfTypeSpecifier");
+        CommonTree FLOATINGPOINTTOK168_tree=null;
+        CommonTree INTEGERTOK170_tree=null;
+        CommonTree STRINGTOK172_tree=null;
+        RewriteRuleTokenStream stream_FLOATINGPOINTTOK=new RewriteRuleTokenStream(adaptor,"token FLOATINGPOINTTOK");
+        RewriteRuleTokenStream stream_STRINGTOK=new RewriteRuleTokenStream(adaptor,"token STRINGTOK");
+        RewriteRuleTokenStream stream_INTEGERTOK=new RewriteRuleTokenStream(adaptor,"token INTEGERTOK");
+        RewriteRuleSubtreeStream stream_ctfBody=new RewriteRuleSubtreeStream(adaptor,"rule ctfBody");
+
+          enter("ctfTypeSpecifier");
 
         try {
-            // Grammar/CTFParser.g:950:1: ( FLOATINGPOINTTOK ctfBody -> ^(
-            // FLOATING_POINT ( ctfBody )? ) | INTEGERTOK ctfBody -> ^( INTEGER
-            // ( ctfBody )? ) | STRINGTOK ( ctfBody )? -> ^( STRING ( ctfBody )?
-            // ) )
-            int alt55 = 3;
-            switch (input.LA(1)) {
-            case FLOATINGPOINTTOK: {
-                alt55 = 1;
-            }
+            // CTFParser.g:952:1: ( FLOATINGPOINTTOK ctfBody -> ^( FLOATING_POINT ( ctfBody )? ) | INTEGERTOK ctfBody -> ^( INTEGER ( ctfBody )? ) | STRINGTOK ( ctfBody )? -> ^( STRING ( ctfBody )? ) )
+            int alt55=3;
+            switch ( input.LA(1) ) {
+            case FLOATINGPOINTTOK:
+                {
+                alt55=1;
+                }
                 break;
-            case INTEGERTOK: {
-                alt55 = 2;
-            }
+            case INTEGERTOK:
+                {
+                alt55=2;
+                }
                 break;
-            case STRINGTOK: {
-                alt55 = 3;
-            }
+            case STRINGTOK:
+                {
+                alt55=3;
+                }
                 break;
             default:
-                if (state.backtracking > 0) {
-                    state.failed = true;
-                    return retval;
-                }
-                NoViableAltException nvae = new NoViableAltException("", 55, 0,
-                        input);
+                if (state.backtracking>0) {state.failed=true; return retval;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 55, 0, input);
 
                 throw nvae;
             }
 
             switch (alt55) {
-            case 1:
-            // Grammar/CTFParser.g:952:5: FLOATINGPOINTTOK ctfBody
-            {
-                FLOATINGPOINTTOK167 = (Token) match(input, FLOATINGPOINTTOK,
-                        FOLLOW_FLOATINGPOINTTOK_in_ctfTypeSpecifier3246);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_FLOATINGPOINTTOK.add(FLOATINGPOINTTOK167);
-                }
+                case 1 :
+                    // CTFParser.g:954:5: FLOATINGPOINTTOK ctfBody
+                    {
+                    FLOATINGPOINTTOK168=(Token)match(input,FLOATINGPOINTTOK,FOLLOW_FLOATINGPOINTTOK_in_ctfTypeSpecifier3259); if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        stream_FLOATINGPOINTTOK.add(FLOATINGPOINTTOK168);
+                    }
 
-                pushFollow(FOLLOW_ctfBody_in_ctfTypeSpecifier3248);
-                ctfBody168 = ctfBody();
+                    pushFollow(FOLLOW_ctfBody_in_ctfTypeSpecifier3261);
+                    ctfBody169=ctfBody();
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_ctfBody.add(ctfBody168.getTree());
-                }
+                    state._fsp--;
+                    if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        stream_ctfBody.add(ctfBody169.getTree());
+                    }
 
-                // AST REWRITE
-                // elements: ctfBody
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
+
+                    // AST REWRITE
+                    // elements: ctfBody
+                    // token labels:
+                    // rule labels: retval
+                    // token list labels:
+                    // rule list labels:
+                    // wildcard labels:
+                    if ( state.backtracking==0 ) {
                     retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
+                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 952:30: -> ^( FLOATING_POINT ( ctfBody )? )
+                    root_0 = (CommonTree)adaptor.nil();
+                    // 954:30: -> ^( FLOATING_POINT ( ctfBody )? )
                     {
-                        // Grammar/CTFParser.g:952:33: ^( FLOATING_POINT (
-                        // ctfBody )? )
+                        // CTFParser.g:954:33: ^( FLOATING_POINT ( ctfBody )? )
                         {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(adaptor
-                                    .create(FLOATING_POINT, "FLOATING_POINT"),
-                                    root_1);
+                        CommonTree root_1 = (CommonTree)adaptor.nil();
+                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(FLOATING_POINT, "FLOATING_POINT"), root_1);
 
-                            // Grammar/CTFParser.g:952:50: ( ctfBody )?
-                            if (stream_ctfBody.hasNext()) {
-                                adaptor.addChild(root_1,
-                                        stream_ctfBody.nextTree());
+                        // CTFParser.g:954:50: ( ctfBody )?
+                        if ( stream_ctfBody.hasNext() ) {
+                            adaptor.addChild(root_1, stream_ctfBody.nextTree());
 
-                            }
-                            stream_ctfBody.reset();
+                        }
+                        stream_ctfBody.reset();
 
-                            adaptor.addChild(root_0, root_1);
+                        adaptor.addChild(root_0, root_1);
                         }
 
                     }
 
-                    retval.tree = root_0;
-                }
-            }
-                break;
-            case 2:
-            // Grammar/CTFParser.g:953:5: INTEGERTOK ctfBody
-            {
-                INTEGERTOK169 = (Token) match(input, INTEGERTOK,
-                        FOLLOW_INTEGERTOK_in_ctfTypeSpecifier3263);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_INTEGERTOK.add(INTEGERTOK169);
-                }
+                    retval.tree = root_0;}
+                    }
+                    break;
+                case 2 :
+                    // CTFParser.g:955:5: INTEGERTOK ctfBody
+                    {
+                    INTEGERTOK170=(Token)match(input,INTEGERTOK,FOLLOW_INTEGERTOK_in_ctfTypeSpecifier3276); if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        stream_INTEGERTOK.add(INTEGERTOK170);
+                    }
 
-                pushFollow(FOLLOW_ctfBody_in_ctfTypeSpecifier3265);
-                ctfBody170 = ctfBody();
+                    pushFollow(FOLLOW_ctfBody_in_ctfTypeSpecifier3278);
+                    ctfBody171=ctfBody();
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_ctfBody.add(ctfBody170.getTree());
-                }
+                    state._fsp--;
+                    if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        stream_ctfBody.add(ctfBody171.getTree());
+                    }
 
-                // AST REWRITE
-                // elements: ctfBody
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
+
+                    // AST REWRITE
+                    // elements: ctfBody
+                    // token labels:
+                    // rule labels: retval
+                    // token list labels:
+                    // rule list labels:
+                    // wildcard labels:
+                    if ( state.backtracking==0 ) {
                     retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
+                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 953:24: -> ^( INTEGER ( ctfBody )? )
+                    root_0 = (CommonTree)adaptor.nil();
+                    // 955:24: -> ^( INTEGER ( ctfBody )? )
                     {
-                        // Grammar/CTFParser.g:953:27: ^( INTEGER ( ctfBody )? )
+                        // CTFParser.g:955:27: ^( INTEGER ( ctfBody )? )
                         {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(
-                                    adaptor.create(INTEGER, "INTEGER"), root_1);
+                        CommonTree root_1 = (CommonTree)adaptor.nil();
+                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(INTEGER, "INTEGER"), root_1);
 
-                            // Grammar/CTFParser.g:953:37: ( ctfBody )?
-                            if (stream_ctfBody.hasNext()) {
-                                adaptor.addChild(root_1,
-                                        stream_ctfBody.nextTree());
+                        // CTFParser.g:955:37: ( ctfBody )?
+                        if ( stream_ctfBody.hasNext() ) {
+                            adaptor.addChild(root_1, stream_ctfBody.nextTree());
 
-                            }
-                            stream_ctfBody.reset();
+                        }
+                        stream_ctfBody.reset();
 
-                            adaptor.addChild(root_0, root_1);
+                        adaptor.addChild(root_0, root_1);
                         }
 
                     }
 
-                    retval.tree = root_0;
-                }
-            }
-                break;
-            case 3:
-            // Grammar/CTFParser.g:954:5: STRINGTOK ( ctfBody )?
-            {
-                STRINGTOK171 = (Token) match(input, STRINGTOK,
-                        FOLLOW_STRINGTOK_in_ctfTypeSpecifier3280);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_STRINGTOK.add(STRINGTOK171);
-                }
-
-                // Grammar/CTFParser.g:954:15: ( ctfBody )?
-                int alt54 = 2;
-                alt54 = dfa54.predict(input);
-                switch (alt54) {
-                case 1:
-                // Grammar/CTFParser.g:954:15: ctfBody
-                {
-                    pushFollow(FOLLOW_ctfBody_in_ctfTypeSpecifier3282);
-                    ctfBody172 = ctfBody();
-
-                    state._fsp--;
-                    if (state.failed) {
+                    retval.tree = root_0;}
+                    }
+                    break;
+                case 3 :
+                    // CTFParser.g:956:5: STRINGTOK ( ctfBody )?
+                    {
+                    STRINGTOK172=(Token)match(input,STRINGTOK,FOLLOW_STRINGTOK_in_ctfTypeSpecifier3293); if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
-                        stream_ctfBody.add(ctfBody172.getTree());
+                    if ( state.backtracking==0 ) {
+                        stream_STRINGTOK.add(STRINGTOK172);
                     }
 
-                }
-                    break;
+                    // CTFParser.g:956:15: ( ctfBody )?
+                    int alt54=2;
+                    alt54 = dfa54.predict(input);
+                    switch (alt54) {
+                        case 1 :
+                            // CTFParser.g:956:15: ctfBody
+                            {
+                            pushFollow(FOLLOW_ctfBody_in_ctfTypeSpecifier3295);
+                            ctfBody173=ctfBody();
+
+                            state._fsp--;
+                            if (state.failed) {
+                                return retval;
+                            }
+                            if ( state.backtracking==0 ) {
+                                stream_ctfBody.add(ctfBody173.getTree());
+                            }
+
+                            }
+                            break;
+
+                    }
 
-                }
 
-                // AST REWRITE
-                // elements: ctfBody
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
+
+                    // AST REWRITE
+                    // elements: ctfBody
+                    // token labels:
+                    // rule labels: retval
+                    // token list labels:
+                    // rule list labels:
+                    // wildcard labels:
+                    if ( state.backtracking==0 ) {
                     retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
+                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 954:24: -> ^( STRING ( ctfBody )? )
+                    root_0 = (CommonTree)adaptor.nil();
+                    // 956:24: -> ^( STRING ( ctfBody )? )
                     {
-                        // Grammar/CTFParser.g:954:27: ^( STRING ( ctfBody )? )
+                        // CTFParser.g:956:27: ^( STRING ( ctfBody )? )
                         {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(
-                                    adaptor.create(STRING, "STRING"), root_1);
+                        CommonTree root_1 = (CommonTree)adaptor.nil();
+                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(STRING, "STRING"), root_1);
 
-                            // Grammar/CTFParser.g:954:36: ( ctfBody )?
-                            if (stream_ctfBody.hasNext()) {
-                                adaptor.addChild(root_1,
-                                        stream_ctfBody.nextTree());
+                        // CTFParser.g:956:36: ( ctfBody )?
+                        if ( stream_ctfBody.hasNext() ) {
+                            adaptor.addChild(root_1, stream_ctfBody.nextTree());
 
-                            }
-                            stream_ctfBody.reset();
+                        }
+                        stream_ctfBody.reset();
 
-                            adaptor.addChild(root_0, root_1);
+                        adaptor.addChild(root_0, root_1);
                         }
 
                     }
 
-                    retval.tree = root_0;
-                }
-            }
-                break;
+                    retval.tree = root_0;}
+                    }
+                    break;
 
             }
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 exit("ctfTypeSpecifier");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "ctfTypeSpecifier"
 
     public static class ctfBody_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "ctfBody"
-    // Grammar/CTFParser.g:957:1: ctfBody : LCURL ( ctfAssignmentExpressionList
-    // )? RCURL -> ( ctfAssignmentExpressionList )? ;
+    // CTFParser.g:959:1: ctfBody : LCURL ( ctfAssignmentExpressionList )? RCURL -> ( ctfAssignmentExpressionList )? ;
     public final CTFParser.ctfBody_return ctfBody() throws RecognitionException {
         Symbols_stack.push(new Symbols_scope());
 
@@ -9985,339 +8771,274 @@ public class CTFParser extends Parser {
 
         CommonTree root_0 = null;
 
-        Token LCURL173 = null;
-        Token RCURL175 = null;
-        CTFParser.ctfAssignmentExpressionList_return ctfAssignmentExpressionList174 = null;
+        Token LCURL174=null;
+        Token RCURL176=null;
+        CTFParser.ctfAssignmentExpressionList_return ctfAssignmentExpressionList175 = null;
+
 
-        CommonTree LCURL173_tree = null;
-        CommonTree RCURL175_tree = null;
-        RewriteRuleTokenStream stream_LCURL = new RewriteRuleTokenStream(
-                adaptor, "token LCURL");
-        RewriteRuleTokenStream stream_RCURL = new RewriteRuleTokenStream(
-                adaptor, "token RCURL");
-        RewriteRuleSubtreeStream stream_ctfAssignmentExpressionList = new RewriteRuleSubtreeStream(
-                adaptor, "rule ctfAssignmentExpressionList");
+        CommonTree LCURL174_tree=null;
+        CommonTree RCURL176_tree=null;
+        RewriteRuleTokenStream stream_LCURL=new RewriteRuleTokenStream(adaptor,"token LCURL");
+        RewriteRuleTokenStream stream_RCURL=new RewriteRuleTokenStream(adaptor,"token RCURL");
+        RewriteRuleSubtreeStream stream_ctfAssignmentExpressionList=new RewriteRuleSubtreeStream(adaptor,"rule ctfAssignmentExpressionList");
 
-        enter("ctfBody");
-        debug_print("Scope push " + +Symbols_stack.size());
-        ((Symbols_scope) Symbols_stack.peek()).types = new HashSet<String>();
+          enter("ctfBody");
+          debug_print("Scope push " +  + Symbols_stack.size());
+          ((Symbols_scope)Symbols_stack.peek()).types = new HashSet<String>();
 
         try {
-            // Grammar/CTFParser.g:968:1: ( LCURL ( ctfAssignmentExpressionList
-            // )? RCURL -> ( ctfAssignmentExpressionList )? )
-            // Grammar/CTFParser.g:969:3: LCURL ( ctfAssignmentExpressionList )?
-            // RCURL
+            // CTFParser.g:970:1: ( LCURL ( ctfAssignmentExpressionList )? RCURL -> ( ctfAssignmentExpressionList )? )
+            // CTFParser.g:971:3: LCURL ( ctfAssignmentExpressionList )? RCURL
             {
-                LCURL173 = (Token) match(input, LCURL,
-                        FOLLOW_LCURL_in_ctfBody3320);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_LCURL.add(LCURL173);
-                }
-
-                // Grammar/CTFParser.g:969:9: ( ctfAssignmentExpressionList )?
-                int alt56 = 2;
-                int LA56_0 = input.LA(1);
-
-                if ((((LA56_0 >= ALIGNTOK) && (LA56_0 <= CLOCKTOK))
-                        || (LA56_0 == SIGN) || (LA56_0 == OCTAL_LITERAL)
-                        || (LA56_0 == DECIMAL_LITERAL)
-                        || (LA56_0 == HEX_LITERAL)
-                        || (LA56_0 == CHARACTER_LITERAL)
-                        || (LA56_0 == STRING_LITERAL) || (LA56_0 == IDENTIFIER))) {
-                    alt56 = 1;
-                }
-                switch (alt56) {
-                case 1:
-                // Grammar/CTFParser.g:969:9: ctfAssignmentExpressionList
-                {
-                    pushFollow(FOLLOW_ctfAssignmentExpressionList_in_ctfBody3322);
-                    ctfAssignmentExpressionList174 = ctfAssignmentExpressionList();
+            LCURL174=(Token)match(input,LCURL,FOLLOW_LCURL_in_ctfBody3333); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_LCURL.add(LCURL174);
+            }
+
+            // CTFParser.g:971:9: ( ctfAssignmentExpressionList )?
+            int alt56=2;
+            int LA56_0 = input.LA(1);
+
+            if ( ((LA56_0>=ALIGNTOK && LA56_0<=CALLSITETOK)||LA56_0==SIGN||LA56_0==OCTAL_LITERAL||LA56_0==DECIMAL_LITERAL||LA56_0==HEX_LITERAL||LA56_0==CHARACTER_LITERAL||LA56_0==STRING_LITERAL||LA56_0==IDENTIFIER) ) {
+                alt56=1;
+            }
+            switch (alt56) {
+                case 1 :
+                    // CTFParser.g:971:9: ctfAssignmentExpressionList
+                    {
+                    pushFollow(FOLLOW_ctfAssignmentExpressionList_in_ctfBody3335);
+                    ctfAssignmentExpressionList175=ctfAssignmentExpressionList();
 
                     state._fsp--;
                     if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
-                        stream_ctfAssignmentExpressionList
-                                .add(ctfAssignmentExpressionList174.getTree());
+                    if ( state.backtracking==0 ) {
+                        stream_ctfAssignmentExpressionList.add(ctfAssignmentExpressionList175.getTree());
                     }
 
-                }
+                    }
                     break;
 
-                }
+            }
 
-                RCURL175 = (Token) match(input, RCURL,
-                        FOLLOW_RCURL_in_ctfBody3325);
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    stream_RCURL.add(RCURL175);
-                }
+            RCURL176=(Token)match(input,RCURL,FOLLOW_RCURL_in_ctfBody3338); if (state.failed) {
+                return retval;
+            }
+            if ( state.backtracking==0 ) {
+                stream_RCURL.add(RCURL176);
+            }
 
-                // AST REWRITE
-                // elements: ctfAssignmentExpressionList
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
-                    retval.tree = root_0;
-//                    RewriteRuleSubtreeStream stream_retval =
-                            new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 969:44: -> ( ctfAssignmentExpressionList )?
-                    {
-                        // Grammar/CTFParser.g:969:47: (
-                        // ctfAssignmentExpressionList )?
-                        if (stream_ctfAssignmentExpressionList.hasNext()) {
-                            adaptor.addChild(root_0,
-                                    stream_ctfAssignmentExpressionList
-                                            .nextTree());
 
-                        }
-                        stream_ctfAssignmentExpressionList.reset();
+            // AST REWRITE
+            // elements: ctfAssignmentExpressionList
+            // token labels:
+            // rule labels: retval
+            // token list labels:
+            // rule list labels:
+            // wildcard labels:
+            if ( state.backtracking==0 ) {
+            retval.tree = root_0;
+            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                    }
+            root_0 = (CommonTree)adaptor.nil();
+            // 971:44: -> ( ctfAssignmentExpressionList )?
+            {
+                // CTFParser.g:971:47: ( ctfAssignmentExpressionList )?
+                if ( stream_ctfAssignmentExpressionList.hasNext() ) {
+                    adaptor.addChild(root_0, stream_ctfAssignmentExpressionList.nextTree());
 
-                    retval.tree = root_0;
                 }
+                stream_ctfAssignmentExpressionList.reset();
+
+            }
+
+            retval.tree = root_0;}
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                debug_print("Scope pop " + +Symbols_stack.size());
+                debug_print("Scope pop " +  + Symbols_stack.size());
                 exit("ctfBody");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-        } finally {
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
             Symbols_stack.pop();
 
         }
         return retval;
     }
-
     // $ANTLR end "ctfBody"
 
-    public static class ctfAssignmentExpressionList_return extends
-            ParserRuleReturnScope {
+    public static class ctfAssignmentExpressionList_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "ctfAssignmentExpressionList"
-    // Grammar/CTFParser.g:972:1: ctfAssignmentExpressionList : (
-    // ctfAssignmentExpression TERM )+ ;
-    public final CTFParser.ctfAssignmentExpressionList_return ctfAssignmentExpressionList()
-            throws RecognitionException {
+    // CTFParser.g:974:1: ctfAssignmentExpressionList : ( ctfAssignmentExpression TERM )+ ;
+    public final CTFParser.ctfAssignmentExpressionList_return ctfAssignmentExpressionList() throws RecognitionException {
         CTFParser.ctfAssignmentExpressionList_return retval = new CTFParser.ctfAssignmentExpressionList_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token TERM177 = null;
-        CTFParser.ctfAssignmentExpression_return ctfAssignmentExpression176 = null;
+        Token TERM178=null;
+        CTFParser.ctfAssignmentExpression_return ctfAssignmentExpression177 = null;
 
-        CommonTree TERM177_tree = null;
+
+        CommonTree TERM178_tree=null;
 
         try {
-            // Grammar/CTFParser.g:972:29: ( ( ctfAssignmentExpression TERM )+ )
-            // Grammar/CTFParser.g:973:3: ( ctfAssignmentExpression TERM )+
+            // CTFParser.g:974:29: ( ( ctfAssignmentExpression TERM )+ )
+            // CTFParser.g:975:3: ( ctfAssignmentExpression TERM )+
             {
-                root_0 = (CommonTree) adaptor.nil();
+            root_0 = (CommonTree)adaptor.nil();
 
-                // Grammar/CTFParser.g:973:3: ( ctfAssignmentExpression TERM )+
-                int cnt57 = 0;
-                loop57: do {
-                    int alt57 = 2;
-                    int LA57_0 = input.LA(1);
+            // CTFParser.g:975:3: ( ctfAssignmentExpression TERM )+
+            int cnt57=0;
+            loop57:
+            do {
+                int alt57=2;
+                int LA57_0 = input.LA(1);
 
-                    if ((((LA57_0 >= ALIGNTOK) && (LA57_0 <= CLOCKTOK))
-                            || (LA57_0 == SIGN) || (LA57_0 == OCTAL_LITERAL)
-                            || (LA57_0 == DECIMAL_LITERAL)
-                            || (LA57_0 == HEX_LITERAL)
-                            || (LA57_0 == CHARACTER_LITERAL)
-                            || (LA57_0 == STRING_LITERAL) || (LA57_0 == IDENTIFIER))) {
-                        alt57 = 1;
-                    }
+                if ( ((LA57_0>=ALIGNTOK && LA57_0<=CALLSITETOK)||LA57_0==SIGN||LA57_0==OCTAL_LITERAL||LA57_0==DECIMAL_LITERAL||LA57_0==HEX_LITERAL||LA57_0==CHARACTER_LITERAL||LA57_0==STRING_LITERAL||LA57_0==IDENTIFIER) ) {
+                    alt57=1;
+                }
 
-                    switch (alt57) {
-                    case 1:
-                    // Grammar/CTFParser.g:973:4: ctfAssignmentExpression TERM
-                    {
-                        pushFollow(FOLLOW_ctfAssignmentExpression_in_ctfAssignmentExpressionList3344);
-                        ctfAssignmentExpression176 = ctfAssignmentExpression();
 
-                        state._fsp--;
-                        if (state.failed) {
-                            return retval;
-                        }
-                        if (state.backtracking == 0) {
-                            adaptor.addChild(root_0,
-                                    ctfAssignmentExpression176.getTree());
-                        }
-                        TERM177 = (Token) match(input, TERM,
-                                FOLLOW_TERM_in_ctfAssignmentExpressionList3346);
-                        if (state.failed) {
-                            return retval;
-                        }
+                switch (alt57) {
+               case 1 :
+                   // CTFParser.g:975:4: ctfAssignmentExpression TERM
+                   {
+                   pushFollow(FOLLOW_ctfAssignmentExpression_in_ctfAssignmentExpressionList3357);
+                   ctfAssignmentExpression177=ctfAssignmentExpression();
 
+                   state._fsp--;
+                   if (state.failed) {
+                        return retval;
+                    }
+                   if ( state.backtracking==0 ) {
+                        adaptor.addChild(root_0, ctfAssignmentExpression177.getTree());
+                    }
+                   TERM178=(Token)match(input,TERM,FOLLOW_TERM_in_ctfAssignmentExpressionList3359); if (state.failed) {
+                        return retval;
                     }
-                        break;
 
-                    default:
-                        if (cnt57 >= 1) {
-                            break loop57;
-                        }
-                        if (state.backtracking > 0) {
-                            state.failed = true;
-                            return retval;
-                        }
-                        EarlyExitException eee = new EarlyExitException(57,
-                                input);
-                        throw eee;
+                   }
+                   break;
+
+               default :
+                   if ( cnt57 >= 1 ) {
+                        break loop57;
                     }
-                    cnt57++;
-                } while (true);
+                   if (state.backtracking>0) {state.failed=true; return retval;}
+                        EarlyExitException eee =
+                            new EarlyExitException(57, input);
+                        throw eee;
+                }
+                cnt57++;
+            } while (true);
+
 
             }
 
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "ctfAssignmentExpressionList"
 
-    public static class ctfAssignmentExpression_return extends
-            ParserRuleReturnScope {
+    public static class ctfAssignmentExpression_return extends ParserRuleReturnScope {
         CommonTree tree;
-
-        @Override
-        public Object getTree() {
-            return tree;
-        }
-    }
+        public Object getTree() { return tree; }
+    };
 
     // $ANTLR start "ctfAssignmentExpression"
-    // Grammar/CTFParser.g:977:1: ctfAssignmentExpression : ( (left=
-    // unaryExpression ( (assignment= ASSIGNMENT right1= unaryExpression ) -> ^(
-    // CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^( CTF_RIGHT $right1) ) |
-    // (type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier ) -> ^(
-    // CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT ^(
-    // TYPE_SPECIFIER_LIST $right2) ) ) ) ) | ( declarationSpecifiers {...}?
-    // declaratorList ) -> ^( TYPEDEF declaratorList declarationSpecifiers ) |
-    // typealiasDecl );
-    public final CTFParser.ctfAssignmentExpression_return ctfAssignmentExpression()
-            throws RecognitionException {
+    // CTFParser.g:979:1: ctfAssignmentExpression : ( (left= unaryExpression ( (assignment= ASSIGNMENT right1= unaryExpression ) -> ^( CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^( CTF_RIGHT $right1) ) | (type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier ) -> ^( CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT ^( TYPE_SPECIFIER_LIST $right2) ) ) ) ) | ( declarationSpecifiers {...}? declaratorList ) -> ^( TYPEDEF declaratorList declarationSpecifiers ) | typealiasDecl );
+    public final CTFParser.ctfAssignmentExpression_return ctfAssignmentExpression() throws RecognitionException {
         CTFParser.ctfAssignmentExpression_return retval = new CTFParser.ctfAssignmentExpression_return();
         retval.start = input.LT(1);
 
         CommonTree root_0 = null;
 
-        Token assignment = null;
-        Token type_assignment = null;
+        Token assignment=null;
+        Token type_assignment=null;
         CTFParser.unaryExpression_return left = null;
 
         CTFParser.unaryExpression_return right1 = null;
 
         CTFParser.typeSpecifier_return right2 = null;
 
-        CTFParser.declarationSpecifiers_return declarationSpecifiers178 = null;
+        CTFParser.declarationSpecifiers_return declarationSpecifiers179 = null;
+
+        CTFParser.declaratorList_return declaratorList180 = null;
 
-        CTFParser.declaratorList_return declaratorList179 = null;
+        CTFParser.typealiasDecl_return typealiasDecl181 = null;
 
-        CTFParser.typealiasDecl_return typealiasDecl180 = null;
 
-        CommonTree assignment_tree = null;
-        CommonTree type_assignment_tree = null;
-        RewriteRuleTokenStream stream_ASSIGNMENT = new RewriteRuleTokenStream(
-                adaptor, "token ASSIGNMENT");
-        RewriteRuleTokenStream stream_TYPE_ASSIGNMENT = new RewriteRuleTokenStream(
-                adaptor, "token TYPE_ASSIGNMENT");
-        RewriteRuleSubtreeStream stream_declaratorList = new RewriteRuleSubtreeStream(
-                adaptor, "rule declaratorList");
-        RewriteRuleSubtreeStream stream_unaryExpression = new RewriteRuleSubtreeStream(
-                adaptor, "rule unaryExpression");
-        RewriteRuleSubtreeStream stream_declarationSpecifiers = new RewriteRuleSubtreeStream(
-                adaptor, "rule declarationSpecifiers");
-        RewriteRuleSubtreeStream stream_typeSpecifier = new RewriteRuleSubtreeStream(
-                adaptor, "rule typeSpecifier");
+        CommonTree assignment_tree=null;
+        CommonTree type_assignment_tree=null;
+        RewriteRuleTokenStream stream_ASSIGNMENT=new RewriteRuleTokenStream(adaptor,"token ASSIGNMENT");
+        RewriteRuleTokenStream stream_TYPE_ASSIGNMENT=new RewriteRuleTokenStream(adaptor,"token TYPE_ASSIGNMENT");
+        RewriteRuleSubtreeStream stream_declaratorList=new RewriteRuleSubtreeStream(adaptor,"rule declaratorList");
+        RewriteRuleSubtreeStream stream_unaryExpression=new RewriteRuleSubtreeStream(adaptor,"rule unaryExpression");
+        RewriteRuleSubtreeStream stream_declarationSpecifiers=new RewriteRuleSubtreeStream(adaptor,"rule declarationSpecifiers");
+        RewriteRuleSubtreeStream stream_typeSpecifier=new RewriteRuleSubtreeStream(adaptor,"rule typeSpecifier");
 
-        enter("ctfAssignmentExpression");
+          enter("ctfAssignmentExpression");
 
         try {
-            // Grammar/CTFParser.g:987:1: ( (left= unaryExpression (
-            // (assignment= ASSIGNMENT right1= unaryExpression ) -> ^(
-            // CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^( CTF_RIGHT $right1) ) |
-            // (type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier ) -> ^(
-            // CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT ^(
-            // TYPE_SPECIFIER_LIST $right2) ) ) ) ) | ( declarationSpecifiers
-            // {...}? declaratorList ) -> ^( TYPEDEF declaratorList
-            // declarationSpecifiers ) | typealiasDecl )
-            int alt59 = 3;
-            switch (input.LA(1)) {
-            case IDENTIFIER: {
+            // CTFParser.g:989:1: ( (left= unaryExpression ( (assignment= ASSIGNMENT right1= unaryExpression ) -> ^( CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^( CTF_RIGHT $right1) ) | (type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier ) -> ^( CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT ^( TYPE_SPECIFIER_LIST $right2) ) ) ) ) | ( declarationSpecifiers {...}? declaratorList ) -> ^( TYPEDEF declaratorList declarationSpecifiers ) | typealiasDecl )
+            int alt59=3;
+            switch ( input.LA(1) ) {
+            case IDENTIFIER:
+                {
                 int LA59_1 = input.LA(2);
 
-                if ((((LA59_1 >= CONSTTOK) && (LA59_1 <= ENUMTOK))
-                        || ((LA59_1 >= FLOATINGPOINTTOK) && (LA59_1 <= SIGNEDTOK))
-                        || ((LA59_1 >= STRINGTOK) && (LA59_1 <= STRUCTTOK))
-                        || ((LA59_1 >= TYPEDEFTOK) && (LA59_1 <= IMAGINARYTOK))
-                        || (LA59_1 == POINTER) || (LA59_1 == IDENTIFIER))
-                        && ((inTypealiasAlias() || isTypeName(input.LT(1)
-                                .getText())))) {
-                    alt59 = 2;
-                } else if ((((LA59_1 >= ASSIGNMENT) && (LA59_1 <= TYPE_ASSIGNMENT))
-                        || (LA59_1 == OPENBRAC) || ((LA59_1 >= ARROW) && (LA59_1 <= DOT)))) {
-                    alt59 = 1;
-                } else {
-                    if (state.backtracking > 0) {
-                        state.failed = true;
-                        return retval;
-                    }
-                    NoViableAltException nvae = new NoViableAltException("",
-                            59, 1, input);
+                if ( ((LA59_1>=ASSIGNMENT && LA59_1<=TYPE_ASSIGNMENT)||LA59_1==OPENBRAC||(LA59_1>=ARROW && LA59_1<=DOT)) ) {
+                    alt59=1;
+                }
+                else if ( ((LA59_1>=CONSTTOK && LA59_1<=ENUMTOK)||(LA59_1>=FLOATINGPOINTTOK && LA59_1<=SIGNEDTOK)||(LA59_1>=STRINGTOK && LA59_1<=STRUCTTOK)||(LA59_1>=TYPEDEFTOK && LA59_1<=IMAGINARYTOK)||LA59_1==POINTER||LA59_1==IDENTIFIER) && ((inTypealiasAlias() || isTypeName(input.LT(1).getText())))) {
+                    alt59=2;
+                }
+                else {
+                    if (state.backtracking>0) {state.failed=true; return retval;}
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 59, 1, input);
 
                     throw nvae;
                 }
-            }
+                }
                 break;
             case ALIGNTOK:
             case EVENTTOK:
@@ -10325,24 +9046,28 @@ public class CTFParser extends Parser {
             case TRACETOK:
             case ENVTOK:
             case CLOCKTOK:
+            case CALLSITETOK:
             case SIGN:
             case OCTAL_LITERAL:
             case DECIMAL_LITERAL:
             case HEX_LITERAL:
             case CHARACTER_LITERAL:
-            case STRING_LITERAL: {
-                alt59 = 1;
-            }
+            case STRING_LITERAL:
+                {
+                alt59=1;
+                }
                 break;
-            case SIGNEDTOK: {
-                switch (input.LA(2)) {
+            case SIGNEDTOK:
+                {
+                switch ( input.LA(2) ) {
                 case ASSIGNMENT:
                 case TYPE_ASSIGNMENT:
                 case OPENBRAC:
                 case ARROW:
-                case DOT: {
-                    alt59 = 1;
-                }
+                case DOT:
+                    {
+                    alt59=1;
+                    }
                     break;
                 case CONSTTOK:
                 case CHARTOK:
@@ -10364,26 +9089,25 @@ public class CTFParser extends Parser {
                 case COMPLEXTOK:
                 case IMAGINARYTOK:
                 case POINTER:
-                case IDENTIFIER: {
-                    alt59 = 2;
-                }
+                case IDENTIFIER:
+                    {
+                    alt59=2;
+                    }
                     break;
-                case TYPEDEFTOK: {
-                    alt59 = 2;
-                }
+                case TYPEDEFTOK:
+                    {
+                    alt59=2;
+                    }
                     break;
                 default:
-                    if (state.backtracking > 0) {
-                        state.failed = true;
-                        return retval;
-                    }
-                    NoViableAltException nvae = new NoViableAltException("",
-                            59, 3, input);
+                    if (state.backtracking>0) {state.failed=true; return retval;}
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 59, 3, input);
 
                     throw nvae;
                 }
 
-            }
+                }
                 break;
             case CONSTTOK:
             case CHARTOK:
@@ -10402,20 +9126,14 @@ public class CTFParser extends Parser {
             case VOIDTOK:
             case BOOLTOK:
             case COMPLEXTOK:
-            case IMAGINARYTOK: {
-                alt59 = 2;
-            }
-                break;
-            case STRINGTOK: {
-                switch (input.LA(2)) {
-                case ASSIGNMENT:
-                case TYPE_ASSIGNMENT:
-                case OPENBRAC:
-                case ARROW:
-                case DOT: {
-                    alt59 = 1;
+            case IMAGINARYTOK:
+                {
+                alt59=2;
                 }
-                    break;
+                break;
+            case STRINGTOK:
+                {
+                switch ( input.LA(2) ) {
                 case CONSTTOK:
                 case CHARTOK:
                 case DOUBLETOK:
@@ -10437,509 +9155,405 @@ public class CTFParser extends Parser {
                 case IMAGINARYTOK:
                 case LCURL:
                 case POINTER:
-                case IDENTIFIER: {
-                    alt59 = 2;
-                }
+                case IDENTIFIER:
+                    {
+                    alt59=2;
+                    }
                     break;
-                case TYPEDEFTOK: {
-                    alt59 = 2;
-                }
+                case TYPEDEFTOK:
+                    {
+                    alt59=2;
+                    }
                     break;
-                default:
-                    if (state.backtracking > 0) {
-                        state.failed = true;
-                        return retval;
+                case ASSIGNMENT:
+                case TYPE_ASSIGNMENT:
+                case OPENBRAC:
+                case ARROW:
+                case DOT:
+                    {
+                    alt59=1;
                     }
-                    NoViableAltException nvae = new NoViableAltException("",
-                            59, 5, input);
+                    break;
+                default:
+                    if (state.backtracking>0) {state.failed=true; return retval;}
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 59, 5, input);
 
                     throw nvae;
                 }
 
-            }
+                }
                 break;
-            case TYPEALIASTOK: {
-                alt59 = 3;
-            }
+            case TYPEALIASTOK:
+                {
+                alt59=3;
+                }
                 break;
             default:
-                if (state.backtracking > 0) {
-                    state.failed = true;
-                    return retval;
-                }
-                NoViableAltException nvae = new NoViableAltException("", 59, 0,
-                        input);
+                if (state.backtracking>0) {state.failed=true; return retval;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 59, 0, input);
 
                 throw nvae;
             }
 
             switch (alt59) {
-            case 1:
-            // Grammar/CTFParser.g:988:3: (left= unaryExpression ( (assignment=
-            // ASSIGNMENT right1= unaryExpression ) -> ^( CTF_EXPRESSION_VAL ^(
-            // CTF_LEFT $left) ^( CTF_RIGHT $right1) ) | (type_assignment=
-            // TYPE_ASSIGNMENT right2= typeSpecifier ) -> ^( CTF_EXPRESSION_TYPE
-            // ^( CTF_LEFT $left) ^( CTF_RIGHT ^( TYPE_SPECIFIER_LIST $right2) )
-            // ) ) )
-            {
-                // Grammar/CTFParser.g:988:3: (left= unaryExpression (
-                // (assignment= ASSIGNMENT right1= unaryExpression ) -> ^(
-                // CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^( CTF_RIGHT $right1) )
-                // | (type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier )
-                // -> ^( CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT ^(
-                // TYPE_SPECIFIER_LIST $right2) ) ) ) )
-                // Grammar/CTFParser.g:989:5: left= unaryExpression (
-                // (assignment= ASSIGNMENT right1= unaryExpression ) -> ^(
-                // CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^( CTF_RIGHT $right1) )
-                // | (type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier )
-                // -> ^( CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT ^(
-                // TYPE_SPECIFIER_LIST $right2) ) ) )
-                {
-                    pushFollow(FOLLOW_unaryExpression_in_ctfAssignmentExpression3381);
-                    left = unaryExpression();
+                case 1 :
+                    // CTFParser.g:990:3: (left= unaryExpression ( (assignment= ASSIGNMENT right1= unaryExpression ) -> ^( CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^( CTF_RIGHT $right1) ) | (type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier ) -> ^( CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT ^( TYPE_SPECIFIER_LIST $right2) ) ) ) )
+                    {
+                    // CTFParser.g:990:3: (left= unaryExpression ( (assignment= ASSIGNMENT right1= unaryExpression ) -> ^( CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^( CTF_RIGHT $right1) ) | (type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier ) -> ^( CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT ^( TYPE_SPECIFIER_LIST $right2) ) ) ) )
+                    // CTFParser.g:991:5: left= unaryExpression ( (assignment= ASSIGNMENT right1= unaryExpression ) -> ^( CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^( CTF_RIGHT $right1) ) | (type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier ) -> ^( CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT ^( TYPE_SPECIFIER_LIST $right2) ) ) )
+                    {
+                    pushFollow(FOLLOW_unaryExpression_in_ctfAssignmentExpression3394);
+                    left=unaryExpression();
 
                     state._fsp--;
                     if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
+                    if ( state.backtracking==0 ) {
                         stream_unaryExpression.add(left.getTree());
                     }
-                    // Grammar/CTFParser.g:990:5: ( (assignment= ASSIGNMENT
-                    // right1= unaryExpression ) -> ^( CTF_EXPRESSION_VAL ^(
-                    // CTF_LEFT $left) ^( CTF_RIGHT $right1) ) |
-                    // (type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier )
-                    // -> ^( CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT
-                    // ^( TYPE_SPECIFIER_LIST $right2) ) ) )
-                    int alt58 = 2;
+                    // CTFParser.g:992:5: ( (assignment= ASSIGNMENT right1= unaryExpression ) -> ^( CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^( CTF_RIGHT $right1) ) | (type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier ) -> ^( CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT ^( TYPE_SPECIFIER_LIST $right2) ) ) )
+                    int alt58=2;
                     int LA58_0 = input.LA(1);
 
-                    if ((LA58_0 == ASSIGNMENT)) {
-                        alt58 = 1;
-                    } else if ((LA58_0 == TYPE_ASSIGNMENT)) {
-                        alt58 = 2;
-                    } else {
-                        if (state.backtracking > 0) {
-                            state.failed = true;
-                            return retval;
-                        }
-                        NoViableAltException nvae = new NoViableAltException(
-                                "", 58, 0, input);
+                    if ( (LA58_0==ASSIGNMENT) ) {
+                        alt58=1;
+                    }
+                    else if ( (LA58_0==TYPE_ASSIGNMENT) ) {
+                        alt58=2;
+                    }
+                    else {
+                        if (state.backtracking>0) {state.failed=true; return retval;}
+                        NoViableAltException nvae =
+                            new NoViableAltException("", 58, 0, input);
 
                         throw nvae;
                     }
                     switch (alt58) {
-                    case 1:
-                    // Grammar/CTFParser.g:991:9: (assignment= ASSIGNMENT
-                    // right1= unaryExpression )
-                    {
-                        // Grammar/CTFParser.g:991:9: (assignment= ASSIGNMENT
-                        // right1= unaryExpression )
-                        // Grammar/CTFParser.g:991:10: assignment= ASSIGNMENT
-                        // right1= unaryExpression
-                        {
-                            assignment = (Token) match(input, ASSIGNMENT,
-                                    FOLLOW_ASSIGNMENT_in_ctfAssignmentExpression3400);
-                            if (state.failed) {
+                        case 1 :
+                            // CTFParser.g:993:9: (assignment= ASSIGNMENT right1= unaryExpression )
+                            {
+                            // CTFParser.g:993:9: (assignment= ASSIGNMENT right1= unaryExpression )
+                            // CTFParser.g:993:10: assignment= ASSIGNMENT right1= unaryExpression
+                            {
+                            assignment=(Token)match(input,ASSIGNMENT,FOLLOW_ASSIGNMENT_in_ctfAssignmentExpression3413); if (state.failed) {
                                 return retval;
                             }
-                            if (state.backtracking == 0) {
+                            if ( state.backtracking==0 ) {
                                 stream_ASSIGNMENT.add(assignment);
                             }
 
-                            pushFollow(FOLLOW_unaryExpression_in_ctfAssignmentExpression3404);
-                            right1 = unaryExpression();
+                            pushFollow(FOLLOW_unaryExpression_in_ctfAssignmentExpression3417);
+                            right1=unaryExpression();
 
                             state._fsp--;
                             if (state.failed) {
                                 return retval;
                             }
-                            if (state.backtracking == 0) {
+                            if ( state.backtracking==0 ) {
                                 stream_unaryExpression.add(right1.getTree());
                             }
 
-                        }
+                            }
+
 
-                        // AST REWRITE
-                        // elements: right1, left
-                        // token labels:
-                        // rule labels: retval, left, right1
-                        // token list labels:
-                        // rule list labels:
-                        // wildcard labels:
-                        if (state.backtracking == 0) {
+
+                            // AST REWRITE
+                            // elements: right1, left
+                            // token labels:
+                            // rule labels: retval, left, right1
+                            // token list labels:
+                            // rule list labels:
+                            // wildcard labels:
+                            if ( state.backtracking==0 ) {
                             retval.tree = root_0;
-                            RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(
-                                    adaptor, "rule retval",
-                                    retval != null ? retval.tree : null);
-                            RewriteRuleSubtreeStream stream_left = new RewriteRuleSubtreeStream(
-                                    adaptor, "rule left",
-                                    left != null ? left.tree : null);
-                            RewriteRuleSubtreeStream stream_right1 = new RewriteRuleSubtreeStream(
-                                    adaptor, "rule right1",
-                                    right1 != null ? right1.tree : null);
-
-                            root_0 = (CommonTree) adaptor.nil();
-                            // 991:56: -> ^( CTF_EXPRESSION_VAL ^( CTF_LEFT
-                            // $left) ^( CTF_RIGHT $right1) )
+                            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+                            RewriteRuleSubtreeStream stream_left=new RewriteRuleSubtreeStream(adaptor,"rule left",left!=null?left.tree:null);
+                            RewriteRuleSubtreeStream stream_right1=new RewriteRuleSubtreeStream(adaptor,"rule right1",right1!=null?right1.tree:null);
+
+                            root_0 = (CommonTree)adaptor.nil();
+                            // 993:56: -> ^( CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^( CTF_RIGHT $right1) )
                             {
-                                // Grammar/CTFParser.g:991:59: ^(
-                                // CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^(
-                                // CTF_RIGHT $right1) )
+                                // CTFParser.g:993:59: ^( CTF_EXPRESSION_VAL ^( CTF_LEFT $left) ^( CTF_RIGHT $right1) )
                                 {
-                                    CommonTree root_1 = (CommonTree) adaptor
-                                            .nil();
-                                    root_1 = (CommonTree) adaptor.becomeRoot(
-                                            adaptor.create(CTF_EXPRESSION_VAL,
-                                                    "CTF_EXPRESSION_VAL"),
-                                            root_1);
-
-                                    // Grammar/CTFParser.g:991:80: ^( CTF_LEFT
-                                    // $left)
-                                    {
-                                        CommonTree root_2 = (CommonTree) adaptor
-                                                .nil();
-                                        root_2 = (CommonTree) adaptor
-                                                .becomeRoot(adaptor.create(
-                                                        CTF_LEFT, "CTF_LEFT"),
-                                                        root_2);
+                                CommonTree root_1 = (CommonTree)adaptor.nil();
+                                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(CTF_EXPRESSION_VAL, "CTF_EXPRESSION_VAL"), root_1);
 
-                                        adaptor.addChild(root_2,
-                                                stream_left.nextTree());
+                                // CTFParser.g:993:80: ^( CTF_LEFT $left)
+                                {
+                                CommonTree root_2 = (CommonTree)adaptor.nil();
+                                root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(CTF_LEFT, "CTF_LEFT"), root_2);
 
-                                        adaptor.addChild(root_1, root_2);
-                                    }
-                                    // Grammar/CTFParser.g:991:98: ^( CTF_RIGHT
-                                    // $right1)
-                                    {
-                                        CommonTree root_2 = (CommonTree) adaptor
-                                                .nil();
-                                        root_2 = (CommonTree) adaptor
-                                                .becomeRoot(
-                                                        adaptor.create(
-                                                                CTF_RIGHT,
-                                                                "CTF_RIGHT"),
-                                                        root_2);
-
-                                        adaptor.addChild(root_2,
-                                                stream_right1.nextTree());
-
-                                        adaptor.addChild(root_1, root_2);
-                                    }
+                                adaptor.addChild(root_2, stream_left.nextTree());
+
+                                adaptor.addChild(root_1, root_2);
+                                }
+                                // CTFParser.g:993:98: ^( CTF_RIGHT $right1)
+                                {
+                                CommonTree root_2 = (CommonTree)adaptor.nil();
+                                root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(CTF_RIGHT, "CTF_RIGHT"), root_2);
+
+                                adaptor.addChild(root_2, stream_right1.nextTree());
+
+                                adaptor.addChild(root_1, root_2);
+                                }
 
-                                    adaptor.addChild(root_0, root_1);
+                                adaptor.addChild(root_0, root_1);
                                 }
 
                             }
 
-                            retval.tree = root_0;
-                        }
-                    }
-                        break;
-                    case 2:
-                    // Grammar/CTFParser.g:992:9: (type_assignment=
-                    // TYPE_ASSIGNMENT right2= typeSpecifier )
-                    {
-                        // Grammar/CTFParser.g:992:9: (type_assignment=
-                        // TYPE_ASSIGNMENT right2= typeSpecifier )
-                        // Grammar/CTFParser.g:992:10: type_assignment=
-                        // TYPE_ASSIGNMENT right2= typeSpecifier
-                        {
-                            type_assignment = (Token) match(input,
-                                    TYPE_ASSIGNMENT,
-                                    FOLLOW_TYPE_ASSIGNMENT_in_ctfAssignmentExpression3438);
-                            if (state.failed) {
+                            retval.tree = root_0;}
+                            }
+                            break;
+                        case 2 :
+                            // CTFParser.g:994:9: (type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier )
+                            {
+                            // CTFParser.g:994:9: (type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier )
+                            // CTFParser.g:994:10: type_assignment= TYPE_ASSIGNMENT right2= typeSpecifier
+                            {
+                            type_assignment=(Token)match(input,TYPE_ASSIGNMENT,FOLLOW_TYPE_ASSIGNMENT_in_ctfAssignmentExpression3451); if (state.failed) {
                                 return retval;
                             }
-                            if (state.backtracking == 0) {
+                            if ( state.backtracking==0 ) {
                                 stream_TYPE_ASSIGNMENT.add(type_assignment);
                             }
 
-                            pushFollow(FOLLOW_typeSpecifier_in_ctfAssignmentExpression3443);
-                            right2 = typeSpecifier();
+                            pushFollow(FOLLOW_typeSpecifier_in_ctfAssignmentExpression3456);
+                            right2=typeSpecifier();
 
                             state._fsp--;
                             if (state.failed) {
                                 return retval;
                             }
-                            if (state.backtracking == 0) {
+                            if ( state.backtracking==0 ) {
                                 stream_typeSpecifier.add(right2.getTree());
                             }
 
-                        }
+                            }
+
 
-                        // AST REWRITE
-                        // elements: left, right2
-                        // token labels:
-                        // rule labels: retval, left, right2
-                        // token list labels:
-                        // rule list labels:
-                        // wildcard labels:
-                        if (state.backtracking == 0) {
+
+                            // AST REWRITE
+                            // elements: right2, left
+                            // token labels:
+                            // rule labels: retval, left, right2
+                            // token list labels:
+                            // rule list labels:
+                            // wildcard labels:
+                            if ( state.backtracking==0 ) {
                             retval.tree = root_0;
-                            RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(
-                                    adaptor, "rule retval",
-                                    retval != null ? retval.tree : null);
-                            RewriteRuleSubtreeStream stream_left = new RewriteRuleSubtreeStream(
-                                    adaptor, "rule left",
-                                    left != null ? left.tree : null);
-                            RewriteRuleSubtreeStream stream_right2 = new RewriteRuleSubtreeStream(
-                                    adaptor, "rule right2",
-                                    right2 != null ? right2.tree : null);
-
-                            root_0 = (CommonTree) adaptor.nil();
-                            // 992:65: -> ^( CTF_EXPRESSION_TYPE ^( CTF_LEFT
-                            // $left) ^( CTF_RIGHT ^( TYPE_SPECIFIER_LIST
-                            // $right2) ) )
+                            RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
+                            RewriteRuleSubtreeStream stream_left=new RewriteRuleSubtreeStream(adaptor,"rule left",left!=null?left.tree:null);
+                            RewriteRuleSubtreeStream stream_right2=new RewriteRuleSubtreeStream(adaptor,"rule right2",right2!=null?right2.tree:null);
+
+                            root_0 = (CommonTree)adaptor.nil();
+                            // 994:65: -> ^( CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT ^( TYPE_SPECIFIER_LIST $right2) ) )
                             {
-                                // Grammar/CTFParser.g:992:68: ^(
-                                // CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^(
-                                // CTF_RIGHT ^( TYPE_SPECIFIER_LIST $right2) ) )
+                                // CTFParser.g:994:68: ^( CTF_EXPRESSION_TYPE ^( CTF_LEFT $left) ^( CTF_RIGHT ^( TYPE_SPECIFIER_LIST $right2) ) )
                                 {
-                                    CommonTree root_1 = (CommonTree) adaptor
-                                            .nil();
-                                    root_1 = (CommonTree) adaptor.becomeRoot(
-                                            adaptor.create(CTF_EXPRESSION_TYPE,
-                                                    "CTF_EXPRESSION_TYPE"),
-                                            root_1);
-
-                                    // Grammar/CTFParser.g:992:90: ^( CTF_LEFT
-                                    // $left)
-                                    {
-                                        CommonTree root_2 = (CommonTree) adaptor
-                                                .nil();
-                                        root_2 = (CommonTree) adaptor
-                                                .becomeRoot(adaptor.create(
-                                                        CTF_LEFT, "CTF_LEFT"),
-                                                        root_2);
+                                CommonTree root_1 = (CommonTree)adaptor.nil();
+                                root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(CTF_EXPRESSION_TYPE, "CTF_EXPRESSION_TYPE"), root_1);
 
-                                        adaptor.addChild(root_2,
-                                                stream_left.nextTree());
+                                // CTFParser.g:994:90: ^( CTF_LEFT $left)
+                                {
+                                CommonTree root_2 = (CommonTree)adaptor.nil();
+                                root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(CTF_LEFT, "CTF_LEFT"), root_2);
 
-                                        adaptor.addChild(root_1, root_2);
-                                    }
-                                    // Grammar/CTFParser.g:992:108: ^( CTF_RIGHT
-                                    // ^( TYPE_SPECIFIER_LIST $right2) )
-                                    {
-                                        CommonTree root_2 = (CommonTree) adaptor
-                                                .nil();
-                                        root_2 = (CommonTree) adaptor
-                                                .becomeRoot(
-                                                        adaptor.create(
-                                                                CTF_RIGHT,
-                                                                "CTF_RIGHT"),
-                                                        root_2);
-
-                                        // Grammar/CTFParser.g:992:120: ^(
-                                        // TYPE_SPECIFIER_LIST $right2)
-                                        {
-                                            CommonTree root_3 = (CommonTree) adaptor
-                                                    .nil();
-                                            root_3 = (CommonTree) adaptor
-                                                    .becomeRoot(
-                                                            adaptor.create(
-                                                                    TYPE_SPECIFIER_LIST,
-                                                                    "TYPE_SPECIFIER_LIST"),
-                                                            root_3);
-
-                                            adaptor.addChild(root_3,
-                                                    stream_right2.nextTree());
-
-                                            adaptor.addChild(root_2, root_3);
-                                        }
-
-                                        adaptor.addChild(root_1, root_2);
-                                    }
+                                adaptor.addChild(root_2, stream_left.nextTree());
 
-                                    adaptor.addChild(root_0, root_1);
+                                adaptor.addChild(root_1, root_2);
+                                }
+                                // CTFParser.g:994:108: ^( CTF_RIGHT ^( TYPE_SPECIFIER_LIST $right2) )
+                                {
+                                CommonTree root_2 = (CommonTree)adaptor.nil();
+                                root_2 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(CTF_RIGHT, "CTF_RIGHT"), root_2);
+
+                                // CTFParser.g:994:120: ^( TYPE_SPECIFIER_LIST $right2)
+                                {
+                                CommonTree root_3 = (CommonTree)adaptor.nil();
+                                root_3 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TYPE_SPECIFIER_LIST, "TYPE_SPECIFIER_LIST"), root_3);
+
+                                adaptor.addChild(root_3, stream_right2.nextTree());
+
+                                adaptor.addChild(root_2, root_3);
+                                }
+
+                                adaptor.addChild(root_1, root_2);
+                                }
+
+                                adaptor.addChild(root_0, root_1);
                                 }
 
                             }
 
-                            retval.tree = root_0;
-                        }
+                            retval.tree = root_0;}
+                            }
+                            break;
+
                     }
-                        break;
+
 
                     }
 
-                }
 
-            }
-                break;
-            case 2:
-            // Grammar/CTFParser.g:998:5: ( declarationSpecifiers {...}?
-            // declaratorList )
-            {
-                // Grammar/CTFParser.g:998:5: ( declarationSpecifiers {...}?
-                // declaratorList )
-                // Grammar/CTFParser.g:998:6: declarationSpecifiers {...}?
-                // declaratorList
-                {
-                    pushFollow(FOLLOW_declarationSpecifiers_in_ctfAssignmentExpression3493);
-                    declarationSpecifiers178 = declarationSpecifiers();
+                    }
+                    break;
+                case 2 :
+                    // CTFParser.g:1000:5: ( declarationSpecifiers {...}? declaratorList )
+                    {
+                    // CTFParser.g:1000:5: ( declarationSpecifiers {...}? declaratorList )
+                    // CTFParser.g:1000:6: declarationSpecifiers {...}? declaratorList
+                    {
+                    pushFollow(FOLLOW_declarationSpecifiers_in_ctfAssignmentExpression3506);
+                    declarationSpecifiers179=declarationSpecifiers();
 
                     state._fsp--;
                     if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
-                        stream_declarationSpecifiers
-                                .add(declarationSpecifiers178.getTree());
+                    if ( state.backtracking==0 ) {
+                        stream_declarationSpecifiers.add(declarationSpecifiers179.getTree());
                     }
-                    if (!((inTypedef()))) {
-                        if (state.backtracking > 0) {
-                            state.failed = true;
-                            return retval;
-                        }
-                        throw new FailedPredicateException(input,
-                                "ctfAssignmentExpression", "inTypedef()");
+                    if ( !((inTypedef())) ) {
+                        if (state.backtracking>0) {state.failed=true; return retval;}
+                        throw new FailedPredicateException(input, "ctfAssignmentExpression", "inTypedef()");
                     }
-                    pushFollow(FOLLOW_declaratorList_in_ctfAssignmentExpression3497);
-                    declaratorList179 = declaratorList();
+                    pushFollow(FOLLOW_declaratorList_in_ctfAssignmentExpression3510);
+                    declaratorList180=declaratorList();
 
                     state._fsp--;
                     if (state.failed) {
                         return retval;
                     }
-                    if (state.backtracking == 0) {
-                        stream_declaratorList.add(declaratorList179.getTree());
+                    if ( state.backtracking==0 ) {
+                        stream_declaratorList.add(declaratorList180.getTree());
                     }
 
-                }
+                    }
 
-                // AST REWRITE
-                // elements: declaratorList, declarationSpecifiers
-                // token labels:
-                // rule labels: retval
-                // token list labels:
-                // rule list labels:
-                // wildcard labels:
-                if (state.backtracking == 0) {
+
+
+                    // AST REWRITE
+                    // elements: declarationSpecifiers, declaratorList
+                    // token labels:
+                    // rule labels: retval
+                    // token list labels:
+                    // rule list labels:
+                    // wildcard labels:
+                    if ( state.backtracking==0 ) {
                     retval.tree = root_0;
-                    RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(
-                            adaptor, "rule retval",
-                            retval != null ? retval.tree : null);
+                    RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 
-                    root_0 = (CommonTree) adaptor.nil();
-                    // 999:5: -> ^( TYPEDEF declaratorList declarationSpecifiers
-                    // )
+                    root_0 = (CommonTree)adaptor.nil();
+                    // 1001:5: -> ^( TYPEDEF declaratorList declarationSpecifiers )
                     {
-                        // Grammar/CTFParser.g:999:8: ^( TYPEDEF declaratorList
-                        // declarationSpecifiers )
+                        // CTFParser.g:1001:8: ^( TYPEDEF declaratorList declarationSpecifiers )
                         {
-                            CommonTree root_1 = (CommonTree) adaptor.nil();
-                            root_1 = (CommonTree) adaptor.becomeRoot(
-                                    adaptor.create(TYPEDEF, "TYPEDEF"), root_1);
+                        CommonTree root_1 = (CommonTree)adaptor.nil();
+                        root_1 = (CommonTree)adaptor.becomeRoot((CommonTree)adaptor.create(TYPEDEF, "TYPEDEF"), root_1);
 
-                            adaptor.addChild(root_1,
-                                    stream_declaratorList.nextTree());
-                            adaptor.addChild(root_1,
-                                    stream_declarationSpecifiers.nextTree());
+                        adaptor.addChild(root_1, stream_declaratorList.nextTree());
+                        adaptor.addChild(root_1, stream_declarationSpecifiers.nextTree());
 
-                            adaptor.addChild(root_0, root_1);
+                        adaptor.addChild(root_0, root_1);
                         }
 
                     }
 
-                    retval.tree = root_0;
-                }
-            }
-                break;
-            case 3:
-            // Grammar/CTFParser.g:1002:5: typealiasDecl
-            {
-                root_0 = (CommonTree) adaptor.nil();
+                    retval.tree = root_0;}
+                    }
+                    break;
+                case 3 :
+                    // CTFParser.g:1004:5: typealiasDecl
+                    {
+                    root_0 = (CommonTree)adaptor.nil();
 
-                pushFollow(FOLLOW_typealiasDecl_in_ctfAssignmentExpression3525);
-                typealiasDecl180 = typealiasDecl();
+                    pushFollow(FOLLOW_typealiasDecl_in_ctfAssignmentExpression3538);
+                    typealiasDecl181=typealiasDecl();
 
-                state._fsp--;
-                if (state.failed) {
-                    return retval;
-                }
-                if (state.backtracking == 0) {
-                    adaptor.addChild(root_0, typealiasDecl180.getTree());
-                }
+                    state._fsp--;
+                    if (state.failed) {
+                        return retval;
+                    }
+                    if ( state.backtracking==0 ) {
+                        adaptor.addChild(root_0, typealiasDecl181.getTree());
+                    }
 
-            }
-                break;
+                    }
+                    break;
 
             }
             retval.stop = input.LT(-1);
 
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
-                retval.tree = (CommonTree) adaptor.rulePostProcessing(root_0);
-                adaptor.setTokenBoundaries(retval.tree, retval.start,
-                        retval.stop);
+            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
+            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
             }
-            if (state.backtracking == 0) {
+            if ( state.backtracking==0 ) {
 
                 if (inTypedef()) {
-                    typedefOff();
+                  typedefOff();
                 }
                 exit("ctfAssignmentExpression");
 
             }
         }
 
-        catch (RecognitionException e) {
-            throw e;
-
+               catch (RecognitionException e)
+               {
+                 throw e;
+               }
+        finally {
         }
         return retval;
     }
-
     // $ANTLR end "ctfAssignmentExpression"
 
     // $ANTLR start synpred1_CTFParser
     public final void synpred1_CTFParser_fragment() throws RecognitionException {
-        // Grammar/CTFParser.g:250:5: ( IDENTIFIER )
-        // Grammar/CTFParser.g:250:6: IDENTIFIER
+        // CTFParser.g:251:5: ( IDENTIFIER )
+        // CTFParser.g:251:6: IDENTIFIER
         {
-            match(input, IDENTIFIER, FOLLOW_IDENTIFIER_in_synpred1_CTFParser470);
-            if (state.failed) {
-                return;
-            }
+        match(input,IDENTIFIER,FOLLOW_IDENTIFIER_in_synpred1_CTFParser474); if (state.failed) {
+            return ;
+        }
 
         }
     }
-
     // $ANTLR end synpred1_CTFParser
 
     // $ANTLR start synpred2_CTFParser
     public final void synpred2_CTFParser_fragment() throws RecognitionException {
-        // Grammar/CTFParser.g:251:5: ( ctfKeyword )
-        // Grammar/CTFParser.g:251:6: ctfKeyword
+        // CTFParser.g:252:5: ( ctfKeyword )
+        // CTFParser.g:252:6: ctfKeyword
         {
-            pushFollow(FOLLOW_ctfKeyword_in_synpred2_CTFParser492);
-            ctfKeyword();
+        pushFollow(FOLLOW_ctfKeyword_in_synpred2_CTFParser496);
+        ctfKeyword();
 
-            state._fsp--;
-            if (state.failed) {
-                return;
-            }
+        state._fsp--;
+        if (state.failed) {
+            return ;
+        }
 
         }
     }
-
     // $ANTLR end synpred2_CTFParser
 
     // $ANTLR start synpred3_CTFParser
     public final void synpred3_CTFParser_fragment() throws RecognitionException {
-        // Grammar/CTFParser.g:252:5: ( STRING_LITERAL )
-        // Grammar/CTFParser.g:252:6: STRING_LITERAL
+        // CTFParser.g:253:5: ( STRING_LITERAL )
+        // CTFParser.g:253:6: STRING_LITERAL
         {
-            match(input, STRING_LITERAL,
-                    FOLLOW_STRING_LITERAL_in_synpred3_CTFParser512);
-            if (state.failed) {
-                return;
-            }
+        match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_synpred3_CTFParser516); if (state.failed) {
+            return ;
+        }
 
         }
     }
-
     // $ANTLR end synpred3_CTFParser
 
     // Delegated rules
@@ -10950,88 +9564,98 @@ public class CTFParser extends Parser {
         try {
             synpred2_CTFParser_fragment(); // can never throw exception
         } catch (RecognitionException re) {
-            if(System.err != null) {//findbugs
-                System.err.println("impossible: " + re);
-            }
+            System.err.println("impossible: "+re);
         }
         boolean success = !state.failed;
         input.rewind(start);
         state.backtracking--;
-        state.failed = false;
+        state.failed=false;
         return success;
     }
-
     public final boolean synpred1_CTFParser() {
         state.backtracking++;
         int start = input.mark();
         try {
             synpred1_CTFParser_fragment(); // can never throw exception
         } catch (RecognitionException re) {
-            if( System.err != null ) {//findbugs
-                System.err.println("impossible: " + re);
-            }
+            System.err.println("impossible: "+re);
         }
         boolean success = !state.failed;
         input.rewind(start);
         state.backtracking--;
-        state.failed = false;
+        state.failed=false;
         return success;
     }
-
     public final boolean synpred3_CTFParser() {
         state.backtracking++;
         int start = input.mark();
         try {
             synpred3_CTFParser_fragment(); // can never throw exception
         } catch (RecognitionException re) {
-            if( System.err != null ) { //findbugs
-                System.err.println("impossible: " + re);
-            }
+            System.err.println("impossible: "+re);
         }
         boolean success = !state.failed;
         input.rewind(start);
         state.backtracking--;
-        state.failed = false;
+        state.failed=false;
         return success;
     }
 
+
     protected DFA10 dfa10 = new DFA10(this);
     protected DFA17 dfa17 = new DFA17(this);
     protected DFA24 dfa24 = new DFA24(this);
     protected DFA32 dfa32 = new DFA32(this);
     protected DFA54 dfa54 = new DFA54(this);
-    static final String DFA10_eotS = "\16\uffff";
-    static final String DFA10_eofS = "\16\uffff";
-    static final String DFA10_minS = "\1\4\15\uffff";
-    static final String DFA10_maxS = "\1\116\15\uffff";
-    static final String DFA10_acceptS = "\1\uffff\2\1\7\uffff\1\2\3\uffff";
-    static final String DFA10_specialS = "\16\uffff}>";
+    static final String DFA10_eotS =
+        "\17\uffff";
+    static final String DFA10_eofS =
+        "\17\uffff";
+    static final String DFA10_minS =
+        "\1\4\16\uffff";
+    static final String DFA10_maxS =
+        "\1\117\16\uffff";
+    static final String DFA10_acceptS =
+        "\1\uffff\2\1\7\uffff\1\2\4\uffff";
+    static final String DFA10_specialS =
+        "\17\uffff}>";
     static final String[] DFA10_transitionS = {
-            "\1\1\4\uffff\1\2\6\uffff\1\1\1\12\1\1\1\uffff\1\12\10\uffff"
-                    + "\2\12\22\uffff\1\1\4\uffff\1\1\1\uffff\1\1\2\uffff\1\1\10\uffff"
-                    + "\1\1\2\uffff\1\1\6\uffff\1\1", "", "", "", "", "", "",
-            "", "", "", "", "", "", "" };
+            "\1\1\4\uffff\1\2\6\uffff\1\1\1\12\1\1\1\uffff\1\12\10\uffff"+
+            "\3\12\22\uffff\1\1\4\uffff\1\1\1\uffff\1\1\2\uffff\1\1\10\uffff"+
+            "\1\1\2\uffff\1\1\6\uffff\1\1",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
 
     static final short[] DFA10_eot = DFA.unpackEncodedString(DFA10_eotS);
     static final short[] DFA10_eof = DFA.unpackEncodedString(DFA10_eofS);
-    static final char[] DFA10_min = DFA
-            .unpackEncodedStringToUnsignedChars(DFA10_minS);
-    static final char[] DFA10_max = DFA
-            .unpackEncodedStringToUnsignedChars(DFA10_maxS);
+    static final char[] DFA10_min = DFA.unpackEncodedStringToUnsignedChars(DFA10_minS);
+    static final char[] DFA10_max = DFA.unpackEncodedStringToUnsignedChars(DFA10_maxS);
     static final short[] DFA10_accept = DFA.unpackEncodedString(DFA10_acceptS);
-    static final short[] DFA10_special = DFA
-            .unpackEncodedString(DFA10_specialS);
+    static final short[] DFA10_special = DFA.unpackEncodedString(DFA10_specialS);
     static final short[][] DFA10_transition;
 
     static {
         int numStates = DFA10_transitionS.length;
         DFA10_transition = new short[numStates][];
-        for (int i = 0; i < numStates; i++) {
+        for (int i=0; i<numStates; i++) {
             DFA10_transition[i] = DFA.unpackEncodedString(DFA10_transitionS[i]);
         }
     }
 
-    static class DFA10 extends DFA {
+    class DFA10 extends DFA {
 
         public DFA10(BaseRecognizer recognizer) {
             this.recognizer = recognizer;
@@ -11044,40 +9668,57 @@ public class CTFParser extends Parser {
             this.special = DFA10_special;
             this.transition = DFA10_transition;
         }
-
-        @Override
         public String getDescription() {
-            return "281:1: postfixExpression : ( ( primaryExpression ) ( postfixExpressionSuffix )* | ( ( ctfSpecifierHead ) ( postfixExpressionSuffix )+ ) );";
-        }
-    }
-
-    static final String DFA17_eotS = "\22\uffff";
-    static final String DFA17_eofS = "\22\uffff";
-    static final String DFA17_minS = "\1\6\21\uffff";
-    static final String DFA17_maxS = "\1\116\21\uffff";
-    static final String DFA17_acceptS = "\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1"
-            + "\15\1\16\1\17\1\20\1\21";
-    static final String DFA17_specialS = "\1\0\21\uffff}>";
+            return "282:1: postfixExpression : ( ( primaryExpression ) ( postfixExpressionSuffix )* | ( ( ctfSpecifierHead ) ( postfixExpressionSuffix )+ ) );";
+        }
+    }
+    static final String DFA17_eotS =
+        "\22\uffff";
+    static final String DFA17_eofS =
+        "\22\uffff";
+    static final String DFA17_minS =
+        "\1\6\21\uffff";
+    static final String DFA17_maxS =
+        "\1\117\21\uffff";
+    static final String DFA17_acceptS =
+        "\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1"+
+        "\15\1\16\1\17\1\20\1\21";
+    static final String DFA17_specialS =
+        "\1\0\21\uffff}>";
     static final String[] DFA17_transitionS = {
-            "\1\7\1\10\1\17\1\uffff\1\20\1\1\1\20\1\2\1\3\1\4\1\5\1\uffff"
-                    + "\1\20\1\15\3\uffff\1\6\1\16\1\11\1\12\1\13\1\14\61\uffff\1\21",
-            "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "" };
+            "\1\7\1\10\1\17\1\uffff\1\20\1\1\1\20\1\2\1\3\1\4\1\5\1\uffff"+
+            "\1\20\1\15\3\uffff\1\6\1\16\1\11\1\12\1\13\1\14\62\uffff\1\21",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
 
     static final short[] DFA17_eot = DFA.unpackEncodedString(DFA17_eotS);
     static final short[] DFA17_eof = DFA.unpackEncodedString(DFA17_eofS);
-    static final char[] DFA17_min = DFA
-            .unpackEncodedStringToUnsignedChars(DFA17_minS);
-    static final char[] DFA17_max = DFA
-            .unpackEncodedStringToUnsignedChars(DFA17_maxS);
+    static final char[] DFA17_min = DFA.unpackEncodedStringToUnsignedChars(DFA17_minS);
+    static final char[] DFA17_max = DFA.unpackEncodedStringToUnsignedChars(DFA17_maxS);
     static final short[] DFA17_accept = DFA.unpackEncodedString(DFA17_acceptS);
-    static final short[] DFA17_special = DFA
-            .unpackEncodedString(DFA17_specialS);
+    static final short[] DFA17_special = DFA.unpackEncodedString(DFA17_specialS);
     static final short[][] DFA17_transition;
 
     static {
         int numStates = DFA17_transitionS.length;
         DFA17_transition = new short[numStates][];
-        for (int i = 0; i < numStates; i++) {
+        for (int i=0; i<numStates; i++) {
             DFA17_transition[i] = DFA.unpackEncodedString(DFA17_transitionS[i]);
         }
     }
@@ -11095,139 +9736,101 @@ public class CTFParser extends Parser {
             this.special = DFA17_special;
             this.transition = DFA17_transition;
         }
-
-        @Override
         public String getDescription() {
-            return "384:1: typeSpecifier : ( FLOATTOK | INTTOK | LONGTOK | SHORTTOK | SIGNEDTOK | UNSIGNEDTOK | CHARTOK | DOUBLETOK | VOIDTOK | BOOLTOK | COMPLEXTOK | IMAGINARYTOK | structSpecifier | variantSpecifier | enumSpecifier | ctfTypeSpecifier | {...}? => typedefName );";
+            return "385:1: typeSpecifier : ( FLOATTOK | INTTOK | LONGTOK | SHORTTOK | SIGNEDTOK | UNSIGNEDTOK | CHARTOK | DOUBLETOK | VOIDTOK | BOOLTOK | COMPLEXTOK | IMAGINARYTOK | structSpecifier | variantSpecifier | enumSpecifier | ctfTypeSpecifier | {...}? => typedefName );";
         }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+               int _s = s;
+            switch ( s ) {
+                    case 0 :
+                        int LA17_0 = input.LA(1);
 
-        @SuppressWarnings({ "synthetic-access" })
-        @Override
-        public int specialStateTransition(final int inputS, IntStream _input)
-                throws NoViableAltException {
-            TokenStream input = (TokenStream) _input;
-            int _s = inputS;
-            int s = inputS;
-            switch (s) {
-            case 0:
-                int LA17_0 = input.LA(1);
 
-                int index17_0 = input.index();
-                input.rewind();
-                s = -1;
-                if ((LA17_0 == FLOATTOK)) {
-                    s = 1;
-                }
+                        int index17_0 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (LA17_0==FLOATTOK) ) {s = 1;}
 
-                else if ((LA17_0 == INTTOK)) {
-                    s = 2;
-                }
+                        else if ( (LA17_0==INTTOK) ) {s = 2;}
 
-                else if ((LA17_0 == LONGTOK)) {
-                    s = 3;
-                }
+                        else if ( (LA17_0==LONGTOK) ) {s = 3;}
 
-                else if ((LA17_0 == SHORTTOK)) {
-                    s = 4;
-                }
+                        else if ( (LA17_0==SHORTTOK) ) {s = 4;}
 
-                else if ((LA17_0 == SIGNEDTOK)) {
-                    s = 5;
-                }
+                        else if ( (LA17_0==SIGNEDTOK) ) {s = 5;}
 
-                else if ((LA17_0 == UNSIGNEDTOK)) {
-                    s = 6;
-                }
+                        else if ( (LA17_0==UNSIGNEDTOK) ) {s = 6;}
 
-                else if ((LA17_0 == CHARTOK)) {
-                    s = 7;
-                }
+                        else if ( (LA17_0==CHARTOK) ) {s = 7;}
 
-                else if ((LA17_0 == DOUBLETOK)) {
-                    s = 8;
-                }
+                        else if ( (LA17_0==DOUBLETOK) ) {s = 8;}
 
-                else if ((LA17_0 == VOIDTOK)) {
-                    s = 9;
-                }
+                        else if ( (LA17_0==VOIDTOK) ) {s = 9;}
 
-                else if ((LA17_0 == BOOLTOK)) {
-                    s = 10;
-                }
+                        else if ( (LA17_0==BOOLTOK) ) {s = 10;}
 
-                else if ((LA17_0 == COMPLEXTOK)) {
-                    s = 11;
-                }
+                        else if ( (LA17_0==COMPLEXTOK) ) {s = 11;}
 
-                else if ((LA17_0 == IMAGINARYTOK)) {
-                    s = 12;
-                }
+                        else if ( (LA17_0==IMAGINARYTOK) ) {s = 12;}
 
-                else if ((LA17_0 == STRUCTTOK)) {
-                    s = 13;
-                }
+                        else if ( (LA17_0==STRUCTTOK) ) {s = 13;}
 
-                else if ((LA17_0 == VARIANTTOK)) {
-                    s = 14;
-                }
+                        else if ( (LA17_0==VARIANTTOK) ) {s = 14;}
 
-                else if ((LA17_0 == ENUMTOK)) {
-                    s = 15;
-                }
+                        else if ( (LA17_0==ENUMTOK) ) {s = 15;}
 
-                else if (((LA17_0 == FLOATINGPOINTTOK)
-                        || (LA17_0 == INTEGERTOK) || (LA17_0 == STRINGTOK))) {
-                    s = 16;
-                }
+                        else if ( (LA17_0==FLOATINGPOINTTOK||LA17_0==INTEGERTOK||LA17_0==STRINGTOK) ) {s = 16;}
 
-                else if ((LA17_0 == IDENTIFIER)
-                        && ((inTypealiasAlias() || isTypeName(input.LT(1)
-                                .getText())))) {
-                    s = 17;
-                }
+                        else if ( (LA17_0==IDENTIFIER) && ((inTypealiasAlias() || isTypeName(input.LT(1).getText())))) {s = 17;}
 
-                input.seek(index17_0);
-                if (s >= 0) {
-                    return s;
-                }
-                break;
-            }
-            if (state.backtracking > 0) {
-                state.failed = true;
-                return -1;
+
+                        input.seek(index17_0);
+                        if ( s>=0 ) {
+                            return s;
+                        }
+                        break;
             }
-            NoViableAltException nvae = new NoViableAltException(
-                    getDescription(), 17, _s, input);
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 17, _s, input);
             error(nvae);
             throw nvae;
         }
     }
-
-    static final String DFA24_eotS = "\6\uffff";
-    static final String DFA24_eofS = "\6\uffff";
-    static final String DFA24_minS = "\1\60\1\5\1\0\1\5\2\uffff";
-    static final String DFA24_maxS = "\2\116\1\0\1\116\2\uffff";
-    static final String DFA24_acceptS = "\4\uffff\1\1\1\2";
-    static final String DFA24_specialS = "\2\uffff\1\0\3\uffff}>";
-    static final String[] DFA24_transitionS = { "\1\1\35\uffff\1\2",
-            "\1\3\52\uffff\1\1\35\uffff\1\2", "\1\uffff",
-            "\1\3\52\uffff\1\1\35\uffff\1\2", "", "" };
+    static final String DFA24_eotS =
+        "\6\uffff";
+    static final String DFA24_eofS =
+        "\6\uffff";
+    static final String DFA24_minS =
+        "\1\61\1\5\1\0\1\5\2\uffff";
+    static final String DFA24_maxS =
+        "\2\117\1\0\1\117\2\uffff";
+    static final String DFA24_acceptS =
+        "\4\uffff\1\1\1\2";
+    static final String DFA24_specialS =
+        "\2\uffff\1\0\3\uffff}>";
+    static final String[] DFA24_transitionS = {
+            "\1\1\35\uffff\1\2",
+            "\1\3\53\uffff\1\1\35\uffff\1\2",
+            "\1\uffff",
+            "\1\3\53\uffff\1\1\35\uffff\1\2",
+            "",
+            ""
+    };
 
     static final short[] DFA24_eot = DFA.unpackEncodedString(DFA24_eotS);
     static final short[] DFA24_eof = DFA.unpackEncodedString(DFA24_eofS);
-    static final char[] DFA24_min = DFA
-            .unpackEncodedStringToUnsignedChars(DFA24_minS);
-    static final char[] DFA24_max = DFA
-            .unpackEncodedStringToUnsignedChars(DFA24_maxS);
+    static final char[] DFA24_min = DFA.unpackEncodedStringToUnsignedChars(DFA24_minS);
+    static final char[] DFA24_max = DFA.unpackEncodedStringToUnsignedChars(DFA24_maxS);
     static final short[] DFA24_accept = DFA.unpackEncodedString(DFA24_acceptS);
-    static final short[] DFA24_special = DFA
-            .unpackEncodedString(DFA24_specialS);
+    static final short[] DFA24_special = DFA.unpackEncodedString(DFA24_specialS);
     static final short[][] DFA24_transition;
 
     static {
         int numStates = DFA24_transitionS.length;
         DFA24_transition = new short[numStates][];
-        for (int i = 0; i < numStates; i++) {
+        for (int i=0; i<numStates; i++) {
             DFA24_transition[i] = DFA.unpackEncodedString(DFA24_transitionS[i]);
         }
     }
@@ -11245,81 +9848,100 @@ public class CTFParser extends Parser {
             this.special = DFA24_special;
             this.transition = DFA24_transition;
         }
-
-        @Override
         public String getDescription() {
-            return "521:7: ({...}? => declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList ) )";
+            return "522:7: ({...}? => declaratorList -> ^( TYPEDEF declaratorList declarationSpecifiers ) | structOrVariantDeclaratorList -> ^( SV_DECLARATION declarationSpecifiers structOrVariantDeclaratorList ) )";
         }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+               int _s = s;
+            switch ( s ) {
+                    case 0 :
+                        int LA24_2 = input.LA(1);
 
-        @Override
-        public int specialStateTransition(int s, IntStream _input)
-                throws NoViableAltException {
-            TokenStream input = (TokenStream) _input;
-            int _s = s;
-            switch (s) {
-            case 0:
-                int LA24_2 = input.LA(1);
 
-                int index24_2 = input.index();
-                input.rewind();
-                s = -1;
-                if (((inTypedef()))) {
-                    s = 4;
-                }
+                        int index24_2 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( ((inTypedef())) ) {s = 4;}
 
-                else if ((true)) {
-                    s = 5;
-                }
+                        else if ( (true) ) {s = 5;}
 
-                input.seek(index24_2);
-                if (s >= 0) {
-                    return s;
-                }
-                break;
-            }
-            if (state.backtracking > 0) {
-                state.failed = true;
-                return -1;
+
+                        input.seek(index24_2);
+                        if ( s>=0 ) {
+                            return s;
+                        }
+                        break;
             }
-            NoViableAltException nvae = new NoViableAltException(
-                    getDescription(), 24, _s, input);
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 24, _s, input);
             error(nvae);
             throw nvae;
         }
     }
-
-    static final String DFA32_eotS = "\35\uffff";
-    static final String DFA32_eofS = "\1\3\34\uffff";
-    static final String DFA32_minS = "\1\5\34\uffff";
-    static final String DFA32_maxS = "\1\116\34\uffff";
-    static final String DFA32_acceptS = "\1\uffff\1\1\1\2\1\3\31\uffff";
-    static final String DFA32_specialS = "\35\uffff}>";
+    static final String DFA32_eotS =
+        "\35\uffff";
+    static final String DFA32_eofS =
+        "\1\3\34\uffff";
+    static final String DFA32_minS =
+        "\1\5\34\uffff";
+    static final String DFA32_maxS =
+        "\1\117\34\uffff";
+    static final String DFA32_acceptS =
+        "\1\uffff\1\1\1\2\1\3\31\uffff";
+    static final String DFA32_specialS =
+        "\35\uffff}>";
     static final String[] DFA32_transitionS = {
-            "\4\3\1\uffff\7\3\1\uffff\2\3\2\uffff\7\3\6\uffff\1\1\2\uffff"
-                    + "\1\3\4\uffff\1\3\1\uffff\1\2\1\uffff\2\3\35\uffff\1\3",
-            "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
-            "", "", "", "", "", "", "", "", "", "", "" };
+            "\4\3\1\uffff\7\3\1\uffff\2\3\2\uffff\7\3\7\uffff\1\1\2\uffff"+
+            "\1\3\4\uffff\1\3\1\uffff\1\2\1\uffff\2\3\35\uffff\1\3",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
 
     static final short[] DFA32_eot = DFA.unpackEncodedString(DFA32_eotS);
     static final short[] DFA32_eof = DFA.unpackEncodedString(DFA32_eofS);
-    static final char[] DFA32_min = DFA
-            .unpackEncodedStringToUnsignedChars(DFA32_minS);
-    static final char[] DFA32_max = DFA
-            .unpackEncodedStringToUnsignedChars(DFA32_maxS);
+    static final char[] DFA32_min = DFA.unpackEncodedStringToUnsignedChars(DFA32_minS);
+    static final char[] DFA32_max = DFA.unpackEncodedStringToUnsignedChars(DFA32_maxS);
     static final short[] DFA32_accept = DFA.unpackEncodedString(DFA32_acceptS);
-    static final short[] DFA32_special = DFA
-            .unpackEncodedString(DFA32_specialS);
+    static final short[] DFA32_special = DFA.unpackEncodedString(DFA32_specialS);
     static final short[][] DFA32_transition;
 
     static {
         int numStates = DFA32_transitionS.length;
         DFA32_transition = new short[numStates][];
-        for (int i = 0; i < numStates; i++) {
+        for (int i=0; i<numStates; i++) {
             DFA32_transition[i] = DFA.unpackEncodedString(DFA32_transitionS[i]);
         }
     }
 
-    static class DFA32 extends DFA {
+    class DFA32 extends DFA {
 
         public DFA32(BaseRecognizer recognizer) {
             this.recognizer = recognizer;
@@ -11332,45 +9954,71 @@ public class CTFParser extends Parser {
             this.special = DFA32_special;
             this.transition = DFA32_transition;
         }
-
-        @Override
         public String getDescription() {
-            return "655:4: ( enumContainerType enumBody | enumBody | )";
-        }
-    }
-
-    static final String DFA54_eotS = "\34\uffff";
-    static final String DFA54_eofS = "\1\2\33\uffff";
-    static final String DFA54_minS = "\1\5\33\uffff";
-    static final String DFA54_maxS = "\1\116\33\uffff";
-    static final String DFA54_acceptS = "\1\uffff\1\1\1\2\31\uffff";
-    static final String DFA54_specialS = "\34\uffff}>";
+            return "656:4: ( enumContainerType enumBody | enumBody | )";
+        }
+    }
+    static final String DFA54_eotS =
+        "\34\uffff";
+    static final String DFA54_eofS =
+        "\1\2\33\uffff";
+    static final String DFA54_minS =
+        "\1\5\33\uffff";
+    static final String DFA54_maxS =
+        "\1\117\33\uffff";
+    static final String DFA54_acceptS =
+        "\1\uffff\1\1\1\2\31\uffff";
+    static final String DFA54_specialS =
+        "\34\uffff}>";
     static final String[] DFA54_transitionS = {
-            "\4\2\1\uffff\7\2\1\uffff\2\2\2\uffff\7\2\11\uffff\1\2\4\uffff"
-                    + "\1\2\1\uffff\1\1\1\uffff\2\2\35\uffff\1\2", "", "", "",
-            "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
-            "", "", "", "", "", "", "" };
+            "\4\2\1\uffff\7\2\1\uffff\2\2\2\uffff\7\2\12\uffff\1\2\4\uffff"+
+            "\1\2\1\uffff\1\1\1\uffff\2\2\35\uffff\1\2",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
 
     static final short[] DFA54_eot = DFA.unpackEncodedString(DFA54_eotS);
     static final short[] DFA54_eof = DFA.unpackEncodedString(DFA54_eofS);
-    static final char[] DFA54_min = DFA
-            .unpackEncodedStringToUnsignedChars(DFA54_minS);
-    static final char[] DFA54_max = DFA
-            .unpackEncodedStringToUnsignedChars(DFA54_maxS);
+    static final char[] DFA54_min = DFA.unpackEncodedStringToUnsignedChars(DFA54_minS);
+    static final char[] DFA54_max = DFA.unpackEncodedStringToUnsignedChars(DFA54_maxS);
     static final short[] DFA54_accept = DFA.unpackEncodedString(DFA54_acceptS);
-    static final short[] DFA54_special = DFA
-            .unpackEncodedString(DFA54_specialS);
+    static final short[] DFA54_special = DFA.unpackEncodedString(DFA54_specialS);
     static final short[][] DFA54_transition;
 
     static {
         int numStates = DFA54_transitionS.length;
         DFA54_transition = new short[numStates][];
-        for (int i = 0; i < numStates; i++) {
+        for (int i=0; i<numStates; i++) {
             DFA54_transition[i] = DFA.unpackEncodedString(DFA54_transitionS[i]);
         }
     }
 
-    static class DFA54 extends DFA {
+    class DFA54 extends DFA {
 
         public DFA54(BaseRecognizer recognizer) {
             this.recognizer = recognizer;
@@ -11383,396 +10031,204 @@ public class CTFParser extends Parser {
             this.special = DFA54_special;
             this.transition = DFA54_transition;
         }
-
-        @Override
         public String getDescription() {
-            return "954:15: ( ctfBody )?";
-        }
-    }
-
-    public static final BitSet FOLLOW_declaration_in_parse321 = new BitSet(
-            new long[] { 0x000000007FFFFFE0L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_EOF_in_parse324 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_SIGN_in_numberLiteral357 = new BitSet(
-            new long[] { 0x0942000000000000L });
-    public static final BitSet FOLLOW_HEX_LITERAL_in_numberLiteral362 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_DECIMAL_LITERAL_in_numberLiteral379 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_OCTAL_LITERAL_in_numberLiteral396 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_numberLiteral_in_constant432 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_enumConstant_in_constant438 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_CHARACTER_LITERAL_in_constant444 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_IDENTIFIER_in_primaryExpression475 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_ctfKeyword_in_primaryExpression497 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_STRING_LITERAL_in_primaryExpression517 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_constant_in_primaryExpression538 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_DOT_in_reference564 = new BitSet(
-            new long[] { 0x0000000000000000L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_ARROW_in_reference570 = new BitSet(
-            new long[] { 0x0000000000000000L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_IDENTIFIER_in_reference573 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_OPENBRAC_in_postfixExpressionSuffix612 = new BitSet(
-            new long[] { 0x0942000060170210L, 0x0000000000004090L });
-    public static final BitSet FOLLOW_unaryExpression_in_postfixExpressionSuffix614 = new BitSet(
-            new long[] { 0x0000040000000000L });
-    public static final BitSet FOLLOW_CLOSEBRAC_in_postfixExpressionSuffix616 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_reference_in_postfixExpressionSuffix624 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_primaryExpression_in_postfixExpression648 = new BitSet(
-            new long[] { 0x000C020000000002L });
-    public static final BitSet FOLLOW_postfixExpressionSuffix_in_postfixExpression652 = new BitSet(
-            new long[] { 0x000C020000000002L });
-    public static final BitSet FOLLOW_ctfSpecifierHead_in_postfixExpression661 = new BitSet(
-            new long[] { 0x000C020000000000L });
-    public static final BitSet FOLLOW_postfixExpressionSuffix_in_postfixExpression666 = new BitSet(
-            new long[] { 0x000C020000000002L });
-    public static final BitSet FOLLOW_postfixExpression_in_unaryExpression700 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_STRING_LITERAL_in_enumConstant725 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_IDENTIFIER_in_enumConstant741 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_ctfKeyword_in_enumConstant757 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_declarationSpecifiers_in_declaration790 = new BitSet(
-            new long[] { 0x0001800000000000L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_declaratorList_in_declaration792 = new BitSet(
-            new long[] { 0x0000800000000000L });
-    public static final BitSet FOLLOW_TERM_in_declaration795 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_ctfSpecifier_in_declaration844 = new BitSet(
-            new long[] { 0x0000800000000000L });
-    public static final BitSet FOLLOW_TERM_in_declaration846 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_storageClassSpecifier_in_declarationSpecifiers891 = new BitSet(
-            new long[] { 0x000000001FCDFDE2L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_typeQualifier_in_declarationSpecifiers898 = new BitSet(
-            new long[] { 0x000000001FCDFDE2L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_typeSpecifier_in_declarationSpecifiers905 = new BitSet(
-            new long[] { 0x000000001FCDFDE2L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_declarator_in_declaratorList946 = new BitSet(
-            new long[] { 0x0000000400000002L });
-    public static final BitSet FOLLOW_SEPARATOR_in_declaratorList949 = new BitSet(
-            new long[] { 0x0001000000000000L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_declarator_in_declaratorList951 = new BitSet(
-            new long[] { 0x0000000400000002L });
-    public static final BitSet FOLLOW_abstractDeclarator_in_abstractDeclaratorList985 = new BitSet(
-            new long[] { 0x0000000400000002L });
-    public static final BitSet FOLLOW_SEPARATOR_in_abstractDeclaratorList988 = new BitSet(
-            new long[] { 0x0001080000000000L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_abstractDeclarator_in_abstractDeclaratorList990 = new BitSet(
-            new long[] { 0x0000000400000002L });
-    public static final BitSet FOLLOW_TYPEDEFTOK_in_storageClassSpecifier1014 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_FLOATTOK_in_typeSpecifier1040 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_INTTOK_in_typeSpecifier1046 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_LONGTOK_in_typeSpecifier1052 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_SHORTTOK_in_typeSpecifier1058 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_SIGNEDTOK_in_typeSpecifier1064 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_UNSIGNEDTOK_in_typeSpecifier1070 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_CHARTOK_in_typeSpecifier1076 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_DOUBLETOK_in_typeSpecifier1082 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_VOIDTOK_in_typeSpecifier1088 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_BOOLTOK_in_typeSpecifier1094 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_COMPLEXTOK_in_typeSpecifier1100 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_IMAGINARYTOK_in_typeSpecifier1106 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_structSpecifier_in_typeSpecifier1112 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_variantSpecifier_in_typeSpecifier1118 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_enumSpecifier_in_typeSpecifier1124 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_ctfTypeSpecifier_in_typeSpecifier1130 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_typedefName_in_typeSpecifier1140 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_CONSTTOK_in_typeQualifier1163 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_ALIGNTOK_in_alignAttribute1176 = new BitSet(
-            new long[] { 0x0000080000000000L });
-    public static final BitSet FOLLOW_LPAREN_in_alignAttribute1178 = new BitSet(
-            new long[] { 0x0942000060170210L, 0x0000000000004090L });
-    public static final BitSet FOLLOW_unaryExpression_in_alignAttribute1180 = new BitSet(
-            new long[] { 0x0000100000000000L });
-    public static final BitSet FOLLOW_RPAREN_in_alignAttribute1182 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_LCURL_in_structBody1223 = new BitSet(
-            new long[] { 0x000040007FFFFFE0L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_structOrVariantDeclarationList_in_structBody1225 = new BitSet(
-            new long[] { 0x0000400000000000L });
-    public static final BitSet FOLLOW_RCURL_in_structBody1228 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_STRUCTTOK_in_structSpecifier1266 = new BitSet(
-            new long[] { 0x0000200000000000L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_structName_in_structSpecifier1288 = new BitSet(
-            new long[] { 0x0000200000000012L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_alignAttribute_in_structSpecifier1304 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_structBody_in_structSpecifier1333 = new BitSet(
-            new long[] { 0x0000000000000012L });
-    public static final BitSet FOLLOW_alignAttribute_in_structSpecifier1358 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_structBody_in_structSpecifier1456 = new BitSet(
-            new long[] { 0x0000000000000012L });
-    public static final BitSet FOLLOW_alignAttribute_in_structSpecifier1474 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_IDENTIFIER_in_structName1550 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_structOrVariantDeclaration_in_structOrVariantDeclarationList1581 = new BitSet(
-            new long[] { 0x000000007FFFFFE2L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_declarationSpecifiers_in_structOrVariantDeclaration1619 = new BitSet(
-            new long[] { 0x0001000000000000L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_declaratorList_in_structOrVariantDeclaration1651 = new BitSet(
-            new long[] { 0x0000800000000000L });
-    public static final BitSet FOLLOW_structOrVariantDeclaratorList_in_structOrVariantDeclaration1685 = new BitSet(
-            new long[] { 0x0000800000000000L });
-    public static final BitSet FOLLOW_typealiasDecl_in_structOrVariantDeclaration1735 = new BitSet(
-            new long[] { 0x0000800000000000L });
-    public static final BitSet FOLLOW_TERM_in_structOrVariantDeclaration1747 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_typeQualifier_in_specifierQualifierList1771 = new BitSet(
-            new long[] { 0x000000001FCDFDE2L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_typeSpecifier_in_specifierQualifierList1775 = new BitSet(
-            new long[] { 0x000000001FCDFDE2L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_structOrVariantDeclarator_in_structOrVariantDeclaratorList1812 = new BitSet(
-            new long[] { 0x0000000400000002L });
-    public static final BitSet FOLLOW_SEPARATOR_in_structOrVariantDeclaratorList1815 = new BitSet(
-            new long[] { 0x0001000000000000L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_structOrVariantDeclarator_in_structOrVariantDeclaratorList1817 = new BitSet(
-            new long[] { 0x0000000400000002L });
-    public static final BitSet FOLLOW_declarator_in_structOrVariantDeclarator1858 = new BitSet(
-            new long[] { 0x0000000800000002L });
-    public static final BitSet FOLLOW_COLON_in_structOrVariantDeclarator1861 = new BitSet(
-            new long[] { 0x0942000000000000L });
-    public static final BitSet FOLLOW_numberLiteral_in_structOrVariantDeclarator1863 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_VARIANTTOK_in_variantSpecifier1897 = new BitSet(
-            new long[] { 0x0000208000000000L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_variantName_in_variantSpecifier1915 = new BitSet(
-            new long[] { 0x0000208000000000L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_variantTag_in_variantSpecifier1946 = new BitSet(
-            new long[] { 0x0000208000000002L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_variantBody_in_variantSpecifier1972 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_variantBody_in_variantSpecifier2040 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_variantTag_in_variantSpecifier2065 = new BitSet(
-            new long[] { 0x0000208000000000L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_variantBody_in_variantSpecifier2067 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_variantBody_in_variantSpecifier2078 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_IDENTIFIER_in_variantName2120 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_LCURL_in_variantBody2156 = new BitSet(
-            new long[] { 0x000000007FFFFFE0L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_structOrVariantDeclarationList_in_variantBody2158 = new BitSet(
-            new long[] { 0x0000400000000000L });
-    public static final BitSet FOLLOW_RCURL_in_variantBody2160 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_LT_in_variantTag2191 = new BitSet(
-            new long[] { 0x0000000000000000L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_IDENTIFIER_in_variantTag2193 = new BitSet(
-            new long[] { 0x0000010000000000L });
-    public static final BitSet FOLLOW_GT_in_variantTag2195 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_ENUMTOK_in_enumSpecifier2225 = new BitSet(
-            new long[] { 0x0000200800000000L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_enumName_in_enumSpecifier2240 = new BitSet(
-            new long[] { 0x0000200800000002L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_enumContainerType_in_enumSpecifier2251 = new BitSet(
-            new long[] { 0x0000200800000000L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_enumBody_in_enumSpecifier2253 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_enumBody_in_enumSpecifier2265 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_enumContainerType_in_enumSpecifier2300 = new BitSet(
-            new long[] { 0x0000200800000000L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_enumBody_in_enumSpecifier2302 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_enumBody_in_enumSpecifier2311 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_IDENTIFIER_in_enumName2356 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_LCURL_in_enumBody2389 = new BitSet(
-            new long[] { 0x0000000000050210L, 0x0000000000004080L });
-    public static final BitSet FOLLOW_enumeratorList_in_enumBody2391 = new BitSet(
-            new long[] { 0x0000400400000000L });
-    public static final BitSet FOLLOW_SEPARATOR_in_enumBody2394 = new BitSet(
-            new long[] { 0x0000400000000000L });
-    public static final BitSet FOLLOW_RCURL_in_enumBody2396 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_RCURL_in_enumBody2400 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_COLON_in_enumContainerType2432 = new BitSet(
-            new long[] { 0x000000001FCDFDE0L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_declarationSpecifiers_in_enumContainerType2434 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_enumerator_in_enumeratorList2465 = new BitSet(
-            new long[] { 0x0000000400000002L });
-    public static final BitSet FOLLOW_SEPARATOR_in_enumeratorList2468 = new BitSet(
-            new long[] { 0x0000000000050210L, 0x0000000000004080L });
-    public static final BitSet FOLLOW_enumerator_in_enumeratorList2470 = new BitSet(
-            new long[] { 0x0000000400000002L });
-    public static final BitSet FOLLOW_enumConstant_in_enumerator2506 = new BitSet(
-            new long[] { 0x0000002000000002L });
-    public static final BitSet FOLLOW_enumeratorValue_in_enumerator2508 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_ASSIGNMENT_in_enumeratorValue2532 = new BitSet(
-            new long[] { 0x0942000060170210L, 0x0000000000004090L });
-    public static final BitSet FOLLOW_unaryExpression_in_enumeratorValue2536 = new BitSet(
-            new long[] { 0x0000001000000002L });
-    public static final BitSet FOLLOW_ELIPSES_in_enumeratorValue2562 = new BitSet(
-            new long[] { 0x0942000060170210L, 0x0000000000004090L });
-    public static final BitSet FOLLOW_unaryExpression_in_enumeratorValue2566 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_pointer_in_declarator2608 = new BitSet(
-            new long[] { 0x0001000000000000L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_directDeclarator_in_declarator2611 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_IDENTIFIER_in_directDeclarator2655 = new BitSet(
-            new long[] { 0x0000020000000002L });
-    public static final BitSet FOLLOW_directDeclaratorSuffix_in_directDeclarator2673 = new BitSet(
-            new long[] { 0x0000020000000002L });
-    public static final BitSet FOLLOW_OPENBRAC_in_directDeclaratorSuffix2686 = new BitSet(
-            new long[] { 0x0942000060170210L, 0x0000000000004090L });
-    public static final BitSet FOLLOW_directDeclaratorLength_in_directDeclaratorSuffix2688 = new BitSet(
-            new long[] { 0x0000040000000000L });
-    public static final BitSet FOLLOW_CLOSEBRAC_in_directDeclaratorSuffix2690 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_unaryExpression_in_directDeclaratorLength2711 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_pointer_in_abstractDeclarator2742 = new BitSet(
-            new long[] { 0x0001080000000002L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_directAbstractDeclarator_in_abstractDeclarator2745 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_directAbstractDeclarator_in_abstractDeclarator2765 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_IDENTIFIER_in_directAbstractDeclarator2805 = new BitSet(
-            new long[] { 0x0000020000000002L });
-    public static final BitSet FOLLOW_LPAREN_in_directAbstractDeclarator2814 = new BitSet(
-            new long[] { 0x0001080000000000L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_abstractDeclarator_in_directAbstractDeclarator2816 = new BitSet(
-            new long[] { 0x0000100000000000L });
-    public static final BitSet FOLLOW_RPAREN_in_directAbstractDeclarator2818 = new BitSet(
-            new long[] { 0x0000020000000002L });
-    public static final BitSet FOLLOW_OPENBRAC_in_directAbstractDeclarator2833 = new BitSet(
-            new long[] { 0x0942040060170210L, 0x0000000000004090L });
-    public static final BitSet FOLLOW_unaryExpression_in_directAbstractDeclarator2835 = new BitSet(
-            new long[] { 0x0000040000000000L });
-    public static final BitSet FOLLOW_CLOSEBRAC_in_directAbstractDeclarator2838 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_POINTER_in_pointer2866 = new BitSet(
-            new long[] { 0x0000000000000022L });
-    public static final BitSet FOLLOW_typeQualifierList_in_pointer2868 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_typeQualifier_in_typeQualifierList2891 = new BitSet(
-            new long[] { 0x0000000000000022L });
-    public static final BitSet FOLLOW_IDENTIFIER_in_typedefName2917 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_declarationSpecifiers_in_typealiasTarget2945 = new BitSet(
-            new long[] { 0x0001080000000002L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_abstractDeclaratorList_in_typealiasTarget2947 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_abstractDeclaratorList_in_typealiasAlias2980 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_declarationSpecifiers_in_typealiasAlias2989 = new BitSet(
-            new long[] { 0x0001080000000002L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_abstractDeclaratorList_in_typealiasAlias2991 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_TYPEALIASTOK_in_typealiasDecl3023 = new BitSet(
-            new long[] { 0x000000001FCDFDE0L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_typealiasTarget_in_typealiasDecl3025 = new BitSet(
-            new long[] { 0x0000004000000000L });
-    public static final BitSet FOLLOW_TYPE_ASSIGNMENT_in_typealiasDecl3027 = new BitSet(
-            new long[] { 0x000108001FCDFDE0L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_typealiasAlias_in_typealiasDecl3029 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_set_in_ctfKeyword0 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_ctfSpecifierHead_in_ctfSpecifier3123 = new BitSet(
-            new long[] { 0x0000200000000000L });
-    public static final BitSet FOLLOW_ctfBody_in_ctfSpecifier3125 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_typealiasDecl_in_ctfSpecifier3144 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_EVENTTOK_in_ctfSpecifierHead3176 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_STREAMTOK_in_ctfSpecifierHead3185 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_TRACETOK_in_ctfSpecifierHead3194 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_ENVTOK_in_ctfSpecifierHead3203 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_CLOCKTOK_in_ctfSpecifierHead3212 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_FLOATINGPOINTTOK_in_ctfTypeSpecifier3246 = new BitSet(
-            new long[] { 0x0000200000000000L });
-    public static final BitSet FOLLOW_ctfBody_in_ctfTypeSpecifier3248 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_INTEGERTOK_in_ctfTypeSpecifier3263 = new BitSet(
-            new long[] { 0x0000200000000000L });
-    public static final BitSet FOLLOW_ctfBody_in_ctfTypeSpecifier3265 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_STRINGTOK_in_ctfTypeSpecifier3280 = new BitSet(
-            new long[] { 0x0000200000000002L });
-    public static final BitSet FOLLOW_ctfBody_in_ctfTypeSpecifier3282 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_LCURL_in_ctfBody3320 = new BitSet(
-            new long[] { 0x094240007FFFFFF0L, 0x0000000000004090L });
-    public static final BitSet FOLLOW_ctfAssignmentExpressionList_in_ctfBody3322 = new BitSet(
-            new long[] { 0x0000400000000000L });
-    public static final BitSet FOLLOW_RCURL_in_ctfBody3325 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_ctfAssignmentExpression_in_ctfAssignmentExpressionList3344 = new BitSet(
-            new long[] { 0x0000800000000000L });
-    public static final BitSet FOLLOW_TERM_in_ctfAssignmentExpressionList3346 = new BitSet(
-            new long[] { 0x094200007FFFFFF2L, 0x0000000000004090L });
-    public static final BitSet FOLLOW_unaryExpression_in_ctfAssignmentExpression3381 = new BitSet(
-            new long[] { 0x0000006000000000L });
-    public static final BitSet FOLLOW_ASSIGNMENT_in_ctfAssignmentExpression3400 = new BitSet(
-            new long[] { 0x0942000060170210L, 0x0000000000004090L });
-    public static final BitSet FOLLOW_unaryExpression_in_ctfAssignmentExpression3404 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_TYPE_ASSIGNMENT_in_ctfAssignmentExpression3438 = new BitSet(
-            new long[] { 0x000000001FCDFDE0L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_typeSpecifier_in_ctfAssignmentExpression3443 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_declarationSpecifiers_in_ctfAssignmentExpression3493 = new BitSet(
-            new long[] { 0x0001000000000000L, 0x0000000000004000L });
-    public static final BitSet FOLLOW_declaratorList_in_ctfAssignmentExpression3497 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_typealiasDecl_in_ctfAssignmentExpression3525 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_IDENTIFIER_in_synpred1_CTFParser470 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_ctfKeyword_in_synpred2_CTFParser492 = new BitSet(
-            new long[] { 0x0000000000000002L });
-    public static final BitSet FOLLOW_STRING_LITERAL_in_synpred3_CTFParser512 = new BitSet(
-            new long[] { 0x0000000000000002L });
-
-}
+            return "956:15: ( ctfBody )?";
+        }
+    }
+
+
+    public static final BitSet FOLLOW_declaration_in_parse325 = new BitSet(new long[]{0x00000000FFFFFFE0L,0x0000000000008000L});
+    public static final BitSet FOLLOW_EOF_in_parse328 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_SIGN_in_numberLiteral361 = new BitSet(new long[]{0x1284000000000000L});
+    public static final BitSet FOLLOW_HEX_LITERAL_in_numberLiteral366 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_DECIMAL_LITERAL_in_numberLiteral383 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_OCTAL_LITERAL_in_numberLiteral400 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_numberLiteral_in_constant436 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_enumConstant_in_constant442 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_CHARACTER_LITERAL_in_constant448 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_IDENTIFIER_in_primaryExpression479 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_ctfKeyword_in_primaryExpression501 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_STRING_LITERAL_in_primaryExpression521 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_constant_in_primaryExpression542 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_DOT_in_reference568 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});
+    public static final BitSet FOLLOW_ARROW_in_reference574 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});
+    public static final BitSet FOLLOW_IDENTIFIER_in_reference577 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_OPENBRAC_in_postfixExpressionSuffix616 = new BitSet(new long[]{0x12840000E0170210L,0x0000000000008120L});
+    public static final BitSet FOLLOW_unaryExpression_in_postfixExpressionSuffix618 = new BitSet(new long[]{0x0000080000000000L});
+    public static final BitSet FOLLOW_CLOSEBRAC_in_postfixExpressionSuffix620 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_reference_in_postfixExpressionSuffix628 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_primaryExpression_in_postfixExpression652 = new BitSet(new long[]{0x0018040000000002L});
+    public static final BitSet FOLLOW_postfixExpressionSuffix_in_postfixExpression656 = new BitSet(new long[]{0x0018040000000002L});
+    public static final BitSet FOLLOW_ctfSpecifierHead_in_postfixExpression665 = new BitSet(new long[]{0x0018040000000000L});
+    public static final BitSet FOLLOW_postfixExpressionSuffix_in_postfixExpression670 = new BitSet(new long[]{0x0018040000000002L});
+    public static final BitSet FOLLOW_postfixExpression_in_unaryExpression704 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_STRING_LITERAL_in_enumConstant729 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_IDENTIFIER_in_enumConstant745 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_ctfKeyword_in_enumConstant761 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_declarationSpecifiers_in_declaration794 = new BitSet(new long[]{0x0003000000000000L,0x0000000000008000L});
+    public static final BitSet FOLLOW_declaratorList_in_declaration796 = new BitSet(new long[]{0x0001000000000000L});
+    public static final BitSet FOLLOW_TERM_in_declaration799 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_ctfSpecifier_in_declaration848 = new BitSet(new long[]{0x0001000000000000L});
+    public static final BitSet FOLLOW_TERM_in_declaration850 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_storageClassSpecifier_in_declarationSpecifiers895 = new BitSet(new long[]{0x000000001FCDFDE2L,0x0000000000008000L});
+    public static final BitSet FOLLOW_typeQualifier_in_declarationSpecifiers902 = new BitSet(new long[]{0x000000001FCDFDE2L,0x0000000000008000L});
+    public static final BitSet FOLLOW_typeSpecifier_in_declarationSpecifiers909 = new BitSet(new long[]{0x000000001FCDFDE2L,0x0000000000008000L});
+    public static final BitSet FOLLOW_declarator_in_declaratorList950 = new BitSet(new long[]{0x0000000800000002L});
+    public static final BitSet FOLLOW_SEPARATOR_in_declaratorList953 = new BitSet(new long[]{0x0002000000000000L,0x0000000000008000L});
+    public static final BitSet FOLLOW_declarator_in_declaratorList955 = new BitSet(new long[]{0x0000000800000002L});
+    public static final BitSet FOLLOW_abstractDeclarator_in_abstractDeclaratorList989 = new BitSet(new long[]{0x0000000800000002L});
+    public static final BitSet FOLLOW_SEPARATOR_in_abstractDeclaratorList992 = new BitSet(new long[]{0x0002100000000000L,0x0000000000008000L});
+    public static final BitSet FOLLOW_abstractDeclarator_in_abstractDeclaratorList994 = new BitSet(new long[]{0x0000000800000002L});
+    public static final BitSet FOLLOW_TYPEDEFTOK_in_storageClassSpecifier1018 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_FLOATTOK_in_typeSpecifier1044 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_INTTOK_in_typeSpecifier1050 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_LONGTOK_in_typeSpecifier1056 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_SHORTTOK_in_typeSpecifier1062 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_SIGNEDTOK_in_typeSpecifier1068 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_UNSIGNEDTOK_in_typeSpecifier1074 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_CHARTOK_in_typeSpecifier1080 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_DOUBLETOK_in_typeSpecifier1086 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_VOIDTOK_in_typeSpecifier1092 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_BOOLTOK_in_typeSpecifier1098 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_COMPLEXTOK_in_typeSpecifier1104 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_IMAGINARYTOK_in_typeSpecifier1110 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_structSpecifier_in_typeSpecifier1116 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_variantSpecifier_in_typeSpecifier1122 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_enumSpecifier_in_typeSpecifier1128 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_ctfTypeSpecifier_in_typeSpecifier1134 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_typedefName_in_typeSpecifier1144 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_CONSTTOK_in_typeQualifier1167 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_ALIGNTOK_in_alignAttribute1180 = new BitSet(new long[]{0x0000100000000000L});
+    public static final BitSet FOLLOW_LPAREN_in_alignAttribute1182 = new BitSet(new long[]{0x12840000E0170210L,0x0000000000008120L});
+    public static final BitSet FOLLOW_unaryExpression_in_alignAttribute1184 = new BitSet(new long[]{0x0000200000000000L});
+    public static final BitSet FOLLOW_RPAREN_in_alignAttribute1186 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_LCURL_in_structBody1227 = new BitSet(new long[]{0x00008000FFFFFFE0L,0x0000000000008000L});
+    public static final BitSet FOLLOW_structOrVariantDeclarationList_in_structBody1229 = new BitSet(new long[]{0x0000800000000000L});
+    public static final BitSet FOLLOW_RCURL_in_structBody1232 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_STRUCTTOK_in_structSpecifier1270 = new BitSet(new long[]{0x0000400000000000L,0x0000000000008000L});
+    public static final BitSet FOLLOW_structName_in_structSpecifier1292 = new BitSet(new long[]{0x0000400000000012L,0x0000000000008000L});
+    public static final BitSet FOLLOW_alignAttribute_in_structSpecifier1308 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_structBody_in_structSpecifier1337 = new BitSet(new long[]{0x0000000000000012L});
+    public static final BitSet FOLLOW_alignAttribute_in_structSpecifier1362 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_structBody_in_structSpecifier1460 = new BitSet(new long[]{0x0000000000000012L});
+    public static final BitSet FOLLOW_alignAttribute_in_structSpecifier1478 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_IDENTIFIER_in_structName1554 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_structOrVariantDeclaration_in_structOrVariantDeclarationList1585 = new BitSet(new long[]{0x00000000FFFFFFE2L,0x0000000000008000L});
+    public static final BitSet FOLLOW_declarationSpecifiers_in_structOrVariantDeclaration1623 = new BitSet(new long[]{0x0002000000000000L,0x0000000000008000L});
+    public static final BitSet FOLLOW_declaratorList_in_structOrVariantDeclaration1655 = new BitSet(new long[]{0x0001000000000000L});
+    public static final BitSet FOLLOW_structOrVariantDeclaratorList_in_structOrVariantDeclaration1689 = new BitSet(new long[]{0x0001000000000000L});
+    public static final BitSet FOLLOW_typealiasDecl_in_structOrVariantDeclaration1739 = new BitSet(new long[]{0x0001000000000000L});
+    public static final BitSet FOLLOW_TERM_in_structOrVariantDeclaration1751 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_typeQualifier_in_specifierQualifierList1775 = new BitSet(new long[]{0x000000001FCDFDE2L,0x0000000000008000L});
+    public static final BitSet FOLLOW_typeSpecifier_in_specifierQualifierList1779 = new BitSet(new long[]{0x000000001FCDFDE2L,0x0000000000008000L});
+    public static final BitSet FOLLOW_structOrVariantDeclarator_in_structOrVariantDeclaratorList1816 = new BitSet(new long[]{0x0000000800000002L});
+    public static final BitSet FOLLOW_SEPARATOR_in_structOrVariantDeclaratorList1819 = new BitSet(new long[]{0x0002000000000000L,0x0000000000008000L});
+    public static final BitSet FOLLOW_structOrVariantDeclarator_in_structOrVariantDeclaratorList1821 = new BitSet(new long[]{0x0000000800000002L});
+    public static final BitSet FOLLOW_declarator_in_structOrVariantDeclarator1862 = new BitSet(new long[]{0x0000001000000002L});
+    public static final BitSet FOLLOW_COLON_in_structOrVariantDeclarator1865 = new BitSet(new long[]{0x1284000000000000L});
+    public static final BitSet FOLLOW_numberLiteral_in_structOrVariantDeclarator1867 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_VARIANTTOK_in_variantSpecifier1901 = new BitSet(new long[]{0x0000410000000000L,0x0000000000008000L});
+    public static final BitSet FOLLOW_variantName_in_variantSpecifier1919 = new BitSet(new long[]{0x0000410000000000L,0x0000000000008000L});
+    public static final BitSet FOLLOW_variantTag_in_variantSpecifier1950 = new BitSet(new long[]{0x0000410000000002L,0x0000000000008000L});
+    public static final BitSet FOLLOW_variantBody_in_variantSpecifier1976 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_variantBody_in_variantSpecifier2044 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_variantTag_in_variantSpecifier2069 = new BitSet(new long[]{0x0000410000000000L,0x0000000000008000L});
+    public static final BitSet FOLLOW_variantBody_in_variantSpecifier2071 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_variantBody_in_variantSpecifier2082 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_IDENTIFIER_in_variantName2124 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_LCURL_in_variantBody2160 = new BitSet(new long[]{0x00000000FFFFFFE0L,0x0000000000008000L});
+    public static final BitSet FOLLOW_structOrVariantDeclarationList_in_variantBody2162 = new BitSet(new long[]{0x0000800000000000L});
+    public static final BitSet FOLLOW_RCURL_in_variantBody2164 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_LT_in_variantTag2195 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});
+    public static final BitSet FOLLOW_IDENTIFIER_in_variantTag2197 = new BitSet(new long[]{0x0000020000000000L});
+    public static final BitSet FOLLOW_GT_in_variantTag2199 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_ENUMTOK_in_enumSpecifier2229 = new BitSet(new long[]{0x0000401000000000L,0x0000000000008000L});
+    public static final BitSet FOLLOW_enumName_in_enumSpecifier2244 = new BitSet(new long[]{0x0000401000000002L,0x0000000000008000L});
+    public static final BitSet FOLLOW_enumContainerType_in_enumSpecifier2255 = new BitSet(new long[]{0x0000401000000000L,0x0000000000008000L});
+    public static final BitSet FOLLOW_enumBody_in_enumSpecifier2257 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_enumBody_in_enumSpecifier2269 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_enumContainerType_in_enumSpecifier2304 = new BitSet(new long[]{0x0000401000000000L,0x0000000000008000L});
+    public static final BitSet FOLLOW_enumBody_in_enumSpecifier2306 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_enumBody_in_enumSpecifier2315 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_IDENTIFIER_in_enumName2360 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_LCURL_in_enumBody2393 = new BitSet(new long[]{0x0000000000050210L,0x0000000000008100L});
+    public static final BitSet FOLLOW_enumeratorList_in_enumBody2395 = new BitSet(new long[]{0x0000800800000000L});
+    public static final BitSet FOLLOW_SEPARATOR_in_enumBody2398 = new BitSet(new long[]{0x0000800000000000L});
+    public static final BitSet FOLLOW_RCURL_in_enumBody2400 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_RCURL_in_enumBody2404 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_COLON_in_enumContainerType2436 = new BitSet(new long[]{0x000000001FCDFDE0L,0x0000000000008000L});
+    public static final BitSet FOLLOW_declarationSpecifiers_in_enumContainerType2438 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_enumerator_in_enumeratorList2469 = new BitSet(new long[]{0x0000000800000002L});
+    public static final BitSet FOLLOW_SEPARATOR_in_enumeratorList2472 = new BitSet(new long[]{0x0000000000050210L,0x0000000000008100L});
+    public static final BitSet FOLLOW_enumerator_in_enumeratorList2474 = new BitSet(new long[]{0x0000000800000002L});
+    public static final BitSet FOLLOW_enumConstant_in_enumerator2510 = new BitSet(new long[]{0x0000004000000002L});
+    public static final BitSet FOLLOW_enumeratorValue_in_enumerator2512 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_ASSIGNMENT_in_enumeratorValue2536 = new BitSet(new long[]{0x12840000E0170210L,0x0000000000008120L});
+    public static final BitSet FOLLOW_unaryExpression_in_enumeratorValue2540 = new BitSet(new long[]{0x0000002000000002L});
+    public static final BitSet FOLLOW_ELIPSES_in_enumeratorValue2566 = new BitSet(new long[]{0x12840000E0170210L,0x0000000000008120L});
+    public static final BitSet FOLLOW_unaryExpression_in_enumeratorValue2570 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_pointer_in_declarator2612 = new BitSet(new long[]{0x0002000000000000L,0x0000000000008000L});
+    public static final BitSet FOLLOW_directDeclarator_in_declarator2615 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_IDENTIFIER_in_directDeclarator2659 = new BitSet(new long[]{0x0000040000000002L});
+    public static final BitSet FOLLOW_directDeclaratorSuffix_in_directDeclarator2677 = new BitSet(new long[]{0x0000040000000002L});
+    public static final BitSet FOLLOW_OPENBRAC_in_directDeclaratorSuffix2690 = new BitSet(new long[]{0x12840000E0170210L,0x0000000000008120L});
+    public static final BitSet FOLLOW_directDeclaratorLength_in_directDeclaratorSuffix2692 = new BitSet(new long[]{0x0000080000000000L});
+    public static final BitSet FOLLOW_CLOSEBRAC_in_directDeclaratorSuffix2694 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_unaryExpression_in_directDeclaratorLength2715 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_pointer_in_abstractDeclarator2746 = new BitSet(new long[]{0x0002100000000002L,0x0000000000008000L});
+    public static final BitSet FOLLOW_directAbstractDeclarator_in_abstractDeclarator2749 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_directAbstractDeclarator_in_abstractDeclarator2769 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_IDENTIFIER_in_directAbstractDeclarator2809 = new BitSet(new long[]{0x0000040000000002L});
+    public static final BitSet FOLLOW_LPAREN_in_directAbstractDeclarator2818 = new BitSet(new long[]{0x0002100000000000L,0x0000000000008000L});
+    public static final BitSet FOLLOW_abstractDeclarator_in_directAbstractDeclarator2820 = new BitSet(new long[]{0x0000200000000000L});
+    public static final BitSet FOLLOW_RPAREN_in_directAbstractDeclarator2822 = new BitSet(new long[]{0x0000040000000002L});
+    public static final BitSet FOLLOW_OPENBRAC_in_directAbstractDeclarator2837 = new BitSet(new long[]{0x12840800E0170210L,0x0000000000008120L});
+    public static final BitSet FOLLOW_unaryExpression_in_directAbstractDeclarator2839 = new BitSet(new long[]{0x0000080000000000L});
+    public static final BitSet FOLLOW_CLOSEBRAC_in_directAbstractDeclarator2842 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_POINTER_in_pointer2870 = new BitSet(new long[]{0x0000000000000022L});
+    public static final BitSet FOLLOW_typeQualifierList_in_pointer2872 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_typeQualifier_in_typeQualifierList2895 = new BitSet(new long[]{0x0000000000000022L});
+    public static final BitSet FOLLOW_IDENTIFIER_in_typedefName2921 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_declarationSpecifiers_in_typealiasTarget2949 = new BitSet(new long[]{0x0002100000000002L,0x0000000000008000L});
+    public static final BitSet FOLLOW_abstractDeclaratorList_in_typealiasTarget2951 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_abstractDeclaratorList_in_typealiasAlias2984 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_declarationSpecifiers_in_typealiasAlias2993 = new BitSet(new long[]{0x0002100000000002L,0x0000000000008000L});
+    public static final BitSet FOLLOW_abstractDeclaratorList_in_typealiasAlias2995 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_TYPEALIASTOK_in_typealiasDecl3027 = new BitSet(new long[]{0x000000001FCDFDE0L,0x0000000000008000L});
+    public static final BitSet FOLLOW_typealiasTarget_in_typealiasDecl3029 = new BitSet(new long[]{0x0000008000000000L});
+    public static final BitSet FOLLOW_TYPE_ASSIGNMENT_in_typealiasDecl3031 = new BitSet(new long[]{0x000210001FCDFDE0L,0x0000000000008000L});
+    public static final BitSet FOLLOW_typealiasAlias_in_typealiasDecl3033 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_set_in_ctfKeyword0 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_ctfSpecifierHead_in_ctfSpecifier3127 = new BitSet(new long[]{0x0000400000000000L});
+    public static final BitSet FOLLOW_ctfBody_in_ctfSpecifier3129 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_typealiasDecl_in_ctfSpecifier3148 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_EVENTTOK_in_ctfSpecifierHead3180 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_STREAMTOK_in_ctfSpecifierHead3189 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_TRACETOK_in_ctfSpecifierHead3198 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_ENVTOK_in_ctfSpecifierHead3207 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_CLOCKTOK_in_ctfSpecifierHead3216 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_CALLSITETOK_in_ctfSpecifierHead3225 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_FLOATINGPOINTTOK_in_ctfTypeSpecifier3259 = new BitSet(new long[]{0x0000400000000000L});
+    public static final BitSet FOLLOW_ctfBody_in_ctfTypeSpecifier3261 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_INTEGERTOK_in_ctfTypeSpecifier3276 = new BitSet(new long[]{0x0000400000000000L});
+    public static final BitSet FOLLOW_ctfBody_in_ctfTypeSpecifier3278 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_STRINGTOK_in_ctfTypeSpecifier3293 = new BitSet(new long[]{0x0000400000000002L});
+    public static final BitSet FOLLOW_ctfBody_in_ctfTypeSpecifier3295 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_LCURL_in_ctfBody3333 = new BitSet(new long[]{0x12848000FFFFFFF0L,0x0000000000008120L});
+    public static final BitSet FOLLOW_ctfAssignmentExpressionList_in_ctfBody3335 = new BitSet(new long[]{0x0000800000000000L});
+    public static final BitSet FOLLOW_RCURL_in_ctfBody3338 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_ctfAssignmentExpression_in_ctfAssignmentExpressionList3357 = new BitSet(new long[]{0x0001000000000000L});
+    public static final BitSet FOLLOW_TERM_in_ctfAssignmentExpressionList3359 = new BitSet(new long[]{0x12840000FFFFFFF2L,0x0000000000008120L});
+    public static final BitSet FOLLOW_unaryExpression_in_ctfAssignmentExpression3394 = new BitSet(new long[]{0x000000C000000000L});
+    public static final BitSet FOLLOW_ASSIGNMENT_in_ctfAssignmentExpression3413 = new BitSet(new long[]{0x12840000E0170210L,0x0000000000008120L});
+    public static final BitSet FOLLOW_unaryExpression_in_ctfAssignmentExpression3417 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_TYPE_ASSIGNMENT_in_ctfAssignmentExpression3451 = new BitSet(new long[]{0x000000001FCDFDE0L,0x0000000000008000L});
+    public static final BitSet FOLLOW_typeSpecifier_in_ctfAssignmentExpression3456 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_declarationSpecifiers_in_ctfAssignmentExpression3506 = new BitSet(new long[]{0x0002000000000000L,0x0000000000008000L});
+    public static final BitSet FOLLOW_declaratorList_in_ctfAssignmentExpression3510 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_typealiasDecl_in_ctfAssignmentExpression3538 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_IDENTIFIER_in_synpred1_CTFParser474 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_ctfKeyword_in_synpred2_CTFParser496 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_STRING_LITERAL_in_synpred3_CTFParser516 = new BitSet(new long[]{0x0000000000000002L});
+
+}
\ No newline at end of file

diff --git a/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/ctfadaptor/CtfTmfEvent.java b/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/ctfadaptor/CtfTmfEvent.java
index 0d56c1707252991225cf4cb1f899dabc982de4c7..29c9dc1a05261f9afab20a5e6b7fc18210243cee 100644 (file)
--- a/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/ctfadaptor/CtfTmfEvent.java
+++ b/org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/tmf/core/ctfadaptor/CtfTmfEvent.java
@@ -17,8 +17,10 @@ import java.util.Iterator;
 import java.util.List;
 import java.util.Map.Entry;
 
+import org.eclipse.linuxtools.ctf.core.event.CTFCallsite;
 import org.eclipse.linuxtools.ctf.core.event.EventDefinition;
 import org.eclipse.linuxtools.ctf.core.event.types.Definition;
+import org.eclipse.linuxtools.ctf.core.event.types.IntegerDefinition;
 import org.eclipse.linuxtools.ctf.core.event.types.StructDefinition;
 import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
 import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
@@ -107,12 +109,12 @@ public final class CtfTmfEvent implements ITmfEvent, Cloneable {
      *            CTF EventDefinition to read
      * @return CtfTmfEventField[] The array of fields that were read
      */
-    public static CtfTmfEventField[] parseFields(EventDefinition eventDef) {
+    private CtfTmfEventField[] parseFields(EventDefinition eventDef) {
         List<CtfTmfEventField> fields = new ArrayList<CtfTmfEventField>();
 
         StructDefinition structFields = eventDef.getFields();
         HashMap<String, Definition> definitions = structFields.getDefinitions();
-        String curFieldName;
+        String curFieldName = null;
         Definition curFieldDef;
         CtfTmfEventField curField;
         Iterator<Entry<String, Definition>> it = definitions.entrySet().iterator();
@@ -125,6 +127,7 @@ public final class CtfTmfEvent implements ITmfEvent, Cloneable {
         }
 
         /* Add context information as CtfTmfEventField */
+        long ip = -1;
         StructDefinition structContext = eventDef.getContext();
         if (structContext != null) {
             definitions = structContext.getDefinitions();
@@ -134,6 +137,11 @@ public final class CtfTmfEvent implements ITmfEvent, Cloneable {
             it = definitions.entrySet().iterator();
             while(it.hasNext()) {
                 Entry<String, Definition> entry = it.next();
+                /* This is to get the instruction pointer if available */
+                if (entry.getKey().equals("_ip") && //$NON-NLS-1$
+                        (entry.getValue() instanceof IntegerDefinition)) {
+                    ip = ((IntegerDefinition) entry.getValue()).getValue();
+                }
                 /* Prefix field name to */
                 curContextName = CONTEXT_FIELD_PREFIX + entry.getKey();
                 curContextDef = entry.getValue();
@@ -141,6 +149,20 @@ public final class CtfTmfEvent implements ITmfEvent, Cloneable {
                 fields.add(curContext);
             }
         }
+        /* Add callsite */
+        final String name = eventDef.getDeclaration().getName();
+        List<CTFCallsite> eventList = fTrace.getCTFTrace().getCallsiteCandidates(name);
+        if (eventList != null) {
+            final String callsite = "callsite"; //$NON-NLS-1$
+            if (eventList.size() == 1 || ip == -1) {
+                CTFCallsite cs = eventList.get(0);
+                fields.add(new CTFStringField(cs.toString(), callsite));
+            } else {
+                fields.add(new CTFStringField(
+                        fTrace.getCTFTrace().getCallsite(name, ip).toString(),
+                        callsite));
+            }
+        }
 
         return fields.toArray(new CtfTmfEventField[fields.size()]);
     }