initial commit

.gitignore

+build
+.gradle
+.idea
+src/gen-res/
+src/gen/
+out/
+*.class

.gitmodules

+[submodule "relast.preprocessor"]
+	path = relast.preprocessor
+	url = git@git-st.inf.tu-dresden.de:jastadd/relast-preprocessor.git

build.gradle

+plugins {
+    id 'java'
+    id 'org.jastadd'
+    id 'application'
+    id 'idea'
+}
+
+ext {
+    mainClassName = 'org.jastadd.preprocessor.Main'
+}
+
+// set the main class name for `gradle run`
+application.mainClassName = "${mainClassName}"
+
+repositories {
+    jcenter()
+}
+
+dependencies {
+    implementation project(':relast.preprocessor')
+    testImplementation testFixtures(project(":relast.preprocessor"))
+}
+
+sourceSets {
+    main {
+        java.srcDir "src/gen/java"
+    }
+}
+
+test {
+    useJUnitPlatform()
+
+    maxHeapSize = '1G'
+}
+
+jar {
+    manifest {
+        attributes "Main-Class": "${mainClassName}"
+    }
+
+    from {
+        configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) }
+    }
+}
+
+// Input and output files for relast
+def relastInputFiles = [
+        "relast.preprocessor/src/main/jastadd/RelAst.relast",
+        "relast.preprocessor/src/main/jastadd/mustache/Mustache.relast"
+]
+def relastOutputFiles = [
+        "src/gen/jastadd/RelAst.ast",
+        "src/gen/jastadd/RelAst.jadd",
+        "src/gen/jastadd/RelAstRefResolver.jadd",
+        "src/gen/jastadd/RelAstResolverStubs.jrag"
+]
+
+
+task relast(type: JavaExec) {
+    classpath = files("relast.preprocessor/libs/relast.jar")
+    group = 'Build'
+
+    doFirst {
+        delete relastOutputFiles
+        mkdir "src/gen/jastadd/"
+    }
+
+    args = [
+            "--listClass=java.util.ArrayList",
+            "--jastAddList=JastAddList",
+            "--useJastAddNames",
+            "--file",
+            "--resolverHelper",
+            "--grammarName=./src/gen/jastadd/RelAst"
+    ] + relastInputFiles
+
+    inputs.files relastInputFiles
+    outputs.files relastOutputFiles
+}
+
+jastadd {
+    configureModuleBuild()
+    modules {
+        //noinspection GroovyAssignabilityCheck
+        module("Preprocessor") {
+
+            jastadd {
+                basedir "."
+                include "relast.preprocessor/src/main/jastadd/**/*.ast"
+                include "relast.preprocessor/src/main/jastadd/**/*.jadd"
+                include "relast.preprocessor/src/main/jastadd/**/*.jrag"
+                include "src/main/jastadd/**/*.ast"
+                include "src/main/jastadd/**/*.jadd"
+                include "src/main/jastadd/**/*.jrag"
+                include "src/gen/jastadd/**/*.ast"
+                include "src/gen/jastadd/**/*.jadd"
+                include "src/gen/jastadd/**/*.jrag"
+            }
+
+            scanner {
+                include "relast.preprocessor/src/main/jastadd/scanner/Header.flex",         [-4]
+                include "relast.preprocessor/src/main/jastadd/scanner/Preamble.flex",       [-3]
+                include "relast.preprocessor/src/main/jastadd/scanner/Macros.flex",         [-2]
+                include "relast.preprocessor/src/main/jastadd/scanner/RulesPreamble.flex",  [-1]
+                include "relast.preprocessor/src/main/jastadd/scanner/Keywords.flex",       [ 0]
+                include "relast.preprocessor/src/main/jastadd/scanner/Symbols.flex",        [ 1]
+                include "relast.preprocessor/src/main/jastadd/scanner/RulesPostamble.flex", [ 2]
+            }
+
+            parser {
+                include "relast.preprocessor/src/main/jastadd/parser/Preamble.parser"
+                include "relast.preprocessor/src/main/jastadd/parser/RelAst.parser"
+            }
+        }
+    }
+
+    cleanGen.doFirst {
+        delete "src/gen"
+        delete "src/gen-res"
+    }
+
+    preprocessParser.doFirst {
+        args += ["--no-beaver-symbol"]
+    }
+
+    module = "Preprocessor"
+
+    astPackage = 'org.jastadd.relast.ast'
+
+    parser.name = 'RelAstParser'
+
+    genDir = 'src/gen/java'
+
+    buildInfoDir = 'src/gen-res'
+
+    scanner.genDir = "src/gen/java/org/jastadd/relast/scanner"
+    parser.genDir = "src/gen/java/org/jastadd/relast/parser"
+
+    jastaddOptions = ["--lineColumnNumbers", "--List=JastAddList", "--safeLazy", "--visitCheck=true", "--rewrite=cnta", "--cache=all"]
+}
+
+clean.dependsOn(cleanGen)
+
+generateAst.dependsOn relast

gradle/wrapper/gradle-wrapper.properties

