Initial commit - version 1.0.0

Extracted from probparsers repo
(hhu-stups/probparsers@8a324637055f6c73ab5dac86c6b35dacd6659387).

.editorconfig

+root = true
+
+[*]
+charset = utf-8
+indent_style = tab
+insert_final_newline = true
+
+[*.yml]
+indent_style = space
+indent_size = 2

.gitignore

+# Gradle
+.gradle/
+build/

.gitlab-ci.yml

+image: openjdk:8-jdk-slim
+stages:
+  - test
+  - deploy
+
+variables:
+  GRADLE_ARGS: --no-daemon --stacktrace --warning-mode=all
+
+before_script:
+  - export GRADLE_USER_HOME=`pwd`/.gradle
+
+tests:
+  stage: test
+  script: ./gradlew ${GRADLE_ARGS} check
+
+publish:
+  stage: deploy
+  script:
+    - ./gradlew ${GRADLE_ARGS} publishPlugins
+  only: 
+    - release

LICENSE.txt

+Eclipse Public License - v 2.0
+
+    THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+    PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION
+    OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+  a) in the case of the initial Contributor, the initial content
+     Distributed under this Agreement, and
+
+  b) in the case of each subsequent Contributor:
+     i) changes to the Program, and
+     ii) additions to the Program;
+  where such changes and/or additions to the Program originate from
+  and are Distributed by that particular Contributor. A Contribution
+  "originates" from a Contributor if it was added to the Program by
+  such Contributor itself or anyone acting on such Contributor's behalf.
+  Contributions do not include changes or additions to the Program that
+  are not Modified Works.
+
+"Contributor" means any person or entity that Distributes the Program.
+
+"Licensed Patents" mean patent claims licensable by a Contributor which
+are necessarily infringed by the use or sale of its Contribution alone
+or when combined with the Program.
+
+"Program" means the Contributions Distributed in accordance with this
+Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement
+or any Secondary License (as applicable), including Contributors.
+
+"Derivative Works" shall mean any work, whether in Source Code or other
+form, that is based on (or derived from) the Program and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship.
+
+"Modified Works" shall mean any work in Source Code or other form that
+results from an addition to, deletion from, or modification of the
+contents of the Program, including, for purposes of clarity any new file
+in Source Code form that contains any contents of the Program. Modified
+Works shall not include works that contain only declarations,
+interfaces, types, classes, structures, or files of the Program solely
+in each case in order to link to, bind by name, or subclass the Program
+or Modified Works thereof.
+
+"Distribute" means the acts of a) distributing or b) making available
+in any manner that enables the transfer of a copy.
+
+"Source Code" means the form of a Program preferred for making
+modifications, including but not limited to software source code,
+documentation source, and configuration files.
+
+"Secondary License" means either the GNU General Public License,
+Version 2.0, or any later versions of that license, including any
+exceptions or additional permissions as identified by the initial
+Contributor.
+
+2. GRANT OF RIGHTS
+
+  a) Subject to the terms of this Agreement, each Contributor hereby
+  grants Recipient a non-exclusive, worldwide, royalty-free copyright
+  license to reproduce, prepare Derivative Works of, publicly display,
+  publicly perform, Distribute and sublicense the Contribution of such
+  Contributor, if any, and such Derivative Works.
+
+  b) Subject to the terms of this Agreement, each Contributor hereby
+  grants Recipient a non-exclusive, worldwide, royalty-free patent
+  license under Licensed Patents to make, use, sell, offer to sell,
+  import and otherwise transfer the Contribution of such Contributor,
+  if any, in Source Code or other form. This patent license shall
+  apply to the combination of the Contribution and the Program if, at
+  the time the Contribution is added by the Contributor, such addition
+  of the Contribution causes such combination to be covered by the
+  Licensed Patents. The patent license shall not apply to any other
+  combinations which include the Contribution. No hardware per se is
+  licensed hereunder.
+
+  c) Recipient understands that although each Contributor grants the
+  licenses to its Contributions set forth herein, no assurances are
+  provided by any Contributor that the Program does not infringe the
+  patent or other intellectual property rights of any other entity.
+  Each Contributor disclaims any liability to Recipient for claims
+  brought by any other entity based on infringement of intellectual
+  property rights or otherwise. As a condition to exercising the
+  rights and licenses granted hereunder, each Recipient hereby
+  assumes sole responsibility to secure any other intellectual
+  property rights needed, if any. For example, if a third party
+  patent license is required to allow Recipient to Distribute the
+  Program, it is Recipient's responsibility to acquire that license
+  before distributing the Program.
+
+  d) Each Contributor represents that to its knowledge it has
+  sufficient copyright rights in its Contribution, if any, to grant
+  the copyright license set forth in this Agreement.
+
+  e) Notwithstanding the terms of any Secondary License, no
+  Contributor makes additional grants to any Recipient (other than
+  those set forth in this Agreement) as a result of such Recipient's
+  receipt of the Program under the terms of a Secondary License
+  (if permitted under the terms of Section 3).
+
+3. REQUIREMENTS
+
+3.1 If a Contributor Distributes the Program in any form, then:
+
+  a) the Program must also be made available as Source Code, in
+  accordance with section 3.2, and the Contributor must accompany
+  the Program with a statement that the Source Code for the Program
+  is available under this Agreement, and informs Recipients how to
+  obtain it in a reasonable manner on or through a medium customarily
+  used for software exchange; and
+
+  b) the Contributor may Distribute the Program under a license
+  different than this Agreement, provided that such license:
+     i) effectively disclaims on behalf of all other Contributors all
+     warranties and conditions, express and implied, including
+     warranties or conditions of title and non-infringement, and
+     implied warranties or conditions of merchantability and fitness
+     for a particular purpose;
+
+     ii) effectively excludes on behalf of all other Contributors all
+     liability for damages, including direct, indirect, special,
+     incidental and consequential damages, such as lost profits;
+
+     iii) does not attempt to limit or alter the recipients' rights
+     in the Source Code under section 3.2; and
+
+     iv) requires any subsequent distribution of the Program by any
+     party to be under a license that satisfies the requirements
+     of this section 3.
+
+3.2 When the Program is Distributed as Source Code:
+
+  a) it must be made available under this Agreement, or if the
+  Program (i) is combined with other material in a separate file or
+  files made available under a Secondary License, and (ii) the initial
+  Contributor attached to the Source Code the notice described in
+  Exhibit A of this Agreement, then the Program may be made available
+  under the terms of such Secondary Licenses, and
+
+  b) a copy of this Agreement must be included with each copy of
+  the Program.
+
+3.3 Contributors may not remove or alter any copyright, patent,
+trademark, attribution notices, disclaimers of warranty, or limitations
+of liability ("notices") contained within the Program from any copy of
+the Program which they Distribute, provided that Contributors may add
+their own appropriate notices.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities
+with respect to end users, business partners and the like. While this
+license is intended to facilitate the commercial use of the Program,
+the Contributor who includes the Program in a commercial product
+offering should do so in a manner which does not create potential
+liability for other Contributors. Therefore, if a Contributor includes
+the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and indemnify every
+other Contributor ("Indemnified Contributor") against any losses,
+damages and costs (collectively "Losses") arising from claims, lawsuits
+and other legal actions brought by a third party against the Indemnified
+Contributor to the extent caused by the acts or omissions of such
+Commercial Contributor in connection with its distribution of the Program
+in a commercial product offering. The obligations in this section do not
+apply to any claims or Losses relating to any actual or alleged
+intellectual property infringement. In order to qualify, an Indemnified
+Contributor must: a) promptly notify the Commercial Contributor in
+writing of such claim, and b) allow the Commercial Contributor to control,
+and cooperate with the Commercial Contributor in, the defense and any
+related settlement negotiations. The Indemnified Contributor may
+participate in any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial
+product offering, Product X. That Contributor is then a Commercial
+Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance
+claims and warranties are such Commercial Contributor's responsibility
+alone. Under this section, the Commercial Contributor would have to
+defend claims against the other Contributors related to those performance
+claims and warranties, and if a court requires any other Contributor to
+pay any damages as a result, the Commercial Contributor must pay
+those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT
+PERMITTED BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN "AS IS"
+BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR
+IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF
+TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR
+PURPOSE. Each Recipient is solely responsible for determining the
+appropriateness of using and distributing the Program and assumes all
+risks associated with its exercise of rights under this Agreement,
+including but not limited to the risks and costs of program errors,
+compliance with applicable laws, damage to or loss of data, programs
+or equipment, and unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT
+PERMITTED BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS
+SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST
+PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE
+EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability of
+the remainder of the terms of this Agreement, and without further
+action by the parties hereto, such provision shall be reformed to the
+minimum extent necessary to make such provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity
+(including a cross-claim or counterclaim in a lawsuit) alleging that the
+Program itself (excluding combinations of the Program with other software
+or hardware) infringes such Recipient's patent(s), then such Recipient's
+rights granted under Section 2(b) shall terminate as of the date such
+litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it
+fails to comply with any of the material terms or conditions of this
+Agreement and does not cure such failure in a reasonable period of
+time after becoming aware of such noncompliance. If all Recipient's
+rights under this Agreement terminate, Recipient agrees to cease use
+and distribution of the Program as soon as reasonably practicable.
+However, Recipient's obligations under this Agreement and any licenses
+granted by Recipient relating to the Program shall continue and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement,
+but in order to avoid inconsistency the Agreement is copyrighted and
+may only be modified in the following manner. The Agreement Steward
+reserves the right to publish new versions (including revisions) of
+this Agreement from time to time. No one other than the Agreement
+Steward has the right to modify this Agreement. The Eclipse Foundation
+is the initial Agreement Steward. The Eclipse Foundation may assign the
+responsibility to serve as the Agreement Steward to a suitable separate
+entity. Each new version of the Agreement will be given a distinguishing
+version number. The Program (including Contributions) may always be
+Distributed subject to the version of the Agreement under which it was
+received. In addition, after a new version of the Agreement is published,
+Contributor may elect to Distribute the Program (including its
+Contributions) under the new version.
+
+Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+receives no rights or licenses to the intellectual property of any
+Contributor under this Agreement, whether expressly, by implication,
+estoppel or otherwise. All rights in the Program not expressly granted
+under this Agreement are reserved. Nothing in this Agreement is intended
+to be enforceable by any entity that is not a Contributor or Recipient.
+No third-party beneficiary rights are created under this Agreement.
+
+Exhibit A - Form of Secondary Licenses Notice
+
+"This Source Code may also be made available under the following 
+Secondary Licenses when the conditions for such availability set forth 
+in the Eclipse Public License, v. 2.0 are satisfied: {name license(s),
+version(s), and exceptions or additional permissions here}."
+
+  Simply including a copy of this Agreement, including this Exhibit A
+  is not sufficient to license the Source Code under Secondary Licenses.
+
+  If it is not possible or desirable to put the notice in a particular
+  file, then You may include the notice in a location (such as a LICENSE
+  file in a relevant directory) where a recipient would be likely to
+  look for such a notice.
+
+  You may add additional accurate notices of copyright ownership.