+#Sun Nov 01 15:07:09 CET 2020
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.7-all.zip
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStorePath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME

gradlew

+#!/usr/bin/env sh
+
+#
+# Copyright 2015 the original author or authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=`expr $i + 1`
+    done
+    case $i in
+        0) set -- ;;
+        1) set -- "$args0" ;;
+        2) set -- "$args0" "$args1" ;;
+        3) set -- "$args0" "$args1" "$args2" ;;
+        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
+}
+APP_ARGS=`save "$@"`
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+exec "$JAVACMD" "$@"

gradlew.bat

+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

relast.preprocessor @ 55ed9bd0

+Subproject commit 55ed9bd0f909000b01065307208801659af0af52

settings.gradle

+pluginManagement {
+    plugins {
+        id 'org.jastadd' version '1.13.3'
+    }
+}
+
+rootProject.name = 'preprocessor'
+
+include 'relast.preprocessor'
+

src/main/jastadd/GrammarToNavigation.jrag

+aspect GrammarToNavigation {
+  syn nta Document Program.toNavigation(boolean useExceptions, boolean useOptionals, String exceptionName) {
+    Document navigation = new Document();
+    navigation.setFileName("Navigation.yaml");
+    MappingElement rootElement = new MappingElement();
+    rootElement.put("useExceptions", useExceptions);
+    rootElement.put("useOptionals", useOptionals);
+    rootElement.put("exceptionName", exceptionName);
+
+    ListElement types = new ListElement();
+    navigation.setRootElement(rootElement);
+    for (TypeDecl typeDecl : typeDecls()) {
+      if (!typeDecl.getSubTypeList().isEmpty()) {
+        MappingElement typeElement = new MappingElement();
+        typeElement.put("typeName", typeDecl.getName());
+        ListElement subTypes = new ListElement();
+        for (TypeDecl subtype : typeDecl.getSubTypeList()) {
+          MappingElement subTypeElement = new MappingElement();
+          subTypeElement.put("subtypeName", subtype.getName());
+          subTypes.add(subTypeElement);
+        }
+        typeElement.put("subtypes", subTypes);
+        types.add(typeElement);
+      }
+    }
+    rootElement.put("types", types);
+
+    navigation.setRootElement(rootElement);
+    return navigation;
+  }
+}

src/main/java/org/jastadd/preprocessor/Main.java

+package org.jastadd.preprocessor;
+
+import org.jastadd.option.ValueOption;
+import org.jastadd.relast.ast.Document;
+import org.jastadd.relast.ast.Program;
+import org.jastadd.relast.compiler.CompilerException;
+
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.nio.file.Path;
+
+import static org.jastadd.relast.compiler.Mustache.javaMustache;
+
+/**
+ * @author Johannes Mey - Initial contribution
+ */
+public class Main extends org.jastadd.relast.compiler.RelAstProcessor {
+
+  private static final String MUSTACHE_TEMPLATE = "Navigation";
+
+  protected ValueOption optionErrorHandling;
+
+  public Main() {
+    super("JastAdd Preprocessor", true);
+  }
+
+  public static void main(String[] args) {
+    try {
+      int returnValue = new Main().run(args);
+      System.exit(returnValue);
+    } catch (CompilerException e) {
+      e.printStackTrace();
+      System.exit(-1);
+    }
+  }
+
+  @Override
+  protected void initOptions() {
+    super.initOptions();
+    optionErrorHandling = addOption(new ValueOption("errorHandling", "null|optional|exception|<exceptionClass> to return null, Optional.empty() or an exception (extending RuntimeException) in case of an error.").acceptAnyValue());
+    optionErrorHandling.defaultValue("null");
+  }
+
+  @Override
+  protected int processGrammar(Program program, Path inputBasePath, Path outputBasePath) throws CompilerException {
+
+    boolean useExceptions = false;
+    String exceptionName = "java.lang.RuntimeException";
+    boolean useOptionals = false;
+
+    String value = optionErrorHandling.value();
+    System.out.println("value is " + value);
+    System.out.println("value is matched " + optionErrorHandling.isMatched());
+    switch (value) {
+      case "null":
+        // this is the default case
+        break;
+      case "optional":
+        useOptionals = true;
+        break;
+      case "exception":
+        useExceptions = true;
+        exceptionName = "RuntimeException";
+        break;
+      default:
+        // in any other case, the String is interpreted as the name of an exception
+        useExceptions = true;
+        exceptionName = value;
+        String errorMsg = "Invalid argument '" + value + "' for parameter 'errorHandling': ";
+        try {
+          Class<?> exceptionClass = Class.forName(exceptionName);
+          if (!RuntimeException.class.isAssignableFrom(exceptionClass)) {
+            System.err.println("class " + exceptionClass);
+            System.err.println(errorMsg + "Not a subclass of RuntimeException.");
+            return -1;
+          }
+          exceptionClass.getDeclaredConstructor().newInstance();
+        } catch (ClassNotFoundException e) {
+          System.err.println(errorMsg + "Class not found (name must be qualified).");
+          return -1;
+        } catch (NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
+          System.err.println(errorMsg + "Class does not have default constructor.");
+          return -1;
+        }
+    }
+
+    Document navigation = program.toNavigation(useExceptions, useOptionals, exceptionName);
+
+    Path yamlFile = outputBasePath.resolve(navigation.getFileName());
+    Path jragFile = yamlFile.getParent().resolve(MUSTACHE_TEMPLATE + ".jrag");
+
+    writeToFile(yamlFile, navigation.prettyPrint(false));
+
+    try {
+      javaMustache(MUSTACHE_TEMPLATE, yamlFile.toString(), jragFile.toString());
+    } catch (IOException e) {
+      throw new CompilerException("Unable to expand template");
+    }
+
+    return 0;
+  }
+}

src/main/resources/AsA.mustache

+/** casts a {{typeName}} into a {{subtypeName}} if possible.
+{{#useExceptions}}
+ *  @return 'this' cast to a {{subtypeName}} or a {{exception}}
+{{/useExceptions}}
+{{^useExceptions}}
+{{#useOptionals}}
+ *  @return an Optional of 'this' cast to a {{subtypeName}} or an empty Optional
+{{/useOptionals}}
+{{^useOptionals}}
+ *  @return 'this' cast to a {{subtypeName}} or 'null'
+{{/useOptionals}}
+{{/useExceptions}}
+ */
+syn {{typeName}} {{typeName}}.as{{subtypeName}}();
+{{#useExceptions}}
+eq {{typeName}}.as{{subtypeName}}() {
+  throw new {{exceptionName}}();
+}
+{{/useExceptions}}
+{{^useExceptions}}
+{{#useOptionals}}
+eq {{typeName}}.as{{subtypeName}}() = java.util.Optional.empty();
+{{/useOptionals}}
+{{^useOptionals}}
+eq {{typeName}}.as{{subtypeName}}() = null;
+{{/useOptionals}}
+{{/useExceptions}}
+{{#useOptionals}}
+eq {{subTypeName}}.as{{subtypeName}}() = java.util.Optional.of(this);
+{{/useOptionals}}
+{{^useOptionals}}
+eq {{subtypeName}}.as{{subtypeName}}() = this;
+{{/useOptionals}}

src/main/resources/IsA.mustache

+/** Tests if {{typeName}} is a {{subtypeName}}.
+*  @return 'true' if this is a {{subtypeName}}, otherwise 'false'
+*/
+syn {{typeName}} {{typeName}}.is{{subtypeName}}() = false;
+eq {{subtypeName}}.is{{subtypeName}}() = true;

src/main/resources/Navigation.mustache

+aspect Navigation {
+{{#types}}{{#subtypes}}
+
+  {{> IsA}}
+{{/subtypes}}{{/types}}
+{{#types}}{{#subtypes}}
+
+  {{> AsA}}
+{{/subtypes}}{{/types}}
+
+}

src/test/java/org/jastadd/preprocessor/PreprocessorTest.java

+package org.jastadd.preprocessor;
+
+import org.jastadd.relast.tests.RelAstProcessorTestBase;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.nio.file.Paths;
+
+public class PreprocessorTest extends RelAstProcessorTestBase {
+
+  @Test
+  void testSimpleInheritance() throws IOException, InterruptedException {
+    directoryTest(Main.class, Paths.get("src/test/resources/SimpleInheritance"));
+  }
+}

src/test/resources/.gitignore

+*/out/

src/test/resources/SimpleInheritance/config.yaml

+- name: "SimpleInheritance (default)"
+  args:
+    - "--inputBaseDir=in"
+    - "--outputBaseDir=out/default/"
+    - "Example.relast"
+- name: "SimpleInheritance (null)"
+  args:
+    - "--inputBaseDir=in"
+    - "--outputBaseDir=out/null/"
+    - "--errorHandling=null"
+    - "Example.relast"
+- name: "SimpleInheritance (java.lang.Optional)"
+  args:
+    - "--inputBaseDir=in"
+    - "--outputBaseDir=out/optional/"
+    - "--errorHandling=optional"
+    - "Example.relast"
+- name: "SimpleInheritance (default exception)"
+  args:
+    - "--inputBaseDir=in"
+    - "--outputBaseDir=out/exception/"
+    - "--errorHandling=exception"
+    - "Example.relast"
+- name: "SimpleInheritance (custom exception)"
+  args:
+    - "--inputBaseDir=in"
+    - "--outputBaseDir=out/customexception/"
+    - "--errorHandling=java.lang.ClassCastException"
+    - "Example.relast"
+- name: "SimpleInheritance (wrong exception)"
+  fail: true
+  err-matches:
+    - "(?s).*Invalid.*"
+  err-contains:
+    - "Invalid argument 'not.a.Class' for parameter 'errorHandling': Class not found (name must be qualified)."
+  args:
+    - "--inputBaseDir=in"
+    - "--outputBaseDir=out/castexception/"
+    - "--errorHandling=not.a.Class"
+    - "Example.relast"

src/test/resources/SimpleInheritance/in/Example.relast

+Root ::= A;
+
+abstract A;
+
+A1 : A;
+A2 : A;