README.md

+# SableCC Gradle plugin
+
+Use the [SableCC](https://sablecc.org/) parser generator as part of a Gradle build.
+
+This plugin has been developed for use with the [STUPS fork of SableCC](https://gitlab.cs.uni-duesseldorf.de/general/stups/sablecc-stups),
+but it is also compatible with the official SableCC 3.x releases.
+
+## Features
+
+* Automatically calls SableCC and manages the generated files
+* Supports multiple grammars per project
+* Allows choosing a custom version of SableCC
+
+## How to use
+
+Apply the plugin:
+
+```groovy
+plugins {
+	id "de.hhu.stups.sablecc" version "1.0.0"
+}
+```
+
+Set the SableCC version to use:
+
+```groovy
+repositories {
+	mavenCentral()
+}
+
+dependencies {
+	sableCC(group: "sablecc", name: "sablecc", version: "3.2-1")
+}
+```
+
+Then put your SableCC grammar(s) under src/main/sablecc.
+Extensions .scc and .sablecc are recognized.
+
+SableCC will now run automatically as part of your build -
+the plugin automatically adds SableCC as a dependency of `compileJava`, `sourcesJar`, etc.
+You can also generate the parsers manually by running the task `generateSableCCSource`
+(or `generate<SourceSetName>SableCCSource` for other source sets).
+
+## Advanced configuration
+
+Some advanced options can be configured directly on the SableCC tasks.
+You normally don't need to do this - all of these options have reasonable defaults.
+
+```groovy
+tasks.named("generateSableCCSource").configure {
+	sableCCClasspath = sourceSets.something.runtimeClasspath
+	maxHeapSize = "512M"
+	// WARNING: The destination dirs will be DELETED every time the SableCC task runs!
+	destinationJavaDir = "my/custom/out/java"
+	destinationResourcesDir = "my/custom/out/resources"
+	// Supports all standard SourceTask configuration options
+	include("my/custom/grammars/**.scc")
+}
+```
+
+## License
+
+The source code is distributed under the [Eclipse Public License - v 2.0](LICENSE.txt).
+
+The SableCC Gradle plugin comes with ABSOLUTELY NO WARRANTY OF ANY KIND !
+This software is distributed in the hope that it will be useful but WITHOUT ANY WARRANTY.
+The author(s) do not accept responsibility to anyone for the consequences of using it
+or for whether it serves any particular purpose or works at all.
+No warranty is made about the software or its performance.
+
+(c) 2022 STUPS group, Heinrich Heine University Düsseldorf

build.gradle

+plugins {
+	id("java-gradle-plugin")
+	id("maven-publish")
+	
+	id("com.gradle.plugin-publish").version("0.21.0")
+}
+
+group = "de.hhu.stups"
+version = "1.0.0"
+
+wrapper {
+	gradleVersion = "7.4.2"
+}
+
+java {
+	sourceCompatibility = JavaVersion.VERSION_1_8
+	targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+gradlePlugin {
+	plugins {
+		sableccPlugin {
+			id = "de.hhu.stups.sablecc"
+			displayName = "SableCC Gradle plugin"
+			description = "Generate parsers using SableCC"
+			implementationClass = "de.hhu.stups.sablecc.gradle.SableCCPlugin"
+		}
+	}
+}
+
+pluginBundle {
+	website = "https://gitlab.cs.uni-duesseldorf.de/general/stups/sablecc_gradle_plugin"
+	vcsUrl = "https://gitlab.cs.uni-duesseldorf.de/general/stups/sablecc_gradle_plugin"
+	tags = ["sablecc", "parser", "generator"]
+}

gradle/wrapper/gradle-wrapper.properties

+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.2-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

gradlew

+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original 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 POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
+
+APP_NAME="Gradle"
+APP_BASE_NAME=${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 "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# 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  ;; #(
+  MSYS* | 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" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+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 Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@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 execute
+
+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 execute
+
+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
+
+: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 %*
+
+: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

settings.gradle

+rootProject.name = "sablecc_gradle_plugin"

src/main/java/de/hhu/stups/sablecc/gradle/DefaultSableCCSourceSet.java

+package de.hhu.stups.sablecc.gradle;
+
+import org.gradle.api.Action;
+import org.gradle.api.NonNullApi;
+import org.gradle.api.file.SourceDirectorySet;
+import org.gradle.api.model.ObjectFactory;
+import org.gradle.api.reflect.HasPublicType;
+import org.gradle.api.reflect.TypeOf;
+
+@NonNullApi
+final class DefaultSableCCSourceSet implements SableCCSourceSet, HasPublicType {
+	private final SourceDirectorySet sableCC;
+	
+	DefaultSableCCSourceSet(final String displayName, final ObjectFactory objectFactory) {
+		super();
+		
+		this.sableCC = objectFactory.sourceDirectorySet(NAME, displayName + " SableCC source");
+		this.sableCC.getFilter().include("**/*.scc");
+		this.sableCC.getFilter().include("**/*.sablecc");
+	}
+	
+	@Override
+	public SourceDirectorySet getSableCC() {
+		return this.sableCC;
+	}
+	
+	@Override
+	public SableCCSourceSet sableCC(final Action<? super SourceDirectorySet> configureAction) {
+		configureAction.execute(this.getSableCC());
+		return this;
+	}
+	
+	@Override
+	public TypeOf<?> getPublicType() {
+		return TypeOf.typeOf(SableCCSourceSet.class);
+	}
+}

src/main/java/de/hhu/stups/sablecc/gradle/SableCCPlugin.java

+package de.hhu.stups.sablecc.gradle;
+
+import javax.inject.Inject;
+
+import org.gradle.api.NonNullApi;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.UnknownTaskException;
+import org.gradle.api.file.Directory;
+import org.gradle.api.internal.tasks.DefaultSourceSet;
+import org.gradle.api.plugins.JavaPlugin;
+import org.gradle.api.plugins.JavaPluginExtension;
+
+@NonNullApi
+public class SableCCPlugin implements Plugin<Project> {
+	public static final String SABLECC_CONFIGURATION_NAME = "sableCC";
+	public static final String SABLECC_TASK_VERB = "generate";
+	public static final String SABLECC_TASK_TARGET = "SableCCSource";
+	
+	@Inject
+	public SableCCPlugin() {
+		super();
+	}
+	
+	@Override
+	public void apply(final Project project) {
+		project.getPluginManager().apply(JavaPlugin.class);
+		
+		// Create the sableCC configuration (used to specify which SableCC version to use).
+		project.getConfigurations().create(SABLECC_CONFIGURATION_NAME)
+			.setVisible(false)
+			.setDescription("The SableCC libraries to be used for this project.");
+		
+		// Use the sableCC configuration as the sableCCClasspath by convention (i. e. unless overridden by the user).
+		project.getTasks().withType(SableCCTask.class).configureEach(sableCCTask ->
+			sableCCTask.getConventionMapping().map("sableCCClasspath", () -> project.getConfigurations().getByName(SABLECC_CONFIGURATION_NAME))
+		);
+		
+		project.getExtensions().getByType(JavaPluginExtension.class).getSourceSets().all(sourceSet -> {
+			// Create the sablecc source directory set.
+			final String sourceSetDisplayName = ((DefaultSourceSet)sourceSet).getDisplayName();
+			final SableCCSourceSet sableCCSourceSet = new DefaultSableCCSourceSet(sourceSetDisplayName, project.getObjects());
+			sourceSet.getExtensions().add(SableCCSourceSet.class, SableCCSourceSet.NAME, sableCCSourceSet);
+			sableCCSourceSet.getSableCC().srcDir("src/" + sourceSet.getName() + "/sablecc");
+			sourceSet.getAllSource().source(sableCCSourceSet.getSableCC());
+			
+			// Create the output directories for the generated Java source and resources.
+			final Directory baseOutputDirectory = project.getLayout().getBuildDirectory().get().dir("generated-src/sablecc/" + sourceSet.getName());
+			final Directory outputJavaDirectory = baseOutputDirectory.dir("java");
+			sourceSet.getJava().srcDir(outputJavaDirectory);
+			final Directory outputResourcesDirectory = baseOutputDirectory.dir("resources");
+			sourceSet.getResources().srcDir(outputResourcesDirectory);
+			
+			// Create the generateSableCCSource task.
+			final String sableCCTaskName = sourceSet.getTaskName(SABLECC_TASK_VERB, SABLECC_TASK_TARGET);
+			project.getTasks().register(sableCCTaskName, SableCCTask.class, task -> {
+				task.setDescription("Compiles the " + sourceSetDisplayName + " SableCC grammars.");
+				task.setSource(sableCCSourceSet.getSableCC());
+				task.setDestinationJavaDir(outputJavaDirectory);
+				task.setDestinationResourcesDir(outputResourcesDirectory);
+			});
+			
+			// Make compileJava, processResources, and sourcesJar depend on generateSableCCSource.
+			project.getTasks().named(sourceSet.getCompileJavaTaskName(), task -> task.dependsOn(sableCCTaskName));
+			project.getTasks().named(sourceSet.getProcessResourcesTaskName(), task -> task.dependsOn(sableCCTaskName));
+			try {
+				project.getTasks().named(sourceSet.getSourcesJarTaskName(), task -> task.dependsOn(sableCCTaskName));
+			} catch (UnknownTaskException ignored) {
+				// No sourcesJar task defined, so no need to add a dependency.
+			}
+		});
+	}
+}

src/main/java/de/hhu/stups/sablecc/gradle/SableCCSourceSet.java

+package de.hhu.stups.sablecc.gradle;
+
+import org.gradle.api.Action;
+import org.gradle.api.NonNullApi;
+import org.gradle.api.file.SourceDirectorySet;
+
+@NonNullApi
+public interface SableCCSourceSet {
+	String NAME = "sablecc";
+	
+	SourceDirectorySet getSableCC();
+	SableCCSourceSet sableCC(final Action<? super SourceDirectorySet> configureAction);
+}

src/main/java/de/hhu/stups/sablecc/gradle/SableCCTask.java

+package de.hhu.stups.sablecc.gradle;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.gradle.api.NonNullApi;
+import org.gradle.api.file.Directory;
+import org.gradle.api.file.DirectoryProperty;
+import org.gradle.api.file.FileCollection;
+import org.gradle.api.file.FileTree;
+import org.gradle.api.tasks.Classpath;
+import org.gradle.api.tasks.IgnoreEmptyDirectories;
+import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.Optional;
+import org.gradle.api.tasks.OutputDirectory;
+import org.gradle.api.tasks.PathSensitive;
+import org.gradle.api.tasks.PathSensitivity;
+import org.gradle.api.tasks.SourceTask;
+import org.gradle.api.tasks.TaskAction;
+import org.gradle.work.NormalizeLineEndings;
+
+@NonNullApi
+public class SableCCTask extends SourceTask {
+	private FileCollection sableCCClasspath;
+	private String maxHeapSize;
+	private final DirectoryProperty destinationJavaDir;
+	private final DirectoryProperty destinationResourcesDir;
+	
+	public SableCCTask() {
+		super();
+		
+		this.sableCCClasspath = null;
+		this.destinationJavaDir = this.getProject().getObjects().directoryProperty();
+		this.destinationResourcesDir = this.getProject().getObjects().directoryProperty();
+	}
+	
+	@IgnoreEmptyDirectories
+	@NormalizeLineEndings
+	@PathSensitive(PathSensitivity.NONE)
+	@Override
+	public FileTree getSource() {
+		return super.getSource();
+	}
+	
+	@Classpath
+	public FileCollection getSableCCClasspath() {
+		return this.sableCCClasspath;
+	}
+	
+	public void setSableCCClasspath(final FileCollection sableCCClasspath) {
+		this.sableCCClasspath = sableCCClasspath;
+	}
+	
+	@Input
+	@Optional
+	public String getMaxHeapSize() {
+		return this.maxHeapSize;
+	}
+	
+	public void setMaxHeapSize(final String maxHeapSize) {
+		this.maxHeapSize = maxHeapSize;
+	}
+	
+	@OutputDirectory
+	public Directory getDestinationJavaDir() {
+		return this.destinationJavaDir.get();
+	}
+	
+	public void setDestinationJavaDir(final Directory destinationJavaDir) {
+		this.destinationJavaDir.set(destinationJavaDir);
+	}
+	
+	@OutputDirectory
+	public Directory getDestinationResourcesDir() {
+		return this.destinationResourcesDir.get();
+	}
+	
+	public void setDestinationResourcesDir(final Directory destinationResourcesDir) {
+		this.destinationResourcesDir.set(destinationResourcesDir);
+	}
+	
+	@TaskAction
+	void execute() {
+		// Delete any previously generated source files, so that no longer existing token and node classes aren't kept around.
+		this.getProject().delete(this.getDestinationJavaDir(), this.getDestinationResourcesDir());
+		this.getProject().mkdir(this.getDestinationJavaDir());
+		this.getProject().mkdir(this.getDestinationResourcesDir());
+		
+		// Call SableCC to generate the source files.
+		this.getProject().javaexec(spec -> {
+			spec.setClasspath(this.getSableCCClasspath());
+			spec.setMaxHeapSize(this.getMaxHeapSize());
+			spec.getMainClass().set("org.sablecc.sablecc.SableCC");
+			final List<String> args = new ArrayList<>();
+			args.add("-d");
+			args.add(destinationJavaDir.get().getAsFile().getPath());
+			for (final File file : this.getSource().getFiles()) {
+				args.add(file.getPath());
+			}
+			spec.setArgs(args);
+		});
+		
+		// Move generated dat files from Java source directory to resources directory.
+		this.getProject().copy(spec -> {
+			spec.from(this.getDestinationJavaDir());
+			spec.into(this.getDestinationResourcesDir());
+			spec.include("**/*.dat");
+		});
+		this.getProject().delete(this.getProject().fileTree(this.getDestinationJavaDir(), files -> files.include("**/*.dat")));
+	}
+}